test(aws-serverless): Add integration coverage for aws-sdk service instrumentation

dev-packages/node-integration-tests/package.json

@@ -25,7 +25,14 @@
   "dependencies": {
     "@anthropic-ai/sdk": "0.63.0",
     "@apollo/server": "^5.5.0",
-    "@aws-sdk/client-s3": "^3.1041.0",
+    "@aws-sdk/client-dynamodb": "3.1041.0",
+    "@aws-sdk/client-kinesis": "3.1041.0",
+    "@aws-sdk/client-lambda": "3.1041.0",
+    "@aws-sdk/client-s3": "3.1041.0",
+    "@aws-sdk/client-secrets-manager": "3.1041.0",
+    "@aws-sdk/client-sfn": "3.1041.0",
+    "@aws-sdk/client-sns": "3.1041.0",
+    "@aws-sdk/client-sqs": "3.1041.0",
     "@google/genai": "^1.20.0",
     "@growthbook/growthbook": "^1.6.1",
     "@hapi/hapi": "^21.3.10",

dev-packages/node-integration-tests/suites/aws-serverless/aws-integration/dynamodb/scenario.js

@@ -0,0 +1,52 @@
+const { loggingTransport } = require('@sentry-internal/node-integration-tests');
+const Sentry = require('@sentry/aws-serverless');
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  tracesSampleRate: 1.0,
+  transport: loggingTransport,
+});
+
+const { DynamoDBClient, PutItemCommand, QueryCommand } = require('@aws-sdk/client-dynamodb');
+const nock = require('nock');
+
+nock.disableNetConnect();
+
+const region = 'us-east-1';
+
+async function run() {
+  await Sentry.startSpan({ name: 'Test Transaction' }, async () => {
+    const client = new DynamoDBClient({
+      region,
+      credentials: { accessKeyId: 'aws-test-key', secretAccessKey: 'aws-test-secret' },
+      maxAttempts: 1,
+    });
+
+    nock(`https://dynamodb.${region}.amazonaws.com`)
+      .post('/')
+      .reply(200, JSON.stringify({}), { 'content-type': 'application/x-amz-json-1.0' });
+
+    await client.send(
+      new PutItemCommand({
+        TableName: 'my-table',
+        Item: { id: { S: 'some-id' } },
+      }),
+    );
+
+    nock(`https://dynamodb.${region}.amazonaws.com`)
+      .post('/')
+      .reply(200, JSON.stringify({ Items: [{ id: { S: 'some-id' } }], Count: 1, ScannedCount: 1 }), {
+        'content-type': 'application/x-amz-json-1.0',
+      });
+
+    await client.send(
+      new QueryCommand({
+        TableName: 'my-table',
+        KeyConditionExpression: 'id = :id',
+        ExpressionAttributeValues: { ':id': { S: 'some-id' } },
+      }),
+    );
+  });
+}
+
+run();

dev-packages/node-integration-tests/suites/aws-serverless/aws-integration/dynamodb/test.ts

@@ -0,0 +1,51 @@
+import { afterAll, describe, expect, test } from 'vitest';
+import { cleanupChildProcesses, createRunner } from '../../../../utils/runner';
+
+describe('awsIntegration - DynamoDB', () => {
+  afterAll(() => {
+    cleanupChildProcesses();
+  });
+
+  test('auto-instruments DynamoDB operations', async () => {
+    await createRunner(__dirname, 'scenario.js')
+      .ignore('event')
+      .expect({
+        transaction: {
+          transaction: 'Test Transaction',
+          spans: expect.arrayContaining([
+            expect.objectContaining({
+              description: 'DynamoDB.PutItem',
+              op: 'db',
+              origin: 'auto.otel.aws',
+              data: expect.objectContaining({
+                'sentry.origin': 'auto.otel.aws',
+                'sentry.op': 'db',
+                'rpc.system': 'aws-api',
+                'rpc.method': 'PutItem',
+                'rpc.service': 'DynamoDB',
+                'db.system': 'dynamodb',
+                'db.name': 'my-table',
+                'db.operation': 'PutItem',
+                'aws.dynamodb.table_names': ['my-table'],
+                'otel.kind': 'CLIENT',
+              }),
+            }),
+            expect.objectContaining({
+              description: 'DynamoDB.Query',
+              op: 'db',
+              origin: 'auto.otel.aws',
+              data: expect.objectContaining({
+                'rpc.method': 'Query',
+                'db.operation': 'Query',
+                'db.name': 'my-table',
+                'aws.dynamodb.count': 1,
+                'aws.dynamodb.scanned_count': 1,
+              }),
+            }),
+          ]),
+        },
+      })
+      .start()
+      .completed();
+  });
+});

dev-packages/node-integration-tests/suites/aws-serverless/aws-integration/kinesis/scenario.js

@@ -0,0 +1,41 @@
+const { loggingTransport } = require('@sentry-internal/node-integration-tests');
+const Sentry = require('@sentry/aws-serverless');
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  tracesSampleRate: 1.0,
+  transport: loggingTransport,
+});
+
+const { KinesisClient, PutRecordCommand } = require('@aws-sdk/client-kinesis');
+// The Kinesis client defaults to an HTTP/2 request handler, which `nock` cannot intercept.
+// Force the HTTP/1 handler so the request is mocked instead of hitting real AWS.
+const { NodeHttpHandler } = require('@smithy/node-http-handler');
+const nock = require('nock');
+
+nock.disableNetConnect();
+
+const region = 'us-east-1';
+
+async function run() {
+  await Sentry.startSpan({ name: 'Test Transaction' }, async () => {
+    const client = new KinesisClient({
+      region,
+      credentials: { accessKeyId: 'aws-test-key', secretAccessKey: 'aws-test-secret' },
+      maxAttempts: 1,
+      requestHandler: new NodeHttpHandler(),
+    });
+
+    nock(`https://kinesis.${region}.amazonaws.com`)
+      .post('/')
+      .reply(200, JSON.stringify({ SequenceNumber: '1', ShardId: 'shardId-000000000000' }), {
+        'content-type': 'application/x-amz-json-1.1',
+      });
+
+    await client.send(
+      new PutRecordCommand({ StreamName: 'my-stream', Data: Buffer.from('data'), PartitionKey: 'partition-key' }),
+    );
+  });
+}
+
+run();

dev-packages/node-integration-tests/suites/aws-serverless/aws-integration/kinesis/test.ts

@@ -0,0 +1,36 @@
+import { afterAll, describe, expect, test } from 'vitest';
+import { cleanupChildProcesses, createRunner } from '../../../../utils/runner';
+
+describe('awsIntegration - Kinesis', () => {
+  afterAll(() => {
+    cleanupChildProcesses();
+  });
+
+  test('auto-instruments Kinesis operations, setting the stream name', async () => {
+    await createRunner(__dirname, 'scenario.js')
+      .ignore('event')
+      .expect({
+        transaction: {
+          transaction: 'Test Transaction',
+          spans: expect.arrayContaining([
+            expect.objectContaining({
+              description: 'Kinesis.PutRecord',
+              op: 'rpc',
+              origin: 'auto.otel.aws',
+              status: 'ok',
+              data: expect.objectContaining({
+                'sentry.origin': 'auto.otel.aws',
+                'rpc.system': 'aws-api',
+                'rpc.method': 'PutRecord',
+                'rpc.service': 'Kinesis',
+                'aws.kinesis.stream.name': 'my-stream',
+                'otel.kind': 'CLIENT',
+              }),
+            }),
+          ]),
+        },
+      })
+      .start()
+      .completed();
+  });
+});

dev-packages/node-integration-tests/suites/aws-serverless/aws-integration/lambda/scenario.js

@@ -0,0 +1,36 @@
+const { loggingTransport } = require('@sentry-internal/node-integration-tests');
+const Sentry = require('@sentry/aws-serverless');
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  tracesSampleRate: 1.0,
+  transport: loggingTransport,
+});
+
+const { LambdaClient, InvokeCommand } = require('@aws-sdk/client-lambda');
+const nock = require('nock');
+
+nock.disableNetConnect();
+
+const region = 'us-east-1';
+
+async function run() {
+  await Sentry.startSpan({ name: 'Test Transaction' }, async () => {
+    const client = new LambdaClient({
+      region,
+      credentials: { accessKeyId: 'aws-test-key', secretAccessKey: 'aws-test-secret' },
+      maxAttempts: 1,
+    });
+
+    nock(`https://lambda.${region}.amazonaws.com`)
+      .post('/2015-03-31/functions/my-function/invocations')
+      .reply(200, JSON.stringify({ result: 'ok' }), {
+        'content-type': 'application/json',
+        'x-amzn-requestid': 'request-id-1',
+      });
+
+    await client.send(new InvokeCommand({ FunctionName: 'my-function' }));
+  });
+}
+
+run();

dev-packages/node-integration-tests/suites/aws-serverless/aws-integration/lambda/test.ts

@@ -0,0 +1,37 @@
+import { afterAll, describe, expect, test } from 'vitest';
+import { cleanupChildProcesses, createRunner } from '../../../../utils/runner';
+
+describe('awsIntegration - Lambda', () => {
+  afterAll(() => {
+    cleanupChildProcesses();
+  });
+
+  test('auto-instruments Lambda invoke, setting faas attributes', async () => {
+    await createRunner(__dirname, 'scenario.js')
+      .ignore('event')
+      .expect({
+        transaction: {
+          transaction: 'Test Transaction',
+          spans: expect.arrayContaining([
+            expect.objectContaining({
+              description: 'my-function Invoke',
+              op: 'rpc',
+              origin: 'auto.otel.aws',
+              data: expect.objectContaining({
+                'sentry.origin': 'auto.otel.aws',
+                'rpc.system': 'aws-api',
+                'rpc.method': 'Invoke',
+                'rpc.service': 'Lambda',
+                'faas.invoked_name': 'my-function',
+                'faas.invoked_provider': 'aws',
+                'faas.execution': 'request-id-1',
+                'otel.kind': 'CLIENT',
+              }),
+            }),
+          ]),
+        },
+      })
+      .start()
+      .completed();
+  });
+});

dev-packages/node-integration-tests/suites/aws-serverless/aws-integration/s3/scenario.js

@@ -4,32 +4,47 @@ const Sentry = require('@sentry/aws-serverless');
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: 1.0,
-  debug: true,
   transport: loggingTransport,
 });
 
 const { S3 } = require('@aws-sdk/client-s3');
 const nock = require('nock');
 
-async function run() {
-  const bucketName = 'aws-test-bucket';
-  const keyName = 'aws-test-object.txt';
-
-  nock(`https://${bucketName}.s3.amazonaws.com`).get(`/${keyName}`).reply(200, 'contents');
-  nock(`https://${bucketName}.s3.amazonaws.com`).put(`/${keyName}`).reply(200, 'contents');
+nock.disableNetConnect();
 
+async function run() {
   await Sentry.startSpan({ name: 'Test Transaction' }, async () => {
     const region = 'us-east-1';
-    const s3Client = new S3({ region });
-    nock(`https://ot-demo-test.s3.${region}.amazonaws.com/`)
-      .put('/aws-ot-s3-test-object.txt?x-id=PutObject')
-      .reply(200, 'test');
-
-    const params = {
-      Bucket: 'ot-demo-test',
-      Key: 'aws-ot-s3-test-object.txt',
-    };
-    await s3Client.putObject(params);
+    const s3Client = new S3({
+      region,
+      credentials: { accessKeyId: 'aws-test-key', secretAccessKey: 'aws-test-secret' },
+      maxAttempts: 1,
+    });
+    const host = `https://ot-demo-test.s3.${region}.amazonaws.com`;
+
+    // Successful PutObject
+    nock(host).put('/aws-ot-s3-test-object.txt?x-id=PutObject').reply(200, 'test');
+    await s3Client.putObject({ Bucket: 'ot-demo-test', Key: 'aws-ot-s3-test-object.txt' });
+
+    // Successful GetObject
+    nock(host).get('/aws-ot-s3-test-object.txt?x-id=GetObject').reply(200, 'contents');
+    const getResult = await s3Client.getObject({ Bucket: 'ot-demo-test', Key: 'aws-ot-s3-test-object.txt' });
+    // Drain the body so the request fully completes
+    await getResult.Body?.transformToString();
+
+    // Failing GetObject (missing key) - should produce a span with error status
+    nock(host)
+      .get('/missing-object.txt?x-id=GetObject')
+      .reply(
+        404,
+        '<?xml version="1.0" encoding="UTF-8"?><Error><Code>NoSuchKey</Code><Message>The specified key does not exist.</Message></Error>',
+        { 'content-type': 'application/xml' },
+      );
+    try {
+      await s3Client.getObject({ Bucket: 'ot-demo-test', Key: 'missing-object.txt' });
+    } catch {
+      // expected
+    }
   });
 }