Add rate limits

Author: timfish

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

@@ -11,7 +11,7 @@ setTimeout(() => {
 Sentry.init({
   dsn: process.env.SENTRY_DSN,
   release: '1.0',
-  integrations: [eventLoopBlockIntegration({ maxBlockedEvents: 2 })],
+  integrations: [eventLoopBlockIntegration({ maxEventsPerHour: 2 })],
 });
 
 setTimeout(() => {

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

@@ -29,13 +29,13 @@ function longWorkIgnored() {
 }
 
 setTimeout(() => {
-  threadBlocked.stopWorker();
+  threadBlocked.stop();
 
   setTimeout(() => {
     longWorkIgnored();
 
     setTimeout(() => {
-      threadBlocked.startWorker();
+      threadBlocked.start();
 
       setTimeout(() => {
         longWork();

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

@@ -122,7 +122,7 @@ describe('Thread Blocked Native', { timeout: 30_000 }, () => {
       .completed();
   });
 
-  test('multiple events via maxBlockedEvents', async () => {
+  test('multiple events via maxEventsPerHour', async () => {
     await createRunner(__dirname, 'basic-multiple.mjs')
       .withMockSentryServer()
       .expect({ event: ANR_EVENT_WITH_DEBUG_META('basic-multiple') })

packages/node-native/src/common.ts

@@ -10,11 +10,11 @@ export interface ThreadBlockedIntegrationOptions {
    */
   threshold: number;
   /**
-   * Maximum number of blocked events to send.
+   * Maximum number of blocked events to send per clock hour.
    *
    * Defaults to 1.
    */
-  maxBlockedEvents: number;
+  maxEventsPerHour: number;
   /**
    * Tags to include with blocked events.
    */

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

@@ -9,10 +9,10 @@ import { POLL_RATIO } from './common';
 
 const { isPromise } = types;
 
-const DEFAULT_THRESHOLD = 1_000;
+const DEFAULT_THRESHOLD_MS = 1_000;
 
 function log(message: string, ...args: unknown[]): void {
-  logger.log(`[Thread Blocked] ${message}`, ...args);
+  logger.log(`[Sentry Block Event Loop] ${message}`, ...args);
 }
 
 /**
@@ -32,15 +32,15 @@ async function getContexts(client: NodeClient): Promise<Contexts> {
 
 const INTEGRATION_NAME = 'ThreadBlocked';
 
-type ThreadBlockedInternal = { startWorker: () => void; stopWorker: () => void };
+type ThreadBlockedInternal = { start: () => void; stop: () => void };
 
 const _eventLoopBlockIntegration = ((options: Partial<ThreadBlockedIntegrationOptions> = {}) => {
   let worker: Promise<() => void> | undefined;
   let client: NodeClient | undefined;
 
   return {
     name: INTEGRATION_NAME,
-    startWorker: () => {
+    start: () => {
       if (worker) {
         return;
       }
@@ -49,7 +49,7 @@ const _eventLoopBlockIntegration = ((options: Partial<ThreadBlockedIntegrationOp
         worker = _startWorker(client, options);
       }
     },
-    stopWorker: () => {
+    stop: () => {
       if (worker) {
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         worker.then(stop => {
@@ -58,12 +58,11 @@ const _eventLoopBlockIntegration = ((options: Partial<ThreadBlockedIntegrationOp
         });
       }
     },
-    async afterAllSetup(initClient: NodeClient) {
+    afterAllSetup(initClient: NodeClient) {
       client = initClient;
 
       registerThread();
-
-      this.startWorker();
+      this.start();
     },
   } as Integration & ThreadBlockedInternal;
 }) satisfies IntegrationFn;
@@ -140,8 +139,8 @@ async function _startWorker(
     dist: initOptions.dist,
     sdkMetadata,
     appRootPath: integrationOptions.appRootPath,
-    threshold: integrationOptions.threshold || DEFAULT_THRESHOLD,
-    maxBlockedEvents: integrationOptions.maxBlockedEvents || 1,
+    threshold: integrationOptions.threshold || DEFAULT_THRESHOLD_MS,
+    maxEventsPerHour: integrationOptions.maxEventsPerHour || 1,
     staticTags: integrationOptions.staticTags || {},
     contexts,
   };
@@ -207,13 +206,13 @@ export function disableBlockedDetectionForCallback<T>(callback: () => T | Promis
     return callback();
   }
 
-  integration.stopWorker();
+  integration.stop();
 
   const result = callback();
   if (isPromise(result)) {
-    return result.finally(() => integration.startWorker());
+    return result.finally(() => integration.start());
   }
 
-  integration.startWorker();
+  integration.start();
   return result;
 }

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

@@ -24,7 +24,7 @@ const {
   dist,
   dsn,
   environment,
-  maxBlockedEvents,
+  maxEventsPerHour,
   release,
   sdkMetadata,
   staticTags: tags,
@@ -33,22 +33,48 @@ const {
 
 const pollInterval = threshold / POLL_RATIO
 const triggeredThreads = new Set<string>();
-let sentAnrEvents = 0;
 
 function log(...msg: unknown[]): void {
   if (debug) {
     // eslint-disable-next-line no-console
-    console.log('[Sentry Blocked Watchdog]', ...msg);
+    console.log('[Sentry Block Event Loop Watchdog]', ...msg);
   }
 }
 
+function createRateLimiter(maxEventsPerHour: number): () => boolean {
+  let currentHour = 0;
+  let currentCount = 0;
+
+  return function isRateLimited(): boolean {
+    const hour = new Date().getHours();
+
+    if (hour !== currentHour) {
+      currentHour = hour;
+      currentCount = 0;
+    }
+
+    if (currentCount >= maxEventsPerHour) {
+      if (currentCount === maxEventsPerHour) {
+        currentCount += 1;
+        log(`Rate limit reached: ${currentCount} events in this hour`);
+      }
+      return true;
+    }
+
+    currentCount += 1;
+    return false;
+  };
+
+}
+
 const url = getEnvelopeEndpointWithUrlEncodedAuth(dsn, tunnel, sdkMetadata.sdk);
 const transport = makeNodeTransport({
   url,
   recordDroppedEvent: () => {
     //
   },
 });
+const isRateLimited = createRateLimiter(maxEventsPerHour);
 
 async function sendAbnormalSession(serializedSession: Session | undefined): Promise<void> {
   if (!serializedSession) {
@@ -193,12 +219,10 @@ function getExceptionAndThreads(
 }
 
 async function sendAnrEvent(crashedThreadId: string): Promise<void> {
-  if (sentAnrEvents >= maxBlockedEvents) {
+  if (isRateLimited()) {
     return;
   }
 
-  sentAnrEvents += 1;
-
   const threads = captureStackTrace<ThreadState>();
   const crashedThread = threads[crashedThreadId];
 
@@ -235,14 +259,6 @@ async function sendAnrEvent(crashedThreadId: string): Promise<void> {
 
   await transport.send(envelope);
   await transport.flush(2000);
-
-  if (sentAnrEvents >= maxBlockedEvents) {
-    // Delay for 5 seconds so that stdio can flush if the main event loop ever restarts.
-    // This is mainly for the benefit of logging or debugging.
-    setTimeout(() => {
-      process.exit(0);
-    }, 5_000);
-  }
 }
 
 setInterval(async () => {