@allstak/react-native 0.3.0 → 0.3.2

package/dist/index.d.mts

@@ -1,20 +1,48 @@
+import * as React from 'react';
+
 /**
- * Minimal HTTP transport for React Native. Uses the global `fetch` (always
- * present in RN >= 0.60) with a 3s timeout. Failed sends fall into a small
- * in-memory ring buffer that we retry on the next successful flush.
+ * Fail-open HTTP transport for React Native. Telemetry sends are best-effort:
+ * they use a short timeout, never reject into the host app, and fall into a
+ * bounded in-memory ring buffer with circuit-breaker backoff when AllStak is
+ * unavailable.
  *
  * No window, no AbortController fallback shims — RN exposes both natively.
  */
+interface TransportStats {
+    queued: number;
+    sent: number;
+    failed: number;
+    dropped: number;
+    consecutiveFailures: number;
+    circuitOpenUntil: number;
+    lastTransportLatencyMs?: number;
+    lastFlushDurationMs?: number;
+}
 declare class HttpTransport {
     private baseUrl;
     private apiKey;
+    private enabled;
     private buffer;
     private flushing;
-    constructor(baseUrl: string, apiKey: string);
+    private consecutiveFailures;
+    private circuitOpenUntil;
+    private sent;
+    private failed;
+    private dropped;
+    private lastTransportLatencyMs;
+    private lastFlushDurationMs;
+    constructor(baseUrl: string, apiKey: string, enabled?: boolean);
     send(path: string, payload: unknown): Promise<void>;
+    private enqueueOrDispatch;
+    private dispatch;
     private doFetch;
+    private push;
+    private scheduleFlush;
     private flushBuffer;
+    private recordFailure;
     getBufferSize(): number;
+    noteDropped(count?: number): void;
+    getStats(): TransportStats;
     /**
      * Wait for the in-flight retry-buffer to drain. Resolves `true` if the
      * buffer empties within `timeoutMs` (default 2000ms), `false` otherwise.
@@ -42,6 +70,10 @@ declare class HttpTransport {
 /** What instrumentation hands to the module per request. */
 interface HttpRequestEvent {
     type: 'http_request';
+    traceId: string;
+    requestId: string;
+    spanId?: string;
+    parentSpanId?: string;
     method: string;
     url: string;
     statusCode?: number;
@@ -53,11 +85,19 @@ interface HttpRequestEvent {
     requestHeaders?: Record<string, string>;
     responseHeaders?: Record<string, string>;
     error?: string;
-    traceId?: string;
+    requestBodyStatus?: string;
+    responseBodyStatus?: string;
+    requestBodyRedactedFields?: string[];
+    responseBodyRedactedFields?: string[];
+    requestBodyTruncated?: boolean;
+    responseBodyTruncated?: boolean;
+    capturePolicy?: string;
+    linkConfidence?: 'exact' | 'inferred' | 'weak' | 'none';
 }
 interface HttpRequestIngestItem {
     type: 'http_request';
     traceId: string;
+    requestId: string;
     direction: 'outbound';
     method: string;
     host: string;
@@ -72,6 +112,16 @@ interface HttpRequestIngestItem {
     requestHeaders?: Record<string, string>;
     responseHeaders?: Record<string, string>;
     error?: string;
+    spanId?: string;
+    parentSpanId?: string;
+    requestBodyStatus?: string;
+    responseBodyStatus?: string;
+    requestBodyRedactedFields?: string[];
+    responseBodyRedactedFields?: string[];
+    requestBodyTruncated?: boolean;
+    responseBodyTruncated?: boolean;
+    capturePolicy?: string;
+    linkConfidence?: 'exact' | 'inferred' | 'weak' | 'none';
     environment?: string;
     release?: string;
     dist?: string;
@@ -239,9 +289,19 @@ interface ReplaySurrogateOptions {
 }
 interface SurrogateEvent {
     ts: number;
-    k: 'screen' | 'appstate' | 'manual';
+    k: 'screen' | 'appstate' | 'manual' | 'request' | 'exception' | 'response' | 'action' | 'retry';
     data: Record<string, unknown>;
 }
+interface TimelineContext {
+    traceId?: string;
+    requestId?: string;
+    spanId?: string;
+    eventId?: string;
+    release?: string;
+    dist?: string;
+    screen?: string;
+    route?: string;
+}
 declare class ReplaySurrogate {
     private transport;
     private buffer;
@@ -254,11 +314,13 @@ declare class ReplaySurrogate {
     /** Enable recording for this session if sample-rate roll passes. */
     start(): boolean;
     /** Record a screen view. Filters params through the safeParams allow-list. */
-    recordScreenView(routeName: string, params?: Record<string, unknown>): void;
+    recordScreenView(routeName: string, params?: Record<string, unknown>, context?: TimelineContext): void;
     /** Record an AppState transition (foreground/background/inactive). */
-    recordAppState(next: string): void;
+    recordAppState(next: string, context?: TimelineContext): void;
     /** Record a free-form, customer-validated checkpoint. */
-    recordManual(label: string, data?: Record<string, unknown>): void;
+    recordManual(label: string, data?: Record<string, unknown>, context?: TimelineContext): void;
+    /** Record a forensic mobile session timeline marker. This is not replay. */
+    recordTimelineMarker(kind: SurrogateEvent['k'], label: string, data?: Record<string, unknown>, context?: TimelineContext): void;
     destroy(): void;
     /** @internal — for tests. */
     isActive(): boolean;
@@ -268,6 +330,28 @@ declare class ReplaySurrogate {
     private flush;
 }
 
+/**
+ * URL + header + body redaction utilities for HTTP instrumentation.
+ *
+ * Hard rules:
+ *   - Authorization, Cookie, X-API-Key, Set-Cookie are ALWAYS redacted
+ *     (host app cannot opt back into capturing them).
+ *   - Query params named `token`, `password`, `api_key`, `apikey`,
+ *     `authorization`, `auth`, `secret`, `access_token`, `refresh_token`,
+ *     `session` are ALWAYS redacted.
+ *   - Host app may add additional names via `redactHeaders` /
+ *     `redactQueryParams`; the always-list is the floor, not the ceiling.
+ *   - Bodies are truncated to `maxBodyBytes` (default 4096) and replaced
+ *     with `'<binary>'` when not safely-stringifiable.
+ *
+ * URL pattern matching for ignoredUrls / allowedUrls accepts strings
+ * (substring match) or RegExp (test-based). String matching is
+ * case-insensitive on the URL.
+ */
+declare const ALWAYS_REDACT_HEADERS: Set<string>;
+declare const ALWAYS_REDACT_QUERY: Set<string>;
+declare const REDACTED = "[REDACTED]";
+declare const DEFAULT_REDACT_BODY_FIELDS: string[];
 interface HttpTrackingOptions {
     /** Capture request body. Default false. Truncated to maxBodyBytes. */
     captureRequestBody?: boolean;
@@ -294,11 +378,69 @@ interface HttpTrackingOptions {
     allowedUrls?: (string | RegExp)[];
     /** Max bytes per captured body. Default 4096. */
     maxBodyBytes?: number;
+    /** Content types eligible for body capture. Default JSON + text payloads. */
+    allowedContentTypes?: string[];
+    /** Additional JSON body fields to redact recursively. */
+    redactBodyFields?: string[];
+}
+interface CapturedBody {
+    body?: string;
+    status: 'disabled' | 'captured' | 'redacted' | 'truncated' | 'unsupported' | 'empty';
+    redactedFields: string[];
+    truncated: boolean;
+    capturePolicy: string;
+}
+/**
+ * Redact sensitive query-string params in a URL. Returns the sanitized
+ * URL string. Falls back to the input when URL parsing fails (relative
+ * URLs in test environments).
+ */
+declare function redactUrl(url: string, opts: HttpTrackingOptions): string;
+/**
+ * Filter + redact an HTTP header dictionary. Returns a NEW object — does
+ * not mutate the input. When `captureHeaders` is false returns undefined
+ * (no headers in the wire payload at all).
+ */
+declare function sanitizeHeaders(headers: Record<string, string | string[] | undefined> | undefined, opts: HttpTrackingOptions): Record<string, string> | undefined;
+/**
+ * Truncate + safely-stringify a body. Returns:
+ *   - undefined when capture is disabled
+ *   - the stringified body when it's a string / number / plain object
+ *   - '<binary>' when it's a Blob / FormData / ArrayBuffer / etc
+ *   - truncated string with `…[truncated]` suffix when over maxBodyBytes
+ */
+declare function captureBodyResult(body: unknown, enabled: boolean, maxBodyBytes: number, opts?: HttpTrackingOptions, contentType?: string): CapturedBody;
+
+/**
+ * Per-console-method capture flags. Defaults are set to keep the
+ * dashboard signal-to-noise high: `warn` and `error` capture by default
+ * (most apps fire those at human-meaningful moments), `log` and `info`
+ * are OFF by default since typical apps log thousands of debug lines
+ * per session.
+ *
+ * Override per-method:
+ *
+ *   <AllStakProvider captureConsole={{ log: true, info: true }} />
+ *
+ * Or to fully suppress:
+ *
+ *   <AllStakProvider captureConsole={{ warn: false, error: false }} />
+ *
+ * Setting `autoConsoleBreadcrumbs={false}` on the provider/install is a
+ * higher-level kill switch — it skips wrapping any console method.
+ */
+interface ConsoleCaptureOptions {
+    log?: boolean;
+    info?: boolean;
+    warn?: boolean;
+    error?: boolean;
 }
+/** @internal — for tests. Resets the wrap-once flag. */
+declare function __resetConsoleInstrumentationFlagForTest(): void;
 
 declare const INGEST_HOST = "https://api.allstak.sa";
 declare const SDK_NAME = "allstak-react-native";
-declare const SDK_VERSION = "0.3.0";
+declare const SDK_VERSION = "0.3.1";
 
 interface AllStakConfig {
     /** Project API key (`ask_live_…`). Required. */
@@ -351,6 +493,12 @@ interface AllStakConfig {
      * are ALWAYS redacted.
      */
     httpTracking?: HttpTrackingOptions;
+    /**
+     * Per-console-method capture flags. Defaults: warn + error captured,
+     * log + info NOT captured (to avoid breadcrumb spam from typical app
+     * logging). Set `{ log: true, info: true }` to opt-in.
+     */
+    captureConsole?: ConsoleCaptureOptions;
     maxBreadcrumbs?: number;
     /**
      * Probability in [0, 1] that any given error is sent. Default: 1 (no sampling).
@@ -363,6 +511,13 @@ interface AllStakConfig {
      * — the event is sent as-is so a buggy hook can't black-hole telemetry.
      */
     beforeSend?: (event: ErrorIngestPayload) => ErrorIngestPayload | null | undefined | Promise<ErrorIngestPayload | null | undefined>;
+    /**
+     * Optional fail-open screenshot capture. Off by default and provider-based
+     * so Expo/RN apps choose their own native or JS screenshot implementation.
+     * The SDK bounds timeout/size/sampling and drops screenshots before it can
+     * hurt app navigation, JS thread responsiveness, or telemetry delivery.
+     */
+    screenshot?: ScreenshotCaptureOptions;
     /** SDK identity overrides (set automatically by installReactNative). */
     sdkName?: string;
     sdkVersion?: string;
@@ -371,6 +526,28 @@ interface AllStakConfig {
     commitSha?: string;
     branch?: string;
 }
+interface ScreenshotArtifact {
+    data?: string;
+    contentType?: 'image/png' | 'image/jpeg' | 'image/webp';
+    width?: number;
+    height?: number;
+    sizeBytes?: number;
+    redacted?: boolean;
+    redactionStrategy?: string;
+}
+interface ScreenshotCaptureOptions {
+    enabled?: boolean;
+    captureOnError?: boolean;
+    timeoutMs?: number;
+    maxBytes?: number;
+    sampleRate?: number;
+    provider?: (reason: {
+        type: 'error';
+        error: Error;
+        traceId?: string;
+        requestId?: string;
+    }) => ScreenshotArtifact | null | undefined | Promise<ScreenshotArtifact | null | undefined>;
+}
 interface Breadcrumb {
     timestamp: string;
     type: string;
@@ -386,6 +563,7 @@ interface PayloadFrame {
     colno?: number;
     inApp?: boolean;
     platform?: string;
+    debugId?: string;
 }
 interface ErrorIngestPayload {
     exceptionClass: string;
@@ -400,6 +578,12 @@ interface ErrorIngestPayload {
     environment?: string;
     release?: string;
     sessionId?: string;
+    traceId?: string;
+    spanId?: string;
+    parentSpanId?: string;
+    requestId?: string;
+    replayId?: string;
+    service?: string;
     user?: {
         id?: string;
         email?: string;
@@ -407,6 +591,12 @@ interface ErrorIngestPayload {
     metadata?: Record<string, unknown>;
     breadcrumbs?: Breadcrumb[];
     fingerprint?: string[];
+    debugMeta?: {
+        images: Array<{
+            type: string;
+            debugId: string;
+        }>;
+    };
 }
 declare class AllStakClient {
     private transport;
@@ -482,8 +672,11 @@ declare class AllStakClient {
     }): void;
     getSessionId(): string;
     getConfig(): AllStakConfig;
+    getTransportStats(): TransportStats;
     destroy(): void;
     private sendLog;
+    private shouldCaptureScreenshot;
+    private withScreenshotMetadata;
     private passesSampleRate;
     /**
      * Returns the effective config layer = base config + every scope on the
@@ -555,11 +748,115 @@ declare const AllStak: {
     instrumentAxios<T = any>(axios: T): T;
     getSessionId(): string;
     getConfig(): AllStakConfig | null;
+    getTransportStats(): TransportStats;
     destroy(): void;
     /** @internal — exposed for testing */
     _getInstance(): AllStakClient | null;
 };
 
+/**
+ * React Native runtime integration — ErrorUtils, Hermes promise rejection
+ * tracking, Platform tags, AppState breadcrumbs, XHR network capture,
+ * fetch breadcrumbs, and console breadcrumbs.
+ *
+ * Extracted from index.ts so AllStakProvider can call it without circular
+ * imports.
+ */
+interface ReactNativeInstallOptions {
+    /** Auto-capture unhandled JS exceptions via ErrorUtils. Default: true */
+    autoErrorHandler?: boolean;
+    /** Auto-capture unhandled promise rejections (Hermes). Default: true */
+    autoPromiseRejections?: boolean;
+    /** Auto-attach Platform.* info as tags. Default: true */
+    autoDeviceTags?: boolean;
+    /** Auto-emit breadcrumbs on AppState change. Default: true */
+    autoAppStateBreadcrumbs?: boolean;
+    /** Auto-instrument XHR (RN's fetch is XHR-based) for network breadcrumbs. Default: true */
+    autoNetworkCapture?: boolean;
+    /** Wrap `globalThis.fetch` to record HTTP breadcrumbs. Default: true */
+    autoFetchBreadcrumbs?: boolean;
+    /**
+     * Wrap `console.*` methods to record log breadcrumbs. Default: true.
+     * Per-method capture is controlled by `captureConsole` in AllStakConfig
+     * (warn + error default on, log + info default off).
+     */
+    autoConsoleBreadcrumbs?: boolean;
+    /**
+     * Auto-detect `@react-navigation/native` and patch `NavigationContainer`
+     * so route changes ship as breadcrumbs without the host app needing
+     * to call `instrumentReactNavigation(ref)`. Default: true. When the
+     * package is not installed, this silently no-ops.
+     */
+    autoNavigationBreadcrumbs?: boolean;
+    /**
+     * Emit a `[AllStak] Navigation auto-instrumentation enabled/not applied`
+     * console log so developers can confirm the wiring at startup. The
+     * provider sets this from its `debug` prop; defaults to false when
+     * called manually.
+     */
+    debugLogs?: boolean;
+}
+declare function installReactNative(options?: ReactNativeInstallOptions): void;
+
+interface AllStakProviderProps extends ReactNativeInstallOptions {
+    children: React.ReactNode;
+    apiKey: string;
+    environment?: string;
+    release?: string;
+    host?: string;
+    user?: {
+        id?: string;
+        email?: string;
+    };
+    tags?: Record<string, string>;
+    debug?: boolean;
+    enableHttpTracking?: boolean;
+    httpTracking?: AllStakConfig['httpTracking'];
+    /**
+     * Per-console-method capture flags. Defaults: warn + error on, log +
+     * info off. Set `{ log: true, info: true }` to opt-in to verbose
+     * capture, or `{ warn: false, error: false }` to suppress.
+     */
+    captureConsole?: AllStakConfig['captureConsole'];
+    sampleRate?: number;
+    beforeSend?: AllStakConfig['beforeSend'];
+    replay?: AllStakConfig['replay'];
+    tracesSampleRate?: number;
+    service?: string;
+    dist?: string;
+    /**
+     * Tear down the SDK when the provider unmounts. Default `false`.
+     *
+     * Most apps mount `AllStakProvider` once at the root and never unmount
+     * it. Setting this to `true` risks disabling telemetry if the provider
+     * re-mounts (Fast Refresh in dev, route key changes, React 18 Strict
+     * Mode double-mount, etc.) — there is a brief window between unmount
+     * and remount where captures throw.
+     *
+     * Leave at the default unless you genuinely need to dispose the SDK
+     * (e.g. test harness, multi-tenant container that switches projects).
+     */
+    destroyOnUnmount?: boolean;
+    fallback?: React.ReactNode | ((props: {
+        error: Error;
+        resetError: () => void;
+    }) => React.ReactNode);
+    onError?: (error: Error, componentStack?: string) => void;
+}
+declare function AllStakProvider({ children, apiKey, environment, release, host, user, tags, debug, enableHttpTracking, httpTracking, captureConsole, sampleRate, beforeSend, replay, tracesSampleRate, service, dist, destroyOnUnmount, fallback, onError, autoErrorHandler, autoPromiseRejections, autoDeviceTags, autoAppStateBreadcrumbs, autoNetworkCapture, autoFetchBreadcrumbs, autoConsoleBreadcrumbs, autoNavigationBreadcrumbs, }: AllStakProviderProps): React.ReactElement;
+declare function useAllStak(): {
+    captureException: (error: Error, ctx?: Record<string, unknown>) => void;
+    captureMessage: (msg: string, level?: "fatal" | "error" | "warning" | "info") => void;
+    setUser: (user: {
+        id?: string;
+        email?: string;
+    }) => void;
+    setTag: (key: string, value: string) => void;
+    addBreadcrumb: (type: string, message: string, level?: string, data?: Record<string, unknown>) => void;
+};
+/** @internal — for tests. Resets the module-level remount-guard. */
+declare function __resetProviderInstanceForTest(): void;
+
 /**
  * React Native navigation breadcrumbs — two opt-in helpers:
  *
@@ -611,6 +908,38 @@ declare function instrumentReactNavigation(navigationRef: NavigationRef, options
  * as breadcrumbs. No-op if `react-native` isn't available (test env).
  */
 declare function instrumentNavigationFromLinking(): void;
+/**
+ * Best-effort automatic instrumentation of `@react-navigation/native`.
+ *
+ * **What it does:**
+ *   - Tries `require('@react-navigation/native')`. If the package is not
+ *     installed, returns `false` and is otherwise a no-op.
+ *   - If found, monkey-patches the module's exported `NavigationContainer`
+ *     with a wrapper that auto-creates an internal ref, forwards the
+ *     user's `ref` prop, and on mount calls `instrumentReactNavigation`
+ *     so route changes ship as breadcrumbs.
+ *   - Idempotent: a flag on the module's exports object prevents double
+ *     patching across hot-reload cycles or repeated `installReactNative`
+ *     calls.
+ *
+ * **Why this works:**
+ *   Babel's CommonJS interop preserves runtime property lookups for
+ *   named imports — `import { NavigationContainer } from '@react-navigation/native'`
+ *   compiles to `_rnav.NavigationContainer` accesses at use-site, so
+ *   patching the module's exports object before the host app renders
+ *   means user code transparently picks up our wrapper.
+ *
+ * **Why it might fail:**
+ *   - `@react-navigation/native` not installed → returns false silently.
+ *   - Module exports frozen or sealed (rare in CJS-style RN builds).
+ *   - User imported `NavigationContainer` via a deep path that bypasses
+ *     the index module.
+ *   In any failure case the manual API (`instrumentReactNavigation(ref)`)
+ *   is still available as a fallback.
+ */
+declare function tryAutoInstrumentNavigation(): boolean;
+/** @internal — for tests. Resets the auto-patch flag on the cached module. */
+declare function __resetAutoNavigationFlagForTest(): void;
 
 /**
  * React Native architecture / runtime detection.
@@ -658,8 +987,21 @@ declare function applyArchitectureTags(setTag: (key: string, value: string) => v
  * `document`, `localStorage`, `sessionStorage`, or browser DOM event
  * listeners.
  *
- * Usage:
+ * Recommended usage (one-liner):
+ *
+ *   import { AllStakProvider } from '@allstak/react-native';
+ *
+ *   export default function App() {
+ *     return (
+ *       <AllStakProvider apiKey="YOUR_API_KEY" environment="production">
+ *         <AppRoot />
+ *       </AllStakProvider>
+ *     );
+ *   }
  *
+ * Advanced / manual usage:
+ *
+ *   import { AllStak, installReactNative } from '@allstak/react-native';
  *   AllStak.init({ apiKey, environment, release });
  *   installReactNative();
  *
@@ -667,29 +1009,24 @@ declare function applyArchitectureTags(setTag: (key: string, value: string) => v
  * under the `native/` directory in this package. See README.
  */
 
-interface ReactNativeInstallOptions {
-    /** Auto-capture unhandled JS exceptions via ErrorUtils. Default: true */
-    autoErrorHandler?: boolean;
-    /** Auto-capture unhandled promise rejections (Hermes). Default: true */
-    autoPromiseRejections?: boolean;
-    /** Auto-attach Platform.* info as tags. Default: true */
-    autoDeviceTags?: boolean;
-    /** Auto-emit breadcrumbs on AppState change. Default: true */
-    autoAppStateBreadcrumbs?: boolean;
-    /** Auto-instrument XHR (RN's fetch is XHR-based) for network breadcrumbs. Default: true */
-    autoNetworkCapture?: boolean;
-    /** Wrap `globalThis.fetch` to record HTTP breadcrumbs. Default: true */
-    autoFetchBreadcrumbs?: boolean;
-    /** Wrap `console.warn`/`console.error` to record log breadcrumbs. Default: true */
-    autoConsoleBreadcrumbs?: boolean;
-}
 declare function __setNativeModuleForTest(mod: any): void;
+/**
+ * DEV-ONLY: deliberately trigger a native iOS or Android crash via the
+ * linked AllStak native module. This is intended for verifying the
+ * native-crash → drain → ingest pipeline during SDK development. It
+ * **terminates the app process** — never expose this in production UI.
+ *
+ *   import { __devTriggerNativeCrash } from '@allstak/react-native';
+ *   if (__DEV__) __devTriggerNativeCrash();  // app dies; relaunch drains
+ *
+ * No-op when the native module is not linked.
+ */
+declare function __devTriggerNativeCrash(): Promise<void>;
 /**
  * Drain any native crash stashed by AllStakCrashHandler on the previous
  * launch and ship it to /ingest/v1/errors. No-op when the native module
  * is not linked (Expo Go, JS-only test runners, etc).
  */
 declare function drainPendingNativeCrashes(release?: string): Promise<void>;
-declare function installReactNative(options?: ReactNativeInstallOptions): void;
 
-export { AllStak, AllStakClient, type AllStakConfig, type ArchitectureInfo, type Breadcrumb, type HttpRequestEvent, HttpRequestModule, type HttpTrackingOptions, INGEST_HOST, type ReactNativeInstallOptions, ReplaySurrogate, type ReplaySurrogateOptions, SDK_NAME, SDK_VERSION, Scope, __setNativeModuleForTest, applyArchitectureTags, detectArchitecture, drainPendingNativeCrashes, installReactNative, instrumentNavigationFromLinking, instrumentReactNavigation };
+export { ALWAYS_REDACT_HEADERS, ALWAYS_REDACT_QUERY, AllStak, AllStakClient, type AllStakConfig, AllStakProvider, type AllStakProviderProps, type ArchitectureInfo, type Breadcrumb, type ConsoleCaptureOptions, DEFAULT_REDACT_BODY_FIELDS, type HttpRequestEvent, HttpRequestModule, type HttpTrackingOptions, INGEST_HOST, REDACTED, type ReactNativeInstallOptions, ReplaySurrogate, type ReplaySurrogateOptions, SDK_NAME, SDK_VERSION, Scope, type ScreenshotArtifact, type ScreenshotCaptureOptions, type TransportStats, __devTriggerNativeCrash, __resetAutoNavigationFlagForTest, __resetConsoleInstrumentationFlagForTest, __resetProviderInstanceForTest, __setNativeModuleForTest, applyArchitectureTags, captureBodyResult, detectArchitecture, drainPendingNativeCrashes, installReactNative, instrumentNavigationFromLinking, instrumentReactNavigation, redactUrl, sanitizeHeaders, tryAutoInstrumentNavigation, useAllStak };