fix: fix for external domain resolution

.github/workflows/dev-ci.yaml

@@ -35,7 +35,7 @@ jobs:
       - name: Build and Push Agent Image
         uses: docker/build-push-action@v3
         with:
-          platforms: linux/amd64,linux/arm64
+          platforms: linux/amd64
           context: .
           file: 'Dockerfile'
           push: true

common/net.go

@@ -218,26 +218,27 @@ func (d *Domain) String() string {
 
 func NewDomain(fqdn string, ips []netaddr.IP) *Domain {
 	d := &Domain{FQDN: fqdn, SpecifyIP: true}
-	if len(ips) > 1 {
-		containsPrivateIPs := false
-		for _, ip := range ips {
-			if !IsIpExternal(ip) {
-				containsPrivateIPs = true
-				break
-			}
-		}
-		if !containsPrivateIPs {
-			d.SpecifyIP = false
-		}
-	}
 	return d
 }
 
 func NewDestinationKey(dst, actualDst netaddr.IPPort, domain *Domain, dstWorkload Workload, actualDestWorkload Workload) DestinationKey {
 	if IsIpExternal(actualDst.IP()) && domain != nil && !domain.SpecifyIP {
 		return DestinationKey{
-			destination: HostPortWithEmptyIP(domain.FQDN, dst.Port()),
+			destination:       HostPortWithEmptyIP(domain.FQDN, dst.Port()),
+			actualDestination: HostPortFromIPPort(actualDst),
+			destinationWorkload: Workload{
+				Kind:      "external",
+				Name:      domain.FQDN,
+				Namespace: "external",
+			},
+			actualDestinationWorkload: Workload{
+				Kind:      "external",
+				Name:      actualDst.IP().String(),
+				Namespace: "external",
+			},
 		}
+	} else if IsIpExternal(actualDst.IP()) && domain != nil && domain.SpecifyIP {
+		klog.Infof("ip %q is external, but domain %q specifies IP, using IP as destination", actualDst.IP(), domain.FQDN)
 	}
 	return DestinationKey{
 		destination:               HostPortFromIPPort(dst),

common/net_test.go

@@ -33,7 +33,7 @@ func TestDestinationKey(t *testing.T) {
 	assert.Equal(t, "1.1.1.1:443 (2.2.2.2:443)", NewDestinationKey(d, ad, nil, Workload{}, Workload{}).String())
 
 	assert.Equal(t,
-		"aa.bb.s3.amazonaws.com:443 ()",
+		"aa.bb.s3.amazonaws.com:443 (2.2.2.2:443)",
 		NewDestinationKey(d, ad, &Domain{FQDN: "aa.bb.s3.amazonaws.com", SpecifyIP: false}, Workload{}, Workload{}).String(),
 	)
 	assert.Equal(t,
@@ -51,7 +51,7 @@ func TestDomain(t *testing.T) {
 	assert.Equal(t, "Domain(fqdn,true)", NewDomain("fqdn", []netaddr.IP{
 		netaddr.MustParseIP("1.1.1.1"),
 	}).String())
-	assert.Equal(t, "Domain(fqdn,false)", NewDomain("fqdn", []netaddr.IP{
+	assert.Equal(t, "Domain(fqdn,true)", NewDomain("fqdn", []netaddr.IP{
 		netaddr.MustParseIP("1.1.1.1"),
 		netaddr.MustParseIP("1.1.1.2"),
 	}).String())

containers/container.go

@@ -763,7 +763,7 @@ func (c *Container) onDNSRequest(r *l7.RequestData) map[netaddr.IP]*common.Domai
 	return ip2fqdn
 }
 
-func (c *Container) onL7Request(pid uint32, fd uint64, timestamp uint64, r *l7.RequestData, iqfqdn map[netaddr.IP]*common.Domain) map[netaddr.IP]*common.Domain {
+func (c *Container) onL7Request(pid uint32, fd uint64, timestamp uint64, r *l7.RequestData) map[netaddr.IP]*common.Domain {
 	c.lock.Lock()
 	defer c.lock.Unlock()
 
@@ -778,17 +778,6 @@ func (c *Container) onL7Request(pid uint32, fd uint64, timestamp uint64, r *l7.R
 	if timestamp != 0 && conn.Timestamp != timestamp {
 		return nil
 	}
-	if conn.dstWorkload.Namespace == "external" && (r.Protocol == l7.ProtocolHTTP || r.Protocol == l7.ProtocolHTTP2) {
-		if host, ok := iqfqdn[conn.DestinationKey.ActualDestination().IP()]; ok {
-			log.Printf("Setting external host %s", host)
-			conn.dstWorkload.Name = host.FQDN
-		} else {
-			host, error := l7.ParseHostFromHttpRequest(string(r.Payload))
-			if error == nil {
-				conn.dstWorkload.Name = host
-			}
-		}
-	}
 
 	// Parse HTTP request once if needed
 	var req *http.Request
@@ -806,7 +795,7 @@ func (c *Container) onL7Request(pid uint32, fd uint64, timestamp uint64, r *l7.R
 	if headers != nil {
 		traceId = trace.ExtractTraceId(headers)
 	}
-	stats := c.l7Stats.get(r.Protocol, conn.DestinationKey, r, conn.srcWorkload, conn.DestinationKey.GetDestinationWorkload(), conn.DestinationKey.GetActualDestinationWorkload(), traceId)
+	stats := c.l7Stats.get(r.Protocol, conn.DestinationKey, r, conn.srcWorkload, traceId)
 	switch r.Protocol {
 	case l7.ProtocolHTTP:
 		stats.observe(r.Status.Http(), "", r.Duration)

containers/l7.go

@@ -38,7 +38,7 @@ func (m *L7Metrics) observe(status, method string, duration time.Duration) {
 
 type L7Stats map[l7.Protocol]map[common.DestinationKey]*L7Metrics // protocol -> dst:actual_dst -> metrics
 
-func (s L7Stats) get(protocol l7.Protocol, key common.DestinationKey, r *l7.RequestData, srcWorkload common.Workload, dstWorkload common.Workload, actualDstWorkload common.Workload, traceId string) *L7Metrics {
+func (s L7Stats) get(protocol l7.Protocol, key common.DestinationKey, r *l7.RequestData, srcWorkload common.Workload, traceId string) *L7Metrics {
 	if protocol == l7.ProtocolHTTP2 {
 		protocol = l7.ProtocolHTTP
 	}
@@ -53,15 +53,15 @@ func (s L7Stats) get(protocol l7.Protocol, key common.DestinationKey, r *l7.Requ
 		protoStats[key] = m
 		constLabels := map[string]string{"destination": key.DestinationLabelValue(),
 			"actual_destination":                    key.ActualDestinationLabelValue(),
-			"destination_workload_kind":             dstWorkload.Kind,
-			"destination_workload_name":             dstWorkload.Name,
-			"destination_workload_namespace":        dstWorkload.Namespace,
+			"destination_workload_kind":             key.GetDestinationWorkload().Kind,
+			"destination_workload_name":             key.GetDestinationWorkload().Name,
+			"destination_workload_namespace":        key.GetDestinationWorkload().Namespace,
 			"src_workload_kind":                     srcWorkload.Kind,
 			"src_workload_name":                     srcWorkload.Name,
 			"src_workload_namespace":                srcWorkload.Namespace,
-			"actual_destination_workload_kind":      actualDstWorkload.Kind,
-			"actual_destination_workload_name":      actualDstWorkload.Name,
-			"actual_destination_workload_namespace": actualDstWorkload.Namespace,
+			"actual_destination_workload_kind":      key.GetActualDestinationWorkload().Kind,
+			"actual_destination_workload_name":      key.GetActualDestinationWorkload().Name,
+			"actual_destination_workload_namespace": key.GetActualDestinationWorkload().Namespace,
 		}
 		if traceId != "" {
 			constLabels["trace_id"] = traceId

containers/registry.go

@@ -294,7 +294,7 @@ func (r *Registry) handleEvents(ch <-chan ebpftracer.Event) {
 					continue
 				}
 				if c := r.containersByPid[e.Pid]; c != nil {
-					ip2fqdn := c.onL7Request(e.Pid, e.Fd, e.Timestamp, e.L7Request, r.ip2fqdn)
+					ip2fqdn := c.onL7Request(e.Pid, e.Fd, e.Timestamp, e.L7Request)
 					r.ip2fqdnLock.Lock()
 					for ip, domain := range ip2fqdn {
 						r.ip2fqdn[ip] = domain