feat(node): Add awsLambdaWebIntegration for Lambda Web Functions (#25355)

This adds a new `awsLambdaWebIntegration` to the Node SDK for
instrumenting [Lambda Web
Functions](https://docs.aws.amazon.com/lambda/latest/dg/web-functions.html).
Web Functions run standard Node HTTP servers like Express or Hono,
without Lambda-specific handlers or adapters.

Enriches event contexts and segment spans with AWS metadata, request
IDs, endpoint names, and cold-start information.

Closes #25317 
conventions PR for new attributes:
getsentry/sentry-conventions#715

---------

Co-authored-by: Codex <codex@openai.com>

Author: msonnb

dev-packages/bun-integration-tests/node-suites/excludes.ts

@@ -7,6 +7,7 @@
 // `node:sqlite`, which `flue` needs, and the Vercel keep-alive, which needs `http.server.response.finish`.
 const NODE_ONLY = [
   'suites/anr/test.ts',
+  'suites/aws-lambda-web/**',
   'suites/aws-serverless/**',
   'suites/breadcrumbs/**',
   'suites/child-process/test.ts',

dev-packages/deno-integration-tests/node-suites/excludes.ts

@@ -2,8 +2,13 @@
 // fails on Deno runs only on the other runtimes, with `test.runIf(supports({ runtimes }))` in the
 // Node suite, and is not listed here.
 
-// Node-only features: ANR and native thread watchdogs, child process and worker thread breadcrumbs.
-const NODE_ONLY = ['suites/anr/test.ts', 'suites/breadcrumbs/**', 'suites/thread-blocked-native/test.ts'];
+// Node-only features: ANR and native thread watchdogs, child process and worker thread breadcrumbs, and the AWS Lambda Node runtime.
+const NODE_ONLY = [
+  'suites/anr/test.ts',
+  'suites/aws-lambda-web/**',
+  'suites/breadcrumbs/**',
+  'suites/thread-blocked-native/test.ts',
+];
 
 // `@sentry/node` instruments `fetch` through undici's diagnostics channels, which Deno's `fetch`
 // does not publish. `@sentry/deno` has its own `fetchIntegration` for this. These suites check

dev-packages/e2e-tests/test-applications/node-exports-test-app/scripts/consistentExports.ts

@@ -51,6 +51,7 @@ const DEPENDENTS: Dependent[] = [
     exports: Object.keys(SentryBun),
     ignoreExports: [
       // not supported in bun:
+      'awsLambdaWebIntegration',
       'NodeClient',
       'NODE_VERSION',
       'childProcessIntegration',

dev-packages/node-integration-tests/suites/aws-lambda-web/requests/instrument.mjs

@@ -0,0 +1,8 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@example.com/1',
+  tracesSampleRate: process.env.NO_TRACING ? undefined : 1,
+  transport: loggingTransport,
+});

dev-packages/node-integration-tests/suites/aws-lambda-web/requests/scenario.mjs

@@ -0,0 +1,28 @@
+import * as Sentry from '@sentry/node';
+import { startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+import express from 'express';
+
+const app = express();
+let releaseFirst;
+const secondRequestStarted = new Promise(resolve => {
+  releaseFirst = resolve;
+});
+
+app.get('/:request', async (req, res) => {
+  if (req.params.request === 'first') {
+    process.stdout.write('FIRST_STARTED\n');
+    await secondRequestStarted;
+  } else {
+    releaseFirst();
+  }
+
+  Sentry.captureException(new Error(req.params.request));
+  Sentry.logger.info('Request handled');
+  Sentry.metrics.count('request_count', 1);
+  res.send({ ok: true });
+  setImmediate(() => {
+    void Sentry.flush();
+  });
+});
+
+startExpressServerAndSendPortToRunner(app);

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

@@ -0,0 +1,111 @@
+import {
+  AWS_LAMBDA_WEB_ENDPOINT_NAME,
+  CLOUD_PLATFORM,
+  CLOUD_PROVIDER,
+  CLOUD_REGION,
+  FAAS_COLDSTART,
+  FAAS_INVOCATION_ID,
+  FAAS_MAX_MEMORY,
+  SENTRY_OP,
+} from '@sentry/conventions/attributes';
+import { expect, vi } from 'vitest';
+import { createEsmAndCjsTests } from '../../../utils/runner';
+
+createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
+  test.each([
+    { name: 'default tracing', tracing: true },
+    { name: 'tracing disabled', tracing: false },
+  ])('$name: isolates concurrent requests and leaves logs and metrics unenriched', async ({ tracing }) => {
+    const runner = createRunner()
+      .withEnv({
+        AWS_LAMBDA_HTTP_ENDPOINT: '0.0.0.0:3000',
+        AWS_REGION: 'us-east-1',
+        AWS_LAMBDA_FUNCTION_MEMORY_SIZE: '2048',
+        AWS_LAMBDA_INITIALIZATION_TYPE: 'native-http',
+        AWS_EXECUTION_ENV: 'AWS_Lambda_nodejs24.x-lite',
+        NO_TRACING: tracing ? '' : '1',
+      })
+      .unordered();
+
+    const spans = [];
+
+    for (const request of ['first', 'second']) {
+      runner.expect({
+        event: {
+          exception: { values: [expect.objectContaining({ value: request })] },
+          contexts: {
+            cloud_resource: {
+              [CLOUD_PROVIDER]: 'aws',
+              [CLOUD_PLATFORM]: 'aws_lambda',
+              [CLOUD_REGION]: 'us-east-1',
+            },
+            'aws.lambda': {
+              memory_size: 2_147_483_648,
+              initialization_type: 'native-http',
+              cold_start: request === 'first',
+              aws_request_id: request,
+              endpoint_name: `${request}-endpoint`,
+            },
+          },
+        },
+      });
+
+      if (tracing) {
+        spans.push({
+          request,
+          collected: runner.collectStreamedSpansUntilSegment(
+            span => span.attributes[FAAS_INVOCATION_ID]?.value === request,
+          ),
+        });
+      }
+    }
+
+    const assertUnenriched = (items: { attributes?: Record<string, unknown> }[]): void => {
+      expect(items).toHaveLength(2);
+      for (const item of items) {
+        expect(Object.keys(item.attributes || {}).filter(key => /^(aws\.lambda\.|faas\.|cloud\.)/.test(key))).toEqual(
+          [],
+        );
+      }
+    };
+
+    runner.expect({ log: container => assertUnenriched(container.items) });
+    runner.expect({ trace_metric: container => assertUnenriched(container.items) });
+
+    const running = runner.start();
+    const first = running.makeRequest('get', '/first', {
+      headers: { 'lambda-web-request-id': 'first', 'lambda-web-endpoint-name': 'first-endpoint' },
+    });
+    await vi.waitFor(() => expect(running.getLogs().join('\n')).toContain('FIRST_STARTED'), { timeout: 10_000 });
+
+    await Promise.all([
+      first,
+      running.makeRequest('get', '/second', {
+        headers: { 'lambda-web-request-id': 'second', 'lambda-web-endpoint-name': 'second-endpoint' },
+      }),
+    ]);
+    await running.completed();
+
+    const segmentSpans = [];
+
+    for (const { request, collected } of spans) {
+      const items = await collected;
+      segmentSpans.push(...items.filter(item => item.is_segment));
+
+      expect(items.find(item => item.is_segment)).toMatchObject({
+        name: 'GET /:request',
+        attributes: {
+          [SENTRY_OP]: { type: 'string', value: 'http.server' },
+          [CLOUD_PLATFORM]: { type: 'string', value: 'aws_lambda' },
+          [CLOUD_REGION]: { type: 'string', value: 'us-east-1' },
+          [FAAS_MAX_MEMORY]: { type: 'integer', value: 2_147_483_648 },
+          [FAAS_COLDSTART]: { type: 'boolean', value: request === 'first' },
+          [FAAS_INVOCATION_ID]: { type: 'string', value: request },
+          [AWS_LAMBDA_WEB_ENDPOINT_NAME]: { type: 'string', value: `${request}-endpoint` },
+        },
+      });
+    }
+
+    expect(segmentSpans).toHaveLength(tracing ? 2 : 0);
+  });
+});

packages/astro/src/index.server.ts

@@ -95,6 +95,7 @@ export {
   nativeNodeFetchIntegration,
   NodeClient,
   nodeContextIntegration,
+  awsLambdaWebIntegration,
   onUncaughtExceptionIntegration,
   onUnhandledRejectionIntegration,
   mistralAIIntegration,

packages/aws-serverless/src/index.ts

@@ -78,6 +78,7 @@ export {
   type NodeRuntimeMetricsOptions,
   contextLinesIntegration,
   nodeContextIntegration,
+  awsLambdaWebIntegration,
   localVariablesIntegration,
   requestDataIntegration,
   functionToStringIntegration,

packages/google-cloud-serverless/src/index.ts

@@ -78,6 +78,7 @@ export {
   type NodeRuntimeMetricsOptions,
   contextLinesIntegration,
   nodeContextIntegration,
+  awsLambdaWebIntegration,
   localVariablesIntegration,
   requestDataIntegration,
   fsIntegration,

packages/node/src/index.ts

@@ -1,4 +1,5 @@
 export { httpIntegration } from './integrations/http';
+export { awsLambdaWebIntegration } from './integrations/awsLambdaWeb';
 export { nativeNodeFetchIntegration } from './integrations/node-fetch';
 export { fsIntegration } from './integrations/fs';
 // oxlint-disable-next-line typescript/no-deprecated