fix(detector-aws): extract full container ID from ECS Fargate cgroup

packages/resource-detector-aws/src/detectors/AwsEcsDetector.ts

@@ -163,10 +163,8 @@ export class AwsEcsDetector implements ResourceDetector {
       );
       const splitData = rawData.trim().split('\n');
       for (const str of splitData) {
-        if (str.length > AwsEcsDetector.CONTAINER_ID_LENGTH) {
-          containerId = str.substring(
-            str.length - AwsEcsDetector.CONTAINER_ID_LENGTH
-          );
+        containerId = this._extractContainerIdFromLine(str);
+        if (containerId) {
           break;
         }
       }
@@ -176,6 +174,53 @@ export class AwsEcsDetector implements ResourceDetector {
     return containerId;
   }
 
+  /**
+   * Extract container ID from a cgroup line using regex pattern matching.
+   * Handles the new AWS ECS Fargate format: /ecs/<taskId>/<taskId>-<containerId>
+   * Returns the last segment after the final '/' which should be the complete container ID.
+   */
+  private _extractContainerIdFromLine(line: string): string | undefined {
+    if (!line) {
+      return undefined;
+    }
+
+    // Primary pattern: Match /ecs/taskId/taskId-containerId format (new ECS Fargate)
+    // This captures the full taskId-containerId part after the last slash
+    const ecsPattern = /\/ecs\/[a-zA-Z0-9-]+\/([a-zA-Z0-9-]+)$/;
+    const ecsMatch = line.match(ecsPattern);
+    if (
+      ecsMatch &&
+      ecsMatch[1] &&
+      ecsMatch[1].length >= 12 &&
+      ecsMatch[1].length <= 128
+    ) {
+      return ecsMatch[1];
+    }
+
+    // Fallback: Extract last segment after slash for any path-like format
+    const segments = line.split('/');
+    if (segments.length > 1) {
+      const lastSegment = segments[segments.length - 1];
+      if (
+        lastSegment &&
+        lastSegment.length >= 12 &&
+        lastSegment.length <= 128
+      ) {
+        return lastSegment;
+      }
+    }
+
+    // Legacy fallback: original logic for lines that are just the container ID (64 chars)
+    if (
+      line.length > AwsEcsDetector.CONTAINER_ID_LENGTH &&
+      !line.includes('/')
+    ) {
+      return line.substring(line.length - AwsEcsDetector.CONTAINER_ID_LENGTH);
+    }
+
+    return undefined;
+  }
+
   /**
    * Add metadata-v4-related resource attributes to `data` (in-place)
    */

packages/resource-detector-aws/test/detectors/AwsEcsDetector.test.ts

@@ -452,4 +452,85 @@ describe('AwsEcsResourceDetector', () => {
       });
     });
   });
+
+  describe('Container ID extraction', () => {
+    const testMetadataUri = 'http://169.254.170.2/v4/test';
+    const testHostname = 'test-hostname';
+    let readStub: sinon.SinonStub;
+
+    beforeEach(() => {
+      process.env.ECS_CONTAINER_METADATA_URI_V4 = testMetadataUri;
+    });
+
+    afterEach(() => {
+      sinon.restore();
+    });
+
+    function setupMocks(cgroupData: string) {
+      sinon.stub(os, 'hostname').returns(testHostname);
+      readStub = sinon
+        .stub(AwsEcsDetector, 'readFileAsync' as any)
+        .resolves(cgroupData);
+    }
+
+    function setupMetadataNock() {
+      return nock('http://169.254.170.2:80')
+        .persist(false)
+        .get('/v4/test')
+        .reply(200, {
+          ContainerARN: 'arn:aws:ecs:us-west-2:111122223333:container/test',
+        })
+        .get('/v4/test/task')
+        .reply(200, {
+          TaskARN: 'arn:aws:ecs:us-west-2:111122223333:task/default/test',
+          Family: 'test-family',
+          Revision: '1',
+          Cluster: 'test-cluster',
+          LaunchType: 'FARGATE',
+        });
+    }
+
+    it('should extract full container ID from new ECS Fargate format', async () => {
+      const taskId = 'c23e5f76c09d438aa1824ca4058bdcab';
+      const containerId = '1234567890abcdef';
+      const cgroupData = `/ecs/${taskId}/${taskId}-${containerId}`;
+
+      setupMocks(cgroupData);
+      const nockScope = setupMetadataNock();
+
+      const resource = detectResources({ detectors: [awsEcsDetector] });
+      await resource.waitForAsyncAttributes?.();
+
+      sinon.assert.calledOnce(readStub);
+      assert.ok(resource);
+      assertEcsResource(resource, {});
+      assertContainerResource(resource, {
+        name: testHostname,
+        id: `${taskId}-${containerId}`,
+      });
+
+      nockScope.done();
+    });
+
+    it('should handle backward compatibility with legacy format', async () => {
+      const legacyContainerId =
+        'abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklm';
+
+      setupMocks(legacyContainerId);
+      const nockScope = setupMetadataNock();
+
+      const resource = detectResources({ detectors: [awsEcsDetector] });
+      await resource.waitForAsyncAttributes?.();
+
+      sinon.assert.calledOnce(readStub);
+      assert.ok(resource);
+      assertEcsResource(resource, {});
+      assertContainerResource(resource, {
+        name: testHostname,
+        id: 'bcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklm',
+      });
+
+      nockScope.done();
+    });
+  });
 });