feat(aws): Support automatic wrapping in ESM

Author: msonnb

dev-packages/e2e-tests/test-applications/aws-serverless/src/lambda-functions-layer/ErrorEsm/index.mjs

@@ -0,0 +1,3 @@
+export const handler = async () => {
+  throw new Error('test esm');
+};

dev-packages/e2e-tests/test-applications/aws-serverless/src/lambda-functions-layer/TracingEsm/index.mjs

@@ -2,7 +2,7 @@ import * as Sentry from '@sentry/aws-serverless';
 
 import * as http from 'node:http';
 
-export const handler = Sentry.wrapHandler(async () => {
+export const handler = async () => {
   await Sentry.startSpan({ name: 'manual-span', op: 'test' }, async () => {
     await new Promise(resolve => {
       http.get('http://example.com', res => {
@@ -16,4 +16,4 @@ export const handler = Sentry.wrapHandler(async () => {
       });
     });
   });
-});
+};

dev-packages/e2e-tests/test-applications/aws-serverless/src/lambda-functions-npm/TracingCjs/index.js

@@ -1,7 +1,7 @@
 const http = require('http');
 const Sentry = require('@sentry/aws-serverless');
 
-exports.handler = Sentry.wrapHandler(async () => {
+exports.handler = async () => {
   await new Promise(resolve => {
     const req = http.request(
       {
@@ -21,4 +21,4 @@ exports.handler = Sentry.wrapHandler(async () => {
   });
 
   Sentry.startSpan({ name: 'manual-span', op: 'manual' }, () => {});
-});
+};

dev-packages/e2e-tests/test-applications/aws-serverless/src/lambda-functions-npm/TracingEsm/index.mjs

@@ -1,7 +1,7 @@
 import * as http from 'node:http';
 import * as Sentry from '@sentry/aws-serverless';
 
-export const handler = Sentry.wrapHandler(async () => {
+export const handler = async () => {
   await new Promise(resolve => {
     const req = http.request(
       {
@@ -21,4 +21,4 @@ export const handler = Sentry.wrapHandler(async () => {
   });
 
   Sentry.startSpan({ name: 'manual-span', op: 'manual' }, () => {});
-});
+};

dev-packages/e2e-tests/test-applications/aws-serverless/tests/layer.test.ts

@@ -160,7 +160,35 @@ test.describe('Lambda layer', () => {
         type: 'Error',
         value: 'test',
         mechanism: {
-          type: 'auto.function.aws-serverless.handler',
+          type: 'auto.function.aws-serverless.otel',
+          handled: false,
+        },
+      }),
+    );
+  });
+
+  test('capturing errors works in ESM', async ({ lambdaClient }) => {
+    const errorEventPromise = waitForError('aws-serverless-lambda-sam', errorEvent => {
+      return errorEvent?.exception?.values?.[0]?.value === 'test esm';
+    });
+
+    await lambdaClient.send(
+      new InvokeCommand({
+        FunctionName: 'LayerErrorEsm',
+        Payload: JSON.stringify({}),
+      }),
+    );
+
+    const errorEvent = await errorEventPromise;
+
+    // shows the SDK sent an error event
+    expect(errorEvent.exception?.values).toHaveLength(1);
+    expect(errorEvent.exception?.values?.[0]).toEqual(
+      expect.objectContaining({
+        type: 'Error',
+        value: 'test esm',
+        mechanism: {
+          type: 'auto.function.aws-serverless.otel',
           handled: false,
         },
       }),

packages/aws-serverless/package.json

@@ -67,8 +67,8 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/instrumentation": "^0.203.0",
-    "@opentelemetry/instrumentation-aws-lambda": "0.54.0",
     "@opentelemetry/instrumentation-aws-sdk": "0.56.0",
+    "@opentelemetry/semantic-conventions": "^1.36.0",
     "@sentry/core": "10.4.0",
     "@sentry/node": "10.4.0",
     "@types/aws-lambda": "^8.10.62"

packages/aws-serverless/src/awslambda-auto.ts

@@ -22,10 +22,6 @@ if (lambdaTaskRoot) {
         : {},
     ),
   });
-
-  if (typeof require !== 'undefined') {
-    Sentry.tryPatchHandler(lambdaTaskRoot, handlerString);
-  }
 } else {
   throw Error('LAMBDA_TASK_ROOT environment variable is not set');
 }

packages/aws-serverless/src/index.ts

@@ -146,5 +146,6 @@ export {
 export { awsIntegration } from './integration/aws';
 export { awsLambdaIntegration } from './integration/awslambda';
 
-export { getDefaultIntegrations, init, tryPatchHandler, wrapHandler } from './sdk';
+export { getDefaultIntegrations, init } from './init';
+export { wrapHandler } from './sdk';
 export type { WrapperOptions } from './sdk';

packages/aws-serverless/src/init.ts

@@ -0,0 +1,31 @@
+import type { Integration, Options } from '@sentry/core';
+import { applySdkMetadata, getSDKSource } from '@sentry/core';
+import type { NodeClient, NodeOptions } from '@sentry/node';
+import { getDefaultIntegrationsWithoutPerformance, initWithoutDefaultIntegrations } from '@sentry/node';
+import { awsIntegration } from './integration/aws';
+import { awsLambdaIntegration } from './integration/awslambda';
+
+/**
+ * Get the default integrations for the AWSLambda SDK.
+ */
+// NOTE: in awslambda-auto.ts, we also call the original `getDefaultIntegrations` from `@sentry/node` to load performance integrations.
+// If at some point we need to filter a node integration out for good, we need to make sure to also filter it out there.
+export function getDefaultIntegrations(_options: Options): Integration[] {
+  return [...getDefaultIntegrationsWithoutPerformance(), awsIntegration(), awsLambdaIntegration()];
+}
+
+/**
+ * Initializes the Sentry AWS Lambda SDK.
+ *
+ * @param options Configuration options for the SDK, @see {@link AWSLambdaOptions}.
+ */
+export function init(options: NodeOptions = {}): NodeClient | undefined {
+  const opts = {
+    defaultIntegrations: getDefaultIntegrations(options),
+    ...options,
+  };
+
+  applySdkMetadata(opts, 'aws-serverless', ['aws-serverless'], getSDKSource());
+
+  return initWithoutDefaultIntegrations(opts);
+}

packages/aws-serverless/src/integration/awslambda.ts

@@ -1,8 +1,8 @@
-import { AwsLambdaInstrumentation } from '@opentelemetry/instrumentation-aws-lambda';
 import type { IntegrationFn } from '@sentry/core';
 import { defineIntegration, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
-import { generateInstrumentOnce } from '@sentry/node';
-import { eventContextExtractor } from '../utils';
+import { captureException, generateInstrumentOnce } from '@sentry/node';
+import { eventContextExtractor, markEventUnhandled } from '../utils';
+import { AwsLambdaInstrumentation } from './instrumentation-aws-lambda/instrumentation';
 
 interface AwsLambdaOptions {
   /**
@@ -27,6 +27,11 @@ export const instrumentAwsLambda = generateInstrumentOnce(
         span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, 'auto.otel.aws-lambda');
         span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'function.aws.lambda');
       },
+      responseHook(_span, { err }) {
+        if (err) {
+          captureException(err, scope => markEventUnhandled(scope, 'auto.function.aws-serverless.otel'));
+        }
+      },
     };
   },
 );