feat(core): Add helpers to get module metadata from injected code

packages/core/src/index.ts

@@ -46,6 +46,7 @@ export { prepareEvent } from './utils/prepareEvent';
 export { createCheckInEnvelope } from './checkin';
 export { hasTracingEnabled } from './utils/hasTracingEnabled';
 export { DEFAULT_ENVIRONMENT } from './constants';
+export { getMetadataForUrl, addMetadataToStackFrames, stripMetadataFromStackFrames } from './metadata';
 
 import * as Integrations from './integrations';
 

packages/core/src/metadata.ts

@@ -0,0 +1,87 @@
+import type { Event, StackFrame, StackParser } from '@sentry/types';
+import { GLOBAL_OBJ } from '@sentry/utils';
+
+function ensureMetadataStacksAreParsed(parser: StackParser): void {
+  if (!GLOBAL_OBJ.__MODULE_METADATA__) {
+    return;
+  }
+
+  for (const stack of Object.keys(GLOBAL_OBJ.__MODULE_METADATA__)) {
+    const metadata = GLOBAL_OBJ.__MODULE_METADATA__[stack];
+
+    // If this stack has already been parsed, skip it
+    if (metadata == false) {
+      continue;
+    }
+
+    // Ensure this stack doesn't get parsed again
+    GLOBAL_OBJ.__MODULE_METADATA__[stack] = false;
+
+    const frames = parser(stack);
+
+    // Go through the frames starting from the top of the stack and find the first one with a filename
+    for (const frame of frames.reverse()) {
+      if (frame.filename) {
+        // Save the metadata for this filename
+        GLOBAL_OBJ.__MODULE_METADATA_PARSED__ = GLOBAL_OBJ.__MODULE_METADATA_PARSED__ || {};
+        GLOBAL_OBJ.__MODULE_METADATA_PARSED__[frame.filename] = metadata;
+        break;
+      }
+    }
+  }
+}
+
+/**
+ * Retrieve metadata for a specific JavaScript file URL.
+ *
+ * Metadata is injected by the Sentry bundler plugins using the `_experiments.moduleMetadata` config option.
+ */
+export function getMetadataForUrl(parser: StackParser, url: string): object | undefined {
+  ensureMetadataStacksAreParsed(parser);
+
+  const metadataObj = GLOBAL_OBJ.__MODULE_METADATA_PARSED__ || {};
+
+  return metadataObj[url];
+}
+
+/**
+ * Adds metadata to stack frames.
+ *
+ * Metadata is injected by the Sentry bundler plugins using the `_experiments.moduleMetadata` config option.
+ */
+export function addMetadataToStackFrames(parser: StackParser, event: Event): void {
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  event.exception!.values!.forEach(exception => {
+    if (!exception.stacktrace) {
+      return;
+    }
+
+    for (const frame of exception.stacktrace.frames || []) {
+      if (!frame.filename) {
+        continue;
+      }
+
+      const metadata = getMetadataForUrl(parser, frame.filename);
+
+      if (metadata) {
+        frame.module_metadata = metadata;
+      }
+    }
+  });
+}
+
+/**
+ * Strips metadata from stack frames.
+ */
+export function stripMetadataFromStackFrames(event: Event): void {
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  event.exception!.values!.forEach(exception => {
+    if (!exception.stacktrace) {
+      return;
+    }
+
+    for (const frame of exception.stacktrace.frames || []) {
+      delete frame.module_metadata;
+    }
+  });
+}

packages/core/test/lib/metadata.test.ts

@@ -0,0 +1,102 @@
+import type { Event } from '@sentry/types';
+import { createStackParser, GLOBAL_OBJ, nodeStackLineParser } from '@sentry/utils';
+
+import { addMetadataToStackFrames, getMetadataForUrl, stripMetadataFromStackFrames } from '../../src';
+
+const parser = createStackParser(nodeStackLineParser());
+
+const stack = new Error().stack || '';
+
+const event: Event = {
+  exception: {
+    values: [
+      {
+        stacktrace: {
+          frames: [
+            {
+              filename: '<anonymous>',
+              function: 'new Promise',
+            },
+            {
+              filename: '/tmp/utils.js',
+              function: 'Promise.then.completed',
+              lineno: 391,
+              colno: 28,
+            },
+            {
+              filename: __filename,
+              function: 'Object.<anonymous>',
+              lineno: 9,
+              colno: 19,
+            },
+          ],
+        },
+      },
+    ],
+  },
+};
+
+describe('Metadata', () => {
+  beforeEach(() => {
+    GLOBAL_OBJ.__MODULE_METADATA__ = GLOBAL_OBJ.__MODULE_METADATA__ || {};
+    GLOBAL_OBJ.__MODULE_METADATA__[stack] = { team: 'frontend' };
+  });
+
+  it('is parsed', () => {
+    const metadata = getMetadataForUrl(parser, __filename);
+
+    expect(metadata).toEqual({ team: 'frontend' });
+    // should now be false so it doesn't get parsed again
+    expect(GLOBAL_OBJ.__MODULE_METADATA__?.[stack]).toBe(false);
+  });
+
+  it('is added and stripped from stack frames', () => {
+    addMetadataToStackFrames(parser, event);
+
+    expect(event.exception?.values?.[0].stacktrace?.frames).toEqual([
+      {
+        filename: '<anonymous>',
+        function: 'new Promise',
+      },
+      {
+        filename: '/tmp/utils.js',
+        function: 'Promise.then.completed',
+        lineno: 391,
+        colno: 28,
+      },
+      {
+        filename: __filename,
+        function: 'Object.<anonymous>',
+        lineno: 9,
+        colno: 19,
+        module_metadata: {
+          team: 'frontend',
+        },
+      },
+    ]);
+
+    // should now be false so it doesn't get parsed again
+    expect(GLOBAL_OBJ.__MODULE_METADATA__?.[stack]).toBe(false);
+
+    stripMetadataFromStackFrames(event);
+
+    expect(event.exception?.values?.[0].stacktrace?.frames).toEqual([
+      {
+        filename: '<anonymous>',
+        function: 'new Promise',
+      },
+      {
+        filename: '/tmp/utils.js',
+        function: 'Promise.then.completed',
+        lineno: 391,
+        colno: 28,
+      },
+      {
+        filename: __filename,
+        function: 'Object.<anonymous>',
+        lineno: 9,
+        colno: 19,
+      },
+    ]);
+  });
+});

packages/types/src/stackframe.ts

@@ -15,4 +15,5 @@ export interface StackFrame {
   addr_mode?: string;
   vars?: { [key: string]: any };
   debug_id?: string;
+  module_metadata?: object;
 }

packages/utils/src/worldwide.ts

@@ -55,6 +55,19 @@ export interface InternalGlobal {
       [key: string]: Function;
     };
   };
+  /**
+   * Raw module metadata that is injected by bundler plugins.
+   *
+   * Keys are `error.stack` strings, values are metadata objects.
+   * Once the stack has been parsed, the value is set to `false` so they do not get parsed multiple times.
+   */
+  __MODULE_METADATA__?: Record<string, object | false>;
+  /**
+   * Parsed module metadata.
+   *
+   * Keys are source filenames/urls, values are metadata objects.
+   */
+  __MODULE_METADATA_PARSED__?: Record<string, object>;
 }
 
 // The code below for 'isGlobalObj' and 'GLOBAL_OBJ' was copied from core-js before modification