feat: container ID detector for cgroup v2

detectors/node/opentelemetry-resource-detector-docker/src/detectors/DockerCGroupV1Detector.ts → detectors/node/opentelemetry-resource-detector-docker/src/detectors/DockerDetector.ts

@@ -25,10 +25,12 @@ import * as fs from 'fs';
 import * as util from 'util';
 import { diag } from '@opentelemetry/api';
 
-export class DockerCGroupV1Detector implements Detector {
+export class DockerDetector implements Detector {
   readonly CONTAINER_ID_LENGTH = 64;
   readonly DEFAULT_CGROUP_PATH = '/proc/self/cgroup';
+  readonly DEFAULT_CGROUP_V2_PATH = '/proc/self/mountinfo';
   readonly UTF8_UNICODE = 'utf8';
+  readonly HOSTNAME = 'hostname';
 
   private static readFileAsync = util.promisify(fs.readFile);
 
@@ -42,7 +44,7 @@ export class DockerCGroupV1Detector implements Detector {
           });
     } catch (e) {
       diag.info(
-        'Docker CGROUP V1 Detector did not identify running inside a supported docker container, no docker attributes will be added to resource: ',
+        'Docker Detector did not identify running inside a supported docker container, no docker attributes will be added to resource: ',
         e
       );
       return Resource.empty();
@@ -51,21 +53,39 @@ export class DockerCGroupV1Detector implements Detector {
 
   private async _getContainerId(): Promise<string | undefined> {
     try {
-      const rawData = await DockerCGroupV1Detector.readFileAsync(
+      let rawData = await DockerDetector.readFileAsync(
         this.DEFAULT_CGROUP_PATH,
         this.UTF8_UNICODE
       );
-      const splitData = rawData.trim().split('\n');
+      let splitData = rawData.trim().split('\n');
       for (const str of splitData) {
         if (str.length >= this.CONTAINER_ID_LENGTH) {
           return str.substring(str.length - this.CONTAINER_ID_LENGTH);
         }
       }
+
+      // If this code is reached - we then check for the V2_PATH
+      rawData = await DockerDetector.readFileAsync(
+        this.DEFAULT_CGROUP_V2_PATH,
+        this.UTF8_UNICODE
+      );
+
+      splitData = rawData.trim().split('\n');
+      for (let str of splitData) {
+        if (str.includes(this.HOSTNAME)) {
+          str = str
+            .split('/')
+            .filter(s => s.length >= this.CONTAINER_ID_LENGTH)[0];
+          if (str.length >= this.CONTAINER_ID_LENGTH) {
+            return str.substring(str.length - this.CONTAINER_ID_LENGTH);
+          }
+        }
+      }
     } catch (e) {
       if (e instanceof Error) {
         const errorMessage = e.message;
         diag.info(
-          'Docker CGROUP V1 Detector failed to read the Container ID: ',
+          'Docker Detector failed to read the Container ID: ',
           errorMessage
         );
       }
@@ -74,4 +94,4 @@ export class DockerCGroupV1Detector implements Detector {
   }
 }
 
-export const dockerCGroupV1Detector = new DockerCGroupV1Detector();
+export const dockerDetector = new DockerDetector();

detectors/node/opentelemetry-resource-detector-docker/src/detectors/index.ts

@@ -13,4 +13,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export * from './DockerCGroupV1Detector';
+export * from './DockerDetector';

detectors/node/opentelemetry-resource-detector-docker/test/DockerCGroupv1Detector.test.ts → detectors/node/opentelemetry-resource-detector-docker/test/DockerDetector.test.ts

@@ -17,18 +17,23 @@
 import * as sinon from 'sinon';
 import * as assert from 'assert';
 import { Resource } from '@opentelemetry/resources';
-import { dockerCGroupV1Detector } from '../src';
+import { dockerDetector } from '../src';
 import {
   assertContainerResource,
   assertEmptyResource,
 } from '@opentelemetry/contrib-test-utils';
 
-import { DockerCGroupV1Detector } from '../src';
+import { DockerDetector } from '../src';
 
 describe('dockerCGroupV1Detector', () => {
   let readStub;
   const correctCgroupData =
     'abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklm';
+  const correctCgroupV2Data =
+    'abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklm/hostname';
+
+  const wrongCgroupV2Data =
+    'abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklm/host';
 
   afterEach(() => {
     sinon.restore();
@@ -37,21 +42,21 @@ describe('dockerCGroupV1Detector', () => {
   describe('Supported docker - Container ID ', () => {
     it('should return a resource attributes without container id - docker cgroup v1 detector', async () => {
       readStub = sinon
-        .stub(DockerCGroupV1Detector, 'readFileAsync' as any)
+        .stub(DockerDetector, 'readFileAsync' as any)
         .resolves(undefined);
 
-      const resource: Resource = await dockerCGroupV1Detector.detect();
+      const resource: Resource = await dockerDetector.detect();
 
       assert.deepStrictEqual(resource.attributes, {});
       assert.ok(resource);
     });
 
     it('should return a resource with container ID with a valid container ID present', async () => {
       readStub = sinon
-        .stub(DockerCGroupV1Detector, 'readFileAsync' as any)
+        .stub(DockerDetector, 'readFileAsync' as any)
         .resolves(correctCgroupData);
 
-      const resource: Resource = await dockerCGroupV1Detector.detect();
+      const resource: Resource = await dockerDetector.detect();
 
       sinon.assert.calledOnce(readStub);
 
@@ -61,15 +66,42 @@ describe('dockerCGroupV1Detector', () => {
       });
     });
 
+    it('should return a resource with container ID with a valid container ID present for v2', async () => {
+      readStub = sinon.stub(DockerDetector, 'readFileAsync' as any);
+
+      readStub.onFirstCall().resolves('');
+      readStub.onSecondCall().resolves(correctCgroupV2Data);
+
+      const resource: Resource = await dockerDetector.detect();
+      sinon.assert.calledTwice(readStub);
+
+      assert.ok(resource);
+      assertContainerResource(resource, {
+        id: 'bcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklm',
+      });
+    });
+
+    it('should return a empty resource with failed hostname check for v2', async () => {
+      readStub = sinon.stub(DockerDetector, 'readFileAsync' as any);
+
+      readStub.onFirstCall().resolves('');
+      readStub.onSecondCall().resolves(wrongCgroupV2Data);
+
+      const resource: Resource = await dockerDetector.detect();
+      sinon.assert.calledTwice(readStub);
+
+      assert.ok(resource);
+    });
+
     it('should return a resource without attribute container.id when cgroup file does not contain valid Container ID', async () => {
       readStub = sinon
-        .stub(DockerCGroupV1Detector, 'readFileAsync' as any)
+        .stub(DockerDetector, 'readFileAsync' as any)
         .resolves('');
 
-      const resource: Resource = await dockerCGroupV1Detector.detect();
+      const resource: Resource = await dockerDetector.detect();
       assert.deepStrictEqual(resource.attributes, {});
 
-      sinon.assert.calledOnce(readStub);
+      sinon.assert.calledTwice(readStub);
       assert.ok(resource);
     });
 
@@ -79,11 +111,27 @@ describe('dockerCGroupV1Detector', () => {
       };
 
       readStub = sinon
-        .stub(DockerCGroupV1Detector, 'readFileAsync' as any)
+        .stub(DockerDetector, 'readFileAsync' as any)
         .rejects(errorMsg.fileNotFoundError);
 
-      const resource: Resource = await dockerCGroupV1Detector.detect();
+      const resource: Resource = await dockerDetector.detect();
+
+      sinon.assert.calledOnce(readStub);
+      assertEmptyResource(resource);
+    });
+
+    //cgroup v2 and containerd test
+
+    it('should return an empty resource when containerId is not valid', async () => {
+      const errorMsg = {
+        fileNotFoundError: new Error('cannot find file in path'),
+      };
+
+      readStub = sinon
+        .stub(DockerDetector, 'readFileAsync' as any)
+        .rejects(errorMsg.fileNotFoundError);
 
+      const resource: Resource = await dockerDetector.detect();
       sinon.assert.calledOnce(readStub);
       assertEmptyResource(resource);
     });