feat: adding k8 support for container id detection

detectors/node/opentelemetry-resource-detector-container/package.json

@@ -51,6 +51,7 @@
     "@opentelemetry/api": "^1.0.0"
   },
   "dependencies": {
+    "@kubernetes/client-node": "^0.20.0",
     "@opentelemetry/resources": "^1.0.0",
     "@opentelemetry/semantic-conventions": "^1.22.0"
   },

detectors/node/opentelemetry-resource-detector-container/src/detectors/ContainerDetector.ts

@@ -25,6 +25,8 @@ import * as fs from 'fs';
 import * as util from 'util';
 import { diag } from '@opentelemetry/api';
 
+const { KubeConfig, CoreV1Api } = require('@kubernetes/client-node');
+
 export class ContainerDetector implements Detector {
   readonly CONTAINER_ID_LENGTH = 64;
   readonly DEFAULT_CGROUP_V1_PATH = '/proc/self/cgroup';
@@ -36,7 +38,12 @@ export class ContainerDetector implements Detector {
 
   async detect(_config?: ResourceDetectionConfig): Promise<Resource> {
     try {
-      const containerId = await this._getContainerId();
+      let containerId = '';
+      if (this._isInKubernetesEnvironment()) {
+        containerId = await this._getContainerIdK8();
+      } else {
+        containerId = (await this._getContainerId()) || '';
+      }
       return !containerId
         ? Resource.empty()
         : new Resource({
@@ -100,6 +107,43 @@ export class ContainerDetector implements Detector {
     return containerIdStr || '';
   }
 
+  private _isInKubernetesEnvironment(): boolean {
+    return process.env.KUBERNETES_SERVICE_HOST !== undefined;
+  }
+
+  private async _getContainerIdK8(): Promise<string> {
+    const kubeconfig = new KubeConfig();
+    kubeconfig.loadFromDefault();
+
+    const api = kubeconfig.makeApiClient(CoreV1Api);
+    const namespace: string = process.env.NAMESPACE || 'default';
+    const containerName: string | undefined = process.env.CONTAINER_NAME;
+    if (!containerName) {
+      throw new Error('Container name not specified in environment');
+    }
+
+    const response = await api.listNamespacePod(namespace);
+
+    const podWithContainer = response.body.items.find(
+      (pod: { spec: { containers: any[] } }) => {
+        return pod.spec.containers.some(
+          container => container.name === containerName
+        );
+      }
+    );
+
+    if (!podWithContainer) {
+      throw new Error(`No pods found with container name '${containerName}'.`);
+    }
+
+    const container = podWithContainer.spec.containers.find(
+      (container: { name: string }) => container.name === containerName
+    );
+    const containerId = container ? container.containerID || '' : '';
+
+    return containerId;
+  }
+
   /*
     cgroupv1 path would still exist in case of container running on v2
     but the cgroupv1 path would no longer have the container id and would

detectors/node/opentelemetry-resource-detector-container/test/ContainerDetector.test.ts

@@ -22,6 +22,7 @@ import {
   assertContainerResource,
   assertEmptyResource,
 } from '@opentelemetry/contrib-test-utils';
+import { KubeConfig } from '@kubernetes/client-node';
 
 import { ContainerDetector } from '../src';
 
@@ -137,4 +138,146 @@ describe('ContainerDetector', () => {
       assertEmptyResource(resource);
     });
   });
+
+  describe('Detect containerId in k8s environment', () => {
+    it('should return an empty Resource when not in a k8s environment', async () => {
+      const containerDetector = new ContainerDetector();
+      sinon
+        .stub(containerDetector, '_isInKubernetesEnvironment' as any)
+        .returns(false);
+
+      const resource: Resource = await containerDetector.detect();
+      assertEmptyResource(resource);
+      sinon.restore();
+    });
+
+    it('should return a Resource with container ID when running in a Kubernetes environment', async () => {
+      // Stub _isInKubernetesEnvironment to return true
+      const containerDetector = new ContainerDetector();
+      sinon
+        .stub(containerDetector, '_isInKubernetesEnvironment' as any)
+        .returns(true);
+      // Stub _getContainerIdK8 to return a mock container ID
+      sinon
+        .stub(containerDetector, '_getContainerIdK8' as any)
+        .resolves(correctCgroupV1Data);
+
+      const resource: Resource = await containerDetector.detect();
+      assert.ok(resource);
+      assertContainerResource(resource, {
+        id: 'bcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklm',
+      });
+      sinon.restore();
+    });
+
+    it('should return an error with no CONTAINER_NAME environment variable defined', async () => {
+      const containerDetector = new ContainerDetector();
+      sinon
+        .stub(containerDetector, '_isInKubernetesEnvironment' as any)
+        .returns(true);
+      const k8Stub = sinon.spy(
+        ContainerDetector.prototype,
+        '_getContainerIdK8' as any
+      );
+      try {
+        await k8Stub();
+      } catch (error: any) {
+        assert.strictEqual(
+          error.message,
+          'Container name not specified in environment'
+        );
+      } finally {
+        k8Stub.restore();
+      }
+    });
+
+    it('should throw "no pod found" for wrong container name', async () => {
+      process.env.CONTAINER_NAME = 'my-container';
+      const containerDetector = new ContainerDetector();
+      sinon
+        .stub(containerDetector, '_isInKubernetesEnvironment' as any)
+        .returns(true);
+      const k8Stub = sinon.spy(
+        ContainerDetector.prototype,
+        '_getContainerIdK8' as any
+      );
+      const listNamespacePodStub = sinon.stub().resolves({
+        body: {
+          items: [
+            {
+              spec: {
+                containers: [{ name: 'container1' }, { name: 'container2' }],
+              },
+            },
+          ],
+        },
+      });
+
+      const apiStub = {
+        listNamespacePod: listNamespacePodStub,
+      };
+      const kubeconfig = new KubeConfig();
+      kubeconfig.loadFromDefault();
+
+      const makeApiClientStub = sinon
+        .stub(KubeConfig.prototype, 'makeApiClient')
+        .returns(apiStub as any);
+      try {
+        await k8Stub();
+        assert(listNamespacePodStub.calledOnceWithExactly('default'));
+        assert(makeApiClientStub.calledOnce);
+      } catch (error: any) {
+        assert.strictEqual(
+          error.message,
+          "No pods found with container name 'my-container'."
+        );
+      } finally {
+        k8Stub.restore();
+      }
+    });
+
+    it('should return a containerId for right container name', async () => {
+      process.env.CONTAINER_NAME = 'container1';
+      const containerDetector = new ContainerDetector();
+      sinon
+        .stub(containerDetector, '_isInKubernetesEnvironment' as any)
+        .returns(true);
+      const k8Stub = sinon.spy(
+        ContainerDetector.prototype,
+        '_getContainerIdK8' as any
+      );
+      const listNamespacePodStub = sinon.stub().resolves({
+        body: {
+          items: [
+            {
+              spec: {
+                containers: [
+                  { name: 'container1', containerID: correctCgroupV1Data },
+                  { name: 'container2' },
+                ],
+              },
+            },
+          ],
+        },
+      });
+
+      const apiStub = {
+        listNamespacePod: listNamespacePodStub,
+      };
+      const kubeconfig = new KubeConfig();
+      kubeconfig.loadFromDefault();
+
+      const makeApiClientStub = sinon
+        .stub(KubeConfig.prototype, 'makeApiClient')
+        .returns(apiStub as any);
+      try {
+        const cid = await k8Stub();
+        assert(listNamespacePodStub.calledOnceWithExactly('default'));
+        assert(makeApiClientStub.calledOnce);
+        assert.strictEqual(cid, correctCgroupV1Data);
+      } finally {
+        k8Stub.restore();
+      }
+    });
+  });
 });