[receiver/k8sclusterreceiver] Add missing attributes to entities in experimental entity feature

.chloggen/partial-fix-issue-39038.yaml

@@ -0,0 +1,27 @@
+# Use this changelog template to create an entry for release notes.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: enhancement
+
+# The name of the component, or a single word describing the area of concern, (e.g. filelogreceiver)
+component: k8sclusterreceiver
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Add missing attributes to entities in experimental entity feature
+
+# Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists.
+issues: [39038]
+
+# (Optional) One or more lines of additional information to render under the primary note.
+# These lines will be padded with 2 spaces and then inserted directly into the document.
+# Use pipe (|) for multiline entries.
+subtext:
+
+# If your change doesn't affect end users or the exported elements of any package,
+# you should instead start your pull request title with [chore] or use the "Skip Changelog" label.
+# Optional: The change log or logs in which this entry should be included.
+# e.g. '[user]' or '[user, api]'
+# Include 'user' if the change is relevant to end users.
+# Include 'api' if there is a change to a library API.
+# Default: '[user]'
+change_logs: [user]

receiver/k8sclusterreceiver/internal/constants/constants.go

@@ -14,11 +14,14 @@ const (
 	K8sKeyReplicationControllerUID = "k8s.replicationcontroller.uid"
 	K8sKeyResourceQuotaUID         = "k8s.resourcequota.uid"
 	K8sKeyClusterResourceQuotaUID  = "openshift.clusterquota.uid"
+	K8sKeyPodUID                   = "k8s.pod.uid"
 
 	// Resource labels keys for Name.
 	K8sKeyReplicationControllerName = "k8s.replicationcontroller.name"
 	K8sKeyResourceQuotaName         = "k8s.resourcequota.name"
 	K8sKeyClusterResourceQuotaName  = "openshift.clusterquota.name"
+	K8sKeyNamespaceName             = "k8s.namespace.name"
+	K8sKeyPodName                   = "k8s.pod.name"
 
 	// Kubernetes resource kinds
 	K8sKindCronJob               = "CronJob"

receiver/k8sclusterreceiver/internal/container/containers.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/open-telemetry/opentelemetry-collector-contrib/internal/common/docker"
 	metadataPkg "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/experimentalmetricmetadata"
+	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8sclusterreceiver/internal/constants"
 	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8sclusterreceiver/internal/metadata"
 	imetadata "github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8sclusterreceiver/internal/metadata"
 	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8sclusterreceiver/internal/utils"
@@ -23,6 +24,9 @@ const (
 	containerKeyStatus         = "container.status"
 	containerKeyStatusReason   = "container.status.reason"
 	containerCreationTimestamp = "container.creation_timestamp"
+	containerName              = "container.name"
+	containerID                = "container.uid"
+	containerImage             = "container.image"
 
 	// Values for container metadata
 	containerStatusRunning    = "running"
@@ -96,9 +100,14 @@ func RecordSpecMetrics(logger *zap.Logger, mb *imetadata.MetricsBuilder, c corev
 	mb.EmitForResource(imetadata.WithResource(rb.Emit()))
 }
 
-func GetMetadata(cs corev1.ContainerStatus) *metadata.KubernetesMetadata {
+func GetMetadata(pod *corev1.Pod, cs corev1.ContainerStatus) *metadata.KubernetesMetadata {
 	mdata := map[string]string{}
 
+	mdata[containerName] = cs.Name
+	mdata[containerImage] = cs.Image
+	mdata[constants.K8sKeyPodName] = pod.Name
+	mdata[constants.K8sKeyPodUID] = string(pod.UID)
+
 	if cs.State.Running != nil {
 		mdata[containerKeyStatus] = containerStatusRunning
 		if !cs.State.Running.StartedAt.IsZero() {

receiver/k8sclusterreceiver/internal/container/containers_test.go

@@ -11,16 +11,32 @@ import (
 	"github.com/stretchr/testify/require"
 	corev1 "k8s.io/api/core/v1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+
+	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8sclusterreceiver/internal/constants"
 )
 
 func TestGetMetadata(t *testing.T) {
 	refTime := v1.Now()
+	pod := &corev1.Pod{
+		ObjectMeta: v1.ObjectMeta{
+			Name:      "test-pod",
+			Namespace: "test-namespace",
+			UID:       types.UID("test-pod-uid"),
+		},
+	}
+
 	tests := []struct {
 		name              string
 		containerState    corev1.ContainerState
 		expectedStatus    string
 		expectedReason    string
 		expectedStartedAt string
+		containerName     string
+		containerID       string
+		containerImage    string
+		podName           string
+		podUID            string
 	}{
 		{
 			name: "Running container",
@@ -31,6 +47,11 @@ func TestGetMetadata(t *testing.T) {
 			},
 			expectedStatus:    containerStatusRunning,
 			expectedStartedAt: refTime.Format(time.RFC3339),
+			containerName:     "my-test-container1",
+			containerID:       "f37ee861-f093-4cea-aa26-f39fff8b0998",
+			containerImage:    "docker/someimage1",
+			podName:           pod.Name,
+			podUID:            string(pod.UID),
 		},
 		{
 			name: "Terminated container",
@@ -46,6 +67,11 @@ func TestGetMetadata(t *testing.T) {
 			expectedStatus:    containerStatusTerminated,
 			expectedReason:    "Completed",
 			expectedStartedAt: refTime.Format(time.RFC3339),
+			containerName:     "my-test-container2",
+			containerID:       "f37ee861-f093-4cea-aa26-f39fff8b0997",
+			containerImage:    "docker/someimage2",
+			podName:           pod.Name,
+			podUID:            string(pod.UID),
 		},
 		{
 			name: "Waiting container",
@@ -56,15 +82,23 @@ func TestGetMetadata(t *testing.T) {
 			},
 			expectedStatus: containerStatusWaiting,
 			expectedReason: "CrashLoopBackOff",
+			containerName:  "my-test-container3",
+			containerID:    "f37ee861-f093-4cea-aa26-f39fff8b0996",
+			containerImage: "docker/someimage3",
+			podName:        pod.Name,
+			podUID:         string(pod.UID),
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			cs := corev1.ContainerStatus{
-				State: tt.containerState,
+				State:       tt.containerState,
+				Name:        tt.containerName,
+				ContainerID: tt.containerID,
+				Image:       tt.containerImage,
 			}
-			md := GetMetadata(cs)
+			md := GetMetadata(pod, cs)
 
 			require.NotNil(t, md)
 			assert.Equal(t, tt.expectedStatus, md.Metadata[containerKeyStatus])
@@ -75,6 +109,10 @@ func TestGetMetadata(t *testing.T) {
 				assert.Contains(t, md.Metadata, containerCreationTimestamp)
 				assert.Equal(t, tt.expectedStartedAt, md.Metadata[containerCreationTimestamp])
 			}
+			assert.Equal(t, tt.containerName, md.Metadata[containerName])
+			assert.Equal(t, tt.containerImage, md.Metadata[containerImage])
+			assert.Equal(t, tt.podName, md.Metadata[constants.K8sKeyPodName])
+			assert.Equal(t, tt.podUID, md.Metadata[constants.K8sKeyPodUID])
 		})
 	}
 }

receiver/k8sclusterreceiver/internal/cronjob/cronjobs_test.go

@@ -59,6 +59,7 @@ func TestCronJobMetadata(t *testing.T) {
 				"concurrency_policy":         "concurrency_policy",
 				"k8s.workload.kind":          "CronJob",
 				"k8s.workload.name":          "test-cronjob-1",
+				"k8s.namespace.name":         "test-namespace",
 			},
 		},
 		*actualMetadata["test-cronjob-1-uid"],

receiver/k8sclusterreceiver/internal/metadata/metadata.go

@@ -55,6 +55,7 @@ func GetGenericMetadata(om *v1.ObjectMeta, resourceType string) *KubernetesMetad
 	metadata[constants.K8sKeyWorkLoadKind] = resourceType
 	metadata[constants.K8sKeyWorkLoadName] = om.Name
 	metadata[rType+".creation_timestamp"] = om.GetCreationTimestamp().Format(time.RFC3339)
+	metadata[constants.K8sKeyNamespaceName] = om.Namespace
 
 	for _, or := range om.OwnerReferences {
 		kind := strings.ToLower(or.Kind)

receiver/k8sclusterreceiver/internal/metadata/metadata_test.go

@@ -19,6 +19,7 @@ func Test_getGenericMetadata(t *testing.T) {
 	om := &v1.ObjectMeta{
 		Name:              "test-name",
 		UID:               "test-uid",
+		Namespace:         "test-namespace",
 		Generation:        0,
 		CreationTimestamp: v1.NewTime(now),
 		Labels: map[string]string{
@@ -46,6 +47,7 @@ func Test_getGenericMetadata(t *testing.T) {
 	assert.Equal(t, map[string]string{
 		"k8s.workload.name":               "test-name",
 		"k8s.workload.kind":               "ResourceType",
+		"k8s.namespace.name":              "test-namespace",
 		"resourcetype.creation_timestamp": now.Format(time.RFC3339),
 		"k8s.owner-kind-1.name":           "owner1",
 		"k8s.owner-kind-1.uid":            "owner1",

receiver/k8sclusterreceiver/internal/pod/pods.go

@@ -164,6 +164,9 @@ func GetMetadata(pod *corev1.Pod, mc *metadata.Store, logger *zap.Logger) map[ex
 		meta = maps.MergeStringMaps(meta, collectPodReplicaSetProperties(pod, store, logger))
 	}
 
+	meta[constants.K8sKeyNamespaceName] = pod.Namespace
+	meta[constants.K8sKeyPodName] = pod.Name
+
 	podID := experimentalmetricmetadata.ResourceID(pod.UID)
 	return metadata.MergeKubernetesMetadataMaps(map[experimentalmetricmetadata.ResourceID]*metadata.KubernetesMetadata{
 		podID: {
@@ -252,7 +255,7 @@ func getWorkloadProperties(ref *v1.OwnerReference, labelKey string) map[string]s
 func getPodContainerProperties(pod *corev1.Pod) map[experimentalmetricmetadata.ResourceID]*metadata.KubernetesMetadata {
 	km := map[experimentalmetricmetadata.ResourceID]*metadata.KubernetesMetadata{}
 	for _, cs := range pod.Status.ContainerStatuses {
-		md := container.GetMetadata(cs)
+		md := container.GetMetadata(pod, cs)
 		km[md.ResourceID] = md
 	}
 	return km

receiver/k8sclusterreceiver/internal/pod/pods_test.go

@@ -235,8 +235,10 @@ func testCaseForPodWorkload(to testCaseOptions) testCase {
 
 func expectedKubernetesMetadata(to testCaseOptions) map[experimentalmetricmetadata.ResourceID]*metadata.KubernetesMetadata {
 	podUIDLabel := "test-pod-0-uid"
+	podNameLabel := "test-pod-0"
 	kindLower := strings.ToLower(to.kind)
 	kindObjName := fmt.Sprintf("test-%s-0", kindLower)
+	namespaceLabel := "test-namespace"
 	kindObjUID := fmt.Sprintf("test-%s-0-uid", kindLower)
 	kindNameLabel := fmt.Sprintf("k8s.%s.name", kindLower)
 	kindUIDLabel := fmt.Sprintf("k8s.%s.uid", kindLower)
@@ -247,9 +249,11 @@ func expectedKubernetesMetadata(to testCaseOptions) map[experimentalmetricmetada
 			ResourceIDKey: "k8s.pod.uid",
 			ResourceID:    experimentalmetricmetadata.ResourceID(podUIDLabel),
 			Metadata: map[string]string{
-				kindNameLabel:   kindObjName,
-				kindUIDLabel:    kindObjUID,
-				"k8s.pod.phase": "Unknown", // Default value when phase is not set.
+				kindNameLabel:        kindObjName,
+				kindUIDLabel:         kindObjUID,
+				"k8s.pod.phase":      "Unknown", // Default value when phase is not set.
+				"k8s.namespace.name": namespaceLabel,
+				"k8s.pod.name":       podNameLabel,
 			},
 		},
 	}
@@ -485,6 +489,8 @@ func TestTransform(t *testing.T) {
 func TestPodMetadata(t *testing.T) {
 	tests := []struct {
 		name             string
+		podName          string
+		namespace        string
 		statusPhase      corev1.PodPhase
 		statusReason     string
 		expectedMetadata map[string]string
@@ -494,6 +500,8 @@ func TestPodMetadata(t *testing.T) {
 			statusPhase:  corev1.PodFailed,
 			statusReason: "Evicted",
 			expectedMetadata: map[string]string{
+				"k8s.pod.name":          "test-pod-0",
+				"k8s.namespace.name":    "test-namespace",
 				"k8s.pod.phase":         "Failed",
 				"k8s.pod.status_reason": "Evicted",
 				"k8s.workload.kind":     "Deployment",
@@ -509,6 +517,8 @@ func TestPodMetadata(t *testing.T) {
 			statusPhase:  corev1.PodRunning,
 			statusReason: "",
 			expectedMetadata: map[string]string{
+				"k8s.pod.name":        "test-pod-0",
+				"k8s.namespace.name":  "test-namespace",
 				"k8s.pod.phase":       "Running",
 				"k8s.workload.kind":   "Deployment",
 				"k8s.workload.name":   "test-deployment-0",

receiver/k8sclusterreceiver/internal/statefulset/statefulsets_test.go

@@ -66,6 +66,7 @@ func TestStatefulsetMetadata(t *testing.T) {
 			Metadata: map[string]string{
 				"k8s.workload.name":              "test-statefulset-1",
 				"k8s.workload.kind":              "StatefulSet",
+				"k8s.namespace.name":             "test-namespace",
 				"statefulset.creation_timestamp": "0001-01-01T00:00:00Z",
 				"foo":                            "bar",
 				"foo1":                           "",

receiver/k8sclusterreceiver/watcher_test.go

@@ -270,7 +270,7 @@ func TestSyncMetadataAndEmitEntityEvents(t *testing.T) {
 		"otel.entity.interval":   int64(7200000), // 2h in milliseconds
 		"otel.entity.type":       "k8s.pod",
 		"otel.entity.id":         map[string]any{"k8s.pod.uid": "pod0"},
-		"otel.entity.attributes": map[string]any{"pod.creation_timestamp": "0001-01-01T00:00:00Z", "k8s.pod.phase": "Unknown"},
+		"otel.entity.attributes": map[string]any{"pod.creation_timestamp": "0001-01-01T00:00:00Z", "k8s.pod.phase": "Unknown", "k8s.namespace.name": "test", "k8s.pod.name": "0"},
 	}
 	assert.EqualValues(t, expected, lr.Attributes().AsRaw())
 	assert.WithinRange(t, lr.Timestamp().AsTime(), step1, step2)
@@ -324,7 +324,7 @@ func TestObjMetadata(t *testing.T) {
 					EntityType:    "k8s.pod",
 					ResourceIDKey: "k8s.pod.uid",
 					ResourceID:    "test-pod-0-uid",
-					Metadata:      allPodMetadata(map[string]string{"k8s.pod.phase": "Succeeded"}),
+					Metadata:      allPodMetadata(map[string]string{"k8s.pod.phase": "Succeeded", "k8s.pod.name": "test-pod-0", "k8s.namespace.name": "test-namespace"}),
 				},
 				experimentalmetricmetadata.ResourceID("container-id"): {
 					EntityType:    "container",
@@ -333,6 +333,10 @@ func TestObjMetadata(t *testing.T) {
 					Metadata: map[string]string{
 						"container.status":             "running",
 						"container.creation_timestamp": "0001-01-01T01:01:01Z",
+						"container.image":              "container-image-name",
+						"container.name":               "container-name",
+						"k8s.pod.name":                 "test-pod-0",
+						"k8s.pod.uid":                  "test-pod-0-uid",
 					},
 				},
 			},
@@ -359,6 +363,8 @@ func TestObjMetadata(t *testing.T) {
 						"k8s.statefulset.uid":   "test-statefulset-0-uid",
 						"k8s.pod.phase":         "Failed",
 						"k8s.pod.status_reason": "Evicted",
+						"k8s.pod.name":          "test-pod-0",
+						"k8s.namespace.name":    "test-namespace",
 					}),
 				},
 			},
@@ -398,6 +404,8 @@ func TestObjMetadata(t *testing.T) {
 						"k8s.service.test-service": "",
 						"k8s-app":                  "my-app",
 						"k8s.pod.phase":            "Running",
+						"k8s.namespace.name":       "test-namespace",
+						"k8s.pod.name":             "test-pod-0",
 					}),
 				},
 			},
@@ -415,6 +423,7 @@ func TestObjMetadata(t *testing.T) {
 						"k8s.workload.kind":            "DaemonSet",
 						"k8s.workload.name":            "test-daemonset-1",
 						"daemonset.creation_timestamp": "0001-01-01T00:00:00Z",
+						"k8s.namespace.name":           "test-namespace",
 					},
 				},
 			},
@@ -433,6 +442,7 @@ func TestObjMetadata(t *testing.T) {
 						"k8s.workload.name":             "test-deployment-1",
 						"k8s.deployment.name":           "test-deployment-1",
 						"deployment.creation_timestamp": "0001-01-01T00:00:00Z",
+						"k8s.namespace.name":            "test-namespace",
 					},
 				},
 			},
@@ -450,6 +460,7 @@ func TestObjMetadata(t *testing.T) {
 						"k8s.workload.kind":      "HPA",
 						"k8s.workload.name":      "test-hpa-1",
 						"hpa.creation_timestamp": "0001-01-01T00:00:00Z",
+						"k8s.namespace.name":     "test-namespace",
 					},
 				},
 			},
@@ -469,6 +480,7 @@ func TestObjMetadata(t *testing.T) {
 						"k8s.workload.kind":      "Job",
 						"k8s.workload.name":      "test-job-1",
 						"job.creation_timestamp": "0001-01-01T00:00:00Z",
+						"k8s.namespace.name":     "test-namespace",
 					},
 				},
 			},
@@ -511,6 +523,7 @@ func TestObjMetadata(t *testing.T) {
 						"k8s.workload.kind":             "ReplicaSet",
 						"k8s.workload.name":             "test-replicaset-1",
 						"replicaset.creation_timestamp": "0001-01-01T00:00:00Z",
+						"k8s.namespace.name":            "test-namespace",
 					},
 				},
 			},
@@ -534,6 +547,7 @@ func TestObjMetadata(t *testing.T) {
 						"k8s.workload.kind":                        "ReplicationController",
 						"k8s.workload.name":                        "test-replicationcontroller-1",
 						"replicationcontroller.creation_timestamp": "0001-01-01T00:00:00Z",
+						"k8s.namespace.name":                       "test-namespace",
 					},
 				},
 			},