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

I’m introducing support for selectively suppressing specific errors.
This is done by adding a new option that allows users to override the
default logging modes. By passing this option down through the
configuration, users will have finer control over which errors are
logged versus ignored. Also added a default array for the errors,
addressing an issue where Vercel’s flush is called during abort, causing
unnecessary error logs.

Author: RulaKhaled

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://public@dsn.ingest.sentry.io/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://public@dsn.ingest.sentry.io/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