Merge branch 'develop' into sig/ioredis-setex

Author: s1gr1d

.size-limit.js

@@ -22,7 +22,7 @@ module.exports = [
     path: 'packages/browser/build/npm/esm/index.js',
     import: createImport('init', 'browserTracingIntegration', 'replayIntegration'),
     gzip: true,
-    limit: '70 KB',
+    limit: '71 KB',
   },
   {
     name: '@sentry/browser (incl. Tracing, Replay) - with treeshaking flags',

packages/browser/src/stack-parsers.ts

@@ -50,14 +50,29 @@ function createFrame(filename: string, func: string, lineno?: number, colno?: nu
   return frame;
 }
 
-// Chromium based browsers: Chrome, Brave, new Opera, new Edge
+// This regex matches frames that have no function name (ie. are at the top level of a module).
+// For example "at http://localhost:5000//script.js:1:126"
+// Frames _with_ function names usually look as follows: "at commitLayoutEffects (react-dom.development.js:23426:1)"
+const chromeRegexNoFnName = /^\s*at (\S+?)(?::(\d+))(?::(\d+))\s*$/i;
+
+// This regex matches all the frames that have a function name.
 const chromeRegex =
   /^\s*at (?:(.+?\)(?: \[.+\])?|.*?) ?\((?:address at )?)?(?:async )?((?:<anonymous>|[-a-z]+:|.*bundle|\/)?.*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
+
 const chromeEvalRegex = /\((\S*)(?::(\d+))(?::(\d+))\)/;
 
+// Chromium based browsers: Chrome, Brave, new Opera, new Edge
 // We cannot call this variable `chrome` because it can conflict with global `chrome` variable in certain environments
 // See: https://github.com/getsentry/sentry-javascript/issues/6880
 const chromeStackParserFn: StackLineParserFn = line => {
+  // If the stack line has no function name, we need to parse it differently
+  const noFnParts = chromeRegexNoFnName.exec(line);
+
+  if (noFnParts) {
+    const [, filename, line, col] = noFnParts;
+    return createFrame(filename, UNKNOWN_FUNCTION, +line, +col);
+  }
+
   const parts = chromeRegex.exec(line);
 
   if (parts) {

packages/browser/test/unit/tracekit/chromium.test.ts

@@ -579,6 +579,7 @@ describe('Tracekit - Chrome Tests', () => {
       name: 'Error',
       stack: `Error: bad
           at something (http://localhost:5000/(some)/(thing)/index.html:20:16)
+          at http://localhost:5000/(group)/[route]/script.js:1:126
           at more (http://localhost:5000/(some)/(thing)/index.html:25:7)`,
     };
 
@@ -596,6 +597,13 @@ describe('Tracekit - Chrome Tests', () => {
             colno: 7,
             in_app: true,
           },
+          {
+            filename: 'http://localhost:5000/(group)/[route]/script.js',
+            function: '?',
+            lineno: 1,
+            colno: 126,
+            in_app: true,
+          },
           {
             filename: 'http://localhost:5000/(some)/(thing)/index.html',
             function: 'something',

packages/browser/test/unit/tracekit/firefox.test.ts

@@ -311,6 +311,41 @@ describe('Tracekit - Firefox Tests', () => {
     });
   });
 
+  it('should correctly parse parentheses', () => {
+    const PARENTHESIS_FRAME_EXCEPTION = {
+      message: 'aha',
+      name: 'Error',
+      stack:
+        'onClick@http://localhost:3002/_next/static/chunks/app/(group)/[route]/script.js:1:644\n' +
+        '@http://localhost:3002/_next/static/chunks/app/(group)/[route]/script.js:1:126',
+    };
+
+    const stacktrace = exceptionFromError(parser, PARENTHESIS_FRAME_EXCEPTION);
+
+    expect(stacktrace).toEqual({
+      value: 'aha',
+      type: 'Error',
+      stacktrace: {
+        frames: [
+          {
+            colno: 126,
+            filename: 'http://localhost:3002/_next/static/chunks/app/(group)/[route]/script.js',
+            function: '?',
+            in_app: true,
+            lineno: 1,
+          },
+          {
+            colno: 644,
+            filename: 'http://localhost:3002/_next/static/chunks/app/(group)/[route]/script.js',
+            function: 'onClick',
+            in_app: true,
+            lineno: 1,
+          },
+        ],
+      },
+    });
+  });
+
   it('should parse Firefox errors with `file` inside an identifier', () => {
     const FIREFOX_FILE_IN_IDENTIFIER = {
       stack:

packages/browser/test/unit/tracekit/safari.test.ts

@@ -320,4 +320,39 @@ describe('Tracekit - Safari Tests', () => {
       },
     });
   });
+
+  it('should correctly parse parentheses', () => {
+    const PARENTHESIS_FRAME_EXCEPTION = {
+      message: 'aha',
+      name: 'Error',
+      stack:
+        '@http://localhost:3000/(group)/[route]/script.js:1:131\n' +
+        'global code@http://localhost:3000/(group)/[route]/script.js:1:334',
+    };
+
+    const ex = exceptionFromError(parser, PARENTHESIS_FRAME_EXCEPTION);
+
+    expect(ex).toEqual({
+      value: 'aha',
+      type: 'Error',
+      stacktrace: {
+        frames: [
+          {
+            colno: 334,
+            filename: 'http://localhost:3000/(group)/[route]/script.js',
+            function: 'global code',
+            in_app: true,
+            lineno: 1,
+          },
+          {
+            colno: 131,
+            filename: 'http://localhost:3000/(group)/[route]/script.js',
+            function: '?',
+            in_app: true,
+            lineno: 1,
+          },
+        ],
+      },
+    });
+  });
 });

packages/core/src/index.ts

@@ -95,6 +95,7 @@ export { extraErrorDataIntegration } from './integrations/extraerrordata';
 export { rewriteFramesIntegration } from './integrations/rewriteframes';
 export { sessionTimingIntegration } from './integrations/sessiontiming';
 export { zodErrorsIntegration } from './integrations/zoderrors';
+export { thirdPartyErrorFilterIntegration } from './integrations/third-party-errors-filter';
 export { metrics } from './metrics/exports';
 export type { MetricData } from '@sentry/types';
 export { metricsDefault } from './metrics/exports-default';

packages/core/src/integrations/dedupe.ts

@@ -1,5 +1,5 @@
 import type { Event, Exception, IntegrationFn, StackFrame } from '@sentry/types';
-import { logger } from '@sentry/utils';
+import { getFramesFromEvent, logger } from '@sentry/utils';
 import { defineIntegration } from '../integration';
 
 import { DEBUG_BUILD } from '../debug-build';
@@ -106,8 +106,8 @@ function _isSameExceptionEvent(currentEvent: Event, previousEvent: Event): boole
 }
 
 function _isSameStacktrace(currentEvent: Event, previousEvent: Event): boolean {
-  let currentFrames = _getFramesFromEvent(currentEvent);
-  let previousFrames = _getFramesFromEvent(previousEvent);
+  let currentFrames = getFramesFromEvent(currentEvent);
+  let previousFrames = getFramesFromEvent(previousEvent);
 
   // If neither event has a stacktrace, they are assumed to be the same
   if (!currentFrames && !previousFrames) {
@@ -173,17 +173,3 @@ function _isSameFingerprint(currentEvent: Event, previousEvent: Event): boolean
 function _getExceptionFromEvent(event: Event): Exception | undefined {
   return event.exception && event.exception.values && event.exception.values[0];
 }
-
-function _getFramesFromEvent(event: Event): StackFrame[] | undefined {
-  const exception = event.exception;
-
-  if (exception) {
-    try {
-      // @ts-expect-error Object could be undefined
-      return exception.values[0].stacktrace.frames;
-    } catch (_oO) {
-      return undefined;
-    }
-  }
-  return undefined;
-}

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

@@ -0,0 +1,114 @@
+import type { Event, EventItem } from '@sentry/types';
+import { forEachEnvelopeItem, getFramesFromEvent } from '@sentry/utils';
+import { defineIntegration } from '../integration';
+import { addMetadataToStackFrames, stripMetadataFromStackFrames } from '../metadata';
+
+interface Options {
+  /**
+   * Keys that have been provided in the Sentry bundler plugin via the the `applicationKey` option, identifying your bundles.
+   *
+   * - Webpack plugin: https://www.npmjs.com/package/@sentry/webpack-plugin#applicationkey
+   * - Vite plugin: https://www.npmjs.com/package/@sentry/vite-plugin#applicationkey
+   * - Esbuild plugin: https://www.npmjs.com/package/@sentry/esbuild-plugin#applicationkey
+   * - Rollup plugin: https://www.npmjs.com/package/@sentry/rollup-plugin#applicationkey
+   */
+  filterKeys: string[];
+
+  /**
+   * Defines how the integration should behave. "Third-Party Stack Frames" are stack frames that did not come from files marked with a matching bundle key.
+   *
+   * You can define the behaviour with one of 4 modes:
+   * - `drop-error-if-contains-third-party-frames`: Drop error events that contain at least one third-party stack frame.
+   * - `drop-error-if-exclusively-contains-third-party-frames`: Drop error events that exclusively contain third-party stack frames.
+   * - `apply-tag-if-contains-third-party-frames`: Keep all error events, but apply a `third_party_code: true` tag in case the error contains at least one third-party stack frame.
+   * - `apply-tag-if-exclusively-contains-third-party-frames`: Keep all error events, but apply a `third_party_code: true` tag in case the error contains exclusively third-party stack frames.
+   *
+   * If you chose the mode to only apply tags, the tags can then be used in Sentry to filter your issue stream by entering `!third_party_code:True` in the search bar.
+   */
+  behaviour:
+    | 'drop-error-if-contains-third-party-frames'
+    | 'drop-error-if-exclusively-contains-third-party-frames'
+    | 'apply-tag-if-contains-third-party-frames'
+    | 'apply-tag-if-exclusively-contains-third-party-frames';
+}
+
+/**
+ * This integration allows you to filter out, or tag error events that do not come from user code marked with a bundle key via the Sentry bundler plugins.
+ */
+export const thirdPartyErrorFilterIntegration = defineIntegration((options: Options) => {
+  return {
+    name: 'ThirdPartyErrorsFilter',
+    setup(client) {
+      // We need to strip metadata from stack frames before sending them to Sentry since these are client side only.
+      // TODO(lforst): Move this cleanup logic into a more central place in the SDK.
+      client.on('beforeEnvelope', envelope => {
+        forEachEnvelopeItem(envelope, (item, type) => {
+          if (type === 'event') {
+            const event = Array.isArray(item) ? (item as EventItem)[1] : undefined;
+
+            if (event) {
+              stripMetadataFromStackFrames(event);
+              item[1] = event;
+            }
+          }
+        });
+      });
+    },
+    processEvent(event, _hint, client) {
+      const stackParser = client.getOptions().stackParser;
+      addMetadataToStackFrames(stackParser, event);
+
+      const frameKeys = getBundleKeysForAllFramesWithFilenames(event);
+
+      if (frameKeys) {
+        const arrayMethod =
+          options.behaviour === 'drop-error-if-contains-third-party-frames' ||
+          options.behaviour === 'apply-tag-if-contains-third-party-frames'
+            ? 'some'
+            : 'every';
+
+        const behaviourApplies = frameKeys[arrayMethod](keys => !keys.some(key => options.filterKeys.includes(key)));
+
+        if (behaviourApplies) {
+          const shouldDrop =
+            options.behaviour === 'drop-error-if-contains-third-party-frames' ||
+            options.behaviour === 'drop-error-if-exclusively-contains-third-party-frames';
+          if (shouldDrop) {
+            return null;
+          } else {
+            event.tags = {
+              ...event.tags,
+              third_party_code: true,
+            };
+          }
+        }
+      }
+
+      return event;
+    },
+  };
+});
+
+function getBundleKeysForAllFramesWithFilenames(event: Event): string[][] | undefined {
+  const frames = getFramesFromEvent(event);
+
+  if (!frames) {
+    return undefined;
+  }
+
+  return (
+    frames
+      // Exclude frames without a filename since these are likely native code or built-ins
+      .filter(frame => !!frame.filename)
+      .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));
+        }
+        return [];
+      })
+  );
+}
+
+const BUNDLER_PLUGIN_APP_KEY_PREFIX = '_sentryBundlerPluginAppKey:';

packages/core/src/metadata.ts

@@ -60,7 +60,7 @@ export function addMetadataToStackFrames(parser: StackParser, event: Event): voi
       }
 
       for (const frame of exception.stacktrace.frames || []) {
-        if (!frame.filename) {
+        if (!frame.filename || frame.module_metadata) {
           continue;
         }