feat(node): Add eventLoopBlockIntegration

dev-packages/e2e-tests/verdaccio-config/config.yaml

@@ -104,6 +104,12 @@ packages:
     unpublish: $all
     # proxy: npmjs # Don't proxy for E2E tests!
 
+  '@sentry/node-native':
+    access: $all
+    publish: $all
+    unpublish: $all
+    # proxy: npmjs # Don't proxy for E2E tests!
+
   '@sentry/opentelemetry':
     access: $all
     publish: $all

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

@@ -0,0 +1,23 @@
+import * as Sentry from '@sentry/node';
+import { threadBlockedIntegration } 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: [threadBlockedIntegration({ blockedThreshold: 100, 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 { threadBlockedIntegration } 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: [threadBlockedIntegration({ blockedThreshold: 100, maxBlockedEvents: 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 { threadBlockedIntegration } = 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: [threadBlockedIntegration({ blockedThreshold: 100 })],
+});
+
+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 { threadBlockedIntegration } 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: [threadBlockedIntegration({ blockedThreshold: 100 })],
+});
+
+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 { threadBlockedIntegration } 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: [threadBlockedIntegration({ blockedThreshold: 100 })],
+});
+
+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 { threadBlockedIntegration } from '@sentry/node-native';
+
+Sentry.init({
+  debug: true,
+  dsn: process.env.SENTRY_DSN,
+  release: '1.0',
+  integrations: [threadBlockedIntegration({ blockedThreshold: 100 })],
+});

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 < 20; 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 { threadBlockedIntegration } = require('@sentry/node-native');
+
+function configureSentry() {
+  Sentry.init({
+    dsn: 'https://[email protected]/1337',
+    release: '1.0',
+    debug: true,
+    integrations: [threadBlockedIntegration()],
+  });
+}
+
+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 { threadBlockedIntegration } = require('@sentry/node-native');
+
+function configureSentry() {
+  Sentry.init({
+    dsn: 'https://[email protected]/1337',
+    release: '1.0',
+    debug: true,
+    integrations: [threadBlockedIntegration()],
+  });
+}
+
+async function main() {
+  configureSentry();
+  await new Promise(resolve => setTimeout(resolve, 1000));
+}
+
+main();

dev-packages/node-integration-tests/suites/thread-blocked-native/stop-and-start.js

@@ -0,0 +1,45 @@
+const Sentry = require('@sentry/node');
+const { threadBlockedIntegration } = require('@sentry/node-native');
+const { longWork } = require('./long-work.js');
+const crypto = require('crypto');
+const assert = require('assert');
+
+setTimeout(() => {
+  process.exit();
+}, 10000);
+
+const threadBlocked = threadBlockedIntegration({ blockedThreshold: 100 });
+
+Sentry.init({
+  dsn: process.env.SENTRY_DSN,
+  release: '1.0',
+  debug: true,
+  integrations: [threadBlocked],
+});
+
+Sentry.setUser({ email: '[email protected]' });
+Sentry.addBreadcrumb({ message: 'important message!' });
+
+function longWorkIgnored() {
+  for (let i = 0; i < 20; i++) {
+    const salt = crypto.randomBytes(128).toString('base64');
+    const hash = crypto.pbkdf2Sync('myPassword', salt, 10000, 512, 'sha512');
+    assert.ok(hash);
+  }
+}
+
+setTimeout(() => {
+  threadBlocked.stopWorker();
+
+  setTimeout(() => {
+    longWorkIgnored();
+
+    setTimeout(() => {
+      threadBlocked.startWorker();
+
+      setTimeout(() => {
+        longWork();
+      });
+    }, 2000);
+  }, 2000);
+}, 2000);