@grafana/faro-react-native 1.2.0 → 1.3.0

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

@@ -0,0 +1,42 @@
+import { type ExceptionEvent, initializeFaro, type TransportItem } from '@grafana/faro-core';
+import { mockConfig, MockTransport } from '@grafana/faro-test-utils';
+
+import { CrashReportingInstrumentation } from './index';
+import type { CrashReport } from './types';
+
+describe('CrashReportingInstrumentation', () => {
+  it('should report native crashes as fatal exceptions', () => {
+    const transport = new MockTransport();
+    const instrumentation = new CrashReportingInstrumentation({ enabled: false });
+
+    initializeFaro(
+      mockConfig({
+        transports: [transport],
+        instrumentations: [instrumentation],
+      })
+    );
+
+    (
+      instrumentation as unknown as {
+        sendCrashReport: (crash: CrashReport) => void;
+      }
+    ).sendCrashReport({
+      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'),
+    });
+
+    expect(transport.items).toHaveLength(1);
+    const item = transport.items[0] as TransportItem<ExceptionEvent>;
+    expect(item.payload.type).toBe('crash');
+    expect(item.payload.fatal).toBe(true);
+    expect(item.payload.context?.mechanism).toBe('crash');
+    expect(item.payload.context?.signal).toBe('SIGSEGV (11)');
+    expect(item.payload.context?.trace).toContain('#00 pc');
+  });
+});

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

@@ -0,0 +1,62 @@
+import { VERSION } from '@grafana/faro-core';
+
+import { BaseCrashReportingInstrumentation } from '../BaseCrashReportingInstrumentation';
+import type { CrashReport } from '../types';
+
+import { resolveCrashErrorMessage, shouldSkipCrashReport } from './crashErrorMessage';
+import { type ParsedIosCrashTrace, parseIosCrashTrace } from './parseIosCrashTrace';
+
+/**
+ * iOS Crash Reporting Instrumentation.
+ *
+ * Uses PLCrashReporter to capture native crashes from previous sessions:
+ * - SIGSEGV: Segmentation fault / invalid memory access
+ * - SIGABRT: Abnormal termination (e.g., assertion failure, uncaught exception)
+ * - SIGBUS: Bus error / alignment/hardware error
+ * - SIGILL: Illegal instruction
+ * - SIGFPE: Floating point exception
+ * - SIGTRAP: Breakpoint/debugger trap
+ * - Mach exceptions (EXC_BAD_ACCESS, EXC_CRASH, etc.)
+ *
+ * Stack frames are symbolicated on the native side before being surfaced.
+ */
+export class IosCrashReportingInstrumentation extends BaseCrashReportingInstrumentation {
+  readonly name = '@grafana/faro-react-native:instrumentation-crash-ios';
+  readonly version = VERSION;
+
+  protected parseCrashTrace(trace: string): ParsedIosCrashTrace | null {
+    return parseIosCrashTrace(trace);
+  }
+
+  protected resolveCrashErrorMessage(crash: CrashReport, parsedTrace: ParsedIosCrashTrace | null): string {
+    return resolveCrashErrorMessage(crash, parsedTrace);
+  }
+
+  protected shouldSkipCrashReport(crash: CrashReport): boolean {
+    return shouldSkipCrashReport(crash);
+  }
+
+  protected getStackFrames(parsedTrace: ParsedIosCrashTrace | null): any[] {
+    return parsedTrace?.frames ?? [];
+  }
+
+  protected buildPlatformContext(parsedTrace: ParsedIosCrashTrace | null, context: Record<string, string>): void {
+    if (parsedTrace?.exceptionName) {
+      context['nativeExceptionName'] = parsedTrace.exceptionName;
+    }
+    if (parsedTrace?.signalName) {
+      context['signalName'] = parsedTrace.signalName;
+    }
+    if (parsedTrace?.signalDescription) {
+      context['signalDescription'] = parsedTrace.signalDescription;
+    }
+  }
+
+  protected getParseFailureWarning(): string {
+    return 'Native crash trace present but no frames parsed; check iOS PLCrashReporter format';
+  }
+
+  protected getTraceUnavailableWarning(): string {
+    return 'Native crash trace unavailable (PLCrashReporter trace was null at crash time)';
+  }
+}

package/src/instrumentations/crashReporting/ios/crashErrorMessage.test.ts

@@ -0,0 +1,170 @@
+import type { CrashReport } from '../types';
+
+import { buildFallbackCrashMessage, resolveCrashErrorMessage, shouldSkipCrashReport } from './crashErrorMessage';
+import type { ParsedIosCrashTrace } from './parseIosCrashTrace';
+
+const baseCrash: CrashReport = {
+  reason: 'SIGSEGV',
+  timestamp: 1_700_000_000_000,
+  status: 0,
+};
+
+describe('resolveCrashErrorMessage', () => {
+  it('prefers exception name and reason for uncaught exceptions', () => {
+    const parsed: ParsedIosCrashTrace = {
+      exceptionName: 'NSInternalInconsistencyException',
+      exceptionReason: 'unable to dequeue a cell with identifier Cell',
+      frames: [],
+    };
+
+    expect(resolveCrashErrorMessage(baseCrash, parsed)).toBe(
+      'NSInternalInconsistencyException: unable to dequeue a cell with identifier Cell'
+    );
+  });
+
+  it('uses exception name alone if no reason', () => {
+    const parsed: ParsedIosCrashTrace = {
+      exceptionName: 'NSRangeException',
+      frames: [],
+    };
+
+    expect(resolveCrashErrorMessage(baseCrash, parsed)).toBe('NSRangeException');
+  });
+
+  it('uses signal description from parsed trace', () => {
+    const parsed: ParsedIosCrashTrace = {
+      signalDescription: 'Segmentation fault',
+      frames: [],
+    };
+
+    expect(resolveCrashErrorMessage(baseCrash, parsed)).toBe('Segmentation fault');
+  });
+
+  it('uses signal name from parsed trace', () => {
+    const parsed: ParsedIosCrashTrace = {
+      signalName: 'SIGSEGV',
+      frames: [],
+    };
+
+    expect(resolveCrashErrorMessage(baseCrash, parsed)).toBe('Segmentation fault');
+  });
+
+  it('maps known signal names to descriptions', () => {
+    const parsed: ParsedIosCrashTrace = {
+      signalName: 'SIGABRT',
+      frames: [],
+    };
+
+    expect(resolveCrashErrorMessage(baseCrash, parsed)).toBe('Abort trap');
+  });
+
+  it('uses signal name as-is if unknown', () => {
+    const parsed: ParsedIosCrashTrace = {
+      signalName: 'SIGUNKNOWN',
+      frames: [],
+    };
+
+    expect(resolveCrashErrorMessage(baseCrash, parsed)).toBe('SIGUNKNOWN');
+  });
+
+  it('falls back to crash description if present', () => {
+    expect(resolveCrashErrorMessage({ ...baseCrash, description: 'Fatal error' }, null)).toBe('Fatal error');
+  });
+
+  it('uses crash reason with signal mapping', () => {
+    expect(resolveCrashErrorMessage({ ...baseCrash, reason: 'SIGBUS' }, null)).toBe('Bus error');
+  });
+
+  it('skips generic crash descriptions', () => {
+    const crashWithGeneric = { ...baseCrash, description: 'Application crash' };
+    expect(resolveCrashErrorMessage(crashWithGeneric, null)).toBe('SIGSEGV: Segmentation fault, status: 0');
+  });
+
+  it('recognizes all generic crash description variations (case-insensitive)', () => {
+    expect(resolveCrashErrorMessage({ ...baseCrash, description: 'CRASH' }, null)).toBe(
+      'SIGSEGV: Segmentation fault, status: 0'
+    );
+    expect(resolveCrashErrorMessage({ ...baseCrash, description: 'Application Crash' }, null)).toBe(
+      'SIGSEGV: Segmentation fault, status: 0'
+    );
+    expect(resolveCrashErrorMessage({ ...baseCrash, description: 'Signal Crash' }, null)).toBe(
+      'SIGSEGV: Segmentation fault, status: 0'
+    );
+  });
+
+  it('uses simple signal description when no description is provided', () => {
+    expect(resolveCrashErrorMessage(baseCrash, null)).toBe('Segmentation fault');
+  });
+
+  it('uses exception reason alone with default "Exception" name', () => {
+    const parsed: ParsedIosCrashTrace = {
+      exceptionReason: 'Array index out of bounds',
+      frames: [],
+    };
+
+    expect(resolveCrashErrorMessage(baseCrash, parsed)).toBe('Exception: Array index out of bounds');
+  });
+
+  it('uses meaningful description even for unknown crash reason', () => {
+    const crashWithUnknownReason = { ...baseCrash, reason: 'CUSTOM_SIGNAL', description: 'Custom error' };
+    expect(resolveCrashErrorMessage(crashWithUnknownReason, null)).toBe('Custom error');
+  });
+
+  it('uses buildFallbackCrashMessage for unknown signal with no description', () => {
+    const crashWithUnknownReason = { reason: 'CUSTOM_SIGNAL', timestamp: 123, status: 5 };
+    expect(resolveCrashErrorMessage(crashWithUnknownReason, null)).toBe('CUSTOM_SIGNAL: Application crash, status: 5');
+  });
+
+  it('handles empty/whitespace strings correctly', () => {
+    const crashWithEmptyDescription = { ...baseCrash, description: '   ' };
+    expect(resolveCrashErrorMessage(crashWithEmptyDescription, null)).toBe('Segmentation fault');
+  });
+});
+
+describe('shouldSkipCrashReport', () => {
+  it('keeps crashes with trace', () => {
+    expect(shouldSkipCrashReport({ ...baseCrash, trace: '0  MyApp  0x100abc123' })).toBe(false);
+  });
+
+  it('keeps crashes with signal', () => {
+    expect(shouldSkipCrashReport({ ...baseCrash, signal: 'SIGSEGV (11)' })).toBe(false);
+  });
+
+  it('keeps crashes with meaningful description', () => {
+    expect(shouldSkipCrashReport({ ...baseCrash, description: 'Fatal error in module' })).toBe(false);
+  });
+
+  it('skips crashes with no useful information', () => {
+    expect(shouldSkipCrashReport({ reason: 'UNKNOWN', timestamp: 123, status: 0 })).toBe(true);
+  });
+
+  it('skips crashes with only generic descriptions', () => {
+    expect(shouldSkipCrashReport({ ...baseCrash, description: 'crash' })).toBe(true);
+  });
+
+  it('handles empty/whitespace trace and signal correctly', () => {
+    expect(shouldSkipCrashReport({ ...baseCrash, trace: '   ', signal: '   ' })).toBe(true);
+  });
+
+  it('keeps crashes with signal crash description if trace or signal present', () => {
+    expect(shouldSkipCrashReport({ ...baseCrash, trace: 'stack', description: 'signal crash' })).toBe(false);
+  });
+});
+
+describe('buildFallbackCrashMessage', () => {
+  it('builds fallback with known signal', () => {
+    expect(buildFallbackCrashMessage({ reason: 'SIGSEGV', timestamp: 123, status: 11 })).toBe(
+      'SIGSEGV: Segmentation fault, status: 11'
+    );
+  });
+
+  it('uses description for unknown signals', () => {
+    expect(
+      buildFallbackCrashMessage({ reason: 'CUSTOM', timestamp: 123, status: 0, description: 'Custom crash' })
+    ).toBe('CUSTOM: Custom crash, status: 0');
+  });
+
+  it('handles missing reason', () => {
+    expect(buildFallbackCrashMessage({ timestamp: 123, status: 0 })).toBe('UNKNOWN: Application crash, status: 0');
+  });
+});

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

@@ -0,0 +1,111 @@
+import type { CrashReport } from '../types';
+
+import type { ParsedIosCrashTrace } from './parseIosCrashTrace';
+
+/**
+ * Human-readable exception value for iOS PLCrashReporter crash reports.
+ * Priority: exception reason → signal description → signal name → fallback.
+ */
+export function resolveCrashErrorMessage(crash: CrashReport, parsedTrace: ParsedIosCrashTrace | null): string {
+  // iOS uncaught exceptions (NSException) have name and reason
+  if (parsedTrace?.exceptionName || parsedTrace?.exceptionReason) {
+    const name = parsedTrace.exceptionName || 'Exception';
+    const reason = parsedTrace.exceptionReason?.trim();
+    if (reason) {
+      return `${name}: ${reason}`;
+    }
+    return name;
+  }
+
+  // Use signal description if available from parsed trace
+  if (parsedTrace?.signalDescription?.trim()) {
+    return parsedTrace.signalDescription.trim();
+  }
+
+  // Use signal name from parsed trace
+  if (parsedTrace?.signalName?.trim()) {
+    const signalName = parsedTrace.signalName.trim();
+    const description = SIGNAL_DESCRIPTIONS[signalName];
+    return description || signalName;
+  }
+
+  // Check crash description - use if meaningful
+  const description = crash.description?.trim();
+  if (description && !isGenericCrashDescription(description)) {
+    return description;
+  }
+
+  // Check if we have a known signal reason
+  const reason = crash.reason?.trim();
+  if (reason && SIGNAL_DESCRIPTIONS[reason]) {
+    // If description is explicitly generic, use full format
+    if (description && isGenericCrashDescription(description)) {
+      return buildFallbackCrashMessage(crash);
+    }
+    // No description - use simple signal description
+    return SIGNAL_DESCRIPTIONS[reason];
+  }
+
+  // Final fallback: format with signal name, description, and status
+  return buildFallbackCrashMessage(crash);
+}
+
+/**
+ * Skip crash reports that have no useful information.
+ * iOS crashes should always have either a trace or a signal.
+ */
+export function shouldSkipCrashReport(crash: CrashReport): boolean {
+  if (crash.trace?.trim()) {
+    return false;
+  }
+
+  if (crash.signal?.trim()) {
+    return false;
+  }
+
+  const description = crash.description?.trim();
+  if (description && !isGenericCrashDescription(description)) {
+    return false;
+  }
+
+  return true;
+}
+
+/** BSD signal names to human-readable descriptions */
+const SIGNAL_DESCRIPTIONS: Record<string, string> = {
+  SIGHUP: 'Hangup',
+  SIGINT: 'Interrupt',
+  SIGQUIT: 'Quit',
+  SIGILL: 'Illegal instruction',
+  SIGTRAP: 'Trace/BPT trap',
+  SIGABRT: 'Abort trap',
+  SIGEMT: 'EMT trap',
+  SIGFPE: 'Floating point exception',
+  SIGKILL: 'Killed',
+  SIGBUS: 'Bus error',
+  SIGSEGV: 'Segmentation fault',
+  SIGSYS: 'Bad system call',
+  SIGPIPE: 'Broken pipe',
+  SIGALRM: 'Alarm clock',
+  SIGTERM: 'Terminated',
+};
+
+function isGenericCrashDescription(description: string): boolean {
+  const normalized = description.trim().toLowerCase();
+  return normalized === 'crash' || normalized === 'application crash' || normalized === 'signal crash';
+}
+
+/** Generic fallback when the trace carries no parseable signal or description. */
+export function buildFallbackCrashMessage(crash: CrashReport): string {
+  const reason = crash.reason || 'UNKNOWN';
+  const status = crash.status ?? 0;
+
+  let description: string;
+  if (SIGNAL_DESCRIPTIONS[reason]) {
+    description = SIGNAL_DESCRIPTIONS[reason];
+  } else {
+    description = crash.description || 'Application crash';
+  }
+
+  return `${reason}: ${description}, status: ${status}`;
+}

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

@@ -0,0 +1,4 @@
+export { IosCrashReportingInstrumentation } from './IosCrashReportingInstrumentation';
+export { parseIosCrashTrace } from './parseIosCrashTrace';
+export type { ParsedIosCrashTrace, IosCrashStackFrame } from './parseIosCrashTrace';
+export { resolveCrashErrorMessage, shouldSkipCrashReport } from './crashErrorMessage';

package/src/instrumentations/crashReporting/ios/parseIosCrashTrace.test.ts

@@ -0,0 +1,86 @@
+import { parseIosCrashTrace } from './parseIosCrashTrace';
+
+describe('parseIosCrashTrace', () => {
+  it('parses iOS PLCrashReporter stack trace format', () => {
+    const trace = [
+      '0  libsystem_kernel.dylib  0x00000001a2b3c000',
+      '1  MyApp  0x0000000100abc123',
+      '2  UIKitCore  0x00000001b4567890',
+      '3  Foundation  0x00000001a8901234',
+    ].join('\n');
+
+    const parsed = parseIosCrashTrace(trace);
+
+    expect(parsed).toEqual({
+      frames: [
+        {
+          module: 'libsystem_kernel.dylib',
+          function: '0x00000001a2b3c000',
+          filename: 'libsystem_kernel.dylib',
+          lineno: 0,
+          instructionPointer: '0x00000001a2b3c000',
+        },
+        {
+          module: 'MyApp',
+          function: '0x0000000100abc123',
+          filename: 'MyApp',
+          lineno: 1,
+          instructionPointer: '0x0000000100abc123',
+        },
+        {
+          module: 'UIKitCore',
+          function: '0x00000001b4567890',
+          filename: 'UIKitCore',
+          lineno: 2,
+          instructionPointer: '0x00000001b4567890',
+        },
+        {
+          module: 'Foundation',
+          function: '0x00000001a8901234',
+          filename: 'Foundation',
+          lineno: 3,
+          instructionPointer: '0x00000001a8901234',
+        },
+      ],
+    });
+  });
+
+  it('returns null for empty input', () => {
+    expect(parseIosCrashTrace('')).toBeNull();
+    expect(parseIosCrashTrace('   ')).toBeNull();
+  });
+
+  it('handles stack traces with whitespace variations', () => {
+    const trace = ['  0   libsystem_kernel.dylib   0x00000001a2b3c000  ', '1  MyApp  0x0000000100abc123'].join('\n');
+
+    const parsed = parseIosCrashTrace(trace);
+
+    expect(parsed?.frames).toHaveLength(2);
+    expect(parsed?.frames[0]).toMatchObject({
+      module: 'libsystem_kernel.dylib',
+      instructionPointer: '0x00000001a2b3c000',
+      lineno: 0,
+    });
+  });
+
+  it('returns null when no valid frames are found', () => {
+    const trace = ['Not a valid frame', 'Another invalid line', 'Signal: SIGSEGV'].join('\n');
+
+    expect(parseIosCrashTrace(trace)).toBeNull();
+  });
+
+  it('handles mixed valid and invalid lines', () => {
+    const trace = [
+      'Exception: NSInternalInconsistencyException',
+      '0  MyApp  0x0000000100abc123',
+      'Some metadata line',
+      '1  UIKitCore  0x00000001b4567890',
+    ].join('\n');
+
+    const parsed = parseIosCrashTrace(trace);
+
+    expect(parsed?.frames).toHaveLength(2);
+    expect(parsed?.frames[0].module).toBe('MyApp');
+    expect(parsed?.frames[1].module).toBe('UIKitCore');
+  });
+});

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

@@ -0,0 +1,83 @@
+import type { ExceptionStackFrame } from '@grafana/faro-core';
+
+/**
+ * iOS PLCrashReporter stack frames include library name and instruction pointers.
+ * Format: "0  libsystem_kernel.dylib  0x00000001a2b3c000"
+ */
+export interface IosCrashStackFrame extends ExceptionStackFrame {
+  /** Library/module name (e.g., "MyApp", "UIKitCore") */
+  module: string;
+  /** Instruction pointer address (hex string) */
+  instructionPointer?: string;
+  /** Library base address (hex string) */
+  libraryBaseAddress?: string;
+}
+
+export interface ParseIosCrashTraceOptions {
+  releaseBundleFilename?: string;
+}
+
+export interface ParsedIosCrashTrace {
+  /** Signal name (e.g., "SIGSEGV", "SIGABRT") */
+  signalName?: string;
+  /** Human-readable signal description */
+  signalDescription?: string;
+  /** Exception name for uncaught exceptions (e.g., "NSInternalInconsistencyException") */
+  exceptionName?: string;
+  /** Exception reason/message for uncaught exceptions */
+  exceptionReason?: string;
+  /** iOS native frames (library + instruction pointer for symbolication) */
+  frames: IosCrashStackFrame[];
+}
+
+/**
+ * iOS PLCrashReporter stack trace line format:
+ * "0  libsystem_kernel.dylib  0x00000001a2b3c000"
+ * frame_number  library_name  instruction_pointer
+ */
+const IOS_STACK_FRAME_LINE = /^\s*(\d+)\s+(.+?)\s+(0x[0-9a-fA-F]+)\s*$/;
+
+/**
+ * Parse a raw iOS crash trace from PLCrashReporter into structured stack frames.
+ *
+ * iOS crashes from PLCrashReporter come with formatted stack traces where each line
+ * contains: frame number, library name, and instruction pointer hex address.
+ *
+ * The collector will use the library name and instruction pointer for symbolication
+ * with dSYM files or Breakpad symbols.
+ */
+export function parseIosCrashTrace(trace: string, _options?: ParseIosCrashTraceOptions): ParsedIosCrashTrace | null {
+  const trimmed = trace.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  const lines = trimmed.split('\n');
+  const frames: IosCrashStackFrame[] = [];
+
+  for (const line of lines) {
+    const frameMatch = line.match(IOS_STACK_FRAME_LINE);
+
+    if (frameMatch) {
+      const [, frameNumber, libraryName, instructionPointer] = frameMatch;
+
+      if (!libraryName || !instructionPointer || !frameNumber) {
+        continue;
+      }
+
+      frames.push({
+        module: libraryName.trim(),
+        function: instructionPointer,
+        filename: libraryName.trim(),
+        lineno: parseInt(frameNumber, 10),
+        instructionPointer: instructionPointer,
+      });
+    }
+  }
+
+  if (frames.length === 0) {
+    return null;
+  }
+
+  return { frames };
+}

package/src/instrumentations/crashReporting/types.ts

@@ -1,70 +1,31 @@
 /**
- * Configuration options for Crash Reporting instrumentation.
- *
- * **Platform Support**:
- * - **Android**: Uses ApplicationExitInfo API (Android 11+ / API 30+)
- *   Captures: CRASH, CRASH_NATIVE, ANR, LOW_MEMORY, EXCESSIVE_RESOURCE_USAGE
- * - **iOS**: Uses PLCrashReporter (automatically included via podspec)
- *   Captures: Signal crashes (SIGSEGV, SIGABRT, etc.) and Mach exceptions
- */
-export interface CrashReportingOptions {
-  /**
-   * Whether to enable crash reporting.
-   * Default: true
-   */
-  enabled?: boolean;
-}
-
-/**
- * Crash report data from native module.
- *
- * Field names match Faro Flutter SDK for consistency across mobile platforms.
- * Both Android (ApplicationExitInfo) and iOS (PLCrashReporter) produce JSON
- * matching this interface.
+ * Crash report data structure returned from native module.
  */
 export interface CrashReport {
-  /**
-   * Reason for the crash (e.g., "CRASH", "CRASH_NATIVE", "ANR", "LOW_MEMORY")
-   */
-  reason: string;
-
-  /**
-   * Timestamp when the crash occurred (milliseconds since epoch)
-   */
-  timestamp: number;
-
-  /**
-   * Exit status code
-   */
-  status?: number;
-
-  /**
-   * Description of the crash
-   */
+  trace?: string;
+  signal?: string;
+  timestamp?: number;
   description?: string;
-
-  /**
-   * Process importance level
-   */
-  importance?: number;
-
-  /**
-   * Process ID
-   */
-  pid?: number;
-
-  /**
-   * Process name
-   */
   processName?: string;
+  pid?: number;
+  importance?: number;
+  // iOS-specific fields
+  reason?: string; // Signal name (e.g., 'SIGSEGV')
+  status?: number; // Exit status code
+}
 
+/**
+ * Configuration options for crash reporting instrumentation.
+ */
+export interface CrashReportingOptions {
   /**
-   * Stack trace (if available)
+   * Enable or disable crash reporting. Defaults to true.
    */
-  trace?: string;
+  enabled?: boolean;
 
   /**
-   * Signal name (for iOS crashes)
+   * Optional release bundle filename hint for R8 retracing.
+   * e.g., "index.android.bundle"
    */
-  signal?: string;
+  releaseBundleFilename?: string;
 }

package/src/instrumentations/errors/index.ts

@@ -136,7 +136,6 @@ export class ErrorsInstrumentation extends BaseInstrumentation {
           error,
           {
             mechanism: ErrorMechanism.UNCAUGHT,
-            isFatal: String(isFatal ?? false),
           },
           { releaseBundleFilename: this.options.releaseBundleFilename }
         );
@@ -145,6 +144,7 @@ export class ErrorsInstrumentation extends BaseInstrumentation {
         this.api.pushError(enhancedError, {
           type: enhancedError.name || 'Error',
           context,
+          fatal: isFatal ?? false,
           stackFrames,
         });
 
@@ -209,6 +209,7 @@ export class ErrorsInstrumentation extends BaseInstrumentation {
         this.api.pushError(enhancedError, {
           type: errorType,
           context,
+          fatal: false,
           stackFrames,
         });