feat(node): Capture scope when event loop blocked (#18040)

- Closes #17887

This currently only capture scope if it gets forked as isolation scope
(`Sentry.withIsolationScope`)

Author: timfish

dev-packages/node-integration-tests/suites/thread-blocked-native/isolated.mjs

@@ -0,0 +1,37 @@
+import * as Sentry from '@sentry/node';
+import { longWork } from './long-work.js';
+
+setTimeout(() => {
+  process.exit();
+}, 10000);
+
+function neverResolve() {
+  return new Promise(() => {
+    //
+  });
+}
+
+const fns = [
+  neverResolve,
+  neverResolve,
+  neverResolve,
+  neverResolve,
+  neverResolve,
+  longWork, // [5]
+  neverResolve,
+  neverResolve,
+  neverResolve,
+  neverResolve,
+];
+
+setTimeout(() => {
+  for (let id = 0; id < 10; id++) {
+    Sentry.withIsolationScope(async () => {
+      // eslint-disable-next-line no-console
+      console.log(`Starting task ${id}`);
+      Sentry.setUser({ id });
+
+      await fns[id]();
+    });
+  }
+}, 1000);

dev-packages/node-integration-tests/suites/thread-blocked-native/test.ts

@@ -1,6 +1,7 @@
 import { join } from 'node:path';
 import type { Event } from '@sentry/core';
 import { afterAll, describe, expect, test } from 'vitest';
+import { NODE_VERSION } from '../../utils/index';
 import { cleanupChildProcesses, createRunner } from '../../utils/runner';
 
 function EXCEPTION(thread_id = '0', fn = 'longWork') {
@@ -34,9 +35,17 @@ function EXCEPTION(thread_id = '0', fn = 'longWork') {
   };
 }
 
-const ANR_EVENT = {
+const ANR_EVENT = (trace: boolean = false) => ({
   // Ensure we have context
   contexts: {
+    ...(trace
+      ? {
+          trace: {
+            span_id: expect.stringMatching(/[a-f\d]{16}/),
+            trace_id: expect.stringMatching(/[a-f\d]{32}/),
+          },
+        }
+      : {}),
     device: {
       arch: expect.any(String),
     },
@@ -63,11 +72,11 @@ const ANR_EVENT = {
   },
   // and an exception that is our ANR
   exception: EXCEPTION(),
-};
+});
 
 function ANR_EVENT_WITH_DEBUG_META(file: string): Event {
   return {
-    ...ANR_EVENT,
+    ...ANR_EVENT(),
     debug_meta: {
       images: [
         {
@@ -103,7 +112,7 @@ describe('Thread Blocked Native', { timeout: 30_000 }, () => {
 
   test('Custom appRootPath', async () => {
     const ANR_EVENT_WITH_SPECIFIC_DEBUG_META: Event = {
-      ...ANR_EVENT,
+      ...ANR_EVENT(),
       debug_meta: {
         images: [
           {
@@ -134,7 +143,7 @@ describe('Thread Blocked Native', { timeout: 30_000 }, () => {
   test('blocked indefinitely', async () => {
     await createRunner(__dirname, 'indefinite.mjs')
       .withMockSentryServer()
-      .expect({ event: ANR_EVENT })
+      .expect({ event: ANR_EVENT() })
       .start()
       .completed();
   });
@@ -160,7 +169,7 @@ describe('Thread Blocked Native', { timeout: 30_000 }, () => {
       .withMockSentryServer()
       .expect({
         event: {
-          ...ANR_EVENT,
+          ...ANR_EVENT(),
           exception: EXCEPTION('0', 'longWorkOther'),
         },
       })
@@ -179,7 +188,7 @@ describe('Thread Blocked Native', { timeout: 30_000 }, () => {
           expect(crashedThread).toBeDefined();
 
           expect(event).toMatchObject({
-            ...ANR_EVENT,
+            ...ANR_EVENT(),
             exception: {
               ...EXCEPTION(crashedThread),
             },
@@ -210,4 +219,52 @@ describe('Thread Blocked Native', { timeout: 30_000 }, () => {
       .start()
       .completed();
   });
+
+  test('Capture scope via AsyncLocalStorage', async ctx => {
+    if (NODE_VERSION < 24) {
+      ctx.skip();
+      return;
+    }
+
+    const instrument = join(__dirname, 'instrument.mjs');
+    await createRunner(__dirname, 'isolated.mjs')
+      .withMockSentryServer()
+      .withInstrument(instrument)
+      .expect({
+        event: event => {
+          const crashedThread = event.threads?.values?.find(thread => thread.crashed)?.id as string;
+          expect(crashedThread).toBeDefined();
+
+          expect(event).toMatchObject({
+            ...ANR_EVENT(true),
+            exception: {
+              ...EXCEPTION(crashedThread),
+            },
+            breadcrumbs: [
+              {
+                timestamp: expect.any(Number),
+                category: 'console',
+                data: { arguments: ['Starting task 5'], logger: 'console' },
+                level: 'log',
+                message: 'Starting task 5',
+              },
+            ],
+            user: { id: 5 },
+            threads: {
+              values: [
+                {
+                  id: '0',
+                  name: 'main',
+                  crashed: true,
+                  current: true,
+                  main: true,
+                },
+              ],
+            },
+          });
+        },
+      })
+      .start()
+      .completed();
+  });
 });

dev-packages/node-integration-tests/utils/index.ts

@@ -3,7 +3,7 @@ import { parseSemver } from '@sentry/core';
 import type * as http from 'http';
 import { describe } from 'vitest';
 
-const NODE_VERSION = parseSemver(process.versions.node).major;
+export const NODE_VERSION = parseSemver(process.versions.node).major || 0;
 
 export type TestServerConfig = {
   url: string;

packages/node-core/src/sdk/client.ts

@@ -12,7 +12,7 @@ import {
   SDK_VERSION,
   ServerRuntimeClient,
 } from '@sentry/core';
-import { getTraceContextForScope } from '@sentry/opentelemetry';
+import { type AsyncLocalStorageLookup, getTraceContextForScope } from '@sentry/opentelemetry';
 import { isMainThread, threadId } from 'worker_threads';
 import { DEBUG_BUILD } from '../debug-build';
 import type { NodeClientOptions } from '../types';
@@ -22,6 +22,8 @@ const DEFAULT_CLIENT_REPORT_FLUSH_INTERVAL_MS = 60_000; // 60s was chosen arbitr
 /** A client for using Sentry with Node & OpenTelemetry. */
 export class NodeClient extends ServerRuntimeClient<NodeClientOptions> {
   public traceProvider: BasicTracerProvider | undefined;
+  public asyncLocalStorageLookup: AsyncLocalStorageLookup | undefined;
+
   private _tracer: Tracer | undefined;
   private _clientReportInterval: NodeJS.Timeout | undefined;
   private _clientReportOnExitFlushListener: (() => void) | undefined;

packages/node-native/package.json

@@ -63,7 +63,7 @@
     "build:tarball": "npm pack"
   },
   "dependencies": {
-    "@sentry-internal/node-native-stacktrace": "^0.2.2",
+    "@sentry-internal/node-native-stacktrace": "^0.3.0",
     "@sentry/core": "10.29.0",
     "@sentry/node": "10.29.0"
   },

packages/node-native/src/event-loop-block-integration.ts

@@ -1,7 +1,6 @@
 import { isPromise } from 'node:util/types';
 import { isMainThread, Worker } from 'node:worker_threads';
 import type {
-  Client,
   ClientOptions,
   Contexts,
   DsnComponents,
@@ -47,7 +46,7 @@ function poll(enabled: boolean, clientOptions: ClientOptions): void {
     // serialized without making it a SerializedSession
     const session = currentSession ? { ...currentSession, toJSON: undefined } : undefined;
     // message the worker to tell it the main event loop is still running
-    threadPoll({ session, debugImages: getFilenameToDebugIdMap(clientOptions.stackParser) }, !enabled);
+    threadPoll(enabled, { session, debugImages: getFilenameToDebugIdMap(clientOptions.stackParser) });
   } catch {
     // we ignore all errors
   }
@@ -57,10 +56,15 @@ function poll(enabled: boolean, clientOptions: ClientOptions): void {
  * Starts polling
  */
 function startPolling(
-  client: Client,
+  client: NodeClient,
   integrationOptions: Partial<ThreadBlockedIntegrationOptions>,
 ): IntegrationInternal | undefined {
-  registerThread();
+  if (client.asyncLocalStorageLookup) {
+    const { asyncLocalStorage, contextSymbol } = client.asyncLocalStorageLookup;
+    registerThread({ asyncLocalStorage, stateLookup: ['_currentContext', contextSymbol] });
+  } else {
+    registerThread();
+  }
 
   let enabled = true;
 
@@ -160,15 +164,19 @@ const _eventLoopBlockIntegration = ((options: Partial<ThreadBlockedIntegrationOp
         return;
       }
 
-      try {
-        polling = await startPolling(client, options);
-
-        if (isMainThread) {
-          await startWorker(dsn, client, options);
+      // Otel is not setup until after afterAllSetup returns.
+      setImmediate(async () => {
+        try {
+          polling = startPolling(client, options);
+
+          if (isMainThread) {
+            await startWorker(dsn, client, options);
+          }
+        } catch (err) {
+          log('Failed to start integration', err);
+          return;
         }
-      } catch (err) {
-        log('Failed to start integration', err);
-      }
+      });
     },
     start() {
       polling?.start();

packages/node-native/src/event-loop-block-watchdog.ts

@@ -1,12 +1,16 @@
 import { workerData } from 'node:worker_threads';
-import type { DebugImage, Event, Session, StackFrame, Thread } from '@sentry/core';
+import type { DebugImage, Event, ScopeData, Session, StackFrame, Thread } from '@sentry/core';
 import {
+  applyScopeDataToEvent,
   createEventEnvelope,
   createSessionEnvelope,
   filenameIsInApp,
+  generateSpanId,
   getEnvelopeEndpointWithUrlEncodedAuth,
   makeSession,
+  mergeScopeData,
   normalizeUrlToBase,
+  Scope,
   stripSentryFramesAndReverse,
   updateSession,
   uuid4,
@@ -16,6 +20,11 @@ import { captureStackTrace, getThreadsLastSeen } from '@sentry-internal/node-nat
 import type { ThreadState, WorkerStartData } from './common';
 import { POLL_RATIO } from './common';
 
+type CurrentScopes = {
+  scope: Scope;
+  isolationScope: Scope;
+};
+
 const {
   threshold,
   appRootPath,
@@ -178,7 +187,7 @@ function applyDebugMeta(event: Event, debugImages: Record<string, string>): void
 
 function getExceptionAndThreads(
   crashedThreadId: string,
-  threads: ReturnType<typeof captureStackTrace<ThreadState>>,
+  threads: ReturnType<typeof captureStackTrace<CurrentScopes, ThreadState>>,
 ): Event {
   const crashedThread = threads[crashedThreadId];
 
@@ -217,12 +226,28 @@ function getExceptionAndThreads(
   };
 }
 
+function applyScopeToEvent(event: Event, scope: ScopeData): void {
+  applyScopeDataToEvent(event, scope);
+
+  if (!event.contexts?.trace) {
+    const { traceId, parentSpanId, propagationSpanId } = scope.propagationContext;
+    event.contexts = {
+      trace: {
+        trace_id: traceId,
+        span_id: propagationSpanId || generateSpanId(),
+        parent_span_id: parentSpanId,
+      },
+      ...event.contexts,
+    };
+  }
+}
+
 async function sendBlockEvent(crashedThreadId: string): Promise<void> {
   if (isRateLimited()) {
     return;
   }
 
-  const threads = captureStackTrace<ThreadState>();
+  const threads = captureStackTrace<CurrentScopes, ThreadState>();
   const crashedThread = threads[crashedThreadId];
 
   if (!crashedThread) {
@@ -231,7 +256,7 @@ async function sendBlockEvent(crashedThreadId: string): Promise<void> {
   }
 
   try {
-    await sendAbnormalSession(crashedThread.state?.session);
+    await sendAbnormalSession(crashedThread.pollState?.session);
   } catch (error) {
     log(`Failed to send abnormal session for thread '${crashedThreadId}':`, error);
   }
@@ -250,8 +275,17 @@ async function sendBlockEvent(crashedThreadId: string): Promise<void> {
     ...getExceptionAndThreads(crashedThreadId, threads),
   };
 
+  const asyncState = threads[crashedThreadId]?.asyncState;
+  if (asyncState) {
+    // We need to rehydrate the scopes from the serialized objects so we can call getScopeData()
+    const scope = Object.assign(new Scope(), asyncState.scope).getScopeData();
+    const isolationScope = Object.assign(new Scope(), asyncState.isolationScope).getScopeData();
+    mergeScopeData(scope, isolationScope);
+    applyScopeToEvent(event, scope);
+  }
+
   const allDebugImages: Record<string, string> = Object.values(threads).reduce((acc, threadState) => {
-    return { ...acc, ...threadState.state?.debugImages };
+    return { ...acc, ...threadState.pollState?.debugImages };
   }, {});
 
   applyDebugMeta(event, allDebugImages);