fix(aws-serverless): Only start root span in Sentry wrapper if Otel didn't wrap handler

Author: Lms24

dev-packages/e2e-tests/test-applications/aws-lambda-layer-cjs/src/lambda-function.js

@@ -3,7 +3,7 @@ const Sentry = require('@sentry/aws-serverless');
 const http = require('http');
 
 async function handle() {
-  await Sentry.startSpan({ name: 'aws-lambda-layer-test-txn', op: 'test' }, async () => {
+  await Sentry.startSpan({ name: 'manual-span', op: 'test' }, async () => {
     await new Promise(resolve => {
       http.get('http://example.com', res => {
         res.on('data', d => {

dev-packages/e2e-tests/test-applications/aws-lambda-layer-cjs/src/run-lambda.js

@@ -1,2 +1,7 @@
 const { handle } = require('./lambda-function');
-handle();
+const event = {};
+const context = {
+  invokedFunctionArn: 'arn:aws:lambda:us-east-1:123453789012:function:my-lambda',
+  functionName: 'my-lambda',
+};
+handle(event, context);

dev-packages/e2e-tests/test-applications/aws-lambda-layer-cjs/src/run.js

@@ -4,7 +4,8 @@ child_process.execSync('node ./src/run-lambda.js', {
   stdio: 'inherit',
   env: {
     ...process.env,
-    LAMBDA_TASK_ROOT: '/var/task',
+    // On AWS, LAMBDA_TASK_ROOT is usually /var/task but for testing, we set it to the CWD to correctly apply our handler
+    LAMBDA_TASK_ROOT: process.cwd(),
     _HANDLER: 'src/lambda-function.handle',
 
     NODE_OPTIONS: '--require @sentry/aws-serverless/dist/awslambda-auto',

dev-packages/e2e-tests/test-applications/aws-lambda-layer-cjs/tests/basic.test.ts

@@ -4,7 +4,7 @@ import { waitForTransaction } from '@sentry-internal/test-utils';
 
 test('Lambda layer SDK bundle sends events', async ({ request }) => {
   const transactionEventPromise = waitForTransaction('aws-serverless-lambda-layer-cjs', transactionEvent => {
-    return transactionEvent?.transaction === 'aws-lambda-layer-test-txn';
+    return transactionEvent?.transaction === 'my-lambda';
   });
 
   // Waiting for 1s here because attaching the listener for events in `waitForTransaction` is not synchronous
@@ -24,17 +24,46 @@ test('Lambda layer SDK bundle sends events', async ({ request }) => {
   const transactionEvent = await transactionEventPromise;
 
   // shows the SDK sent a transaction
-  expect(transactionEvent.transaction).toEqual('aws-lambda-layer-test-txn');
+  expect(transactionEvent.transaction).toEqual('my-lambda'); // name should be the function name
+  expect(transactionEvent.contexts?.trace).toEqual({
+    data: {
+      'sentry.sample_rate': 1,
+      'sentry.source': 'custom',
+      'sentry.origin': 'auto.otel.aws-lambda',
+      'cloud.account.id': '123453789012',
+      'faas.id': 'arn:aws:lambda:us-east-1:123453789012:function:my-lambda',
+      'otel.kind': 'SERVER',
+    },
+    origin: 'auto.otel.aws-lambda',
+    span_id: expect.any(String),
+    status: 'ok',
+    trace_id: expect.any(String),
+  });
+
+  expect(transactionEvent.spans).toHaveLength(2);
 
   // shows that the Otel Http instrumentation is working
-  expect(transactionEvent.spans).toHaveLength(1);
-  expect(transactionEvent.spans![0]).toMatchObject({
-    data: expect.objectContaining({
-      'sentry.op': 'http.client',
-      'sentry.origin': 'auto.http.otel.http',
-      url: 'http://example.com/',
+  expect(transactionEvent.spans).toContainEqual(
+    expect.objectContaining({
+      data: expect.objectContaining({
+        'sentry.op': 'http.client',
+        'sentry.origin': 'auto.http.otel.http',
+        url: 'http://example.com/',
+      }),
+      description: 'GET http://example.com/',
+      op: 'http.client',
     }),
-    description: 'GET http://example.com/',
-    op: 'http.client',
-  });
+  );
+
+  // shows that the manual span creation is working
+  expect(transactionEvent.spans).toContainEqual(
+    expect.objectContaining({
+      data: expect.objectContaining({
+        'sentry.op': 'test',
+        'sentry.origin': 'manual',
+      }),
+      description: 'manual-span',
+      op: 'test',
+    }),
+  );
 });

packages/aws-serverless/src/sdk.ts

@@ -20,7 +20,12 @@ import { isString, logger } from '@sentry/utils';
 import type { Context, Handler } from 'aws-lambda';
 import { performance } from 'perf_hooks';
 
-import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '@sentry/core';
+import {
+  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
+  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
+  getActiveSpan,
+  spanToJSON,
+} from '@sentry/core';
 
 import { DEBUG_BUILD } from './debug-build';
 import { awsIntegration } from './integration/aws';
@@ -320,15 +325,20 @@ export function wrapHandler<TEvent, TResult>(
         throw e;
       } finally {
         clearTimeout(timeoutWarningTimer);
-        span?.end();
+        if (span && span.isRecording()) {
+          span.end();
+        }
         await flush(options.flushTimeout).catch(e => {
           DEBUG_BUILD && logger.error(e);
         });
       }
       return rv;
     }
 
-    if (options.startTrace) {
+    // Only start a trace and root span if the handler is not already wrapped by Otel instrumentation
+    // Otherwise, we create two root spans (one from otel, one from our wrapper).
+    // If Otel instrumentation didn't work or was filtered by users, we still want to trace the handler.
+    if (options.startTrace && !isWrappedByOtel(handler)) {
       const eventWithHeaders = event as { headers?: { [key: string]: string } };
 
       const sentryTrace =
@@ -361,3 +371,19 @@ export function wrapHandler<TEvent, TResult>(
     });
   };
 }
+
+/**
+ * Checks if Otel's AWSLambda instrumentation successfully wrapped the handler.
+ * Check taken from @opentelemetry/core
+ */
+function isWrappedByOtel(
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  handler: Function & { __original?: unknown; __unwrap?: unknown; __wrapped?: boolean },
+): boolean {
+  return (
+    typeof handler === 'function' &&
+    typeof handler.__original === 'function' &&
+    typeof handler.__unwrap === 'function' &&
+    handler.__wrapped === true
+  );
+}