@grafana/faro-react-native 1.3.0 → 1.4.0

package/src/instrumentations/crashReporting/instrumentation.test.ts

@@ -1,10 +1,124 @@
 import { type ExceptionEvent, initializeFaro, type TransportItem } from '@grafana/faro-core';
 import { mockConfig, MockTransport } from '@grafana/faro-test-utils';
 
+import { FetchTransport } from '../../transports/fetch';
+
+import { AndroidCrashReportingInstrumentation } from './android/AndroidCrashReportingInstrumentation';
 import { CrashReportingInstrumentation } from './index';
+import { IosCrashReportingInstrumentation } from './ios/IosCrashReportingInstrumentation';
 import type { CrashReport } from './types';
 
+const CRASH_TRACE = [
+  "ABI: 'arm64'",
+  'backtrace:',
+  '      #00 pc 0000000000001234  /data/app/lib/arm64-v8a/libappmodules.so (nativeCrash+8)',
+].join('\n');
+
+type NativeCrashModule = {
+  acknowledgeCrashReports: ReturnType<typeof jest.fn>;
+  getCrashReport?: ReturnType<typeof jest.fn>;
+  getPendingCrashReports: ReturnType<typeof jest.fn>;
+  recordCrashSessionContext: ReturnType<typeof jest.fn>;
+};
+
+type TestableAndroidCrashInstrumentation = {
+  prepareCrashReporting: (nativeModule: NativeCrashModule) => void;
+  processCrashReports: (nativeModule: NativeCrashModule) => Promise<void>;
+};
+
+type TestableIosCrashInstrumentation = {
+  prepareCrashReporting: (nativeModule: NativeCrashModule) => void;
+  processCrashReports: (nativeModule: NativeCrashModule) => Promise<void>;
+};
+
+function createCrashReport(overrides: Partial<CrashReport> = {}): CrashReport {
+  return {
+    reportId: 'report-a',
+    reason: 'CRASH_NATIVE',
+    sessionId: 'session-a',
+    timestamp: Date.now() - 1000,
+    trace: CRASH_TRACE,
+    ...overrides,
+  };
+}
+
+function createNativeCrashModule(
+  reports: Array<CrashReport | string>,
+  recordSessionContextResult: boolean | undefined = true
+): NativeCrashModule {
+  return {
+    acknowledgeCrashReports: jest.fn().mockResolvedValue(undefined),
+    getPendingCrashReports: jest
+      .fn()
+      .mockResolvedValue(reports.map((report) => (typeof report === 'string' ? report : JSON.stringify(report)))),
+    recordCrashSessionContext: jest.fn().mockReturnValue(recordSessionContextResult),
+  };
+}
+
+function setupAndroidReplay(
+  reports: Array<CrashReport | string>,
+  beforeSend?: (item: TransportItem) => TransportItem | null,
+  recordSessionContextResult: boolean | undefined = true
+) {
+  const transport = new FetchTransport({ url: 'http://example.com/collect' });
+  const instrumentation = new AndroidCrashReportingInstrumentation({ enabled: false });
+  const faro = initializeFaro(
+    mockConfig({
+      transports: [transport],
+      instrumentations: [instrumentation],
+      ...(beforeSend ? { beforeSend } : {}),
+    })
+  );
+  faro.api.setSession({ id: 'session-b' });
+
+  const nativeModule = createNativeCrashModule(reports, recordSessionContextResult);
+  const sendSpy = jest.spyOn(transport, 'sendWithResult').mockResolvedValue({
+    outcome: 'accepted',
+    status: 202,
+  });
+  const testable = instrumentation as unknown as TestableAndroidCrashInstrumentation;
+  testable.prepareCrashReporting(nativeModule);
+
+  return { faro, instrumentation, nativeModule, sendSpy, testable };
+}
+
+function setupIosReplay(reports: Array<CrashReport | string>) {
+  const transport = new FetchTransport({ url: 'http://example.com/collect' });
+  const instrumentation = new IosCrashReportingInstrumentation({ enabled: false });
+  const faro = initializeFaro(
+    mockConfig({
+      transports: [transport],
+      instrumentations: [instrumentation],
+    })
+  );
+  faro.api.setSession({ id: 'session-b' });
+
+  const nativeModule = createNativeCrashModule(reports);
+  const sendSpy = jest.spyOn(transport, 'sendWithResult').mockResolvedValue({
+    outcome: 'accepted',
+    status: 202,
+  });
+  const testable = instrumentation as unknown as TestableIosCrashInstrumentation;
+  testable.prepareCrashReporting(nativeModule);
+
+  return { faro, instrumentation, nativeModule, sendSpy, testable };
+}
+
 describe('CrashReportingInstrumentation', () => {
+  const androidInstrumentations: AndroidCrashReportingInstrumentation[] = [];
+  const iosInstrumentations: IosCrashReportingInstrumentation[] = [];
+
+  beforeEach(() => {
+    jest.restoreAllMocks();
+    delete (global as any).faro;
+  });
+
+  afterEach(() => {
+    androidInstrumentations.splice(0).forEach((instrumentation) => instrumentation.unpatch());
+    iosInstrumentations.splice(0).forEach((instrumentation) => instrumentation.unpatch());
+    delete (global as any).faro;
+  });
+
   it('should report native crashes as fatal exceptions', () => {
     const transport = new MockTransport();
     const instrumentation = new CrashReportingInstrumentation({ enabled: false });
@@ -24,11 +138,7 @@ describe('CrashReportingInstrumentation', () => {
       reason: 'CRASH_NATIVE',
       signal: 'SIGSEGV (11)',
       timestamp: 1710000000000,
-      trace: [
-        "ABI: 'arm64'",
-        'backtrace:',
-        '      #00 pc 0000000000001234  /data/app/lib/arm64-v8a/libappmodules.so (nativeCrash+8)',
-      ].join('\n'),
+      trace: CRASH_TRACE,
     });
 
     expect(transport.items).toHaveLength(1);
@@ -39,4 +149,322 @@ describe('CrashReportingInstrumentation', () => {
     expect(item.payload.context?.signal).toBe('SIGSEGV (11)');
     expect(item.payload.context?.trace).toContain('#00 pc');
   });
+
+  it('replays a recovered crash with its original session and timestamp without changing the live session', async () => {
+    const crashTimestamp = Date.now() - 1000;
+    const setup = setupAndroidReplay([
+      createCrashReport({
+        appVersion: '1.2.3',
+        reportId: 'report-a',
+        sessionId: 'session-a',
+        timestamp: crashTimestamp,
+      }),
+    ]);
+    androidInstrumentations.push(setup.instrumentation);
+
+    await setup.testable.processCrashReports(setup.nativeModule);
+
+    expect(setup.sendSpy).toHaveBeenCalledTimes(1);
+    const item = setup.sendSpy.mock.calls[0]?.[0]?.[0] as TransportItem<ExceptionEvent>;
+    expect(item.meta.session?.id).toBe('session-a');
+    expect(item.meta.app?.version).toBe('1.2.3');
+    expect(item.payload.timestamp).toBe(new Date(crashTimestamp).toISOString());
+    expect(item.payload.fatal).toBe(true);
+    expect(setup.faro.metas.value.session?.id).toBe('session-b');
+    expect(setup.nativeModule.acknowledgeCrashReports).toHaveBeenCalledWith(['report-a']);
+    expect(setup.nativeModule.recordCrashSessionContext).toHaveBeenCalledWith(
+      expect.objectContaining({ sessionId: 'session-b' })
+    );
+  });
+
+  it('retains the crash-time sampling decision across same-session metadata updates', () => {
+    const setup = setupAndroidReplay([]);
+    androidInstrumentations.push(setup.instrumentation);
+
+    setup.faro.api.setSession({
+      id: 'session-b',
+      attributes: { isSampled: 'false' },
+    });
+    const callsBeforeMetadataUpdate = setup.nativeModule.recordCrashSessionContext.mock.calls.length;
+    expect(setup.nativeModule.recordCrashSessionContext).toHaveBeenLastCalledWith(
+      expect.objectContaining({ sessionId: 'session-b', isSampled: false })
+    );
+
+    setup.faro.api.setSession({
+      id: 'session-b',
+      attributes: { custom: 'value' },
+    });
+
+    expect(setup.nativeModule.recordCrashSessionContext).toHaveBeenCalledTimes(callsBeforeMetadataUpdate);
+  });
+
+  it('does not carry a sampling decision into a different session', () => {
+    const setup = setupAndroidReplay([]);
+    androidInstrumentations.push(setup.instrumentation);
+
+    setup.faro.api.setSession({
+      id: 'session-b',
+      attributes: { isSampled: 'false' },
+    });
+
+    setup.faro.api.setSession({ id: 'session-c' });
+
+    const recordedContext = setup.nativeModule.recordCrashSessionContext.mock.lastCall?.[0];
+    expect(recordedContext).toEqual(
+      expect.objectContaining({
+        sessionId: 'session-c',
+        activatedAt: expect.any(Number),
+      })
+    );
+    expect(recordedContext).not.toHaveProperty('isSampled');
+  });
+
+  it('replays an iOS crash with its original session and acknowledges it after delivery', async () => {
+    const crashTimestamp = Date.now() - 1000;
+    const setup = setupIosReplay([
+      createCrashReport({
+        reason: 'SIGSEGV',
+        reportId: 'ios-report-a',
+        sessionId: 'session-a',
+        timestamp: crashTimestamp,
+      }),
+    ]);
+    iosInstrumentations.push(setup.instrumentation);
+
+    await setup.testable.processCrashReports(setup.nativeModule);
+
+    expect(setup.sendSpy).toHaveBeenCalledTimes(1);
+    const item = setup.sendSpy.mock.calls[0]?.[0]?.[0] as TransportItem<ExceptionEvent>;
+    expect(item.meta.session?.id).toBe('session-a');
+    expect(item.payload.timestamp).toBe(new Date(crashTimestamp).toISOString());
+    expect(setup.faro.metas.value.session?.id).toBe('session-b');
+    expect(setup.nativeModule.acknowledgeCrashReports).toHaveBeenCalledWith(['ios-report-a']);
+  });
+
+  it('uses legacy iOS crash replay when the native module does not support acknowledgements', async () => {
+    const transport = new MockTransport();
+    const instrumentation = new IosCrashReportingInstrumentation({ enabled: false });
+    const faro = initializeFaro(
+      mockConfig({
+        transports: [transport],
+        instrumentations: [instrumentation],
+      })
+    );
+    faro.api.setSession({ id: 'session-b' });
+    iosInstrumentations.push(instrumentation);
+
+    const nativeModule = {
+      getCrashReport: jest.fn().mockResolvedValue([JSON.stringify(createCrashReport())]),
+    } as unknown as NativeCrashModule;
+    const testable = instrumentation as unknown as TestableIosCrashInstrumentation;
+    testable.prepareCrashReporting(nativeModule);
+
+    await testable.processCrashReports(nativeModule);
+
+    expect(nativeModule.getCrashReport).toHaveBeenCalledTimes(1);
+    expect(transport.items).toHaveLength(1);
+    expect(transport.items[0]?.meta.session?.id).toBe('session-b');
+  });
+
+  it('leaves an iOS crash pending when delivery fails', async () => {
+    const setup = setupIosReplay([createCrashReport({ reportId: 'ios-report-a' })]);
+    iosInstrumentations.push(setup.instrumentation);
+    setup.sendSpy.mockResolvedValue({ outcome: 'failed' });
+
+    await setup.testable.processCrashReports(setup.nativeModule);
+
+    expect(setup.sendSpy).toHaveBeenCalledTimes(1);
+    expect(setup.nativeModule.acknowledgeCrashReports).not.toHaveBeenCalled();
+  });
+
+  it('discards an iOS crash without assigning the current session when its original session is unavailable', async () => {
+    const setup = setupIosReplay([
+      createCrashReport({
+        reportId: 'ios-report-a',
+        sessionId: undefined,
+      }),
+    ]);
+    iosInstrumentations.push(setup.instrumentation);
+
+    await setup.testable.processCrashReports(setup.nativeModule);
+
+    expect(setup.sendSpy).not.toHaveBeenCalled();
+    expect(setup.faro.metas.value.session?.id).toBe('session-b');
+    expect(setup.nativeModule.acknowledgeCrashReports).toHaveBeenCalledWith(['ios-report-a']);
+  });
+
+  it('discards an iOS crash older than the replay window', async () => {
+    const now = 1_800_000_000_000;
+    jest.spyOn(Date, 'now').mockReturnValue(now);
+    const setup = setupIosReplay([
+      createCrashReport({
+        reportId: 'ios-report-a',
+        timestamp: now - 7 * 24 * 60 * 60 * 1000 - 1,
+      }),
+    ]);
+    iosInstrumentations.push(setup.instrumentation);
+
+    await setup.testable.processCrashReports(setup.nativeModule);
+
+    expect(setup.sendSpy).not.toHaveBeenCalled();
+    expect(setup.nativeModule.acknowledgeCrashReports).toHaveBeenCalledWith(['ios-report-a']);
+  });
+
+  it('persists later live-session changes without mutating a recovered crash', async () => {
+    const setup = setupAndroidReplay([createCrashReport()]);
+    androidInstrumentations.push(setup.instrumentation);
+
+    setup.faro.api.setSession({ id: 'session-c' });
+    await setup.testable.processCrashReports(setup.nativeModule);
+
+    expect(setup.nativeModule.recordCrashSessionContext.mock.calls.map(([context]) => context.sessionId)).toEqual([
+      'session-b',
+      'session-c',
+    ]);
+    const sentItem = setup.sendSpy.mock.calls[0]?.[0]?.[0];
+    expect(sentItem?.meta.session?.id).toBe('session-a');
+    expect(setup.faro.metas.value.session?.id).toBe('session-c');
+  });
+
+  it('retries persisting session context until native storage confirms success', () => {
+    const setup = setupAndroidReplay([], undefined, false);
+    androidInstrumentations.push(setup.instrumentation);
+    setup.nativeModule.recordCrashSessionContext.mockReturnValue(undefined);
+
+    setup.testable.prepareCrashReporting(setup.nativeModule);
+    setup.testable.prepareCrashReporting(setup.nativeModule);
+
+    expect(setup.nativeModule.recordCrashSessionContext).toHaveBeenCalledTimes(3);
+    expect(setup.nativeModule.recordCrashSessionContext).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({ sessionId: 'session-b' })
+    );
+  });
+
+  it.each(['failed', 'rejected', 'skipped'] as const)(
+    'leaves the report pending when delivery is %s',
+    async (outcome) => {
+      const setup = setupAndroidReplay([createCrashReport()]);
+      androidInstrumentations.push(setup.instrumentation);
+      setup.sendSpy.mockResolvedValue(
+        outcome === 'rejected'
+          ? { outcome, status: 500 }
+          : {
+              outcome,
+            }
+      );
+
+      await setup.testable.processCrashReports(setup.nativeModule);
+
+      expect(setup.sendSpy).toHaveBeenCalledTimes(1);
+      expect(setup.nativeModule.acknowledgeCrashReports).not.toHaveBeenCalled();
+    }
+  );
+
+  it('replays multiple historical crashes under their own sessions and de-duplicates report IDs', async () => {
+    const setup = setupAndroidReplay([
+      createCrashReport({ reportId: 'report-a', sessionId: 'session-a', timestamp: Date.now() - 2000 }),
+      createCrashReport({ reportId: 'report-b', sessionId: 'session-b-old', timestamp: Date.now() - 1000 }),
+      createCrashReport({ reportId: 'report-a', sessionId: 'session-a', timestamp: Date.now() - 2000 }),
+    ]);
+    androidInstrumentations.push(setup.instrumentation);
+
+    await setup.testable.processCrashReports(setup.nativeModule);
+
+    expect(setup.sendSpy).toHaveBeenCalledTimes(2);
+    expect(setup.sendSpy.mock.calls.map(([items]) => items[0]?.meta.session?.id)).toEqual([
+      'session-a',
+      'session-b-old',
+    ]);
+    expect(setup.nativeModule.acknowledgeCrashReports).toHaveBeenCalledTimes(2);
+    expect(setup.nativeModule.acknowledgeCrashReports).toHaveBeenNthCalledWith(1, ['report-a']);
+    expect(setup.nativeModule.acknowledgeCrashReports).toHaveBeenNthCalledWith(2, ['report-b']);
+    expect(setup.faro.metas.value.session?.id).toBe('session-b');
+  });
+
+  it('accepts the seven-day boundary and acknowledges an older report without sending it', async () => {
+    const now = 1_800_000_000_000;
+    jest.spyOn(Date, 'now').mockReturnValue(now);
+    const sevenDaysMs = 7 * 24 * 60 * 60 * 1000;
+    const setup = setupAndroidReplay([
+      createCrashReport({ reportId: 'boundary', timestamp: now - sevenDaysMs }),
+      createCrashReport({ reportId: 'expired', timestamp: now - sevenDaysMs - 1 }),
+    ]);
+    androidInstrumentations.push(setup.instrumentation);
+
+    await setup.testable.processCrashReports(setup.nativeModule);
+
+    expect(setup.sendSpy).toHaveBeenCalledTimes(1);
+    expect(setup.nativeModule.acknowledgeCrashReports).toHaveBeenCalledWith(['boundary']);
+    expect(setup.nativeModule.acknowledgeCrashReports).toHaveBeenCalledWith(['expired']);
+  });
+
+  it('acknowledges a report without sending it when the original session context is missing', async () => {
+    const setup = setupAndroidReplay([createCrashReport({ sessionId: undefined })]);
+    androidInstrumentations.push(setup.instrumentation);
+
+    await setup.testable.processCrashReports(setup.nativeModule);
+
+    expect(setup.sendSpy).not.toHaveBeenCalled();
+    expect(setup.nativeModule.acknowledgeCrashReports).toHaveBeenCalledWith(['report-a']);
+    expect(setup.faro.metas.value.session?.id).toBe('session-b');
+  });
+
+  it('acknowledges only the malformed report when its stable ID is available', async () => {
+    const setup = setupAndroidReplay([
+      createCrashReport({ reportId: 'malformed', timestamp: Number.NaN }),
+      createCrashReport({ reportId: 'valid' }),
+    ]);
+    androidInstrumentations.push(setup.instrumentation);
+
+    await setup.testable.processCrashReports(setup.nativeModule);
+
+    expect(setup.sendSpy).toHaveBeenCalledTimes(1);
+    expect(setup.nativeModule.acknowledgeCrashReports).toHaveBeenCalledWith(['malformed']);
+    expect(setup.nativeModule.acknowledgeCrashReports).toHaveBeenCalledWith(['valid']);
+  });
+
+  it('acknowledges a platform-filtered report without sending it repeatedly', async () => {
+    const setup = setupAndroidReplay([
+      createCrashReport({
+        description: 'Input dispatching timed out',
+        reportId: 'anr-report',
+      }),
+    ]);
+    androidInstrumentations.push(setup.instrumentation);
+
+    await setup.testable.processCrashReports(setup.nativeModule);
+
+    expect(setup.sendSpy).not.toHaveBeenCalled();
+    expect(setup.nativeModule.acknowledgeCrashReports).toHaveBeenCalledWith(['anr-report']);
+  });
+
+  it('honors beforeSend filtering and acknowledges the handled report', async () => {
+    const beforeSend = jest.fn(() => null);
+    const setup = setupAndroidReplay([createCrashReport()], beforeSend);
+    androidInstrumentations.push(setup.instrumentation);
+
+    await setup.testable.processCrashReports(setup.nativeModule);
+
+    expect(beforeSend).toHaveBeenCalledWith(
+      expect.objectContaining({
+        meta: expect.objectContaining({
+          session: expect.objectContaining({ id: 'session-a' }),
+        }),
+      })
+    );
+    expect(setup.sendSpy).not.toHaveBeenCalled();
+    expect(setup.nativeModule.acknowledgeCrashReports).toHaveBeenCalledWith(['report-a']);
+  });
+
+  it('treats an invalid undefined beforeSend result as filtered', async () => {
+    const beforeSend = jest.fn(() => undefined) as unknown as (item: TransportItem) => TransportItem | null;
+    const setup = setupAndroidReplay([createCrashReport()], beforeSend);
+    androidInstrumentations.push(setup.instrumentation);
+
+    await setup.testable.processCrashReports(setup.nativeModule);
+
+    expect(setup.sendSpy).not.toHaveBeenCalled();
+    expect(setup.nativeModule.acknowledgeCrashReports).toHaveBeenCalledWith(['report-a']);
+  });
 });

package/src/instrumentations/crashReporting/ios/IosCrashReportingInstrumentation.ts

@@ -1,6 +1,6 @@
 import { VERSION } from '@grafana/faro-core';
 
-import { BaseCrashReportingInstrumentation } from '../BaseCrashReportingInstrumentation';
+import { RecoveredCrashReportingInstrumentation } from '../RecoveredCrashReportingInstrumentation';
 import type { CrashReport } from '../types';
 
 import { resolveCrashErrorMessage, shouldSkipCrashReport } from './crashErrorMessage';
@@ -20,7 +20,7 @@ import { type ParsedIosCrashTrace, parseIosCrashTrace } from './parseIosCrashTra
  *
  * Stack frames are symbolicated on the native side before being surfaced.
  */
-export class IosCrashReportingInstrumentation extends BaseCrashReportingInstrumentation {
+export class IosCrashReportingInstrumentation extends RecoveredCrashReportingInstrumentation {
   readonly name = '@grafana/faro-react-native:instrumentation-crash-ios';
   readonly version = VERSION;
 

package/src/instrumentations/crashReporting/types.ts

@@ -2,6 +2,7 @@
  * Crash report data structure returned from native module.
  */
 export interface CrashReport {
+  reportId?: string;
   trace?: string;
   signal?: string;
   timestamp?: number;
@@ -12,6 +13,12 @@ export interface CrashReport {
   // iOS-specific fields
   reason?: string; // Signal name (e.g., 'SIGSEGV')
   status?: number; // Exit status code
+  // Recovered-crash session context
+  sessionId?: string;
+  isSampled?: boolean;
+  appVersion?: string;
+  appRelease?: string;
+  appBundleId?: string;
 }
 
 /**

package/src/instrumentations/errors/index.ts

@@ -14,7 +14,9 @@ declare const global: {
   removeEventListener?: (event: string, handler: (event: PromiseRejectionEvent) => void) => void;
 };
 
-type ErrorHandlerCallback = (error: Error | unknown, isFatal?: boolean) => void;
+// Mirrors RN's ErrorHandler: a thrown value is not necessarily an Error, and
+// isFatal is always supplied by the runtime.
+type ErrorHandlerCallback = (error: unknown, isFatal: boolean) => void;
 
 export interface ErrorsInstrumentationOptions {
   /**
@@ -115,8 +117,14 @@ export class ErrorsInstrumentation extends BaseInstrumentation {
     this.originalErrorHandler = global.ErrorUtils.getGlobalHandler();
 
     // Set our custom handler
-    global.ErrorUtils.setGlobalHandler((error: Error, isFatal?: boolean) => {
+    global.ErrorUtils.setGlobalHandler((thrown: unknown, isFatal: boolean) => {
       try {
+        // JS can throw any value, so normalise before the Error-shaped paths
+        // below. String() can itself throw — on a null-prototype object, or one
+        // with a throwing toString — so keep it inside the try, or finally never
+        // runs and React Native's own handler never sees the crash.
+        const error = thrown instanceof Error ? thrown : new Error(String(thrown));
+
         // Check if error should be ignored
         if (this.shouldIgnoreError(error)) {
           return;
@@ -144,7 +152,7 @@ export class ErrorsInstrumentation extends BaseInstrumentation {
         this.api.pushError(enhancedError, {
           type: enhancedError.name || 'Error',
           context,
-          fatal: isFatal ?? false,
+          fatal: isFatal,
           stackFrames,
         });
 
@@ -157,7 +165,7 @@ export class ErrorsInstrumentation extends BaseInstrumentation {
       } finally {
         // Always call the original handler to maintain normal error behavior
         if (this.originalErrorHandler) {
-          this.originalErrorHandler(error, isFatal);
+          this.originalErrorHandler(thrown, isFatal);
         }
       }
     });

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

@@ -577,5 +577,40 @@ describe('ErrorsInstrumentation', () => {
       expect(() => errorHandler(errorWithoutStack, false)).not.toThrow();
       expect(transport.items).toHaveLength(1);
     });
+
+    it.each([
+      ['a null-prototype object', () => Object.create(null)],
+      [
+        'an object with a throwing toString',
+        () => ({
+          toString: () => {
+            throw new Error('toString exploded');
+          },
+        }),
+      ],
+    ])('should still forward %s to the original handler', (_name, makeThrown) => {
+      const originalHandler = jest.fn();
+      mockGlobal.ErrorUtils.getGlobalHandler = jest.fn(() => originalHandler);
+
+      let errorHandler: any;
+      mockGlobal.ErrorUtils.setGlobalHandler = jest.fn((handler) => {
+        errorHandler = handler;
+      });
+
+      const transport = new MockTransport();
+      initializeFaro(
+        mockConfig({
+          transports: [transport],
+          instrumentations: [new ErrorsInstrumentation()],
+        })
+      );
+
+      // String(thrown) throws for these values, so Faro cannot report them.
+      // React Native's handler must still see the original value and flag.
+      const thrown = makeThrown();
+      expect(() => errorHandler(thrown, true)).not.toThrow();
+      expect(originalHandler).toHaveBeenCalledWith(thrown, true);
+      expect(transport.items).toHaveLength(0);
+    });
   });
 });