[chore] remove utils internal package (#43637)

Moving funcs in use to different package

Part of
#41780

---------

Signed-off-by: alex boten <223565+codeboten@users.noreply.github.com>

Author: codeboten

receiver/k8sclusterreceiver/internal/container/containers.go

@@ -4,6 +4,7 @@
 package container // import "github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8sclusterreceiver/internal/container"
 
 import (
+	"regexp"
 	"time"
 
 	"go.opentelemetry.io/collector/pdata/pcommon"
@@ -15,7 +16,6 @@ import (
 	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"
-	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8sclusterreceiver/internal/utils"
 )
 
 const (
@@ -134,7 +134,7 @@ func RecordSpecMetrics(logger *zap.Logger, mb *metadata.MetricsBuilder, c corev1
 	rb.SetK8sPodName(pod.Name)
 	rb.SetK8sNodeName(pod.Spec.NodeName)
 	rb.SetK8sNamespaceName(pod.Namespace)
-	rb.SetContainerID(utils.StripContainerID(containerID))
+	rb.SetContainerID(stripContainerID(containerID))
 	rb.SetK8sContainerName(c.Name)
 	image, err := docker.ParseImageName(imageStr)
 	if err != nil {
@@ -186,7 +186,7 @@ func GetMetadata(pod *corev1.Pod, cs corev1.ContainerStatus, logger *zap.Logger)
 	return &metadata.KubernetesMetadata{
 		EntityType:    "container",
 		ResourceIDKey: string(conventions.ContainerIDKey),
-		ResourceID:    metadataPkg.ResourceID(utils.StripContainerID(cs.ContainerID)),
+		ResourceID:    metadataPkg.ResourceID(stripContainerID(cs.ContainerID)),
 		Metadata:      mdata,
 	}
 }
@@ -197,3 +197,10 @@ func boolToInt64(b bool) int64 {
 	}
 	return 0
 }
+
+var re = regexp.MustCompile(`^[\w_-]+://`)
+
+// stripContainerID returns a pure container id without the runtime scheme://.
+func stripContainerID(id string) string {
+	return re.ReplaceAllString(id, "")
+}

receiver/k8sclusterreceiver/internal/pod/pods.go

@@ -25,7 +25,6 @@ import (
 	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8sclusterreceiver/internal/gvk"
 	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8sclusterreceiver/internal/metadata"
 	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8sclusterreceiver/internal/service"
-	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8sclusterreceiver/internal/utils"
 )
 
 const (
@@ -184,12 +183,12 @@ func GetMetadata(pod *corev1.Pod, mc *metadata.Store, logger *zap.Logger) map[ex
 // collectPodJobProperties checks if pod owner of type Job is cached. Check owners reference
 // on Job to see if it was created by a CronJob. Sync metadata accordingly.
 func collectPodJobProperties(pod *corev1.Pod, jobStores map[string]cache.Store, logger *zap.Logger) map[string]string {
-	jobRef := utils.FindOwnerWithKind(pod.OwnerReferences, constants.K8sKindJob)
+	jobRef := findOwnerWithKind(pod.OwnerReferences, constants.K8sKindJob)
 	if jobRef != nil {
 		var job any
 		var err error
 
-		job, err = utils.GetObjectFromStore(pod.Namespace, jobRef.Name, jobStores)
+		job, err = getObjectFromStore(pod.Namespace, jobRef.Name, jobStores)
 		if err != nil {
 			logError(err, jobRef, pod.UID, logger)
 			return nil
@@ -204,7 +203,7 @@ func collectPodJobProperties(pod *corev1.Pod, jobStores map[string]cache.Store,
 			logError(fmt.Errorf("cannot cast %T to *batchv1.Job", job), jobRef, pod.UID, logger)
 			return nil
 		}
-		if cronJobRef := utils.FindOwnerWithKind(jobObj.OwnerReferences, constants.K8sKindCronJob); cronJobRef != nil {
+		if cronJobRef := findOwnerWithKind(jobObj.OwnerReferences, constants.K8sKindCronJob); cronJobRef != nil {
 			return getWorkloadProperties(cronJobRef, string(conventions.K8SCronJobNameKey))
 		}
 		return getWorkloadProperties(jobRef, string(conventions.K8SJobNameKey))
@@ -215,12 +214,12 @@ func collectPodJobProperties(pod *corev1.Pod, jobStores map[string]cache.Store,
 // collectPodReplicaSetProperties checks if pod owner of type ReplicaSet is cached. Check owners reference
 // on ReplicaSet to see if it was created by a Deployment. Sync metadata accordingly.
 func collectPodReplicaSetProperties(pod *corev1.Pod, replicaSetStores map[string]cache.Store, logger *zap.Logger) map[string]string {
-	rsRef := utils.FindOwnerWithKind(pod.OwnerReferences, constants.K8sKindReplicaSet)
+	rsRef := findOwnerWithKind(pod.OwnerReferences, constants.K8sKindReplicaSet)
 	if rsRef != nil {
 		var replicaSet any
 		var err error
 
-		replicaSet, err = utils.GetObjectFromStore(pod.Namespace, rsRef.Name, replicaSetStores)
+		replicaSet, err = getObjectFromStore(pod.Namespace, rsRef.Name, replicaSetStores)
 		if err != nil {
 			logError(err, rsRef, pod.UID, logger)
 			return nil
@@ -235,7 +234,7 @@ func collectPodReplicaSetProperties(pod *corev1.Pod, replicaSetStores map[string
 			logError(fmt.Errorf("cannot cast %T to *appsv1.ReplicaSet", replicaSet), rsRef, pod.UID, logger)
 			return nil
 		}
-		if deployRef := utils.FindOwnerWithKind(replicaSetObj.OwnerReferences, constants.K8sKindDeployment); deployRef != nil {
+		if deployRef := findOwnerWithKind(replicaSetObj.OwnerReferences, constants.K8sKindDeployment); deployRef != nil {
 			return getWorkloadProperties(deployRef, string(conventions.K8SDeploymentNameKey))
 		}
 		return getWorkloadProperties(rsRef, string(conventions.K8SReplicaSetNameKey))
@@ -280,3 +279,38 @@ func getPodContainerProperties(pod *corev1.Pod, logger *zap.Logger) map[experime
 	}
 	return km
 }
+
+// getIDForCache returns keys to lookup resources from the cache exposed
+// by shared informers.
+func getIDForCache(namespace, resourceName string) string {
+	return fmt.Sprintf("%s/%s", namespace, resourceName)
+}
+
+// getObjectFromStore retrieves the requested object from the given stores.
+// first, the object is attempted to be retrieved from the store for all namespaces,
+// and if it is not found there, the namespace-specific store is used
+func getObjectFromStore(namespace, objName string, stores map[string]cache.Store) (any, error) {
+	for _, storeKey := range [2]string{metadata.ClusterWideInformerKey, namespace} {
+		if store, ok := stores[storeKey]; ok {
+			obj, exists, err := store.GetByKey(getIDForCache(namespace, objName))
+			if err != nil {
+				return nil, err
+			}
+			if exists {
+				return obj, nil
+			}
+		}
+	}
+	return nil, nil
+}
+
+// findOwnerWithKind returns the OwnerReference of the matching kind from
+// the provided list of owner references.
+func findOwnerWithKind(ors []v1.OwnerReference, kind string) *v1.OwnerReference {
+	for _, or := range ors {
+		if or.Kind == kind {
+			return &or
+		}
+	}
+	return nil
+}

receiver/k8sclusterreceiver/internal/pod/pods_test.go

@@ -673,3 +673,78 @@ func TestPodContainerReasonMetrics(t *testing.T) {
 	),
 	)
 }
+
+func TestGetIDForCache(t *testing.T) {
+	ns := "namespace"
+	resName := "resName"
+
+	actual := getIDForCache(ns, resName)
+
+	require.Equal(t, ns+"/"+resName, actual)
+}
+
+func TestGetObjectFromStore_ObjectInClusterWideStore(t *testing.T) {
+	ms := metadata.NewStore()
+
+	store := &testutils.MockStore{
+		Cache: map[string]any{},
+	}
+
+	ms.Setup(gvk.Job, metadata.ClusterWideInformerKey, store)
+	store.Cache["test-namespace/test-job-0"] = testutils.NewJob("0")
+
+	obj, err := getObjectFromStore("test-namespace", "test-job-0", ms.Get(gvk.Job))
+
+	require.NoError(t, err)
+	require.NotNil(t, obj)
+}
+
+func TestGetObjectFromStore_ObjectInNamespacedStore(t *testing.T) {
+	ms := metadata.NewStore()
+
+	store := &testutils.MockStore{
+		Cache: map[string]any{},
+	}
+
+	ms.Setup(gvk.Job, "test-namespace", store)
+	store.Cache["test-namespace/test-job-0"] = testutils.NewJob("0")
+
+	obj, err := getObjectFromStore("test-namespace", "test-job-0", ms.Get(gvk.Job))
+
+	require.NoError(t, err)
+	require.NotNil(t, obj)
+}
+
+func TestGetObjectFromStore_ObjectNotFound(t *testing.T) {
+	ms := metadata.NewStore()
+
+	store := &testutils.MockStore{
+		Cache: map[string]any{},
+	}
+
+	ms.Setup(gvk.Job, "other-test-namespace", store)
+	store.Cache["test-namespace/test-job-0"] = testutils.NewJob("0")
+
+	obj, err := getObjectFromStore("test-namespace", "test-job-0", ms.Get(gvk.Job))
+
+	require.NoError(t, err)
+	require.Nil(t, obj)
+}
+
+func TestGetObjectFromStore_ReturnsError(t *testing.T) {
+	ms := metadata.NewStore()
+
+	store := &testutils.MockStore{
+		Cache: map[string]any{},
+	}
+
+	store.WantErr = true
+
+	ms.Setup(gvk.Job, "test-namespace", store)
+	store.Cache["test-namespace/test-job-0"] = testutils.NewJob("0")
+
+	obj, err := getObjectFromStore("test-namespace", "test-job-0", ms.Get(gvk.Job))
+
+	require.Error(t, err)
+	require.Nil(t, obj)
+}