prometheus · LaurenceChau · Jul 31, 2024
diff --git a/prober/dns.go b/prober/dns.go
@@ -124,7 +124,7 @@ func validRcode(rcode int, valid []string, logger log.Logger) bool {
 	return false
 }
 
-func ProbeDNS(ctx context.Context, target string, module config.Module, registry *prometheus.Registry, logger log.Logger) bool {
+func ProbeDNS(ctx context.Context, opts probeOpts, module config.Module, registry *prometheus.Registry, logger log.Logger) bool {
 	var dialProtocol string
 	probeDNSDurationGaugeVec := prometheus.NewGaugeVec(prometheus.GaugeOpts{
 		Name: "probe_dns_duration_seconds",
@@ -187,15 +187,15 @@ func ProbeDNS(ctx context.Context, target string, module config.Module, registry
 		return false
 	}
 
-	targetAddr, port, err := net.SplitHostPort(target)
+	targetAddr, port, err := net.SplitHostPort(opts.target)
 	if err != nil {
 		// Target only contains host so fallback to default port and set targetAddr as target.
 		if module.DNS.DNSOverTLS {
 			port = "853"
 		} else {
 			port = "53"
 		}
-		targetAddr = target
+		targetAddr = opts.target
 	}
 	ip, lookupTime, err := chooseProtocol(ctx, module.DNS.IPProtocol, module.DNS.IPProtocolFallback, targetAddr, registry, logger)
 	if err != nil {

diff --git a/prober/dns_test.go b/prober/dns_test.go
@@ -170,7 +170,7 @@ func TestRecursiveDNSResponse(t *testing.T) {
 
 			testCTX, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 			defer cancel()
-			result := ProbeDNS(testCTX, addr.String(), config.Module{Timeout: time.Second, DNS: test.Probe}, registry, log.NewNopLogger())
+			result := ProbeDNS(testCTX, probeOpts{target: addr.String()}, config.Module{Timeout: time.Second, DNS: test.Probe}, registry, log.NewNopLogger())
 			if result != test.ShouldSucceed {
 				t.Fatalf("Test %d had unexpected result: %v", i, result)
 			}
@@ -374,7 +374,7 @@ func TestAuthoritativeDNSResponse(t *testing.T) {
 			registry := prometheus.NewRegistry()
 			testCTX, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 			defer cancel()
-			result := ProbeDNS(testCTX, addr.String(), config.Module{Timeout: time.Second, DNS: test.Probe}, registry, log.NewNopLogger())
+			result := ProbeDNS(testCTX, probeOpts{target: addr.String()}, config.Module{Timeout: time.Second, DNS: test.Probe}, registry, log.NewNopLogger())
 			if result != test.ShouldSucceed {
 				t.Fatalf("Test %d had unexpected result: %v", i, result)
 			}
@@ -449,7 +449,7 @@ func TestServfailDNSResponse(t *testing.T) {
 			registry := prometheus.NewRegistry()
 			testCTX, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 			defer cancel()
-			result := ProbeDNS(testCTX, addr.String(), config.Module{Timeout: time.Second, DNS: test.Probe}, registry, log.NewNopLogger())
+			result := ProbeDNS(testCTX, probeOpts{target: addr.String()}, config.Module{Timeout: time.Second, DNS: test.Probe}, registry, log.NewNopLogger())
 			if result != test.ShouldSucceed {
 				t.Fatalf("Test %d had unexpected result: %v", i, result)
 			}
@@ -509,7 +509,7 @@ func TestDNSProtocol(t *testing.T) {
 		registry := prometheus.NewRegistry()
 		testCTX, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 		defer cancel()
-		result := ProbeDNS(testCTX, net.JoinHostPort("localhost", port), module, registry, log.NewNopLogger())
+		result := ProbeDNS(testCTX, probeOpts{target: net.JoinHostPort("localhost", port)}, module, registry, log.NewNopLogger())
 		if !result {
 			t.Fatalf("DNS protocol: \"%v\", preferred \"ip6\" connection test failed, expected success.", protocol)
 		}
@@ -535,7 +535,7 @@ func TestDNSProtocol(t *testing.T) {
 		registry = prometheus.NewRegistry()
 		testCTX, cancel = context.WithTimeout(context.Background(), 10*time.Second)
 		defer cancel()
-		result = ProbeDNS(testCTX, net.JoinHostPort("localhost", port), module, registry, log.NewNopLogger())
+		result = ProbeDNS(testCTX, probeOpts{target: net.JoinHostPort("localhost", port)}, module, registry, log.NewNopLogger())
 		if !result {
 			t.Fatalf("DNS protocol: \"%v\", preferred \"ip4\" connection test failed, expected success.", protocol)
 		}
@@ -561,7 +561,7 @@ func TestDNSProtocol(t *testing.T) {
 		registry = prometheus.NewRegistry()
 		testCTX, cancel = context.WithTimeout(context.Background(), 10*time.Second)
 		defer cancel()
-		result = ProbeDNS(testCTX, net.JoinHostPort("localhost", port), module, registry, log.NewNopLogger())
+		result = ProbeDNS(testCTX, probeOpts{target: net.JoinHostPort("localhost", port)}, module, registry, log.NewNopLogger())
 		if !result {
 			t.Fatalf("DNS protocol: \"%v\" connection test failed, expected success.", protocol)
 		}
@@ -586,7 +586,7 @@ func TestDNSProtocol(t *testing.T) {
 		registry = prometheus.NewRegistry()
 		testCTX, cancel = context.WithTimeout(context.Background(), 10*time.Second)
 		defer cancel()
-		result = ProbeDNS(testCTX, net.JoinHostPort("localhost", port), module, registry, log.NewNopLogger())
+		result = ProbeDNS(testCTX, probeOpts{target: net.JoinHostPort("localhost", port)}, module, registry, log.NewNopLogger())
 		if protocol == "udp" {
 			if !result {
 				t.Fatalf("DNS test connection with protocol %s failed, expected success.", protocol)
@@ -629,7 +629,7 @@ func TestDNSMetrics(t *testing.T) {
 	registry := prometheus.NewRegistry()
 	testCTX, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
-	result := ProbeDNS(testCTX, net.JoinHostPort("localhost", port), module, registry, log.NewNopLogger())
+	result := ProbeDNS(testCTX, probeOpts{target: net.JoinHostPort("localhost", port)}, module, registry, log.NewNopLogger())
 	if !result {
 		t.Fatalf("DNS test connection failed, expected success.")
 	}

diff --git a/prober/grpc.go b/prober/grpc.go
@@ -15,6 +15,11 @@ package prober
 
 import (
 	"context"
+	"net"
+	"net/url"
+	"strings"
+	"time"
+
 	"github.com/go-kit/log"
 	"github.com/go-kit/log/level"
 	"github.com/prometheus/blackbox_exporter/config"
@@ -27,10 +32,6 @@ import (
 	"google.golang.org/grpc/health/grpc_health_v1"
 	"google.golang.org/grpc/peer"
 	"google.golang.org/grpc/status"
-	"net"
-	"net/url"
-	"strings"
-	"time"
 )
 
 type GRPCHealthCheck interface {
@@ -74,7 +75,7 @@ func (c *gRPCHealthCheckClient) Check(ctx context.Context, service string) (bool
 	return false, returnStatus.Code(), nil, "", err
 }
 
-func ProbeGRPC(ctx context.Context, target string, module config.Module, registry *prometheus.Registry, logger log.Logger) (success bool) {
+func ProbeGRPC(ctx context.Context, opts probeOpts, module config.Module, registry *prometheus.Registry, logger log.Logger) (success bool) {
 
 	var (
 		durationGaugeVec = prometheus.NewGaugeVec(prometheus.GaugeOpts{
@@ -125,11 +126,11 @@ func ProbeGRPC(ctx context.Context, target string, module config.Module, registr
 	registry.MustRegister(probeTLSVersion)
 	registry.MustRegister(probeSSLLastInformation)
 
-	if !strings.HasPrefix(target, "http://") && !strings.HasPrefix(target, "https://") {
-		target = "http://" + target
+	if !strings.HasPrefix(opts.target, "http://") && !strings.HasPrefix(opts.target, "https://") {
+		opts.target = "http://" + opts.target
 	}
 
-	targetURL, err := url.Parse(target)
+	targetURL, err := url.Parse(opts.target)
 	if err != nil {
 		level.Error(logger).Log("msg", "Could not parse target URL", "err", err)
 		return false
@@ -166,23 +167,23 @@ func ProbeGRPC(ctx context.Context, target string, module config.Module, registr
 		targetURL.Host = net.JoinHostPort(ip.String(), targetPort)
 	}
 
-	var opts []grpc.DialOption
-	target = targetHost + ":" + targetPort
+	var grpcOpts []grpc.DialOption
+	opts.target = targetHost + ":" + targetPort
 	if !module.GRPC.TLS {
 		level.Debug(logger).Log("msg", "Dialing GRPC without TLS")
-		opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials()))
+		grpcOpts = append(grpcOpts, grpc.WithTransportCredentials(insecure.NewCredentials()))
 		if len(targetPort) == 0 {
-			target = targetHost + ":80"
+			opts.target = targetHost + ":80"
 		}
 	} else {
 		creds := credentials.NewTLS(tlsConfig)
-		opts = append(opts, grpc.WithTransportCredentials(creds))
+		grpcOpts = append(grpcOpts, grpc.WithTransportCredentials(creds))
 		if len(targetPort) == 0 {
-			target = targetHost + ":443"
+			opts.target = targetHost + ":443"
 		}
 	}
 
-	conn, err := grpc.NewClient(target, opts...)
+	conn, err := grpc.NewClient(opts.target, grpcOpts...)
 
 	if err != nil {
 		level.Error(logger).Log("did not connect: %v", err)

diff --git a/prober/grpc_test.go b/prober/grpc_test.go
@@ -63,7 +63,7 @@ func TestGRPCConnection(t *testing.T) {
 	defer cancel()
 	registry := prometheus.NewRegistry()
 
-	result := ProbeGRPC(testCTX, "localhost:"+port,
+	result := ProbeGRPC(testCTX, probeOpts{target: "localhost:" + port},
 		config.Module{Timeout: time.Second, GRPC: config.GRPCProbe{
 			IPProtocolFallback: false,
 		},
@@ -129,7 +129,7 @@ func TestMultipleGRPCservices(t *testing.T) {
 	defer cancel()
 	registryService1 := prometheus.NewRegistry()
 
-	resultService1 := ProbeGRPC(testCTX, "localhost:"+port,
+	resultService1 := ProbeGRPC(testCTX, probeOpts{target: "localhost:" + port},
 		config.Module{Timeout: time.Second, GRPC: config.GRPCProbe{
 			IPProtocolFallback: false,
 			Service:            "service1",
@@ -141,7 +141,7 @@ func TestMultipleGRPCservices(t *testing.T) {
 	}
 
 	registryService2 := prometheus.NewRegistry()
-	resultService2 := ProbeGRPC(testCTX, "localhost:"+port,
+	resultService2 := ProbeGRPC(testCTX, probeOpts{target: "localhost:" + port},
 		config.Module{Timeout: time.Second, GRPC: config.GRPCProbe{
 			IPProtocolFallback: false,
 			Service:            "service2",
@@ -153,7 +153,7 @@ func TestMultipleGRPCservices(t *testing.T) {
 	}
 
 	registryService3 := prometheus.NewRegistry()
-	resultService3 := ProbeGRPC(testCTX, "localhost:"+port,
+	resultService3 := ProbeGRPC(testCTX, probeOpts{target: "localhost:" + port},
 		config.Module{Timeout: time.Second, GRPC: config.GRPCProbe{
 			IPProtocolFallback: false,
 			Service:            "service3",
@@ -225,7 +225,7 @@ func TestGRPCTLSConnection(t *testing.T) {
 	defer cancel()
 	registry := prometheus.NewRegistry()
 
-	result := ProbeGRPC(testCTX, "localhost:"+port,
+	result := ProbeGRPC(testCTX, probeOpts{target: "localhost:" + port},
 		config.Module{Timeout: time.Second, GRPC: config.GRPCProbe{
 			TLS:                true,
 			TLSConfig:          pconfig.TLSConfig{InsecureSkipVerify: true},
@@ -286,7 +286,7 @@ func TestNoTLSConnection(t *testing.T) {
 	defer cancel()
 	registry := prometheus.NewRegistry()
 
-	result := ProbeGRPC(testCTX, "localhost:"+port,
+	result := ProbeGRPC(testCTX, probeOpts{target: "localhost:" + port},
 		config.Module{Timeout: time.Second, GRPC: config.GRPCProbe{
 			TLS:                true,
 			TLSConfig:          pconfig.TLSConfig{InsecureSkipVerify: true},
@@ -341,7 +341,7 @@ func TestGRPCServiceNotFound(t *testing.T) {
 	defer cancel()
 	registry := prometheus.NewRegistry()
 
-	result := ProbeGRPC(testCTX, "localhost:"+port,
+	result := ProbeGRPC(testCTX, probeOpts{target: "localhost:" + port},
 		config.Module{Timeout: time.Second, GRPC: config.GRPCProbe{
 			IPProtocolFallback: false,
 			Service:            "NonExistingService",
@@ -391,7 +391,7 @@ func TestGRPCHealthCheckUnimplemented(t *testing.T) {
 	defer cancel()
 	registry := prometheus.NewRegistry()
 
-	result := ProbeGRPC(testCTX, "localhost:"+port,
+	result := ProbeGRPC(testCTX, probeOpts{target: "localhost:" + port},
 		config.Module{Timeout: time.Second, GRPC: config.GRPCProbe{
 			IPProtocolFallback: false,
 			Service:            "NonExistingService",

diff --git a/prober/handler.go b/prober/handler.go
@@ -116,7 +116,9 @@ func Handler(w http.ResponseWriter, r *http.Request, c *config.Config, logger lo
 	registry := prometheus.NewRegistry()
 	registry.MustRegister(probeSuccessGauge)
 	registry.MustRegister(probeDurationGauge)
-	success := prober(ctx, target, module, registry, sl)
+	success := prober(ctx,
+		probeOpts{target: target, sourceIPAddress: params.Get("sourceIPAddress")},
+		module, registry, sl)
 	duration := time.Since(start).Seconds()
 	probeDurationGauge.Set(duration)
 	if success {

diff --git a/prober/http.go b/prober/http.go
@@ -235,7 +235,7 @@ func (bc *byteCounter) Read(p []byte) (int, error) {
 
 var userAgentDefaultHeader = fmt.Sprintf("Blackbox Exporter/%s", version.Version)
 
-func ProbeHTTP(ctx context.Context, target string, module config.Module, registry *prometheus.Registry, logger log.Logger) (success bool) {
+func ProbeHTTP(ctx context.Context, opts probeOpts, module config.Module, registry *prometheus.Registry, logger log.Logger) (success bool) {
 	var redirects int
 	var (
 		durationGaugeVec = prometheus.NewGaugeVec(prometheus.GaugeOpts{
@@ -314,11 +314,11 @@ func ProbeHTTP(ctx context.Context, target string, module config.Module, registr
 
 	httpConfig := module.HTTP
 
-	if !strings.HasPrefix(target, "http://") && !strings.HasPrefix(target, "https://") {
-		target = "http://" + target
+	if !strings.HasPrefix(opts.target, "http://") && !strings.HasPrefix(opts.target, "https://") {
+		opts.target = "http://" + opts.target
 	}
 
-	targetURL, err := url.Parse(target)
+	targetURL, err := url.Parse(opts.target)
 	if err != nil {
 		level.Error(logger).Log("msg", "Could not parse target URL", "err", err)
 		return false