@sentry/react-native 5.3.0 → 5.4.0

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

@@ -0,0 +1,54 @@
+import { Scope } from '@sentry/core';
+import type { Attachment, Breadcrumb, User } from '@sentry/types';
+/**
+ * Extends the scope methods to set scope on the Native SDKs
+ */
+export declare class ReactNativeScope extends Scope {
+    /**
+     * @inheritDoc
+     */
+    setUser(user: User | null): this;
+    /**
+     * @inheritDoc
+     */
+    setTag(key: string, value: string): this;
+    /**
+     * @inheritDoc
+     */
+    setTags(tags: {
+        [key: string]: string;
+    }): this;
+    /**
+     * @inheritDoc
+     */
+    setExtras(extras: {
+        [key: string]: any;
+    }): this;
+    /**
+     * @inheritDoc
+     */
+    setExtra(key: string, extra: any): this;
+    /**
+     * @inheritDoc
+     */
+    addBreadcrumb(breadcrumb: Breadcrumb, maxBreadcrumbs?: number): this;
+    /**
+     * @inheritDoc
+     */
+    clearBreadcrumbs(): this;
+    /**
+     * @inheritDoc
+     */
+    setContext(key: string, context: {
+        [key: string]: any;
+    } | null): this;
+    /**
+     * @inheritDoc
+     */
+    addAttachment(attachment: Attachment): this;
+    /**
+     * @inheritDoc
+     */
+    clearAttachments(): this;
+}
+//# sourceMappingURL=scope.d.ts.map

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

@@ -0,0 +1,63 @@
+import type { Scope } from '@sentry/core';
+import { Hub } from '@sentry/core';
+import type { UserFeedback } from '@sentry/types';
+import * as React from 'react';
+import type { ReactNativeOptions, ReactNativeWrapperOptions } from './options';
+/**
+ * Inits the SDK and returns the final options.
+ */
+export declare function init(passedOptions: ReactNativeOptions): void;
+/**
+ * Inits the Sentry React Native SDK with automatic instrumentation and wrapped features.
+ */
+export declare function wrap<P extends JSX.IntrinsicAttributes>(RootComponent: React.ComponentType<P>, options?: ReactNativeWrapperOptions): React.ComponentType<P>;
+/**
+ * Deprecated. Sets the release on the event.
+ * NOTE: Does not set the release on sessions.
+ * @deprecated
+ */
+export declare function setRelease(release: string): void;
+/**
+ * Deprecated. Sets the dist on the event.
+ * NOTE: Does not set the dist on sessions.
+ * @deprecated
+ */
+export declare function setDist(dist: string): void;
+/**
+ * If native client is available it will trigger a native crash.
+ * Use this only for testing purposes.
+ */
+export declare function nativeCrash(): void;
+/**
+ * Flushes all pending events in the queue to disk.
+ * Use this before applying any realtime updates such as code-push or expo updates.
+ */
+export declare function flush(): Promise<boolean>;
+/**
+ * Closes the SDK, stops sending events.
+ */
+export declare function close(): Promise<void>;
+/**
+ * Captures user feedback and sends it to Sentry.
+ */
+export declare function captureUserFeedback(feedback: UserFeedback): void;
+/**
+ * Creates a new scope with and executes the given operation within.
+ * The scope is automatically removed once the operation
+ * finishes or throws.
+ *
+ * This is essentially a convenience function for:
+ *
+ *     pushScope();
+ *     callback();
+ *     popScope();
+ *
+ * @param callback that will be enclosed into push/popScope.
+ */
+export declare function withScope(callback: (scope: Scope) => void): ReturnType<Hub['withScope']>;
+/**
+ * Callback to set context information onto the scope.
+ * @param callback Callback function that receives Scope.
+ */
+export declare function configureScope(callback: (scope: Scope) => void): ReturnType<Hub['configureScope']>;
+//# sourceMappingURL=sdk.d.ts.map

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

@@ -0,0 +1,71 @@
+import * as React from 'react';
+export declare type TouchEventBoundaryProps = {
+    /**
+     * The category assigned to the breadcrumb that is logged by the touch event.
+     */
+    breadcrumbCategory?: string;
+    /**
+     * The type assigned to the breadcrumb that is logged by the touch event.
+     */
+    breadcrumbType?: string;
+    /**
+     * The max number of components to display when logging a touch's component tree.
+     */
+    maxComponentTreeSize?: number;
+    /**
+     * Component name(s) to ignore when logging the touch event. This prevents unhelpful logs such as
+     * "Touch event within element: View" where you still can't tell which View it occurred in.
+     */
+    ignoreNames?: Array<string | RegExp>;
+    /**
+     * Deprecated, use ignoreNames instead
+     * @deprecated
+     */
+    ignoredDisplayNames?: Array<string | RegExp>;
+    /**
+     * React Node wrapped by TouchEventBoundary.
+     */
+    children?: React.ReactNode;
+    /**
+     * Label Name used to identify the touched element.
+     */
+    labelName?: string;
+};
+/**
+ * Boundary to log breadcrumbs for interaction events.
+ */
+declare class TouchEventBoundary extends React.Component<TouchEventBoundaryProps> {
+    static displayName: string;
+    static defaultProps: Partial<TouchEventBoundaryProps>;
+    readonly name: string;
+    private _tracingIntegration;
+    /**
+     * Registers the TouchEventBoundary as a Sentry Integration.
+     */
+    componentDidMount(): void;
+    /**
+     *
+     */
+    render(): React.ReactNode;
+    /**
+     * Logs the touch event given the component tree names and a label.
+     */
+    private _logTouchEvent;
+    /**
+     * Checks if the name is supposed to be ignored.
+     */
+    private _isNameIgnored;
+    /**
+     * Traverses through the component tree when a touch happens and logs it.
+     * @param e
+     */
+    private _onTouchStart;
+}
+/**
+ * Convenience Higher-Order-Component for TouchEventBoundary
+ * @param WrappedComponent any React Component
+ * @param boundaryProps TouchEventBoundaryProps
+ */
+declare const withTouchEventBoundary: (InnerComponent: React.ComponentType<any>, boundaryProps?: TouchEventBoundaryProps | undefined) => React.FunctionComponent;
+export { TouchEventBoundary, withTouchEventBoundary };
+//# sourceMappingURL=touchevents.d.ts.map

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

@@ -0,0 +1,20 @@
+import type { Hub } from '@sentry/types';
+export declare const DEFAULT_BREADCRUMB_CATEGORY = "gesture";
+export declare const DEFAULT_BREADCRUMB_TYPE = "user";
+export declare const GESTURE_POSTFIX_LENGTH: number;
+export declare const ACTION_GESTURE_FALLBACK = "gesture";
+interface GestureTracingOptions {
+    getCurrentHub: () => Hub;
+}
+/**
+ * Patches React Native Gesture Handler v2 Gesture to start a transaction on gesture begin with the appropriate label.
+ * Example: ShoppingCartScreen.dismissGesture
+ */
+export declare function sentryTraceGesture<GestureT>(
+/**
+ * Label of the gesture to be used in transaction name.
+ * Example: dismissGesture
+ */
+label: string, gesture: GestureT, options?: Partial<GestureTracingOptions>): GestureT;
+export {};
+//# sourceMappingURL=gesturetracing.d.ts.map

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

@@ -0,0 +1,10 @@
+export { ReactNativeTracing } from './reactnativetracing';
+export { RoutingInstrumentation, RoutingInstrumentationInstance } from './routingInstrumentation';
+export { ReactNavigationInstrumentation, ReactNavigationV5Instrumentation, } from './reactnavigation';
+export { ReactNavigationV4Instrumentation } from './reactnavigationv4';
+export { ReactNativeNavigationInstrumentation } from './reactnativenavigation';
+export { ReactNavigationCurrentRoute, ReactNavigationRoute, ReactNavigationTransactionContext } from './types';
+export { ReactNativeProfiler } from './reactnativeprofiler';
+export { sentryTraceGesture } from './gesturetracing';
+export * from './ops';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,64 @@
+import type { Transaction } from '@sentry/core';
+import type { EventProcessor, Measurements, MeasurementUnit } from '@sentry/types';
+export interface FramesMeasurements extends Measurements {
+    frames_total: {
+        value: number;
+        unit: MeasurementUnit;
+    };
+    frames_slow: {
+        value: number;
+        unit: MeasurementUnit;
+    };
+    frames_frozen: {
+        value: number;
+        unit: MeasurementUnit;
+    };
+}
+/**
+ * Instrumentation to add native slow/frozen frames measurements onto transactions.
+ */
+export declare class NativeFramesInstrumentation {
+    /** The native frames at the transaction finish time, keyed by traceId. */
+    private _finishFrames;
+    /** The listeners for each native frames response, keyed by traceId */
+    private _framesListeners;
+    /** The native frames at the finish time of the most recent span. */
+    private _lastSpanFinishFrames?;
+    constructor(addGlobalEventProcessor: (e: EventProcessor) => void, doesExist: () => boolean);
+    /**
+     * To be called when a transaction is started.
+     * Logs the native frames at this start point and instruments child span finishes.
+     */
+    onTransactionStart(transaction: Transaction): void;
+    /**
+     * To be called when a transaction is finished
+     */
+    onTransactionFinish(transaction: Transaction): void;
+    /**
+     * Called on a span finish to fetch native frames to support transactions with trimEnd.
+     * Only to be called when a span does not have an end timestamp.
+     */
+    private _onSpanFinish;
+    /**
+     * Returns the computed frames measurements and awaits for them if they are not ready yet.
+     */
+    private _getFramesMeasurements;
+    /**
+     * Returns the computed frames measurements given ready data
+     */
+    private _prepareMeasurements;
+    /**
+     * Fetch finish frames for a transaction at the current time. Calls any awaiting listeners.
+     */
+    private _fetchFramesForTransaction;
+    /**
+     * On a finish frames failure, we cancel the await.
+     */
+    private _cancelFinishFrames;
+    /**
+     * Adds frames measurements to an event. Called from a valid event processor.
+     * Awaits for finish frames if needed.
+     */
+    private _processEvent;
+}
+//# sourceMappingURL=nativeframes.d.ts.map

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

@@ -0,0 +1,8 @@
+export declare const DEFAULT = "default";
+export declare const NAVIGATION = "navigation";
+export declare const UI_LOAD = "ui.load";
+export declare const UI_ACTION = "ui.action";
+export declare const UI_ACTION_TOUCH = "ui.action.touch";
+export declare const APP_START_COLD = "app.start.cold";
+export declare const APP_START_WARM = "app.start.warm";
+//# sourceMappingURL=ops.d.ts.map

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

@@ -0,0 +1,85 @@
+import type { EmitterSubscription } from 'react-native/Libraries/vendor/emitter/EventEmitter';
+import type { OnConfirmRoute, TransactionCreator } from './routingInstrumentation';
+import { InternalRoutingInstrumentation } from './routingInstrumentation';
+import type { BeforeNavigate } from './types';
+interface ReactNativeNavigationOptions {
+    /**
+     * How long the instrumentation will wait for the route to mount after a change has been initiated,
+     * before the transaction is discarded.
+     * Time is in ms.
+     *
+     * Default: 1000
+     */
+    routeChangeTimeoutMs: number;
+    /**
+     * Instrumentation will create a transaction on tab change.
+     * By default only navigation commands create transactions.
+     *
+     * Default: true
+     */
+    enableTabsInstrumentation: boolean;
+}
+interface ComponentEvent {
+    componentId: string;
+}
+declare type ComponentType = 'Component' | 'TopBarTitle' | 'TopBarBackground' | 'TopBarButton';
+export interface ComponentWillAppearEvent extends ComponentEvent {
+    componentName: string;
+    passProps?: Record<string | number | symbol, unknown>;
+    componentType: ComponentType;
+}
+export interface EventSubscription {
+    remove(): void;
+}
+export interface BottomTabPressedEvent {
+    tabIndex: number;
+}
+export interface EventsRegistry {
+    registerComponentWillAppearListener(callback: (event: ComponentWillAppearEvent) => void): EmitterSubscription;
+    registerCommandListener(callback: (name: string, params: unknown) => void): EventSubscription;
+    registerBottomTabPressedListener(callback: (event: BottomTabPressedEvent) => void): EmitterSubscription;
+}
+export interface NavigationDelegate {
+    events: () => EventsRegistry;
+}
+/**
+ * Instrumentation for React Native Navigation. See docs or sample app for usage.
+ *
+ * How this works:
+ * - `_onCommand` is called every time a commands happens and sets an IdleTransaction on the scope without any route context.
+ * - `_onComponentWillAppear` is then called AFTER the state change happens due to a dispatch and sets the route context onto the active transaction.
+ * - If `_onComponentWillAppear` isn't called within `options.routeChangeTimeoutMs` of the dispatch, then the transaction is not sampled and finished.
+ */
+export declare class ReactNativeNavigationInstrumentation extends InternalRoutingInstrumentation {
+    static instrumentationName: string;
+    readonly name: string;
+    private _navigation;
+    private _options;
+    private _prevComponentEvent;
+    private _latestTransaction?;
+    private _recentComponentIds;
+    private _stateChangeTimeout?;
+    constructor(
+    /** The react native navigation `NavigationDelegate`. This is usually the import named `Navigation`. */
+    navigation: unknown, options?: Partial<ReactNativeNavigationOptions>);
+    /**
+     * Registers the event listeners for React Native Navigation
+     */
+    registerRoutingInstrumentation(listener: TransactionCreator, beforeNavigate: BeforeNavigate, onConfirmRoute: OnConfirmRoute): void;
+    /**
+     * To be called when a navigation is initiated. (Command, BottomTabSelected, etc.)
+     */
+    private _onNavigation;
+    /**
+     * To be called AFTER the state has been changed to populate the transaction with the current route.
+     */
+    private _onComponentWillAppear;
+    /** Creates final transaction context before confirmation */
+    private _prepareFinalContext;
+    /** Cancels the latest transaction so it does not get sent to Sentry. */
+    private _discardLatestTransaction;
+    /** Cancels the latest transaction so it does not get sent to Sentry. */
+    private _clearStateChangeTimeout;
+}
+export {};
+//# sourceMappingURL=reactnativenavigation.d.ts.map

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

@@ -0,0 +1,12 @@
+import { Profiler } from '@sentry/react';
+/**
+ * Custom profiler for the React Native app root.
+ */
+export declare class ReactNativeProfiler extends Profiler {
+    readonly name: string;
+    /**
+     * Get the app root mount time.
+     */
+    componentDidMount(): void;
+}
+//# sourceMappingURL=reactnativeprofiler.d.ts.map

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

@@ -0,0 +1,142 @@
+import type { RequestInstrumentationOptions } from '@sentry/browser';
+import type { Hub, Transaction } from '@sentry/core';
+import type { EventProcessor, Integration, Transaction as TransactionType } from '@sentry/types';
+import type { RoutingInstrumentationInstance } from '../tracing/routingInstrumentation';
+import { NativeFramesInstrumentation } from './nativeframes';
+import { StallTrackingInstrumentation } from './stalltracking';
+import type { BeforeNavigate } from './types';
+export interface ReactNativeTracingOptions extends RequestInstrumentationOptions {
+    /**
+     * @deprecated Replaced by idleTimeoutMs
+     */
+    idleTimeout: number;
+    /**
+     * @deprecated Replaced by maxTransactionDurationMs
+     */
+    maxTransactionDuration: number;
+    /**
+     * The time to wait in ms until the transaction will be finished. The transaction will use the end timestamp of
+     * the last finished span as the endtime for the transaction.
+     * Time is in ms.
+     *
+     * Default: 1000
+     */
+    idleTimeoutMs: number;
+    /**
+     * The maximum duration (transaction duration + idle timeout) of a transaction
+     * before it will be marked as "deadline_exceeded".
+     * If you never want to mark a transaction set it to 0.
+     * Time is in ms.
+     *
+     * Default: 600000
+     */
+    finalTimeoutMs: number;
+    /**
+     * The routing instrumentation to be used with the tracing integration.
+     * There is no routing instrumentation if nothing is passed.
+     */
+    routingInstrumentation?: RoutingInstrumentationInstance;
+    /**
+     * Does not sample transactions that are from routes that have been seen any more and don't have any spans.
+     * This removes a lot of the clutter as most back navigation transactions are now ignored.
+     *
+     * Default: true
+     */
+    ignoreEmptyBackNavigationTransactions: boolean;
+    /**
+     * beforeNavigate is called before a navigation transaction is created and allows users to modify transaction
+     * context data, or drop the transaction entirely (by setting `sampled = false` in the context).
+     *
+     * @param context: The context data which will be passed to `startTransaction` by default
+     *
+     * @returns A (potentially) modified context object, with `sampled = false` if the transaction should be dropped.
+     */
+    beforeNavigate: BeforeNavigate;
+    /**
+     * Track the app start time by adding measurements to the first route transaction. If there is no routing instrumentation
+     * an app start transaction will be started.
+     *
+     * Default: true
+     */
+    enableAppStartTracking: boolean;
+    /**
+     * Track slow/frozen frames from the native layer and adds them as measurements to all transactions.
+     */
+    enableNativeFramesTracking: boolean;
+    /**
+     * Track when and how long the JS event loop stalls for. Adds stalls as measurements to all transactions.
+     */
+    enableStallTracking: boolean;
+    /**
+     * Trace User Interaction events like touch and gestures.
+     */
+    enableUserInteractionTracing: boolean;
+}
+/**
+ * Tracing integration for React Native.
+ */
+export declare class ReactNativeTracing implements Integration {
+    /**
+     * @inheritDoc
+     */
+    static id: string;
+    /** We filter out App starts more than 60s */
+    private static _maxAppStart;
+    /**
+     * @inheritDoc
+     */
+    name: string;
+    /** ReactNativeTracing options */
+    options: ReactNativeTracingOptions;
+    nativeFramesInstrumentation?: NativeFramesInstrumentation;
+    stallTrackingInstrumentation?: StallTrackingInstrumentation;
+    useAppStartWithProfiler: boolean;
+    private _inflightInteractionTransaction?;
+    private _getCurrentHub?;
+    private _awaitingAppStartData?;
+    private _appStartFinishTimestamp?;
+    private _currentRoute?;
+    constructor(options?: Partial<ReactNativeTracingOptions>);
+    /**
+     *  Registers routing and request instrumentation.
+     */
+    setupOnce(addGlobalEventProcessor: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void;
+    /**
+     * To be called on a transaction start. Can have async methods
+     */
+    onTransactionStart(transaction: Transaction): void;
+    /**
+     * To be called on a transaction finish. Cannot have async methods.
+     */
+    onTransactionFinish(transaction: Transaction, endTimestamp?: number): void;
+    /**
+     * Called by the ReactNativeProfiler component on first component mount.
+     */
+    onAppStartFinish(endTimestamp: number): void;
+    /**
+     * Starts a new transaction for a user interaction.
+     * @param userInteractionId Consists of `op` representation UI Event and `elementId` unique element identifier on current screen.
+     */
+    startUserInteractionTransaction(userInteractionId: {
+        elementId: string | undefined;
+        op: string;
+    }): TransactionType | undefined;
+    /**
+     * Instruments the app start measurements on the first route transaction.
+     * Starts a route transaction if there isn't routing instrumentation.
+     */
+    private _instrumentAppStart;
+    /**
+     * Adds app start measurements and starts a child span on a transaction.
+     */
+    private _addAppStartData;
+    /** To be called when the route changes, but BEFORE the components of the new route mount. */
+    private _onRouteWillChange;
+    /**
+     * Creates a breadcrumb and sets the current route as a tag.
+     */
+    private _onConfirmRoute;
+    /** Create routing idle transaction. */
+    private _createRouteTransaction;
+}
+//# sourceMappingURL=reactnativetracing.d.ts.map

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

@@ -0,0 +1,83 @@
+import type { OnConfirmRoute, TransactionCreator } from './routingInstrumentation';
+import { InternalRoutingInstrumentation } from './routingInstrumentation';
+import type { BeforeNavigate } from './types';
+export interface NavigationRoute {
+    name: string;
+    key: string;
+    params?: Record<string, any>;
+}
+interface ReactNavigationOptions {
+    /**
+     * How long the instrumentation will wait for the route to mount after a change has been initiated,
+     * before the transaction is discarded.
+     * Time is in ms.
+     *
+     * Default: 1000
+     */
+    routeChangeTimeoutMs: number;
+}
+/**
+ * Instrumentation for React-Navigation V5 and above. See docs or sample app for usage.
+ *
+ * How this works:
+ * - `_onDispatch` is called every time a dispatch happens and sets an IdleTransaction on the scope without any route context.
+ * - `_onStateChange` is then called AFTER the state change happens due to a dispatch and sets the route context onto the active transaction.
+ * - If `_onStateChange` isn't called within `STATE_CHANGE_TIMEOUT_DURATION` of the dispatch, then the transaction is not sampled and finished.
+ */
+export declare class ReactNavigationInstrumentation extends InternalRoutingInstrumentation {
+    static instrumentationName: string;
+    readonly name: string;
+    private _navigationContainer;
+    private readonly _maxRecentRouteLen;
+    private _latestRoute?;
+    private _latestTransaction?;
+    private _initialStateHandled;
+    private _stateChangeTimeout?;
+    private _recentRouteKeys;
+    private _options;
+    constructor(options?: Partial<ReactNavigationOptions>);
+    /**
+     * Extends by calling _handleInitialState at the end.
+     */
+    registerRoutingInstrumentation(listener: TransactionCreator, beforeNavigate: BeforeNavigate, onConfirmRoute: OnConfirmRoute): void;
+    /**
+     * Pass the ref to the navigation container to register it to the instrumentation
+     * @param navigationContainerRef Ref to a `NavigationContainer`
+     */
+    registerNavigationContainer(navigationContainerRef: any): void;
+    /**
+     * To be called on every React-Navigation action dispatch.
+     * It does not name the transaction or populate it with route information. Instead, it waits for the state to fully change
+     * and gets the route information from there, @see _onStateChange
+     */
+    private _onDispatch;
+    /**
+     * To be called AFTER the state has been changed to populate the transaction with the current route.
+     */
+    private _onStateChange;
+    /** Creates final transaction context before confirmation */
+    private _prepareFinalContext;
+    /** Pushes a recent route key, and removes earlier routes when there is greater than the max length */
+    private _pushRecentRouteKey;
+    /** Cancels the latest transaction so it does not get sent to Sentry. */
+    private _discardLatestTransaction;
+    /**
+     *
+     */
+    private _clearStateChangeTimeout;
+}
+/**
+ * Backwards compatibility alias for ReactNavigationInstrumentation
+ * @deprecated Use ReactNavigationInstrumentation
+ */
+export declare const ReactNavigationV5Instrumentation: typeof ReactNavigationInstrumentation;
+export declare const BLANK_TRANSACTION_CONTEXT: {
+    name: string;
+    op: string;
+    tags: {
+        'routing.instrumentation': string;
+    };
+    data: {};
+};
+export {};
+//# sourceMappingURL=reactnavigation.d.ts.map