fix(node): Ensure tool errors for vercelAiIntegration have correct trace connected (#17132)

This fixes the problem that for tool errors triggered from vercel-ai
integration, traces were not connected.
This seemed to happen because errors bubble up to the global unhandled
rejection handler, where the span is no longer active and thus the trace
cannot be connected.

This PR fixes this by attaching the active span to the error and using
this in the unhandled rejection handler, if it exists.

Closes #17108

Author: mydea

dev-packages/e2e-tests/test-applications/aws-lambda-layer-cjs/package.json

@@ -1,7 +1,8 @@
 {
-  "name": "node-express-app",
+  "name": "aws-lambda-layer-cjs",
   "version": "1.0.0",
   "private": true,
+  "type": "commonjs",
   "scripts": {
     "start": "node src/run.js",
     "test": "playwright test",

dev-packages/node-integration-tests/suites/express/handle-error-tracesSampleRate-0/server.ts

@@ -5,7 +5,7 @@ Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   transport: loggingTransport,
-  tracesSampleRate: 1,
+  tracesSampleRate: 0,
 });
 
 import express from 'express';

dev-packages/node-integration-tests/suites/express/handle-error-tracesSampleRate-0/test.ts

@@ -7,7 +7,6 @@ afterAll(() => {
 
 test('should capture and send Express controller error with txn name if tracesSampleRate is 0', async () => {
   const runner = createRunner(__dirname, 'server.ts')
-    .ignore('transaction')
     .expect({
       event: {
         exception: {

dev-packages/node-integration-tests/suites/express/handle-error/server.ts

@@ -0,0 +1,21 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1,
+  transport: loggingTransport,
+});
+
+import express from 'express';
+
+const app = express();
+
+app.get('/test/express/:id', req => {
+  throw new Error(`test_error with id ${req.params.id}`);
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/express/handle-error/test.ts

@@ -0,0 +1,44 @@
+import { afterAll, expect, test } from 'vitest';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+  cleanupChildProcesses();
+});
+
+test('should capture and send Express controller error with txn name if tracesSampleRate is 1', async () => {
+  const runner = createRunner(__dirname, 'server.ts')
+    .expect({
+      transaction: {
+        transaction: 'GET /test/express/:id',
+      },
+    })
+    .expect({
+      event: {
+        exception: {
+          values: [
+            {
+              mechanism: {
+                type: 'middleware',
+                handled: false,
+              },
+              type: 'Error',
+              value: 'test_error with id 123',
+              stacktrace: {
+                frames: expect.arrayContaining([
+                  expect.objectContaining({
+                    function: expect.any(String),
+                    lineno: expect.any(Number),
+                    colno: expect.any(Number),
+                  }),
+                ]),
+              },
+            },
+          ],
+        },
+        transaction: 'GET /test/express/:id',
+      },
+    })
+    .start();
+  runner.makeRequest('get', '/test/express/123', { expectError: true });
+  await runner.completed();
+});

dev-packages/node-integration-tests/suites/public-api/onUnhandledRejectionIntegration/scenario-with-span-ended.ts

@@ -0,0 +1,46 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1,
+  transport: loggingTransport,
+});
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+recordSpan(async () => {
+  // eslint-disable-next-line @typescript-eslint/no-floating-promises
+  doSomething();
+  // eslint-disable-next-line @typescript-eslint/no-floating-promises
+  doSomethingWithError();
+});
+
+async function doSomething(): Promise<void> {
+  return Promise.resolve();
+}
+
+async function doSomethingWithError(): Promise<void> {
+  await new Promise(resolve => setTimeout(resolve, 100));
+  throw new Error('test error');
+}
+
+// Duplicating some code from vercel-ai to verify how things work in more complex/weird scenarios
+function recordSpan(fn: (span: unknown) => Promise<void>): Promise<void> {
+  return Sentry.startSpanManual({ name: 'test-span' }, async span => {
+    try {
+      const result = await fn(span);
+      span.end();
+      return result;
+    } catch (error) {
+      try {
+        span.setStatus({ code: 2 });
+      } finally {
+        // always stop the span when there is an error:
+        span.end();
+      }
+
+      throw error;
+    }
+  });
+}

dev-packages/node-integration-tests/suites/public-api/onUnhandledRejectionIntegration/scenario-with-span.ts

@@ -0,0 +1,14 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1,
+  transport: loggingTransport,
+});
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+Sentry.startSpan({ name: 'test-span' }, async () => {
+  throw new Error('test error');
+});

dev-packages/node-integration-tests/suites/public-api/onUnhandledRejectionIntegration/test.ts

@@ -1,3 +1,4 @@
+import type { Event } from '@sentry/node';
 import * as childProcess from 'child_process';
 import * as path from 'path';
 import { afterAll, describe, expect, test } from 'vitest';
@@ -123,4 +124,58 @@ test rejection`);
       .start()
       .completed();
   });
+
+  test('handles unhandled rejection in spans', async () => {
+    let transactionEvent: Event | undefined;
+    let errorEvent: Event | undefined;
+
+    await createRunner(__dirname, 'scenario-with-span.ts')
+      .expect({
+        transaction: transaction => {
+          transactionEvent = transaction;
+        },
+      })
+      .expect({
+        event: event => {
+          errorEvent = event;
+        },
+      })
+      .start()
+      .completed();
+
+    expect(transactionEvent).toBeDefined();
+    expect(errorEvent).toBeDefined();
+
+    expect(transactionEvent!.transaction).toBe('test-span');
+
+    expect(transactionEvent!.contexts!.trace!.trace_id).toBe(errorEvent!.contexts!.trace!.trace_id);
+    expect(transactionEvent!.contexts!.trace!.span_id).toBe(errorEvent!.contexts!.trace!.span_id);
+  });
+
+  test('handles unhandled rejection in spans that are ended early', async () => {
+    let transactionEvent: Event | undefined;
+    let errorEvent: Event | undefined;
+
+    await createRunner(__dirname, 'scenario-with-span-ended.ts')
+      .expect({
+        transaction: transaction => {
+          transactionEvent = transaction;
+        },
+      })
+      .expect({
+        event: event => {
+          errorEvent = event;
+        },
+      })
+      .start()
+      .completed();
+
+    expect(transactionEvent).toBeDefined();
+    expect(errorEvent).toBeDefined();
+
+    expect(transactionEvent!.transaction).toBe('test-span');
+
+    expect(transactionEvent!.contexts!.trace!.trace_id).toBe(errorEvent!.contexts!.trace!.trace_id);
+    expect(transactionEvent!.contexts!.trace!.span_id).toBe(errorEvent!.contexts!.trace!.span_id);
+  });
 });

dev-packages/node-integration-tests/suites/tracing/vercelai/instrument-with-pii.mjs

@@ -7,5 +7,5 @@ Sentry.init({
   tracesSampleRate: 1.0,
   sendDefaultPii: true,
   transport: loggingTransport,
-  integrations: [Sentry.vercelAIIntegration({ force: true })],
+  integrations: [Sentry.vercelAIIntegration()],
 });

dev-packages/node-integration-tests/suites/tracing/vercelai/instrument.mjs

@@ -6,5 +6,5 @@ Sentry.init({
   release: '1.0',
   tracesSampleRate: 1.0,
   transport: loggingTransport,
-  integrations: [Sentry.vercelAIIntegration({ force: true })],
+  integrations: [Sentry.vercelAIIntegration()],
 });