@grafana/faro-react-native 1.0.0 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grafana/faro-react-native",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Faro instrumentations, metas, transports for React Native.",
   "keywords": [
     "observability",
@@ -61,16 +61,12 @@
     "react-native-device-info": "^11.1.0"
   },
   "peerDependencies": {
-    "@grafana/faro-react-native-tracing": ">=1.0.0",
     "@react-navigation/native": ">=6.0.0",
     "react": ">=18.0.0",
     "react-native": ">=0.70.0",
     "react-native-mmkv": ">=2.0.0"
   },
   "peerDependenciesMeta": {
-    "@grafana/faro-react-native-tracing": {
-      "optional": true
-    },
     "@react-navigation/native": {
       "optional": true
     },
@@ -79,13 +75,14 @@
     }
   },
   "devDependencies": {
-    "@types/node": "24.10.1",
-    "@types/react": "^19.1.1",
-    "@types/react-native": "^0.73.0",
-    "react-native-mmkv": "^4.3.1"
+    "@types/node": "24.12.3",
+    "@types/react": "19.2.14",
+    "@types/react-native": "0.73.0",
+    "react-native-mmkv": "4.3.1",
+    "react-native-nitro-modules": "0.35.6"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "00172e294e05bcf2faa2193d01aabc43c3cc8134"
+  "gitHead": "65b49f4c649e3400c74495257d33bd28d9af4b58"
 }

package/react-native.config.js

@@ -1,8 +1,16 @@
 module.exports = {
   dependency: {
     platforms: {
-      ios: {},
       android: {},
+      ios: {
+        scriptPhases: [
+          {
+            name: '[Faro] Upload composed source map (Release)',
+            path: './ios/faro-upload-composed-source-map.sh',
+            execution_position: 'any',
+          },
+        ],
+      },
     },
   },
 };

package/src/config/getRNInstrumentations.ts

@@ -79,7 +79,11 @@ export function getRNInstrumentations(config: Partial<ReactNativeConfig> = {}):
 
   // Error reporting (Flutter: enableFlutterErrorReporting)
   if (enableErrorReporting) {
-    instrumentations.push(new ErrorsInstrumentation());
+    instrumentations.push(
+      new ErrorsInstrumentation({
+        releaseBundleFilename: config.releaseBundleFilename,
+      })
+    );
   }
 
   // Console capture - not in Flutter SDK, RN-specific

package/src/config/makeRNConfig.test.ts

@@ -127,4 +127,15 @@ describe('makeRNConfig', () => {
       (cfg as { preloadedSessionDeviceAttributes?: { device_id: string } }).preloadedSessionDeviceAttributes?.device_id
     ).toBe('test-preloaded-id');
   });
+
+  it('uses releaseBundleFilename in default parseStacktrace when set', () => {
+    const cfg = makeRNConfig({
+      ...base,
+      releaseBundleFilename: 'main.jsbundle',
+    });
+    const err = new Error('x');
+    err.stack = 'g@1:2';
+    const parsed = cfg.parseStacktrace?.(err);
+    expect(parsed?.frames?.[0]?.filename).toBe('main.jsbundle');
+  });
 });

package/src/config/makeRNConfig.ts

@@ -65,9 +65,11 @@ function buildInstrumentations(config: ReactNativeConfig): Config['instrumentati
 /**
  * React Native stacktrace parser. Uses getStackFramesFromError for RN-specific formats.
  */
-const parseStacktrace: Config['parseStacktrace'] = (err) => ({
-  frames: getStackFramesFromError(err),
-});
+function createParseStacktrace(releaseBundleFilename: string | undefined): Config['parseStacktrace'] {
+  return (err) => ({
+    frames: getStackFramesFromError(err, { releaseBundleFilename }),
+  });
+}
 
 /**
  * Creates a full Faro config from React Native flag-based config.
@@ -86,6 +88,7 @@ export function makeRNConfig(
   const transports = buildTransports(config);
   const instrumentations = buildInstrumentations(config);
 
+  const releaseBundleFilename = config.releaseBundleFilename;
   return {
     app: config.app,
     ...(preloadedSessionDeviceAttributes != null && {
@@ -95,7 +98,7 @@ export function makeRNConfig(
     globalObjectKey: config.globalObjectKey ?? defaultGlobalObjectKey,
     internalLoggerLevel: config.internalLoggerLevel ?? InternalLoggerLevel.ERROR,
     isolate: config.isolate ?? false,
-    parseStacktrace: config.parseStacktrace ?? parseStacktrace,
+    parseStacktrace: config.parseStacktrace ?? createParseStacktrace(releaseBundleFilename),
     paused: config.paused ?? false,
     preventGlobalExposure: config.preventGlobalExposure ?? false,
     unpatchedConsole: config.unpatchedConsole ?? defaultUnpatchedConsole,

package/src/config/types.ts

@@ -70,6 +70,11 @@ type ReactNativeConfigOverrides = {
   consoleCaptureOptions?: Config['consoleInstrumentation'];
   enableUserActions?: boolean;
   userActionsOptions?: Config['userActionsInstrumentation'];
+  /**
+   * Hermes / minified release stack lines omit a file path. This must match the Metro plugin
+   * source map top-level `file` (default `bundle.js`, or your `sourceMapFile` option there).
+   */
+  releaseBundleFilename?: string;
 };
 
 /**

package/src/generated/faroRNPackageMeta.ts

@@ -2,4 +2,4 @@
  * NPM package identity for this build. Generated by scripts/sync-faro-rn-package-meta.mjs - do not edit.
  */
 export const FARO_REACT_NATIVE_NPM_NAME = '@grafana/faro-react-native' as const;
-export const FARO_REACT_NATIVE_NPM_VERSION = '1.0.0' as const;
+export const FARO_REACT_NATIVE_NPM_VERSION = '1.2.0' as const;

package/src/initialize.test.ts

@@ -8,10 +8,17 @@ import { SessionInstrumentation } from './instrumentations/session';
 import * as sessionAttributes from './instrumentations/session/sessionAttributes';
 
 describe('initializeFaro', () => {
+  const preambleKey = '__faroBundleId_test';
+
   beforeEach(() => {
     jest.clearAllMocks();
     jest.clearAllTimers();
     delete (global as any).faro;
+    delete (globalThis as Record<string, unknown>)[preambleKey];
+  });
+
+  afterEach(() => {
+    delete (globalThis as Record<string, unknown>)[preambleKey];
   });
 
   it('should initialize Faro', async () => {
@@ -123,4 +130,22 @@ describe('initializeFaro', () => {
 
     spy.mockRestore();
   });
+
+  it('should set meta.app.bundleId from Faro Metro preamble global (__faroBundleId_<app.name>)', async () => {
+    (globalThis as Record<string, unknown>)[preambleKey] = 'release-bundle-from-metro';
+
+    const faro = await initializeFaro(
+      mockConfig({
+        url: 'http://localhost:12345/collect',
+        transports: [new MockTransport()],
+        instrumentations: [new SessionInstrumentation()],
+        sessionTracking: {
+          enabled: true,
+          persistent: false,
+        },
+      })
+    );
+
+    expect(faro.metas.value.app?.bundleId).toBe('release-bundle-from-metro');
+  });
 });

package/src/instrumentations/errors/index.ts

@@ -40,6 +40,12 @@ export interface ErrorsInstrumentationOptions {
    * Older errors are removed when this limit is reached
    */
   maxDeduplicationEntries?: number;
+
+  /**
+   * Bundle filename for Hermes/minified release lines (`func@line:col`).
+   * Must match the Metro plugin source map `file` field (default `bundle.js`).
+   */
+  releaseBundleFilename?: string;
 }
 
 interface ErrorFingerprint {
@@ -80,7 +86,9 @@ export class ErrorsInstrumentation extends BaseInstrumentation {
 
   private originalErrorHandler?: ErrorHandlerCallback;
   private unhandledRejectionListener?: (event: PromiseRejectionEvent) => void;
-  private options: Required<ErrorsInstrumentationOptions>;
+  private options: Required<Omit<ErrorsInstrumentationOptions, 'releaseBundleFilename'>> & {
+    releaseBundleFilename?: string;
+  };
   private errorFingerprints: ErrorFingerprint[] = [];
 
   constructor(options: ErrorsInstrumentationOptions = {}) {
@@ -90,6 +98,7 @@ export class ErrorsInstrumentation extends BaseInstrumentation {
       enableDeduplication: options.enableDeduplication ?? true,
       deduplicationWindow: options.deduplicationWindow ?? 5000,
       maxDeduplicationEntries: options.maxDeduplicationEntries ?? 50,
+      releaseBundleFilename: options.releaseBundleFilename,
     };
   }
 
@@ -123,10 +132,14 @@ export class ErrorsInstrumentation extends BaseInstrumentation {
           error: enhancedError,
           stackFrames,
           context,
-        } = enhanceErrorWithContext(error, {
-          mechanism: ErrorMechanism.UNCAUGHT,
-          isFatal: String(isFatal ?? false),
-        });
+        } = enhanceErrorWithContext(
+          error,
+          {
+            mechanism: ErrorMechanism.UNCAUGHT,
+            isFatal: String(isFatal ?? false),
+          },
+          { releaseBundleFilename: this.options.releaseBundleFilename }
+        );
 
         // Push error to Faro with enhanced data (type from error.name, matches Web SDK)
         this.api.pushError(enhancedError, {
@@ -182,9 +195,13 @@ export class ErrorsInstrumentation extends BaseInstrumentation {
           error: enhancedError,
           stackFrames,
           context,
-        } = enhanceErrorWithContext(error, {
-          mechanism: ErrorMechanism.UNHANDLED_REJECTION,
-        });
+        } = enhanceErrorWithContext(
+          error,
+          {
+            mechanism: ErrorMechanism.UNHANDLED_REJECTION,
+          },
+          { releaseBundleFilename: this.options.releaseBundleFilename }
+        );
 
         // Type: use actual error type for Error objects; 'UnhandledRejection' for primitives (Web SDK)
         const errorType = isPrimitiveRejection ? primitiveUnhandledType : enhancedError.name || 'Error';

package/src/instrumentations/errors/stackTraceParser.test.ts

@@ -65,6 +65,29 @@ describe('Stack Trace Parser', () => {
         filename: '<unknown>',
         lineno: 123,
         colno: 456,
+        releaseLine: true,
+      });
+    });
+
+    it('should normalize Hermes Android "address at index.android.bundle" file segment', () => {
+      const line = '  at someFunction (address at index.android.bundle:42:15)';
+      const frame = parseStackTraceLine(line);
+
+      expect(frame).toEqual({
+        function: 'someFunction',
+        filename: 'index.android.bundle',
+        lineno: 42,
+        colno: 15,
+      });
+    });
+
+    it('should parse Hermes-style parenthesis frame with bundle filename', () => {
+      const line = '  at reportError (index.android.bundle:1:849989)';
+      expect(parseStackTraceLine(line)).toEqual({
+        function: 'reportError',
+        filename: 'index.android.bundle',
+        lineno: 1,
+        colno: 849989,
       });
     });
 
@@ -165,6 +188,39 @@ describe('Stack Trace Parser', () => {
       const faroFrames = toFaroStackFrames([]);
       expect(faroFrames).toEqual([]);
     });
+
+    it('maps release placeholders to bundle.js in Faro frames', () => {
+      const parsed = parseStackTraceLine('a@123:456');
+      expect(parsed).not.toBeNull();
+      const faroFrames = toFaroStackFrames([parsed!]);
+      expect(faroFrames[0]?.filename).toBe('bundle.js');
+    });
+
+    it('maps release placeholders to a custom bundle filename', () => {
+      const parsed = parseStackTraceLine('a@123:456');
+      expect(parsed).not.toBeNull();
+      const faroFrames = toFaroStackFrames([parsed!], { releaseBundleFilename: 'index.android.bundle' });
+      expect(faroFrames[0]?.filename).toBe('index.android.bundle');
+    });
+
+    it('collapses Hermes absolute .app bundle path to basename so uploads match ingest keys', () => {
+      const iosPath =
+        '/Users/ci/Library/Developer/CoreSimulator/Devices/ABC/Data/Containers/Bundle/Application/62A2/QuickPizza.app/main.jsbundle';
+      const parsed = parseStackTraceLine(`  at reportHandledException (${iosPath}:1:1249030)`);
+      expect(parsed).not.toBeNull();
+      const faroFrames = toFaroStackFrames([parsed!], { releaseBundleFilename: 'main.jsbundle' });
+      expect(faroFrames[0]?.filename).toBe('main.jsbundle');
+      expect(faroFrames[0]?.lineno).toBe(1);
+      expect(faroFrames[0]?.colno).toBe(1249030);
+    });
+
+    it('collapses absolute Android artifact path ending in index.android.bundle', () => {
+      const apkPath = '/data/app/org.example.cp/base.apk/assets/index.android.bundle';
+      const parsed = parseStackTraceLine(`  at reportError (${apkPath}:1:849989)`);
+      expect(parsed).not.toBeNull();
+      const faroFrames = toFaroStackFrames([parsed!], { releaseBundleFilename: 'index.android.bundle' });
+      expect(faroFrames[0]?.filename).toBe('index.android.bundle');
+    });
   });
 
   describe('getStackFramesFromError', () => {
@@ -243,5 +299,14 @@ describe('Stack Trace Parser', () => {
       expect(result.context).toHaveProperty('customField', 'customValue');
       expect(result.context).toHaveProperty('platform');
     });
+
+    it('applies stack parse options for release frames', () => {
+      const error = new Error('Test');
+      error.stack = 'global@10:20';
+
+      const result = enhanceErrorWithContext(error, undefined, { releaseBundleFilename: 'main.jsbundle' });
+
+      expect(result.stackFrames[0]?.filename).toBe('main.jsbundle');
+    });
   });
 });

package/src/instrumentations/errors/stackTraceParser.ts

@@ -28,35 +28,85 @@ const REACT_NATIVE_RELEASE_REGEX = /^(.+?)@(\d+):(\d+)$/;
 const REACT_NATIVE_ANONYMOUS_REGEX = /^\s*at\s+anonymous\s+\((.+?):(\d+):(\d+)\)$/;
 const METRO_BUNDLER_REGEX = /^\s*at\s+(?:Object\.)?(.+?)\s+\((.+?):(\d+):(\d+)\)$/;
 
+/**
+ * Hermes (Android release) often reports the bundle segment as `address at index.android.bundle`
+ * inside parentheses. The collector hashes `frame.filename` for uploaded maps; it must match the
+ * source map `file` field (e.g. `index.android.bundle`), not the verbose Hermes label.
+ */
+export function normalizeHermesStackFilename(filename: string): string {
+  const trimmed = filename.trim();
+  const m = /^address\s+at\s+(.+)$/i.exec(trimmed);
+  return m?.[1]?.trim() ?? filename;
+}
+
+/**
+ * iOS Simulator (and Android) stacks often carry full filesystem paths such as
+ * `…/Foo.app/main.jsbundle` while uploaded maps are keyed by the bundle basename (`main.jsbundle`)
+ * that matches Metro’s source map `file` field — same as ingest’s bundle lookup hashes.
+ */
+function collapseBundledArtifactPath(filename: string, releaseBasename: string): string {
+  const key = releaseBasename.trim();
+  if (!key || filename === key) {
+    return filename;
+  }
+  const suffix = `/${key}`;
+  return filename.endsWith(suffix) ? key : filename;
+}
+
 export interface ParsedStackFrame {
   function?: string;
   filename?: string;
   lineno?: number;
   colno?: number;
   isNative?: boolean;
+  /** Set when the line matched Hermes/minified `func@line:col` (no path). */
+  releaseLine?: boolean;
+}
+
+/** Which parser branch handled a stack line (internal). */
+type ParsedStackLineKind =
+  | 'react_native_paren'
+  | 'metro_paren'
+  | 'anonymous_paren'
+  | 'native'
+  | 'release_func_at'
+  | 'unparsed';
+
+const UNKNOWN_RELEASE_FILENAME = '<unknown>';
+
+export interface StackFrameParseOptions {
+  /**
+   * Hermes / minified RN release lines use `func@line:col` with no file path. Those frames are tagged
+   * with `releaseLine` and use this as `filename` (default `bundle.js`). Match the Metro plugin’s
+   * source map `file` field (or `sourceMapFile` option there).
+   */
+  releaseBundleFilename?: string;
 }
 
 /**
- * Parse a single stack trace line into a structured frame
+ * Parse a single stack trace line into a structured frame and record how it was parsed.
  */
-export function parseStackTraceLine(line: string): ParsedStackFrame | null {
+function parseStackTraceLineDetailed(line: string): { frame: ParsedStackFrame | null; kind: ParsedStackLineKind } {
   if (!line || typeof line !== 'string') {
-    return null;
+    return { frame: null, kind: 'unparsed' };
   }
 
   const trimmedLine = line.trim();
   if (!trimmedLine) {
-    return null;
+    return { frame: null, kind: 'unparsed' };
   }
 
   // Try standard React Native format: at functionName (file.js:123:45)
   let match = trimmedLine.match(REACT_NATIVE_STACK_REGEX);
   if (match && match[2] && match[3] && match[4]) {
     return {
-      function: match[1] || '<anonymous>',
-      filename: match[2],
-      lineno: parseInt(match[3], 10),
-      colno: parseInt(match[4], 10),
+      kind: 'react_native_paren',
+      frame: {
+        function: match[1] || '<anonymous>',
+        filename: normalizeHermesStackFilename(match[2]),
+        lineno: parseInt(match[3], 10),
+        colno: parseInt(match[4], 10),
+      },
     };
   }
 
@@ -64,10 +114,13 @@ export function parseStackTraceLine(line: string): ParsedStackFrame | null {
   match = trimmedLine.match(METRO_BUNDLER_REGEX);
   if (match && match[2] && match[3] && match[4]) {
     return {
-      function: match[1] || '<anonymous>',
-      filename: match[2],
-      lineno: parseInt(match[3], 10),
-      colno: parseInt(match[4], 10),
+      kind: 'metro_paren',
+      frame: {
+        function: match[1] || '<anonymous>',
+        filename: normalizeHermesStackFilename(match[2]),
+        lineno: parseInt(match[3], 10),
+        colno: parseInt(match[4], 10),
+      },
     };
   }
 
@@ -75,10 +128,13 @@ export function parseStackTraceLine(line: string): ParsedStackFrame | null {
   match = trimmedLine.match(REACT_NATIVE_ANONYMOUS_REGEX);
   if (match && match[1] && match[2] && match[3]) {
     return {
-      function: '<anonymous>',
-      filename: match[1],
-      lineno: parseInt(match[2], 10),
-      colno: parseInt(match[3], 10),
+      kind: 'anonymous_paren',
+      frame: {
+        function: '<anonymous>',
+        filename: normalizeHermesStackFilename(match[1]),
+        lineno: parseInt(match[2], 10),
+        colno: parseInt(match[3], 10),
+      },
     };
   }
 
@@ -86,9 +142,12 @@ export function parseStackTraceLine(line: string): ParsedStackFrame | null {
   match = trimmedLine.match(REACT_NATIVE_NATIVE_REGEX);
   if (match) {
     return {
-      function: match[1] || '<native>',
-      filename: '<native>',
-      isNative: true,
+      kind: 'native',
+      frame: {
+        function: match[1] || '<native>',
+        filename: '<native>',
+        isNative: true,
+      },
     };
   }
 
@@ -96,15 +155,25 @@ export function parseStackTraceLine(line: string): ParsedStackFrame | null {
   match = trimmedLine.match(REACT_NATIVE_RELEASE_REGEX);
   if (match && match[2] && match[3]) {
     return {
-      function: match[1] || '<anonymous>',
-      filename: '<unknown>',
-      lineno: parseInt(match[2], 10),
-      colno: parseInt(match[3], 10),
+      kind: 'release_func_at',
+      frame: {
+        function: match[1] || '<anonymous>',
+        filename: UNKNOWN_RELEASE_FILENAME,
+        lineno: parseInt(match[2], 10),
+        colno: parseInt(match[3], 10),
+        releaseLine: true,
+      },
     };
   }
 
-  // Couldn't parse this line
-  return null;
+  return { frame: null, kind: 'unparsed' };
+}
+
+/**
+ * Parse a single stack trace line into a structured frame
+ */
+export function parseStackTraceLine(line: string): ParsedStackFrame | null {
+  return parseStackTraceLineDetailed(line).frame;
 }
 
 /**
@@ -119,7 +188,7 @@ export function parseStackTrace(stackTrace: string): ParsedStackFrame[] {
   const frames: ParsedStackFrame[] = [];
 
   for (const line of lines) {
-    const frame = parseStackTraceLine(line);
+    const { frame } = parseStackTraceLineDetailed(line);
     if (frame) {
       frames.push(frame);
     }
@@ -131,26 +200,40 @@ export function parseStackTrace(stackTrace: string): ParsedStackFrame[] {
 /**
  * Convert parsed stack frames to Faro's StackFrame format
  */
-export function toFaroStackFrames(parsedFrames: ParsedStackFrame[]): StackFrame[] {
-  return parsedFrames.map((frame, _index) => ({
-    filename: frame.filename || '<unknown>',
-    function: frame.function || '<anonymous>',
-    lineno: frame.lineno,
-    colno: frame.colno,
-  }));
+export function toFaroStackFrames(parsedFrames: ParsedStackFrame[], options?: StackFrameParseOptions): StackFrame[] {
+  const releaseName = options?.releaseBundleFilename ?? 'bundle.js';
+  const keyedBasename =
+    typeof options?.releaseBundleFilename === 'string' && options.releaseBundleFilename.trim() !== ''
+      ? options.releaseBundleFilename.trim()
+      : null;
+
+  return parsedFrames.map((frame, _index) => {
+    let filename = normalizeHermesStackFilename(frame.filename || '<unknown>');
+    if (frame.releaseLine) {
+      filename = releaseName;
+    } else if (keyedBasename) {
+      filename = collapseBundledArtifactPath(filename, keyedBasename);
+    }
+    return {
+      filename,
+      function: frame.function || '<anonymous>',
+      lineno: frame.lineno,
+      colno: frame.colno,
+    };
+  });
 }
 
 /**
  * Extract and parse stack frames from an Error object
  */
-export function getStackFramesFromError(error: Error): StackFrame[] {
+export function getStackFramesFromError(error: Error, options?: StackFrameParseOptions): StackFrame[] {
   if (!error || !error.stack) {
     return [];
   }
 
   try {
     const parsedFrames = parseStackTrace(error.stack);
-    return toFaroStackFrames(parsedFrames);
+    return toFaroStackFrames(parsedFrames, options);
   } catch (_e) {
     // If parsing fails, return empty array
     return [];
@@ -173,13 +256,14 @@ export function getPlatformErrorContext(): Record<string, string> {
  */
 export function enhanceErrorWithContext(
   error: Error,
-  additionalContext?: Record<string, string>
+  additionalContext?: Record<string, string>,
+  stackParseOptions?: StackFrameParseOptions
 ): {
   error: Error;
   stackFrames: StackFrame[];
   context: Record<string, string>;
 } {
-  const stackFrames = getStackFramesFromError(error);
+  const stackFrames = getStackFramesFromError(error, stackParseOptions);
   const platformContext = getPlatformErrorContext();
 
   return {

package/src/util/performanceObserverPolyfill.test.ts

@@ -0,0 +1,48 @@
+import { applyPerformanceObserverPolyfill } from './performanceObserverPolyfill';
+
+describe('applyPerformanceObserverPolyfill', () => {
+  const originalPerformance = global.performance;
+  const originalPerformanceObserver = global.PerformanceObserver;
+
+  afterEach(() => {
+    Object.defineProperty(global, 'performance', {
+      configurable: true,
+      value: originalPerformance,
+      writable: true,
+    });
+    Object.defineProperty(global, 'PerformanceObserver', {
+      configurable: true,
+      value: originalPerformanceObserver,
+      writable: true,
+    });
+  });
+
+  it('returns an empty list for unsupported resource timing lookups', () => {
+    const getEntriesByType = jest.fn(() => [{ entryType: 'mark', name: 'test' }]);
+    Object.defineProperty(global, 'performance', {
+      configurable: true,
+      value: { getEntriesByType },
+      writable: true,
+    });
+
+    applyPerformanceObserverPolyfill();
+
+    expect(global.performance.getEntriesByType('resource')).toEqual([]);
+    expect(getEntriesByType).not.toHaveBeenCalledWith('resource');
+  });
+
+  it('delegates non-resource timing lookups to the original implementation', () => {
+    const markEntry = { entryType: 'mark', name: 'test' };
+    const getEntriesByType = jest.fn(() => [markEntry]);
+    Object.defineProperty(global, 'performance', {
+      configurable: true,
+      value: { getEntriesByType },
+      writable: true,
+    });
+
+    applyPerformanceObserverPolyfill();
+
+    expect(global.performance.getEntriesByType('mark')).toEqual([markEntry]);
+    expect(getEntriesByType).toHaveBeenCalledWith('mark');
+  });
+});