feat(core): Add ignoreSentryInternalFrames option to thirdPartyErrorFilterIntegration (#18632)

Some users get flooded by third party errors despite having set their
third party error filtering to
`"drop-error-if-contains-third-party-frames"`. This comes from the fact
that often the stacktrace includes our internal wrapper logic as last
trace in the stack.

With this PR we're trying to work around this by specifically ignoring
these frames with a new opt-in mechanism. Marked this as experimental,
so users will know this option might lead to errors being misclassified.

- Adds a new experimental option
`experimentalExcludeSentryInternalFrames` to the
`thirdPartyErrorFilterIntegration`
- Once enabled we apply a strict filter for frames to detect our
internal wrapping logic and filter them out so they do not misclassify
injected code as internal errors.

Closes #13835

Author: chargome

packages/core/src/integrations/third-party-errors-filter.ts

@@ -2,6 +2,7 @@ import { defineIntegration } from '../integration';
 import { addMetadataToStackFrames, stripMetadataFromStackFrames } from '../metadata';
 import type { EventItem } from '../types-hoist/envelope';
 import type { Event } from '../types-hoist/event';
+import type { StackFrame } from '../types-hoist/stackframe';
 import { forEachEnvelopeItem } from '../utils/envelope';
 import { getFramesFromEvent } from '../utils/stacktrace';
 
@@ -32,6 +33,13 @@ interface Options {
     | 'drop-error-if-exclusively-contains-third-party-frames'
     | 'apply-tag-if-contains-third-party-frames'
     | 'apply-tag-if-exclusively-contains-third-party-frames';
+
+  /**
+   * @experimental
+   * If set to true, the integration will ignore frames that are internal to the Sentry SDK from the third-party frame detection.
+   * Note that enabling this option might lead to errors being misclassified as third-party errors.
+   */
+  ignoreSentryInternalFrames?: boolean;
 }
 
 /**
@@ -67,7 +75,7 @@ export const thirdPartyErrorFilterIntegration = defineIntegration((options: Opti
     },
 
     processEvent(event) {
-      const frameKeys = getBundleKeysForAllFramesWithFilenames(event);
+      const frameKeys = getBundleKeysForAllFramesWithFilenames(event, options.ignoreSentryInternalFrames);
 
       if (frameKeys) {
         const arrayMethod =
@@ -98,27 +106,71 @@ export const thirdPartyErrorFilterIntegration = defineIntegration((options: Opti
   };
 });
 
-function getBundleKeysForAllFramesWithFilenames(event: Event): string[][] | undefined {
+/**
+ * Checks if a stack frame is a Sentry internal frame by strictly matching:
+ * 1. The frame must be the last frame in the stack
+ * 2. The filename must indicate the internal helpers file
+ * 3. The context_line must contain the exact pattern "fn.apply(this, wrappedArguments)"
+ * 4. The comment pattern "Attempt to invoke user-land function" must be present in pre_context
+ *
+ */
+function isSentryInternalFrame(frame: StackFrame, frameIndex: number): boolean {
+  // Only match the last frame (index 0 in reversed stack)
+  if (frameIndex !== 0 || !frame.context_line || !frame.filename) {
+    return false;
+  }
+
+  if (
+    !frame.filename.includes('sentry') ||
+    !frame.filename.includes('helpers') || // Filename would look something like this: 'node_modules/@sentry/browser/build/npm/esm/helpers.js'
+    !frame.context_line.includes(SENTRY_INTERNAL_FN_APPLY) // Must have context_line with the exact fn.apply pattern
+  ) {
+    return false;
+  }
+
+  // Check pre_context array for comment pattern
+  if (frame.pre_context) {
+    const len = frame.pre_context.length;
+    for (let i = 0; i < len; i++) {
+      if (frame.pre_context[i]?.includes(SENTRY_INTERNAL_COMMENT)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+function getBundleKeysForAllFramesWithFilenames(
+  event: Event,
+  ignoreSentryInternalFrames?: boolean,
+): string[][] | undefined {
   const frames = getFramesFromEvent(event);
 
   if (!frames) {
     return undefined;
   }
 
-  return (
-    frames
+  return frames
+    .filter((frame, index) => {
       // Exclude frames without a filename or without lineno and colno,
       // since these are likely native code or built-ins
-      .filter(frame => !!frame.filename && (frame.lineno ?? frame.colno) != null)
-      .map(frame => {
-        if (frame.module_metadata) {
-          return Object.keys(frame.module_metadata)
-            .filter(key => key.startsWith(BUNDLER_PLUGIN_APP_KEY_PREFIX))
-            .map(key => key.slice(BUNDLER_PLUGIN_APP_KEY_PREFIX.length));
-        }
+      if (!frame.filename || (frame.lineno == null && frame.colno == null)) {
+        return false;
+      }
+      // Optionally ignore Sentry internal frames
+      return !ignoreSentryInternalFrames || !isSentryInternalFrame(frame, index);
+    })
+    .map(frame => {
+      if (!frame.module_metadata) {
         return [];
-      })
-  );
+      }
+      return Object.keys(frame.module_metadata)
+        .filter(key => key.startsWith(BUNDLER_PLUGIN_APP_KEY_PREFIX))
+        .map(key => key.slice(BUNDLER_PLUGIN_APP_KEY_PREFIX.length));
+    });
 }
 
 const BUNDLER_PLUGIN_APP_KEY_PREFIX = '_sentryBundlerPluginAppKey:';
+const SENTRY_INTERNAL_COMMENT = 'Attempt to invoke user-land function';
+const SENTRY_INTERNAL_FN_APPLY = 'fn.apply(this, wrappedArguments)';