feat(node): Add eventLoopBlockIntegration (#16709)

This PR:
- Adds `eventLoopBlockIntegration` which uses
`@sentry-internal/node-native-stacktrace` to detect and capture blocked
event loops
- Adds suite of integration tests to test all the functionality
- Bundling
- Unlike the existing ANR integration, we can't bundle the worker code
into a base64 string because there is a native module and all threads
need to load the same native module
- The worker is loaded via `new Worker(new
URL('./thread-blocked-watchdog.js', import.meta.url))` which will be
bundled correctly by latest Vite and Webpack 5
- For other bundlers you can add an extra entry point pointing at
`@sentry/node-native/thread-blocked-watchdog` which should output
to`thread-blocked-watchdog.js` next to your bundle.

## Usage

If you instrument your application via the Node.js `--import` flag, this
instrumentation will be automatically applied to all worker threads.

`instrument.mjs`

```javascript
import * as Sentry from '@sentry/node';
import { eventLoopBlockIntegration } from '@sentry/node-native';

Sentry.init({
  dsn: '__YOUR_DSN__',
  // Capture stack traces when the event loop is blocked for more than 500ms
  integrations: [eventLoopBlockIntegration({ 
    threshold: 500, // defaults to 1000 ms 
    maxEventsPerHour: 5,  // defaults to 1
  })],
});
```

`app.mjs`

```javascript
import { Worker } from 'worker_threads';

const worker = new Worker(new URL('./worker.mjs', import.meta.url));

// This main thread will be monitored for blocked event loops
```

`worker.mjs`

```javascript
// This worker thread will also be monitored for blocked event loops too

setTimeout(() => {
  longWork();
}, 2_000);
```

Start your application:

```bash
node --import instrument.mjs app.mjs
```

Blocked events are captured with stack traces for all threads:

<img width="892" alt="image"
src="https://github.com/user-attachments/assets/4990eff1-46f9-4a1d-83c7-868493a126d5"
/>

---------

Co-authored-by: Abhijeet Prasad <[email protected]>

Author: timfish

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

@@ -0,0 +1,23 @@
+import * as Sentry from '@sentry/node';
+import { eventLoopBlockIntegration } from '@sentry/node-native';
+import * as path from 'path';
+import * as url from 'url';
+import { longWork } from './long-work.js';
+
+global._sentryDebugIds = { [new Error().stack]: 'aaaaaaaa-aaaa-4aaa-aaaa-aaaaaaaaaa' };
+
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+
+setTimeout(() => {
+  process.exit();
+}, 10000);
+
+Sentry.init({
+  dsn: process.env.SENTRY_DSN,
+  release: '1.0',
+  integrations: [eventLoopBlockIntegration({ appRootPath: __dirname })],
+});
+
+setTimeout(() => {
+  longWork();
+}, 1000);

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

@@ -0,0 +1,23 @@
+import * as Sentry from '@sentry/node';
+import { eventLoopBlockIntegration } from '@sentry/node-native';
+import { longWork } from './long-work.js';
+
+global._sentryDebugIds = { [new Error().stack]: 'aaaaaaaa-aaaa-4aaa-aaaa-aaaaaaaaaa' };
+
+setTimeout(() => {
+  process.exit();
+}, 10000);
+
+Sentry.init({
+  dsn: process.env.SENTRY_DSN,
+  release: '1.0',
+  integrations: [eventLoopBlockIntegration({ maxEventsPerHour: 2 })],
+});
+
+setTimeout(() => {
+  longWork();
+}, 1000);
+
+setTimeout(() => {
+  longWork();
+}, 4000);

dev-packages/node-integration-tests/suites/thread-blocked-native/basic.js

@@ -0,0 +1,24 @@
+const Sentry = require('@sentry/node');
+const { eventLoopBlockIntegration } = require('@sentry/node-native');
+const { longWork } = require('./long-work.js');
+
+global._sentryDebugIds = { [new Error().stack]: 'aaaaaaaa-aaaa-4aaa-aaaa-aaaaaaaaaa' };
+
+setTimeout(() => {
+  process.exit();
+}, 10000);
+
+Sentry.init({
+  dsn: process.env.SENTRY_DSN,
+  release: '1.0',
+  integrations: [eventLoopBlockIntegration()],
+});
+
+setTimeout(() => {
+  longWork();
+}, 2000);
+
+// Ensure we only send one event even with multiple blocking events
+setTimeout(() => {
+  longWork();
+}, 5000);

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

@@ -0,0 +1,24 @@
+import * as Sentry from '@sentry/node';
+import { eventLoopBlockIntegration } from '@sentry/node-native';
+import { longWork } from './long-work.js';
+
+global._sentryDebugIds = { [new Error().stack]: 'aaaaaaaa-aaaa-4aaa-aaaa-aaaaaaaaaa' };
+
+setTimeout(() => {
+  process.exit();
+}, 12000);
+
+Sentry.init({
+  dsn: process.env.SENTRY_DSN,
+  release: '1.0',
+  integrations: [eventLoopBlockIntegration()],
+});
+
+setTimeout(() => {
+  longWork();
+}, 2000);
+
+// Ensure we only send one event even with multiple blocking events
+setTimeout(() => {
+  longWork();
+}, 5000);

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

@@ -0,0 +1,27 @@
+import * as Sentry from '@sentry/node';
+import { eventLoopBlockIntegration } from '@sentry/node-native';
+import * as assert from 'assert';
+import * as crypto from 'crypto';
+
+setTimeout(() => {
+  process.exit();
+}, 10000);
+
+Sentry.init({
+  dsn: process.env.SENTRY_DSN,
+  release: '1.0',
+  integrations: [eventLoopBlockIntegration()],
+});
+
+function longWork() {
+  // This loop will run almost indefinitely
+  for (let i = 0; i < 2000000000; i++) {
+    const salt = crypto.randomBytes(128).toString('base64');
+    const hash = crypto.pbkdf2Sync('myPassword', salt, 10000, 512, 'sha512');
+    assert.ok(hash);
+  }
+}
+
+setTimeout(() => {
+  longWork();
+}, 1000);

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

@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/node';
+import { eventLoopBlockIntegration } from '@sentry/node-native';
+
+Sentry.init({
+  debug: true,
+  dsn: process.env.SENTRY_DSN,
+  release: '1.0',
+  integrations: [eventLoopBlockIntegration()],
+});

dev-packages/node-integration-tests/suites/thread-blocked-native/long-work.js

@@ -0,0 +1,12 @@
+const crypto = require('crypto');
+const assert = require('assert');
+
+function longWork() {
+  for (let i = 0; i < 200; i++) {
+    const salt = crypto.randomBytes(128).toString('base64');
+    const hash = crypto.pbkdf2Sync('myPassword', salt, 10000, 512, 'sha512');
+    assert.ok(hash);
+  }
+}
+
+exports.longWork = longWork;

dev-packages/node-integration-tests/suites/thread-blocked-native/should-exit-forced.js

@@ -0,0 +1,19 @@
+const Sentry = require('@sentry/node');
+const { eventLoopBlockIntegration } = require('@sentry/node-native');
+
+function configureSentry() {
+  Sentry.init({
+    dsn: 'https://[email protected]/1337',
+    release: '1.0',
+    debug: true,
+    integrations: [eventLoopBlockIntegration()],
+  });
+}
+
+async function main() {
+  configureSentry();
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  process.exit(0);
+}
+
+main();

dev-packages/node-integration-tests/suites/thread-blocked-native/should-exit.js

@@ -0,0 +1,18 @@
+const Sentry = require('@sentry/node');
+const { eventLoopBlockIntegration } = require('@sentry/node-native');
+
+function configureSentry() {
+  Sentry.init({
+    dsn: 'https://[email protected]/1337',
+    release: '1.0',
+    debug: true,
+    integrations: [eventLoopBlockIntegration()],
+  });
+}
+
+async function main() {
+  configureSentry();
+  await new Promise(resolve => setTimeout(resolve, 1000));
+}
+
+main();

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

@@ -0,0 +1,200 @@
+import { join } from 'node:path';
+import type { Event } from '@sentry/core';
+import { afterAll, describe, expect, test } from 'vitest';
+import { cleanupChildProcesses, createRunner } from '../../utils/runner';
+
+function EXCEPTION(thread_id = '0') {
+  return {
+    values: [
+      {
+        type: 'EventLoopBlocked',
+        value: 'Event Loop Blocked for at least 1000 ms',
+        mechanism: { type: 'ANR' },
+        thread_id,
+        stacktrace: {
+          frames: expect.arrayContaining([
+            expect.objectContaining({
+              colno: expect.any(Number),
+              lineno: expect.any(Number),
+              filename: expect.any(String),
+              function: '?',
+              in_app: true,
+            }),
+            expect.objectContaining({
+              colno: expect.any(Number),
+              lineno: expect.any(Number),
+              filename: expect.any(String),
+              function: 'longWork',
+              in_app: true,
+            }),
+          ]),
+        },
+      },
+    ],
+  };
+}
+
+const ANR_EVENT = {
+  // Ensure we have context
+  contexts: {
+    device: {
+      arch: expect.any(String),
+    },
+    app: {
+      app_start_time: expect.any(String),
+    },
+    os: {
+      name: expect.any(String),
+    },
+    culture: {
+      timezone: expect.any(String),
+    },
+  },
+  threads: {
+    values: [
+      {
+        id: '0',
+        name: 'main',
+        crashed: true,
+        current: true,
+        main: true,
+      },
+    ],
+  },
+  // and an exception that is our ANR
+  exception: EXCEPTION(),
+};
+
+function ANR_EVENT_WITH_DEBUG_META(file: string): Event {
+  return {
+    ...ANR_EVENT,
+    debug_meta: {
+      images: [
+        {
+          type: 'sourcemap',
+          debug_id: 'aaaaaaaa-aaaa-4aaa-aaaa-aaaaaaaaaa',
+          code_file: expect.stringContaining(file),
+        },
+      ],
+    },
+  };
+}
+
+describe('Thread Blocked Native', { timeout: 30_000 }, () => {
+  afterAll(() => {
+    cleanupChildProcesses();
+  });
+
+  test('CJS', async () => {
+    await createRunner(__dirname, 'basic.js')
+      .withMockSentryServer()
+      .expect({ event: ANR_EVENT_WITH_DEBUG_META('basic') })
+      .start()
+      .completed();
+  });
+
+  test('ESM', async () => {
+    await createRunner(__dirname, 'basic.mjs')
+      .withMockSentryServer()
+      .expect({ event: ANR_EVENT_WITH_DEBUG_META('basic') })
+      .start()
+      .completed();
+  });
+
+  test('Custom appRootPath', async () => {
+    const ANR_EVENT_WITH_SPECIFIC_DEBUG_META: Event = {
+      ...ANR_EVENT,
+      debug_meta: {
+        images: [
+          {
+            type: 'sourcemap',
+            debug_id: 'aaaaaaaa-aaaa-4aaa-aaaa-aaaaaaaaaa',
+            code_file: 'app:///app-path.mjs',
+          },
+        ],
+      },
+    };
+
+    await createRunner(__dirname, 'app-path.mjs')
+      .withMockSentryServer()
+      .expect({ event: ANR_EVENT_WITH_SPECIFIC_DEBUG_META })
+      .start()
+      .completed();
+  });
+
+  test('multiple events via maxEventsPerHour', async () => {
+    await createRunner(__dirname, 'basic-multiple.mjs')
+      .withMockSentryServer()
+      .expect({ event: ANR_EVENT_WITH_DEBUG_META('basic-multiple') })
+      .expect({ event: ANR_EVENT_WITH_DEBUG_META('basic-multiple') })
+      .start()
+      .completed();
+  });
+
+  test('blocked indefinitely', async () => {
+    await createRunner(__dirname, 'indefinite.mjs')
+      .withMockSentryServer()
+      .expect({ event: ANR_EVENT })
+      .start()
+      .completed();
+  });
+
+  test('should exit', async () => {
+    const runner = createRunner(__dirname, 'should-exit.js').start();
+
+    await new Promise(resolve => setTimeout(resolve, 5_000));
+
+    expect(runner.childHasExited()).toBe(true);
+  });
+
+  test('should exit forced', async () => {
+    const runner = createRunner(__dirname, 'should-exit-forced.js').start();
+
+    await new Promise(resolve => setTimeout(resolve, 5_000));
+
+    expect(runner.childHasExited()).toBe(true);
+  });
+
+  test('worker thread', async () => {
+    const instrument = join(__dirname, 'instrument.mjs');
+    await createRunner(__dirname, 'worker-main.mjs')
+      .withMockSentryServer()
+      .withFlags('--import', instrument)
+      .expect({
+        event: event => {
+          const crashedThread = event.threads?.values?.find(thread => thread.crashed)?.id as string;
+          expect(crashedThread).toBeDefined();
+
+          expect(event).toMatchObject({
+            ...ANR_EVENT,
+            exception: {
+              ...EXCEPTION(crashedThread),
+            },
+            threads: {
+              values: [
+                {
+                  id: '0',
+                  name: 'main',
+                  crashed: false,
+                  current: true,
+                  main: true,
+                  stacktrace: {
+                    frames: expect.any(Array),
+                  },
+                },
+                {
+                  id: crashedThread,
+                  name: `worker-${crashedThread}`,
+                  crashed: true,
+                  current: true,
+                  main: false,
+                },
+              ],
+            },
+          });
+        },
+      })
+      .start()
+      .completed();
+  });
+});

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

@@ -0,0 +1,5 @@
+import { longWork } from './long-work.js';
+
+setTimeout(() => {
+  longWork();
+}, 2000);