feat(node-core): Extend onnhandledrejection with ignore errors option

dev-packages/node-integration-tests/suites/public-api/onUnhandledRejectionIntegration/ignore-custom-name.js

@@ -0,0 +1,27 @@
+const Sentry = require('@sentry/node');
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+  integrations: [
+    Sentry.onUnhandledRejectionIntegration({
+      // Use default mode: 'warn' - integration is active but should ignore CustomIgnoredError
+      ignore: [{ name: 'CustomIgnoredError' }],
+    }),
+  ],
+});
+
+// Create a custom error that should be ignored
+class CustomIgnoredError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'CustomIgnoredError';
+  }
+}
+
+setTimeout(() => {
+  process.stdout.write("I'm alive!");
+  process.exit(0);
+}, 500);
+
+// This should be ignored by the custom ignore matcher and not produce a warning
+Promise.reject(new CustomIgnoredError('This error should be ignored'));

dev-packages/node-integration-tests/suites/public-api/onUnhandledRejectionIntegration/ignore-default.js

@@ -0,0 +1,22 @@
+const Sentry = require('@sentry/node');
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+  // Use default mode: 'warn' - integration is active but should ignore AI_NoOutputGeneratedError
+});
+
+// Create an error with the name that should be ignored by default
+class AI_NoOutputGeneratedError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AI_NoOutputGeneratedError';
+  }
+}
+
+setTimeout(() => {
+  process.stdout.write("I'm alive!");
+  process.exit(0);
+}, 500);
+
+// This should be ignored by default and not produce a warning
+Promise.reject(new AI_NoOutputGeneratedError('Stream aborted'));

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

@@ -178,4 +178,32 @@ test rejection`);
     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('should not warn when AI_NoOutputGeneratedError is rejected (default ignore)', () =>
+    new Promise<void>(done => {
+      expect.assertions(3);
+
+      const testScriptPath = path.resolve(__dirname, 'ignore-default.js');
+
+      childProcess.execFile('node', [testScriptPath], { encoding: 'utf8' }, (err, stdout, stderr) => {
+        expect(err).toBeNull();
+        expect(stdout).toBe("I'm alive!");
+        expect(stderr).toBe(''); // No warning should be shown
+        done();
+      });
+    }));
+
+  test('should not warn when custom ignored error by name is rejected', () =>
+    new Promise<void>(done => {
+      expect.assertions(3);
+
+      const testScriptPath = path.resolve(__dirname, 'ignore-custom-name.js');
+
+      childProcess.execFile('node', [testScriptPath], { encoding: 'utf8' }, (err, stdout, stderr) => {
+        expect(err).toBeNull();
+        expect(stdout).toBe("I'm alive!");
+        expect(stderr).toBe(''); // No warning should be shown
+        done();
+      });
+    }));
 });

packages/node-core/src/integrations/onunhandledrejection.ts

@@ -1,24 +1,41 @@
 import type { Client, IntegrationFn, SeverityLevel, Span } from '@sentry/core';
-import { captureException, consoleSandbox, defineIntegration, getClient, withActiveSpan } from '@sentry/core';
+import {
+  captureException,
+  consoleSandbox,
+  defineIntegration,
+  getClient,
+  isMatchingPattern,
+  withActiveSpan,
+} from '@sentry/core';
 import { logAndExitProcess } from '../utils/errorhandling';
 
 type UnhandledRejectionMode = 'none' | 'warn' | 'strict';
 
+type IgnoreMatcher = { name?: string | RegExp; message?: string | RegExp };
+
 interface OnUnhandledRejectionOptions {
   /**
    * Option deciding what to do after capturing unhandledRejection,
    * that mimicks behavior of node's --unhandled-rejection flag.
    */
   mode: UnhandledRejectionMode;
+  /** Rejection Errors to ignore (don't capture or warn). */
+  ignore?: IgnoreMatcher[];
 }
 
 const INTEGRATION_NAME = 'OnUnhandledRejection';
 
+const DEFAULT_IGNORES: IgnoreMatcher[] = [
+  {
+    name: 'AI_NoOutputGeneratedError', // When stream aborts in Vercel AI SDK, Vercel flush() fails with an error
+  },
+];
+
 const _onUnhandledRejectionIntegration = ((options: Partial<OnUnhandledRejectionOptions> = {}) => {
-  const opts = {
-    mode: 'warn',
-    ...options,
-  } satisfies OnUnhandledRejectionOptions;
+  const opts: OnUnhandledRejectionOptions = {
+    mode: options.mode ?? 'warn',
+    ignore: [...DEFAULT_IGNORES, ...(options.ignore ?? [])],
+  };
 
   return {
     name: INTEGRATION_NAME,
@@ -28,27 +45,54 @@ const _onUnhandledRejectionIntegration = ((options: Partial<OnUnhandledRejection
   };
 }) satisfies IntegrationFn;
 
-/**
- * Add a global promise rejection handler.
- */
 export const onUnhandledRejectionIntegration = defineIntegration(_onUnhandledRejectionIntegration);
 
-/**
- * Send an exception with reason
- * @param reason string
- * @param promise promise
- *
- * Exported only for tests.
- */
+/** Extract error info safely */
+function extractErrorInfo(reason: unknown): { name: string; message: string } {
+  // Check if reason is an object (including Error instances, not just plain objects)
+  if (typeof reason !== 'object' || reason === null) {
+    return { name: '', message: String(reason ?? '') };
+  }
+
+  const errorLike = reason as Record<string, unknown>;
+  const name = typeof errorLike.name === 'string' ? errorLike.name : '';
+  const message = typeof errorLike.message === 'string' ? errorLike.message : String(reason);
+
+  return { name, message };
+}
+
+/** Check if a matcher matches the reason */
+function isMatchingReason(matcher: IgnoreMatcher, errorInfo: ReturnType<typeof extractErrorInfo>): boolean {
+  // name/message matcher
+  const nameMatches = matcher.name === undefined || isMatchingPattern(errorInfo.name, matcher.name, true);
+
+  const messageMatches = matcher.message === undefined || isMatchingPattern(errorInfo.message, matcher.message);
+
+  return nameMatches && messageMatches;
+}
+
+/** Match helper */
+function matchesIgnore(list: IgnoreMatcher[], reason: unknown): boolean {
+  const errorInfo = extractErrorInfo(reason);
+  return list.some(matcher => isMatchingReason(matcher, errorInfo));
+}
+
+/** Core handler */
 export function makeUnhandledPromiseHandler(
   client: Client,
   options: OnUnhandledRejectionOptions,
 ): (reason: unknown, promise: unknown) => void {
   return function sendUnhandledPromise(reason: unknown, promise: unknown): void {
+    // Only handle for the active client
     if (getClient() !== client) {
       return;
     }
 
+    // Skip if configured to ignore
+    if (matchesIgnore(options.ignore ?? [], reason)) {
+      return;
+    }
+
     const level: SeverityLevel = options.mode === 'strict' ? 'fatal' : 'error';
 
     // this can be set in places where we cannot reliably get access to the active span/error