chore(pod): retreive real container name from pod cache

Signed-off-by: Vimal Kumar <[email protected]>

Author: vimalk78

internal/k8s/pod/pod.go

@@ -37,7 +37,7 @@ type (
 	Informer interface {
 		service.Initializer
 		service.Runner
-		PodInfo(containerID string) (*PodInfo, error)
+		LookupByContainerID(containerID string) (*PodInfo, string, error)
 	}
 
 	PodInfo struct {
@@ -212,8 +212,8 @@ func (pi *podInformer) Run(ctx context.Context) error {
 	return pi.manager.Start(ctx)
 }
 
-// PodInfo retrieves pod details given a containerID
-func (pi *podInformer) PodInfo(containerID string) (*PodInfo, error) {
+// LookupByContainerID retrieves pod details and container name given a containerID
+func (pi *podInformer) LookupByContainerID(containerID string) (*PodInfo, string, error) {
 	var pods corev1.PodList
 
 	err := pi.manager.GetCache().List(
@@ -222,24 +222,25 @@ func (pi *podInformer) PodInfo(containerID string) (*PodInfo, error) {
 		client.MatchingFields{indexContainerID: containerID},
 	)
 	if err != nil {
-		return nil, fmt.Errorf("error retrieving pod info from cache: %w", err)
+		return nil, "", fmt.Errorf("error retrieving pod info from cache: %w", err)
 	}
 
 	if len(pods.Items) == 0 {
-		return nil, ErrNoPod
+		return nil, "", ErrNoPod
 	}
 
 	if len(pods.Items) > 1 {
-		return nil, fmt.Errorf("multiple pods found for containerID: %s", containerID)
+		return nil, "", fmt.Errorf("multiple pods found for containerID: %s", containerID)
 	}
 
 	pod := pods.Items[0]
-	pi.logger.Debug("pod found for container", "container", containerID, "pod", pod.Name)
+	containerName := pi.findContainerName(&pod, containerID)
+	pi.logger.Debug("pod found for container", "container", containerID, "pod", pod.Name, "containerName", containerName)
 	return &PodInfo{
 		ID:        string(pod.UID),
 		Name:      pod.Name,
 		Namespace: pod.Namespace,
-	}, nil
+	}, containerName, nil
 }
 
 func getConfig(kubeConfigPath string) (*rest.Config, error) {
@@ -273,3 +274,26 @@ func slogLevelToZapLevel(level slog.Level) zapcore.Level {
 		return zapcore.ErrorLevel
 	}
 }
+
+// findContainerName finds the container name for a given containerID in the pod
+func (pi *podInformer) findContainerName(pod *corev1.Pod, containerID string) string {
+	// Check regular containers
+	for _, status := range pod.Status.ContainerStatuses {
+		if status.ContainerID != "" && extractContainerID(status.ContainerID) == containerID {
+			return status.Name
+		}
+	}
+	// Check ephemeral containers
+	for _, status := range pod.Status.EphemeralContainerStatuses {
+		if status.ContainerID != "" && extractContainerID(status.ContainerID) == containerID {
+			return status.Name
+		}
+	}
+	// Check init containers
+	for _, status := range pod.Status.InitContainerStatuses {
+		if status.ContainerID != "" && extractContainerID(status.ContainerID) == containerID {
+			return status.Name
+		}
+	}
+	return ""
+}

internal/k8s/pod/pod_test.go

@@ -154,7 +154,7 @@ func TestPodInfo(t *testing.T) {
 			mock.Anything,
 			mock.Anything,
 		).Return(nil)
-		_, err := pi.PodInfo("container1")
+		_, _, err := pi.LookupByContainerID("container1")
 		assert.ErrorIs(t, err, ErrNoPod, "unexpected error returned")
 	})
 	t.Run("exactly one pod found", func(t *testing.T) {
@@ -179,11 +179,12 @@ func TestPodInfo(t *testing.T) {
 			pods := args.Get(1).(*corev1.PodList)
 			pods.Items = []corev1.Pod{pod1}
 		})
-		retPod, err := pi.PodInfo("container1")
+		retPod, containerName, err := pi.LookupByContainerID("container1")
 		assert.NoError(t, err)
 		assert.Equal(t, string(pod1.UID), retPod.ID, "unexpected pod id")
 		assert.Equal(t, pod1.Name, retPod.Name, "unexpected pod name")
 		assert.Equal(t, pod1.Namespace, retPod.Namespace, "unexpected pod namespace")
+		assert.Equal(t, "", containerName, "expected empty container name")
 	})
 	t.Run("more than one pod found", func(t *testing.T) {
 		pi := NewInformer()
@@ -207,7 +208,7 @@ func TestPodInfo(t *testing.T) {
 			pods := args.Get(1).(*corev1.PodList)
 			pods.Items = []corev1.Pod{pod1, pod1}
 		})
-		_, err := pi.PodInfo("container1")
+		_, _, err := pi.LookupByContainerID("container1")
 		assert.ErrorContains(t, err, "multiple pods found for containerID")
 	})
 	t.Run("cache error", func(t *testing.T) {
@@ -222,7 +223,7 @@ func TestPodInfo(t *testing.T) {
 			mock.Anything,
 			mock.Anything,
 		).Return(fmt.Errorf("!!you shall not pass!!"))
-		_, err := pi.PodInfo("container1")
+		_, _, err := pi.LookupByContainerID("container1")
 		assert.ErrorContains(t, err, "error retrieving pod info from cache")
 	})
 }
@@ -244,7 +245,7 @@ func TestPodInformer_RunIntegration(t *testing.T) {
 			},
 			Status: corev1.PodStatus{
 				ContainerStatuses: []corev1.ContainerStatus{
-					{ContainerID: "containerd://abc123"},
+					{Name: "test-container", ContainerID: "containerd://abc123"},
 				},
 			},
 		}
@@ -279,13 +280,14 @@ func TestPodInformer_RunIntegration(t *testing.T) {
 
 		time.Sleep(50 * time.Millisecond)
 
-		podInfo, err := pi.PodInfo("abc123")
+		podInfo, containerName, err := pi.LookupByContainerID("abc123")
 		if err != nil {
-			t.Logf("PodInfo lookup failed (expected in fake setup): %v", err)
+			t.Logf("LookupByContainerID lookup failed (expected in fake setup): %v", err)
 		} else {
 			assert.Equal(t, "test-pod", podInfo.Name)
 			assert.Equal(t, "default", podInfo.Namespace)
 			assert.Equal(t, "test-uid-123", podInfo.ID)
+			assert.Equal(t, "test-container", containerName)
 		}
 
 		cancel()
@@ -299,6 +301,112 @@ func TestPodInformer_RunIntegration(t *testing.T) {
 	})
 }
 
+func TestFindContainerName(t *testing.T) {
+	pi := NewInformer()
+
+	t.Run("find container in regular containers", func(t *testing.T) {
+		pod := &corev1.Pod{
+			Status: corev1.PodStatus{
+				ContainerStatuses: []corev1.ContainerStatus{
+					{Name: "app-container", ContainerID: "containerd://abc123"},
+					{Name: "sidecar-container", ContainerID: "containerd://def456"},
+				},
+			},
+		}
+		containerName := pi.findContainerName(pod, "abc123")
+		assert.Equal(t, "app-container", containerName)
+
+		containerName = pi.findContainerName(pod, "def456")
+		assert.Equal(t, "sidecar-container", containerName)
+	})
+
+	t.Run("find container in ephemeral containers", func(t *testing.T) {
+		pod := &corev1.Pod{
+			Status: corev1.PodStatus{
+				EphemeralContainerStatuses: []corev1.ContainerStatus{
+					{Name: "debug-container", ContainerID: "cri-o://ephemeral123"},
+				},
+			},
+		}
+		containerName := pi.findContainerName(pod, "ephemeral123")
+		assert.Equal(t, "debug-container", containerName)
+	})
+
+	t.Run("find container in init containers", func(t *testing.T) {
+		pod := &corev1.Pod{
+			Status: corev1.PodStatus{
+				InitContainerStatuses: []corev1.ContainerStatus{
+					{Name: "init-container", ContainerID: "containerd://init123"},
+				},
+			},
+		}
+		containerName := pi.findContainerName(pod, "init123")
+		assert.Equal(t, "init-container", containerName)
+	})
+
+	t.Run("container not found returns empty string", func(t *testing.T) {
+		pod := &corev1.Pod{
+			Status: corev1.PodStatus{
+				ContainerStatuses: []corev1.ContainerStatus{
+					{Name: "app-container", ContainerID: "containerd://abc123"},
+				},
+			},
+		}
+		containerName := pi.findContainerName(pod, "nonexistent")
+		assert.Equal(t, "", containerName)
+	})
+
+	t.Run("empty container ID in status", func(t *testing.T) {
+		pod := &corev1.Pod{
+			Status: corev1.PodStatus{
+				ContainerStatuses: []corev1.ContainerStatus{
+					{Name: "app-container", ContainerID: ""},
+					{Name: "running-container", ContainerID: "containerd://running123"},
+				},
+			},
+		}
+		containerName := pi.findContainerName(pod, "running123")
+		assert.Equal(t, "running-container", containerName)
+	})
+
+	t.Run("mixed container types", func(t *testing.T) {
+		pod := &corev1.Pod{
+			Status: corev1.PodStatus{
+				InitContainerStatuses: []corev1.ContainerStatus{
+					{Name: "init-container", ContainerID: "containerd://init123"},
+				},
+				ContainerStatuses: []corev1.ContainerStatus{
+					{Name: "app-container", ContainerID: "containerd://app123"},
+				},
+				EphemeralContainerStatuses: []corev1.ContainerStatus{
+					{Name: "debug-container", ContainerID: "cri-o://debug123"},
+				},
+			},
+		}
+
+		// Test finding in each type
+		assert.Equal(t, "init-container", pi.findContainerName(pod, "init123"))
+		assert.Equal(t, "app-container", pi.findContainerName(pod, "app123"))
+		assert.Equal(t, "debug-container", pi.findContainerName(pod, "debug123"))
+	})
+
+	t.Run("different container runtime prefixes", func(t *testing.T) {
+		pod := &corev1.Pod{
+			Status: corev1.PodStatus{
+				ContainerStatuses: []corev1.ContainerStatus{
+					{Name: "containerd-container", ContainerID: "containerd://containerd123"},
+					{Name: "crio-container", ContainerID: "cri-o://crio123"},
+					{Name: "docker-container", ContainerID: "docker://docker123"},
+				},
+			},
+		}
+
+		assert.Equal(t, "containerd-container", pi.findContainerName(pod, "containerd123"))
+		assert.Equal(t, "crio-container", pi.findContainerName(pod, "crio123"))
+		assert.Equal(t, "docker-container", pi.findContainerName(pod, "docker123"))
+	})
+}
+
 func TestSlogLevelToZapLevel(t *testing.T) {
 	tests := []struct {
 		input    slog.Level

internal/resource/informer.go

@@ -213,7 +213,7 @@ func (ri *resourceInformer) Refresh() error {
 	containersNoPod := []string{}
 	if ri.podInformer != nil {
 		for _, container := range containersRunning {
-			podInfo, err := ri.podInformer.PodInfo(container.ID)
+			podInfo, containerName, err := ri.podInformer.LookupByContainerID(container.ID)
 			if err != nil {
 				if errors.Is(err, pod.ErrNoPod) {
 					containersNoPod = append(containersNoPod, container.ID)
@@ -229,6 +229,7 @@ func (ri *resourceInformer) Refresh() error {
 				Namespace: podInfo.Namespace,
 			}
 			container.Pod = pod
+			container.Name = containerName
 			_, seen := podsRunning[pod.ID]
 			// reset CPU Time of the pod if it is getting added to the running list for the first time
 			// in the subsequent iteration, the CPUTimeDelta should be incremented by container's CPUTimeDelta

internal/resource/mock_procfs_test.go

@@ -102,12 +102,12 @@ func (m *mockPodInformer) Run(ctx context.Context) error {
 	return args.Error(0)
 }
 
-func (m *mockPodInformer) PodInfo(containerID string) (*pod.PodInfo, error) {
+func (m *mockPodInformer) LookupByContainerID(containerID string) (*pod.PodInfo, string, error) {
 	args := m.Called(containerID)
 	if podInfo, ok := args.Get(0).(*pod.PodInfo); ok {
-		return podInfo, args.Error(1)
+		return podInfo, args.String(1), args.Error(2)
 	}
-	return nil, args.Error(1)
+	return nil, args.String(1), args.Error(2)
 }
 
 func (m *mockPodInformer) Name() string {