Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Use preferred protocol first when resolving hostname #728

Merged
merged 5 commits into from
Jan 5, 2021
Merged

Use preferred protocol first when resolving hostname #728

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
5487581
Use preferred protocol first when resolving hostname
yegle Jan 3, 2021
923274a
Use example.com hostname in test.
yegle Jan 4, 2021
d08e1b0
Inline LookupIP function call.
yegle Jan 5, 2021
5b10683
Remove unused struct.
yegle Jan 5, 2021
f44254d
Make full use of named return variables and simplify the logic.
yegle Jan 5, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
81 changes: 35 additions & 46 deletions prober/utils.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -26,8 +26,13 @@ import (
"github.com/prometheus/client_golang/prometheus"
)

var protocolToGauge = map[string]float64{
"ip4": 4,
"ip6": 6,
}

// Returns the IP for the IPProtocol and lookup time.
func chooseProtocol(ctx context.Context, IPProtocol string, fallbackIPProtocol bool, target string, registry *prometheus.Registry, logger log.Logger) (ip *net.IPAddr, lookupTime float64, err error) {
func chooseProtocol(ctx context.Context, IPProtocol string, fallbackIPProtocol bool, target string, registry *prometheus.Registry, logger log.Logger) (ip *net.IPAddr, lookupTime float64, returnerr error) {
var fallbackProtocol string
probeDNSLookupTimeSeconds := prometheus.NewGauge(prometheus.GaugeOpts{
Name: "probe_dns_lookup_time_seconds",
Expand All @@ -54,64 +59,48 @@ func chooseProtocol(ctx context.Context, IPProtocol string, fallbackIPProtocol b
IPProtocol = "ip4"
fallbackProtocol = "ip6"
}
var usedProtocol string

level.Info(logger).Log("msg", "Resolving target address", "ip_protocol", IPProtocol)
resolveStart := time.Now()

defer func() {
lookupTime = time.Since(resolveStart).Seconds()
probeDNSLookupTimeSeconds.Add(lookupTime)
if usedProtocol != "" {
probeIPProtocolGauge.Set(protocolToGauge[usedProtocol])
}
if ip != nil {
probeIPAddrHash.Set(ipHash(ip.IP))
}
}()

resolver := &net.Resolver{}
ips, err := resolver.LookupIPAddr(ctx, target)
if err != nil {
level.Error(logger).Log("msg", "Resolution with IP protocol failed", "err", err)
return nil, 0.0, err
}

// Return the IP in the requested protocol.
var fallback *net.IPAddr
for _, ip := range ips {
switch IPProtocol {
case "ip4":
if ip.IP.To4() != nil {
level.Info(logger).Log("msg", "Resolved target address", "ip", ip.String())
probeIPProtocolGauge.Set(4)
probeIPAddrHash.Set(ipHash(ip.IP))
return &ip, lookupTime, nil
}

// ip4 as fallback
fallback = &ip

case "ip6":
if ip.IP.To4() == nil {
level.Info(logger).Log("msg", "Resolved target address", "ip", ip.String())
probeIPProtocolGauge.Set(6)
probeIPAddrHash.Set(ipHash(ip.IP))
return &ip, lookupTime, nil
}

// ip6 as fallback
fallback = &ip
}
}

// Unable to find ip and no fallback set.
if fallback == nil || !fallbackIPProtocol {
return nil, 0.0, fmt.Errorf("unable to find ip; no fallback")
level.Info(logger).Log("msg", "Resolving target address", "ip_protocol", IPProtocol)
if ips, err := resolver.LookupIP(ctx, IPProtocol, target); err == nil {
level.Info(logger).Log("msg", "Resolved target address", "ip", ips[0].String())
usedProtocol = IPProtocol
ip = &net.IPAddr{IP: ips[0]}
return
} else if !fallbackIPProtocol {
level.Error(logger).Log("msg", "Resolution with IP protocol failed", "err", err)
returnerr = fmt.Errorf("unable to find ip; no fallback: %s", err)
return
}

// Use fallback ip protocol.
if fallbackProtocol == "ip4" {
probeIPProtocolGauge.Set(4)
} else {
probeIPProtocolGauge.Set(6)
level.Info(logger).Log("msg", "Resolving target address", "ip_protocol", fallbackProtocol)
ips, err := resolver.LookupIP(ctx, fallbackProtocol, target)
if err != nil {
// This could happen when the domain don't have A and AAAA record (e.g.
// only have MX record).
level.Error(logger).Log("msg", "Resolution with IP protocol failed", "err", err)
returnerr = fmt.Errorf("unable to find ip; exhausted fallback: %s", err)
return
}
probeIPAddrHash.Set(ipHash(fallback.IP))
level.Info(logger).Log("msg", "Resolved target address", "ip", fallback.String())
return fallback, lookupTime, nil
level.Info(logger).Log("msg", "Resolved target address", "ip", ips[0].String())
usedProtocol = fallbackProtocol
ip = &net.IPAddr{IP: ips[0]}
return
}

func ipHash(ip net.IP) float64 {
Expand Down
14 changes: 13 additions & 1 deletion prober/utils_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -24,6 +24,7 @@ import (
"math/big"
"net"
"os"
"strings"
"testing"
"time"

Expand Down Expand Up @@ -162,14 +163,25 @@ func TestChooseProtocol(t *testing.T) {
registry = prometheus.NewPedanticRegistry()

ip, _, err = chooseProtocol(ctx, "ip4", false, "ipv6.google.com", registry, logger)
if err != nil && err.Error() != "unable to find ip; no fallback" {
if err != nil && !strings.HasPrefix(err.Error(), "unable to find ip; no fallback") {
t.Error(err)
} else if err == nil {
t.Error("should set error")
}
if ip != nil {
t.Error("without fallback it should not answer")
}

registry = prometheus.NewPedanticRegistry()
ip, _, err = chooseProtocol(ctx, "ip4", true, "does-not-exist.example.com", registry, logger)
if err != nil && !strings.HasPrefix(err.Error(), "unable to find ip; exhausted fallback") {
t.Error(err)
} else if err == nil {
t.Error("should set error")
}
if ip != nil {
t.Error("with exhausted fallback it should not answer")
}
}

func checkMetrics(expected map[string]map[string]map[string]struct{}, mfs []*dto.MetricFamily, t *testing.T) {
Expand Down