fix(dns): polish dual-stack review follow-ups

Signed-off-by: Kevin Glasson <kevinglasson@gmail.com>

Author: elidhu

docs/service-discovery.md

@@ -96,7 +96,7 @@ This configuration will instruct Thanos to discover all endpoints within the `th
 --endpoint=dnssrvnoa+_thanosstores._tcp.mycompany.org
 ```
 
-* `dnsdualstack+` - the domain name after this prefix will be looked up as both A and AAAA queries simultaneously, returning all resolved addresses. This provides dual-stack resilience by resolving both IPv4 and IPv6 addresses, with automatic failover handled by gRPC's built-in health checking. *A port is required for this query type*. This is most useful with `--endpoint-group`, which allows gRPC to manage all resolved addresses as a single logical group with automatic failover. For example:
+* `dnsdualstack+` - the domain name after this prefix will be looked up as both A and AAAA queries, returning all resolved addresses. This provides dual-stack resilience by resolving both IPv4 and IPv6 addresses, with automatic failover handled by gRPC's built-in health checking. *A port is required for this query type*. This is most useful with `--endpoint-group`, which allows gRPC to manage all resolved addresses as a single logical group with automatic failover. For example:
 
 ```
 --endpoint-group=dnsdualstack+stores.thanos.mycompany.org:9090

pkg/discovery/dns/resolver.go

@@ -157,7 +157,7 @@ func (s *dnsSD) Resolve(ctx context.Context, name string, qtype QType) ([]string
 			res = append(res, appendScheme(scheme, net.JoinHostPort(ip.String(), port)))
 		}
 		if len(ips) == 0 {
-			level.Error(s.logger).Log("msg", "failed to lookup IP addresses (dual-stack)", "host", host)
+			level.Error(s.logger).Log("msg", "found no IP addresses (dual-stack)", "host", host)
 		}
 	default:
 		return nil, errors.Errorf("invalid lookup scheme %q", qtype)

pkg/discovery/dns/resolver_test.go

@@ -21,12 +21,15 @@ type mockHostnameResolver struct {
 	resultSRVs map[string][]*net.SRV
 	err        error
 
-	// Per-network results for LookupIPAddrByNetwork. Key format: "network:host".
 	resultByNetwork map[string][]net.IPAddr
 	errByNetwork    map[string]error
 	isNotFound      func(error) bool
 }
 
+func lookupKey(network, host string) string {
+	return network + ":" + host
+}
+
 func (m mockHostnameResolver) LookupIPAddr(ctx context.Context, host string) ([]net.IPAddr, error) {
 	if m.err != nil {
 		return nil, m.err
@@ -35,7 +38,7 @@ func (m mockHostnameResolver) LookupIPAddr(ctx context.Context, host string) ([]
 }
 
 func (m mockHostnameResolver) LookupIPAddrByNetwork(_ context.Context, network, host string) ([]net.IPAddr, error) {
-	key := network + ":" + host
+	key := lookupKey(network, host)
 	if m.errByNetwork != nil {
 		if err, ok := m.errByNetwork[key]; ok {
 			return nil, err
@@ -242,8 +245,8 @@ func TestDnsSD_ResolveDualStack(t *testing.T) {
 			addr: host + ":8080",
 			resolver: &mockHostnameResolver{
 				resultByNetwork: map[string][]net.IPAddr{
-					"ip6:" + host: {{IP: ipv6}},
-					"ip4:" + host: {{IP: ipv4}},
+					lookupKey("ip6", host): {{IP: ipv6}},
+					lookupKey("ip4", host): {{IP: ipv4}},
 				},
 			},
 			expectedResult: []string{"[2001:db8::1]:8080", "192.168.1.1:8080"},
@@ -253,7 +256,7 @@ func TestDnsSD_ResolveDualStack(t *testing.T) {
 			addr: host + ":8080",
 			resolver: &mockHostnameResolver{
 				resultByNetwork: map[string][]net.IPAddr{
-					"ip6:" + host: {{IP: ipv6}},
+					lookupKey("ip6", host): {{IP: ipv6}},
 				},
 			},
 			expectedResult: []string{"[2001:db8::1]:8080"},
@@ -263,7 +266,7 @@ func TestDnsSD_ResolveDualStack(t *testing.T) {
 			addr: host + ":8080",
 			resolver: &mockHostnameResolver{
 				resultByNetwork: map[string][]net.IPAddr{
-					"ip4:" + host: {{IP: ipv4}},
+					lookupKey("ip4", host): {{IP: ipv4}},
 				},
 			},
 			expectedResult: []string{"192.168.1.1:8080"},
@@ -280,10 +283,10 @@ func TestDnsSD_ResolveDualStack(t *testing.T) {
 			addr: host + ":8080",
 			resolver: &mockHostnameResolver{
 				resultByNetwork: map[string][]net.IPAddr{
-					"ip4:" + host: {{IP: ipv4}},
+					lookupKey("ip4", host): {{IP: ipv4}},
 				},
 				errByNetwork: map[string]error{
-					"ip6:" + host: errors.New("network unreachable"),
+					lookupKey("ip6", host): errors.New("network unreachable"),
 				},
 			},
 			expectedResult: []string{"192.168.1.1:8080"},
@@ -293,10 +296,10 @@ func TestDnsSD_ResolveDualStack(t *testing.T) {
 			addr: host + ":8080",
 			resolver: &mockHostnameResolver{
 				resultByNetwork: map[string][]net.IPAddr{
-					"ip6:" + host: {{IP: ipv6}},
+					lookupKey("ip6", host): {{IP: ipv6}},
 				},
 				errByNetwork: map[string]error{
-					"ip4:" + host: errors.New("network unreachable"),
+					lookupKey("ip4", host): errors.New("network unreachable"),
 				},
 			},
 			expectedResult: []string{"[2001:db8::1]:8080"},
@@ -329,8 +332,8 @@ func TestDnsSD_ResolveDualStack_Errors(t *testing.T) {
 	t.Run("both families fail propagates error", func(t *testing.T) {
 		resolver := &mockHostnameResolver{
 			errByNetwork: map[string]error{
-				"ip6:" + host: errors.New("network unreachable"),
-				"ip4:" + host: errors.New("network unreachable"),
+				lookupKey("ip6", host): errors.New("network unreachable"),
+				lookupKey("ip4", host): errors.New("network unreachable"),
 			},
 		}
 		dnsSD := dnsSD{resolver, log.NewNopLogger()}
@@ -343,8 +346,8 @@ func TestDnsSD_ResolveDualStack_Errors(t *testing.T) {
 		notFound := &net.DNSError{Err: "no such host", Name: host, IsNotFound: true}
 		resolver := &mockHostnameResolver{
 			errByNetwork: map[string]error{
-				"ip6:" + host: notFound,
-				"ip4:" + host: notFound,
+				lookupKey("ip6", host): notFound,
+				lookupKey("ip4", host): notFound,
 			},
 			isNotFound: func(err error) bool {
 				dnsErr, ok := err.(*net.DNSError)
@@ -362,8 +365,8 @@ func TestDnsSD_ResolveDualStack_Errors(t *testing.T) {
 		notFound := &net.DNSError{Err: "no such host", Name: host, IsNotFound: true}
 		resolver := &mockHostnameResolver{
 			errByNetwork: map[string]error{
-				"ip6:" + host: notFound,
-				"ip4:" + host: errors.New("server misbehaving"),
+				lookupKey("ip6", host): notFound,
+				lookupKey("ip4", host): errors.New("server misbehaving"),
 			},
 			isNotFound: func(err error) bool {
 				dnsErr, ok := err.(*net.DNSError)