@sentry/react-native 5.3.1 → 5.4.1

package/ts3.8/dist/js/tracing/stalltracking.d.ts

@@ -0,0 +1,94 @@
+import type { IdleTransaction, Transaction } from '@sentry/core';
+import type { Measurements, MeasurementUnit } from '@sentry/types';
+import { STALL_COUNT, STALL_LONGEST_TIME, STALL_TOTAL_TIME } from '../measurements';
+export interface StallMeasurements extends Measurements {
+    [STALL_COUNT]: {
+        value: number;
+        unit: MeasurementUnit;
+    };
+    [STALL_TOTAL_TIME]: {
+        value: number;
+        unit: MeasurementUnit;
+    };
+    [STALL_LONGEST_TIME]: {
+        value: number;
+        unit: MeasurementUnit;
+    };
+}
+export declare type StallTrackingOptions = {
+    /**
+     * How long in milliseconds an event loop iteration can be delayed for before being considered a "stall."
+     * @default 100
+     */
+    minimumStallThreshold: number;
+};
+/**
+ * Stall measurement tracker inspired by the `JSEventLoopWatchdog` used internally in React Native:
+ * https://github.com/facebook/react-native/blob/006f5afe120c290a37cf6ff896748fbc062bf7ed/Libraries/Interaction/JSEventLoopWatchdog.js
+ *
+ * However, we modified the interval implementation to instead have a fixed loop timeout interval of `LOOP_TIMEOUT_INTERVAL_MS`.
+ * We then would consider that iteration a stall when the total time for that interval to run is greater than `LOOP_TIMEOUT_INTERVAL_MS + minimumStallThreshold`
+ */
+export declare class StallTrackingInstrumentation {
+    isTracking: boolean;
+    private _minimumStallThreshold;
+    /** Total amount of time of all stalls that occurred during the current tracking session */
+    private _totalStallTime;
+    /** Total number of stalls that occurred during the current tracking session */
+    private _stallCount;
+    /** The last timestamp the iteration ran in milliseconds */
+    private _lastIntervalMs;
+    private _timeout;
+    private _statsByTransaction;
+    constructor(options?: StallTrackingOptions);
+    /**
+     * @inheritDoc
+     * Not used for this integration. Instead call `registerTransactionStart` to start tracking.
+     */
+    setupOnce(): void;
+    /**
+     * Register a transaction as started. Starts stall tracking if not already running.
+     * @returns A finish method that returns the stall measurements.
+     */
+    onTransactionStart(transaction: Transaction): void;
+    /**
+     * Logs a transaction as finished.
+     * Stops stall tracking if no more transactions are running.
+     * @returns The stall measurements
+     */
+    onTransactionFinish(transaction: Transaction | IdleTransaction, passedEndTimestamp?: number): void;
+    /**
+     * Logs the finish time of the span for use in `trimEnd: true` transactions.
+     */
+    private _markSpanFinish;
+    /**
+     * Get the current stats for a transaction at a given time.
+     */
+    private _getCurrentStats;
+    /**
+     * Start tracking stalls
+     */
+    private _startTracking;
+    /**
+     * Stops the stall tracking interval and calls reset().
+     */
+    private _stopTracking;
+    /**
+     * Will stop tracking if there are no more transactions.
+     */
+    private _shouldStopTracking;
+    /**
+     * Clears all the collected stats
+     */
+    private _reset;
+    /**
+     * Iteration of the stall tracking interval. Measures how long the timer strayed from its expected time of running, and how
+     * long the stall is for.
+     */
+    private _iteration;
+    /**
+     * Deletes leaked transactions (Earliest transactions when we have more than MAX_RUNNING_TRANSACTIONS transactions.)
+     */
+    private _flushLeakedTransactions;
+}
+//# sourceMappingURL=stalltracking.d.ts.map

package/ts3.8/dist/js/tracing/transaction.d.ts

@@ -0,0 +1,7 @@
+import type { BeforeFinishCallback } from '@sentry/core/types/tracing/idletransaction';
+/**
+ * Idle Transaction callback to only sample transactions with child spans.
+ * To avoid side effects of other callbacks this should be hooked as the last callback.
+ */
+export declare const onlySampleIfChildSpans: BeforeFinishCallback;
+//# sourceMappingURL=transaction.d.ts.map

package/ts3.8/dist/js/tracing/types.d.ts

@@ -0,0 +1,29 @@
+import type { TransactionContext } from '@sentry/types';
+export interface ReactNavigationRoute {
+    name: string;
+    key: string;
+    params: Record<string, any>;
+}
+export interface ReactNavigationCurrentRoute extends ReactNavigationRoute {
+    hasBeenSeen: boolean;
+}
+export declare type RouteChangeContextData = {
+    previousRoute?: {
+        [key: string]: unknown;
+        name: string;
+    } | null;
+    route: {
+        [key: string]: unknown;
+        name: string;
+        hasBeenSeen: boolean;
+    };
+};
+export interface ReactNavigationTransactionContext extends TransactionContext {
+    tags: {
+        'routing.instrumentation': string;
+        'routing.route.name': string;
+    };
+    data: RouteChangeContextData;
+}
+export declare type BeforeNavigate = (context: TransactionContext) => TransactionContext;
+//# sourceMappingURL=types.d.ts.map

package/ts3.8/dist/js/tracing/utils.d.ts

@@ -0,0 +1,27 @@
+import type { IdleTransaction, Span, Transaction } from '@sentry/core';
+import type { TransactionContext, TransactionSource } from '@sentry/types';
+export declare const defaultTransactionSource: TransactionSource;
+export declare const customTransactionSource: TransactionSource;
+export declare const getBlankTransactionContext: (name: string) => TransactionContext;
+/**
+ * A margin of error of 50ms is allowed for the async native bridge call.
+ * Anything larger would reduce the accuracy of our frames measurements.
+ */
+export declare const MARGIN_OF_ERROR_SECONDS = 0.05;
+/**
+ *
+ */
+export declare function adjustTransactionDuration(maxDurationMs: number, transaction: IdleTransaction, endTimestamp: number): void;
+/**
+ * Returns the timestamp where the JS global scope was initialized.
+ */
+export declare function getTimeOriginMilliseconds(): number;
+/**
+ * Calls the callback every time a child span of the transaction is finished.
+ */
+export declare function instrumentChildSpanFinish(transaction: Transaction, callback: (span: Span, endTimestamp?: number) => void): void;
+/**
+ * Determines if the timestamp is now or within the specified margin of error from now.
+ */
+export declare function isNearToNow(timestamp: number): boolean;
+//# sourceMappingURL=utils.d.ts.map

package/ts3.8/dist/js/transports/TextEncoder.d.ts

@@ -0,0 +1,3 @@
+import type { TextEncoderInternal } from '@sentry/types';
+export declare const makeUtf8TextEncoder: () => TextEncoderInternal;
+//# sourceMappingURL=TextEncoder.d.ts.map

package/ts3.8/dist/js/transports/native.d.ts

@@ -0,0 +1,39 @@
+import type { BaseTransportOptions, Envelope, Transport } from '@sentry/types';
+import type { PromiseBuffer } from '@sentry/utils';
+export declare const DEFAULT_BUFFER_SIZE = 30;
+export declare type BaseNativeTransport = BaseTransportOptions;
+export interface BaseNativeTransportOptions {
+    bufferSize?: number;
+}
+/** Native Transport class implementation */
+export declare class NativeTransport implements Transport {
+    /** A simple buffer holding all requests. */
+    protected readonly _buffer: PromiseBuffer<void>;
+    constructor(options?: BaseNativeTransportOptions);
+    /**
+     * Sends the envelope to the Store endpoint in Sentry.
+     *
+     * @param envelope Envelope that should be sent to Sentry.
+     */
+    send(envelope: Envelope): PromiseLike<void>;
+    /**
+     * Wait for all envelopes to be sent or the timeout to expire, whichever comes first.
+     *
+     * @param timeout Maximum time in ms the transport should wait for envelopes to be flushed. Omitting this parameter will
+     *   cause the transport to wait until all events are sent before resolving the promise.
+     * @returns A promise that will resolve with `true` if all events are sent before the timeout, or `false` if there are
+     * still events in the queue when the timeout is reached.
+     */
+    flush(timeout?: number): PromiseLike<boolean>;
+}
+/**
+ * Creates a Native Transport.
+ */
+export declare function makeNativeTransport(options?: BaseNativeTransportOptions): NativeTransport;
+/**
+ * Creates a Native Transport factory if the native transport is available.
+ */
+export declare function makeNativeTransportFactory({ enableNative, }: {
+    enableNative?: boolean;
+}): typeof makeNativeTransport | null;
+//# sourceMappingURL=native.d.ts.map

package/ts3.8/dist/js/user.d.ts

@@ -0,0 +1,6 @@
+import type { User } from '@sentry/types';
+/** Requires all the keys defined on User interface to be present on an object */
+export declare type RequiredKeysUser = {
+    [P in keyof Required<User>]: User[P] | undefined;
+};
+//# sourceMappingURL=user.d.ts.map

package/ts3.8/dist/js/utils/envelope.d.ts

@@ -0,0 +1,12 @@
+import type { DsnComponents, EventEnvelope, SdkMetadata, UserFeedback } from '@sentry/types';
+export declare const header = 0;
+export declare const items = 1;
+/**
+ * Creates an envelope from a user feedback.
+ */
+export declare function createUserFeedbackEnvelope(feedback: UserFeedback, { metadata, tunnel, dsn, }: {
+    metadata: SdkMetadata | undefined;
+    tunnel: string | undefined;
+    dsn: DsnComponents | undefined;
+}): EventEnvelope;
+//# sourceMappingURL=envelope.d.ts.map

package/ts3.8/dist/js/utils/environment.d.ts

@@ -0,0 +1,7 @@
+/** Checks if the React Native Hermes engine is running */
+export declare function isHermesEnabled(): boolean;
+/** Checks if the React Native TurboModules are enabled */
+export declare function isTurboModuleEnabled(): boolean;
+/** Checks if the React Native Fabric renderer is running */
+export declare function isFabricEnabled(): boolean;
+//# sourceMappingURL=environment.d.ts.map

package/ts3.8/dist/js/utils/ignorerequirecyclelogs.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This is a workaround for using fetch on RN, this is a known issue in react-native and only generates a warning.
+ */
+export declare function ignoreRequireCycleLogs(): void;
+//# sourceMappingURL=ignorerequirecyclelogs.d.ts.map

package/ts3.8/dist/js/utils/normalize.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Converts any input into a valid record with string keys.
+ */
+export declare function convertToNormalizedObject(data: unknown): Record<string, any>;
+//# sourceMappingURL=normalize.d.ts.map

package/ts3.8/dist/js/utils/outcome.d.ts

@@ -0,0 +1,6 @@
+import type { Outcome } from '@sentry/types';
+/**
+ * Merges buffer with new outcomes.
+ */
+export declare function mergeOutcomes(...merge: Outcome[][]): Outcome[];
+//# sourceMappingURL=outcome.d.ts.map

package/ts3.8/dist/js/utils/safe.d.ts

@@ -0,0 +1,21 @@
+import type { ReactNativeOptions } from '../options';
+declare type DangerTypesWithoutCallSignature = Object | null | undefined;
+/**
+ * Returns callback factory wrapped with try/catch
+ * or the original passed value is it's not a function.
+ *
+ * If the factory fails original data are returned as it.
+ * They might be partially modified by the failed function.
+ */
+export declare function safeFactory<A extends [
+    R,
+    ...unknown[]
+], R, T extends DangerTypesWithoutCallSignature>(danger: ((...args: A) => R) | T, options?: {
+    loggerMessage?: string;
+}): ((...args: A) => R) | T;
+/**
+ * Returns sage tracesSampler that returns 0 if the original failed.
+ */
+export declare function safeTracesSampler(tracesSampler: ReactNativeOptions['tracesSampler']): ReactNativeOptions['tracesSampler'];
+export {};
+//# sourceMappingURL=safe.d.ts.map

package/ts3.8/dist/js/utils/worldwide.d.ts

@@ -0,0 +1,15 @@
+import type { InternalGlobal } from '@sentry/utils';
+import type { ErrorUtils } from 'react-native/types';
+/** Internal Global object interface with common and Sentry specific properties */
+export interface ReactNativeInternalGlobal extends InternalGlobal {
+    __sentry_rn_v4_registered?: boolean;
+    __sentry_rn_v5_registered?: boolean;
+    HermesInternal: unknown;
+    Promise: unknown;
+    __turboModuleProxy: unknown;
+    nativeFabricUIManager: unknown;
+    ErrorUtils?: ErrorUtils;
+}
+/** Get's the global object for the current JavaScript runtime */
+export declare const RN_GLOBAL_OBJ: ReactNativeInternalGlobal;
+//# sourceMappingURL=worldwide.d.ts.map

package/ts3.8/dist/js/vendor/buffer/index.d.ts

@@ -0,0 +1,2 @@
+export { utf8ToBytes } from './utf8ToBytes';
+//# sourceMappingURL=index.d.ts.map

package/ts3.8/dist/js/vendor/buffer/utf8ToBytes.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Convert a string to a byte array
+ */
+export declare function utf8ToBytes(string: string, units?: number): number[];
+//# sourceMappingURL=utf8ToBytes.d.ts.map

package/ts3.8/dist/js/vendor/index.d.ts

@@ -0,0 +1,2 @@
+export { utf8ToBytes } from './buffer';
+//# sourceMappingURL=index.d.ts.map

package/ts3.8/dist/js/version.d.ts

@@ -0,0 +1,4 @@
+export declare const SDK_PACKAGE_NAME = "npm:@sentry/react-native";
+export declare const SDK_NAME = "sentry.javascript.react-native";
+export declare const SDK_VERSION = "5.4.1";
+//# sourceMappingURL=version.d.ts.map

package/ts3.8/dist/js/wrapper.d.ts

@@ -0,0 +1,55 @@
+import type { Breadcrumb, Envelope, EnvelopeItem, Event, Package, SeverityLevel, User } from '@sentry/types';
+import { Platform } from 'react-native';
+import type { NativeAppStartResponse, NativeDeviceContextsResponse, NativeFramesResponse, NativeReleaseResponse, Spec } from './NativeRNSentry';
+import type { ReactNativeClientOptions } from './options';
+export interface Screenshot {
+    data: Uint8Array;
+    contentType: string;
+    filename: string;
+}
+interface SentryNativeWrapper {
+    enableNative: boolean;
+    nativeIsReady: boolean;
+    platform: typeof Platform.OS;
+    _NativeClientError: Error;
+    _DisabledNativeError: Error;
+    _processItem(envelopeItem: EnvelopeItem): EnvelopeItem;
+    _processLevels(event: Event): Event;
+    _processLevel(level: SeverityLevel): SeverityLevel;
+    _serializeObject(data: {
+        [key: string]: unknown;
+    }): {
+        [key: string]: string;
+    };
+    _isModuleLoaded(module: Spec | undefined): module is Spec;
+    _getBreadcrumbs(event: Event): Breadcrumb[] | undefined;
+    isNativeAvailable(): boolean;
+    initNativeSdk(options: Partial<ReactNativeClientOptions>): PromiseLike<boolean>;
+    closeNativeSdk(): PromiseLike<void>;
+    sendEnvelope(envelope: Envelope): Promise<void>;
+    captureScreenshot(): Promise<Screenshot[] | null>;
+    fetchNativeRelease(): PromiseLike<NativeReleaseResponse>;
+    fetchNativeDeviceContexts(): PromiseLike<NativeDeviceContextsResponse>;
+    fetchNativeAppStart(): PromiseLike<NativeAppStartResponse | null>;
+    fetchNativeFrames(): PromiseLike<NativeFramesResponse | null>;
+    fetchNativeSdkInfo(): PromiseLike<Package | null>;
+    disableNativeFramesTracking(): void;
+    enableNativeFramesTracking(): void;
+    addBreadcrumb(breadcrumb: Breadcrumb): void;
+    setContext(key: string, context: {
+        [key: string]: unknown;
+    } | null): void;
+    clearBreadcrumbs(): void;
+    setExtra(key: string, extra: unknown): void;
+    setUser(user: User | null): void;
+    setTag(key: string, value: string): void;
+    nativeCrash(): void;
+    fetchModules(): Promise<Record<string, string> | null>;
+    fetchViewHierarchy(): PromiseLike<Uint8Array | null>;
+}
+/**
+ * Our internal interface for calling native functions
+ */
+export declare const NATIVE: SentryNativeWrapper;
+export {};
+//# sourceMappingURL=wrapper.d.ts.map