Fix eks cluster detection

translator/util/eksdetector/eksdetector.go

@@ -4,18 +4,15 @@
 package eksdetector
 
 import (
-	"context"
 	"fmt"
 	"strings"
 	"sync"
 
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
 )
 
 type Detector interface {
-	getConfigMap(namespace string, name string) (map[string]string, error)
 	getServerVersion() (string, error)
 }
 
@@ -28,11 +25,6 @@ type IsEKSCache struct {
 	Err   error
 }
 
-const (
-	authConfigNamespace = "kube-system"
-	authConfigConfigMap = "aws-auth"
-)
-
 var _ Detector = (*EksDetector)(nil)
 
 var (
@@ -56,8 +48,8 @@ var (
 		return detector, errors
 	}
 
-	// IsEKS checks if the agent is running on EKS. This is done by using the kubernetes API to determine if the aws-auth
-	// configmap exists in the kube-system namespace
+	// IsEKS checks if the agent is running on EKS. This is done by using the kubernetes API
+	// to determine if the server version string contains "eks".
 	IsEKS = func() IsEKSCache {
 		once.Do(func() {
 			var errors error
@@ -72,14 +64,7 @@ var (
 				// Check server version
 				serverVersion, err := eksDetector.getServerVersion()
 				if err == nil {
-					fmt.Println("Server version: ", serverVersion)
 					value = strings.Contains(strings.ToLower(serverVersion), "eks")
-				} else {
-					// Make HTTP GET request
-					awsAuth, err := eksDetector.getConfigMap(authConfigNamespace, authConfigConfigMap)
-					if err == nil {
-						value = awsAuth != nil
-					}
 				}
 			}
 			isEKSCacheSingleton = IsEKSCache{Value: value, Err: errors}
@@ -89,16 +74,7 @@ var (
 	}
 )
 
-// getConfigMap retrieves the configmap with the provided name in the provided namespace
-func (d *EksDetector) getConfigMap(namespace string, name string) (map[string]string, error) {
-	configMap, err := d.Clientset.CoreV1().ConfigMaps(namespace).Get(context.TODO(), name, metav1.GetOptions{})
-	if err != nil {
-		return nil, fmt.Errorf("failed to retrieve ConfigMap %s/%s: %w", namespace, name, err)
-	}
-
-	return configMap.Data, nil
-}
-
+// getServerVersion retrieves the cluster's server version
 func (d *EksDetector) getServerVersion() (string, error) {
 	version, err := d.Clientset.Discovery().ServerVersion()
 	if err != nil {

translator/util/eksdetector/eksdetector_test.go

@@ -5,18 +5,23 @@ package eksdetector
 
 import (
 	"fmt"
+	"sync"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	conventions "go.opentelemetry.io/collector/semconv/v1.6.1"
-	v1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/kubernetes/fake"
 	"k8s.io/client-go/rest"
 )
 
+func resetTestState() {
+	once = sync.Once{}
+	isEKSCacheSingleton = IsEKSCache{}
+}
+
 func TestNewDetector(t *testing.T) {
+	resetTestState()
+
 	getInClusterConfig = func() (*rest.Config, error) {
 		return &rest.Config{}, nil
 	}
@@ -33,6 +38,8 @@ func TestNewDetector(t *testing.T) {
 }
 
 func TestIsEKSSingleton(t *testing.T) {
+	resetTestState()
+
 	getInClusterConfig = func() (*rest.Config, error) {
 		return &rest.Config{}, nil
 	}
@@ -42,54 +49,43 @@ func TestIsEKSSingleton(t *testing.T) {
 	assert.NoError(t, value1.Err)
 	value2 := IsEKS()
 	assert.NoError(t, value2.Err)
-
 	assert.True(t, value1 == value2)
 }
 
 // Tests EKS resource detector running in EKS environment
 func TestEKS(t *testing.T) {
+	resetTestState()
 	testDetector := new(MockDetector)
 	NewDetector = func() (Detector, error) {
 		return testDetector, nil
 	}
 
-	testDetector.On("getConfigMap", authConfigNamespace, authConfigConfigMap).Return(map[string]string{conventions.AttributeK8SClusterName: "my-cluster"}, nil)
+	testDetector.On("getServerVersion").Return("v1.23-eks", nil)
 	isEks := IsEKS()
 	assert.True(t, isEks.Value)
 	assert.NoError(t, isEks.Err)
 }
 
-func Test_getConfigMap(t *testing.T) {
-	// No matching configmap
+func Test_getServerVersion(t *testing.T) {
+	resetTestState()
 	client := fake.NewSimpleClientset()
 	testDetector := &EksDetector{Clientset: client}
-	res, err := testDetector.getConfigMap("test", "test")
-	assert.Error(t, err)
-	assert.Nil(t, res)
-
-	// matching configmap
-	cm := &v1.ConfigMap{
-		TypeMeta:   metav1.TypeMeta{Kind: "ConfigMap", APIVersion: "v1"},
-		ObjectMeta: metav1.ObjectMeta{Namespace: authConfigNamespace, Name: authConfigConfigMap},
-		Data:       make(map[string]string),
-	}
-
-	client = fake.NewSimpleClientset(cm)
-	testDetector = &EksDetector{Clientset: client}
-
-	res, err = testDetector.getConfigMap(authConfigNamespace, authConfigConfigMap)
+	res, err := testDetector.getServerVersion()
 	assert.NoError(t, err)
-	assert.NotNil(t, res)
+	assert.NotEmpty(t, res)
 }
 
 func Test_getClientError(t *testing.T) {
+	resetTestState()
+
 	//InClusterConfig error
 	getInClusterConfig = func() (*rest.Config, error) {
 		return nil, fmt.Errorf("test error")
 	}
 
 	_, err := getClient()
 	assert.Error(t, err)
+	resetTestState()
 
 	//Getting Kubernetes client error
 	getInClusterConfig = func() (*rest.Config, error) {

translator/util/eksdetector/eksdetectortestutil.go

@@ -5,27 +5,20 @@ package eksdetector
 
 import (
 	"github.com/stretchr/testify/mock"
-	v1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes/fake"
 )
 
 var (
 	// TestEKSDetector is used for unit testing EKS route
 	TestEKSDetector = func() (Detector, error) {
-		cm := &v1.ConfigMap{
-			TypeMeta:   metav1.TypeMeta{Kind: "ConfigMap", APIVersion: "v1"},
-			ObjectMeta: metav1.ObjectMeta{Namespace: "kube-system", Name: "aws-auth"},
-			Data:       make(map[string]string),
-		}
-		return &EksDetector{Clientset: fake.NewSimpleClientset(cm)}, nil
+		return &EksDetector{Clientset: fake.NewSimpleClientset()}, nil
 	}
 	// TestK8sDetector is used for unit testing k8s route
 	TestK8sDetector = func() (Detector, error) {
 		return &EksDetector{Clientset: fake.NewSimpleClientset()}, nil
 	}
 
-	// TestIsEKSCacheEKS os used for unit testing EKS route
+	// TestIsEKSCacheEKS is used for unit testing EKS route
 	TestIsEKSCacheEKS = func() IsEKSCache {
 		return IsEKSCache{Value: true, Err: nil}
 	}
@@ -40,11 +33,6 @@ type MockDetector struct {
 	mock.Mock
 }
 
-func (detector *MockDetector) getConfigMap(namespace string, name string) (map[string]string, error) {
-	args := detector.Called(namespace, name)
-	return args.Get(0).(map[string]string), args.Error(1)
-}
-
 func (detector *MockDetector) getServerVersion() (string, error) {
 	args := detector.Called()
 	return args.Get(0).(string), args.Error(1)