@sentry/react-native 5.25.0 → 5.26.0

package/ios/RNSentryReplayBreadcrumbConverter.m

@@ -0,0 +1,168 @@
+#import "RNSentryReplayBreadcrumbConverter.h"
+
+@import Sentry;
+
+#if SENTRY_TARGET_REPLAY_SUPPORTED
+
+@implementation RNSentryReplayBreadcrumbConverter {
+  SentrySRDefaultBreadcrumbConverter *defaultConverter;
+}
+
+- (instancetype _Nonnull)init {
+  if (self = [super init]) {
+    self->defaultConverter =
+        [SentrySessionReplayIntegration createDefaultBreadcrumbConverter];
+  }
+  return self;
+}
+
+- (id<SentryRRWebEvent> _Nullable)convertFrom:
+    (SentryBreadcrumb *_Nonnull)breadcrumb {
+  assert(breadcrumb.timestamp != nil);
+
+  if ([breadcrumb.category isEqualToString:@"sentry.event"] ||
+      [breadcrumb.category isEqualToString:@"sentry.transaction"]) {
+    // Do not add Sentry Event breadcrumbs to replay
+    return nil;
+  }
+
+  if ([breadcrumb.category isEqualToString:@"http"]) {
+    // Drop native network breadcrumbs to avoid duplicates
+    return nil;
+  }
+
+  if ([breadcrumb.category isEqualToString:@"touch"]) {
+    return [self convertTouch:breadcrumb];
+  }
+
+  if ([breadcrumb.category isEqualToString:@"navigation"]) {
+    return [SentrySessionReplayIntegration
+        createBreadcrumbwithTimestamp:breadcrumb.timestamp
+                             category:breadcrumb.category
+                              message:nil
+                                level:breadcrumb.level
+                                 data:breadcrumb.data];
+  }
+
+  if ([breadcrumb.category isEqualToString:@"xhr"]) {
+    return [self convertNavigation:breadcrumb];
+  }
+
+  SentryRRWebEvent *nativeBreadcrumb =
+    [self->defaultConverter convertFrom:breadcrumb];
+
+  // ignore native navigation breadcrumbs
+  if (nativeBreadcrumb && nativeBreadcrumb.data &&
+      nativeBreadcrumb.data[@"payload"] &&
+      nativeBreadcrumb.data[@"payload"][@"category"] &&
+      [nativeBreadcrumb.data[@"payload"][@"category"]
+          isEqualToString:@"navigation"]) {
+    return nil;
+  }
+
+  return nativeBreadcrumb;
+}
+
+- (id<SentryRRWebEvent> _Nullable) convertTouch:(SentryBreadcrumb *_Nonnull)breadcrumb {
+  if (breadcrumb.data == nil) {
+    return nil;
+  }
+
+  NSMutableArray *path = [breadcrumb.data valueForKey:@"path"];
+  NSString* message = [RNSentryReplayBreadcrumbConverter getTouchPathMessageFrom:path];
+
+  return [SentrySessionReplayIntegration
+      createBreadcrumbwithTimestamp:breadcrumb.timestamp
+                           category:@"ui.tap"
+                            message:message
+                              level:breadcrumb.level
+                               data:breadcrumb.data];
+}
+
++ (NSString* _Nullable) getTouchPathMessageFrom:(NSArray* _Nullable) path {
+  if (path == nil) {
+    return nil;
+  }
+
+  NSInteger pathCount = [path count];
+  if (pathCount <= 0) {
+    return nil;
+  }
+
+  NSMutableString *message = [[NSMutableString alloc] init];
+  for (NSInteger i = MIN(3, pathCount - 1); i >= 0; i--) {
+    NSDictionary *item = [path objectAtIndex:i];
+    if (item == nil) {
+      return nil; // There should be no nil (undefined) from JS, but to be safe we check it here
+    }
+
+    id name = [item objectForKey:@"name"];
+    id label = [item objectForKey:@"label"];
+    BOOL hasName = [name isKindOfClass:[NSString class]];
+    BOOL hasLabel = [label isKindOfClass:[NSString class]];
+    if (!hasName && !hasLabel) {
+      return nil; // This again should never be allowed in JS, but to be safe we check it here
+    }
+    if (hasLabel) {
+      [message appendString:(NSString *)label];
+    } else if (hasName) {
+      [message appendString:(NSString *)name];
+    }
+
+    id element = [item objectForKey:@"element"];
+    id file = [item objectForKey:@"file"];
+    BOOL hasElement = [element isKindOfClass:[NSString class]];
+    BOOL hasFile = [file isKindOfClass:[NSString class]];
+    if (hasElement && hasFile) {
+      [message appendFormat:@"(%@, %@)", (NSString *)element, (NSString *)file];
+    } else if (hasElement) {
+      [message appendFormat:@"(%@)", (NSString *)element];
+    } else if (hasFile) {
+      [message appendFormat:@"(%@)", (NSString *)file];
+    }
+
+    if (i > 0) {
+      [message appendString:@" > "];
+    }
+  }
+
+  return message;
+}
+
+- (id<SentryRRWebEvent> _Nullable)convertNavigation: (SentryBreadcrumb *_Nonnull)breadcrumb {
+  NSNumber* startTimestamp = [breadcrumb.data[@"start_timestamp"] isKindOfClass:[NSNumber class]]
+    ? breadcrumb.data[@"start_timestamp"] : nil;
+  NSNumber* endTimestamp = [breadcrumb.data[@"end_timestamp"] isKindOfClass:[NSNumber class]]
+    ? breadcrumb.data[@"end_timestamp"] : nil;
+  NSString* url = [breadcrumb.data[@"url"] isKindOfClass:[NSString class]]
+    ? breadcrumb.data[@"url"] : nil;
+
+  if (startTimestamp == nil || endTimestamp == nil || url == nil) {
+    return nil;
+  }
+
+  NSMutableDictionary* data = [[NSMutableDictionary alloc] init];
+  if ([breadcrumb.data[@"method"] isKindOfClass:[NSString class]]) {
+    data[@"method"] = breadcrumb.data[@"method"];
+  }
+  if ([breadcrumb.data[@"status_code"] isKindOfClass:[NSNumber class]]) {
+    data[@"statusCode"] = breadcrumb.data[@"status_code"];
+  }
+  if ([breadcrumb.data[@"request_body_size"] isKindOfClass:[NSNumber class]]) {
+    data[@"requestBodySize"] = breadcrumb.data[@"request_body_size"];
+  }
+  if ([breadcrumb.data[@"response_body_size"] isKindOfClass:[NSNumber class]]) {
+    data[@"responseBodySize"] = breadcrumb.data[@"response_body_size"];
+  }
+
+  return [SentrySessionReplayIntegration
+          createNetworkBreadcrumbWithTimestamp:[NSDate dateWithTimeIntervalSince1970:(startTimestamp.doubleValue / 1000)]
+          endTimestamp:[NSDate dateWithTimeIntervalSince1970:(endTimestamp.doubleValue / 1000)]
+          operation:@"resource.http"
+          description:url
+          data:data];
+}
+
+@end
+
+#endif

package/package.json

@@ -2,7 +2,7 @@
   "name": "@sentry/react-native",
   "homepage": "https://github.com/getsentry/sentry-react-native",
   "repository": "https://github.com/getsentry/sentry-react-native",
-  "version": "5.25.0",
+  "version": "5.26.0",
   "description": "Official Sentry SDK for react-native",
   "typings": "dist/js/index.d.ts",
   "types": "dist/js/index.d.ts",
@@ -67,6 +67,7 @@
     "react-native": ">=0.65.0"
   },
   "dependencies": {
+    "@sentry/babel-plugin-component-annotate": "2.20.1",
     "@sentry/browser": "7.117.0",
     "@sentry/cli": "2.31.2",
     "@sentry/core": "7.117.0",

package/src/js/NativeRNSentry.ts

@@ -44,6 +44,8 @@ export interface Spec extends TurboModule {
   fetchNativePackageName(): string | undefined | null;
   fetchNativeStackFramesBy(instructionsAddr: number[]): NativeStackFrames | undefined | null;
   initNativeReactNavigationNewFrameTracking(): Promise<void>;
+  captureReplay(isHardCrash: boolean): Promise<string | undefined | null>;
+  getCurrentReplayId(): string | undefined | null;
 }
 
 export type NativeStackFrame = {

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

@@ -39,6 +39,8 @@ export interface Spec extends TurboModule {
     fetchNativePackageName(): string | undefined | null;
     fetchNativeStackFramesBy(instructionsAddr: number[]): NativeStackFrames | undefined | null;
     initNativeReactNavigationNewFrameTracking(): Promise<void>;
+    captureReplay(isHardCrash: boolean): Promise<string | undefined | null>;
+    getCurrentReplayId(): string | undefined | null;
 }
 export type NativeStackFrame = {
     platform: string;

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

@@ -35,6 +35,10 @@ export declare class ReactNativeClient extends BaseClient<ReactNativeClientOptio
      * Sends user feedback to Sentry.
      */
     captureUserFeedback(feedback: UserFeedback): void;
+    /**
+     * @inheritDoc
+     */
+    init(): void;
     /**
      * Sets up the integrations
      */

package/ts3.8/dist/js/integrations/exports.d.ts

@@ -12,5 +12,6 @@ export { screenshotIntegration } from './screenshot';
 export { viewHierarchyIntegration } from './viewhierarchy';
 export { expoContextIntegration } from './expocontext';
 export { spotlightIntegration } from './spotlight';
-export { breadcrumbsIntegration, browserApiErrorsIntegration, dedupeIntegration, functionToStringIntegration, globalHandlersIntegration as browserGlobalHandlersIntegration, httpClientIntegration, httpContextIntegration, inboundFiltersIntegration, linkedErrorsIntegration as browserLinkedErrorsIntegration, rewriteFramesIntegration, } from '@sentry/react';
+export { mobileReplayIntegration } from '../replay/mobilereplay';
+export { breadcrumbsIntegration, browserApiErrorsIntegration, dedupeIntegration, functionToStringIntegration, globalHandlersIntegration as browserGlobalHandlersIntegration, httpClientIntegration, httpContextIntegration, inboundFiltersIntegration, linkedErrorsIntegration as browserLinkedErrorsIntegration, rewriteFramesIntegration, replayIntegration as browserReplayIntegration, } from '@sentry/react';
 //# sourceMappingURL=exports.d.ts.map

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

@@ -12,4 +12,5 @@ export { Screenshot } from './screenshot';
 export { ViewHierarchy } from './viewhierarchy';
 export { ExpoContext } from './expocontext';
 export { Spotlight } from './spotlight';
+export { mobileReplayIntegration } from '../replay/mobilereplay';
 //# sourceMappingURL=index.d.ts.map

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

@@ -159,6 +159,28 @@ export interface BaseReactNativeOptions {
      * from the function, no screenshot will be attached.
      */
     beforeScreenshot?: (event: Event, hint: EventHint) => boolean;
+    /**
+     * Options which are in beta, or otherwise not guaranteed to be stable.
+     */
+    _experiments?: {
+        [key: string]: unknown;
+        /**
+         * The sample rate for profiling
+         * 1.0 will profile all transactions and 0 will profile none.
+         */
+        profilesSampleRate?: number;
+        /**
+         * The sample rate for session-long replays.
+         * 1.0 will record all sessions and 0 will record none.
+         */
+        replaysSessionSampleRate?: number;
+        /**
+         * The sample rate for sessions that has had an error occur.
+         * This is independent of `sessionSampleRate`.
+         * 1.0 will record all sessions and 0 will record none.
+         */
+        replaysOnErrorSampleRate?: number;
+    };
 }
 export interface ReactNativeTransportOptions extends BrowserTransportOptions {
     /**
@@ -170,9 +192,9 @@ export interface ReactNativeTransportOptions extends BrowserTransportOptions {
  * Configuration options for the Sentry ReactNative SDK.
  * @see ReactNativeFrontend for more information.
  */
-export interface ReactNativeOptions extends Options<ReactNativeTransportOptions>, BaseReactNativeOptions {
+export interface ReactNativeOptions extends Omit<Options<ReactNativeTransportOptions>, '_experiments'>, BaseReactNativeOptions {
 }
-export interface ReactNativeClientOptions extends Omit<ClientOptions<ReactNativeTransportOptions>, 'tunnel'>, BaseReactNativeOptions {
+export interface ReactNativeClientOptions extends Omit<ClientOptions<ReactNativeTransportOptions>, 'tunnel' | '_experiments'>, BaseReactNativeOptions {
 }
 export interface ReactNativeWrapperOptions {
     /** Props for the root React profiler */

package/ts3.8/dist/js/replay/mobilereplay.d.ts

@@ -0,0 +1,47 @@
+import type { IntegrationFnResult } from '@sentry/types';
+export declare const MOBILE_REPLAY_INTEGRATION_NAME = "MobileReplay";
+export interface MobileReplayOptions {
+    /**
+     * Mask all text in recordings
+     *
+     * @default true
+     */
+    maskAllText?: boolean;
+    /**
+     * Mask all text in recordings
+     *
+     * @default true
+     */
+    maskAllImages?: boolean;
+    /**
+     * Mask all vector graphics in recordings
+     * Supports `react-native-svg`
+     *
+     * @default true
+     */
+    maskAllVectors?: boolean;
+}
+type MobileReplayIntegration = IntegrationFnResult & {
+    options: Required<MobileReplayOptions>;
+};
+/**
+ * The Mobile Replay Integration, let's you adjust the default mobile replay options.
+ * To be passed to `Sentry.init` with `replaysOnErrorSampleRate` or `replaysSessionSampleRate`.
+ *
+ * ```javascript
+ * Sentry.init({
+ *  _experiments: {
+ *    replaysOnErrorSampleRate: 1.0,
+ *    replaysSessionSampleRate: 1.0,
+ *  },
+ *  integrations: [mobileReplayIntegration({
+ *    // Adjust the default options
+ *  })],
+ * });
+ * ```
+ *
+ * @experimental
+ */
+export declare const mobileReplayIntegration: (initOptions?: MobileReplayOptions) => MobileReplayIntegration;
+export {};
+//# sourceMappingURL=mobilereplay.d.ts.map

package/ts3.8/dist/js/replay/networkUtils.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react-native" />
+/// <reference types="react" />
+/** Convert a Content-Length header to number/undefined. */
+export declare function parseContentLengthHeader(header: string | null | undefined): number | undefined;
+export type RequestBody = null | Blob | FormData | URLSearchParams | string | ArrayBuffer | undefined;
+/** Get the size of a body. */
+export declare function getBodySize(body: RequestBody): number | undefined;
+//# sourceMappingURL=networkUtils.d.ts.map

package/ts3.8/dist/js/replay/xhrUtils.d.ts

@@ -0,0 +1,6 @@
+import type { Breadcrumb, BreadcrumbHint } from '@sentry/types';
+/**
+ * Enrich an XHR breadcrumb with additional data for Mobile Replay network tab.
+ */
+export declare function enrichXhrBreadcrumbsForMobileReplay(breadcrumb: Breadcrumb, hint: BreadcrumbHint | undefined): void;
+//# sourceMappingURL=xhrUtils.d.ts.map

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

@@ -0,0 +1,10 @@
+import type { Client } from '@sentry/types';
+/**
+ * Checks if the provided Sentry client has hooks implemented.
+ * @param client The Sentry client object to check.
+ * @returns True if the client has hooks, false otherwise.
+ */
+export declare function hasHooks(client: Client): client is Client & {
+    on: Required<Client>['on'];
+};
+//# sourceMappingURL=clientutils.d.ts.map

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

@@ -16,6 +16,10 @@ export declare function getExpoGoVersion(): string | undefined;
 export declare function getExpoSdkVersion(): string | undefined;
 /** Checks if the current platform is not web */
 export declare function notWeb(): boolean;
+/** Checks if the current platform is supported mobile platform (iOS or Android) */
+export declare function isMobileOs(): boolean;
+/** Checks if the current platform is not supported mobile platform (iOS or Android) */
+export declare function notMobileOs(): boolean;
 /** Returns Hermes Version if hermes is present in the runtime */
 export declare function getHermesVersion(): string | undefined;
 /** Returns default environment based on __DEV__ */

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

@@ -22,7 +22,13 @@ export interface ReactNativeInternalGlobal extends InternalGlobal {
     };
     __BUNDLE_START_TIME__?: number;
     nativePerformanceNow?: () => number;
+    TextEncoder?: TextEncoder;
 }
+type TextEncoder = {
+    new (): TextEncoder;
+    encode(input?: string): Uint8Array;
+};
 /** Get's the global object for the current JavaScript runtime */
 export declare const RN_GLOBAL_OBJ: ReactNativeInternalGlobal;
+export {};
 //# sourceMappingURL=worldwide.d.ts.map

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

@@ -1,4 +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.25.0";
+export declare const SDK_VERSION = "5.26.0";
 //# sourceMappingURL=version.d.ts.map

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

@@ -4,6 +4,7 @@ import type { NativeAppStartResponse, NativeDeviceContextsResponse, NativeFrames
 import type { ReactNativeClientOptions } from './options';
 import type * as Hermes from './profiling/hermes';
 import type { NativeAndroidProfileEvent, NativeProfileEvent } from './profiling/nativeTypes';
+import type { MobileReplayOptions } from './replay/mobilereplay';
 /**
  * Returns the RNSentry module. Dynamically resolves if NativeModule or TurboModule is used.
  */
@@ -13,6 +14,9 @@ export interface Screenshot {
     contentType: string;
     filename: string;
 }
+export type NativeSdkOptions = Partial<ReactNativeClientOptions> & {
+    mobileReplayOptions: MobileReplayOptions | undefined;
+};
 interface SentryNativeWrapper {
     enableNative: boolean;
     nativeIsReady: boolean;
@@ -29,7 +33,7 @@ interface SentryNativeWrapper {
     };
     _isModuleLoaded(module: Spec | undefined): module is Spec;
     isNativeAvailable(): boolean;
-    initNativeSdk(options: Partial<ReactNativeClientOptions>): PromiseLike<boolean>;
+    initNativeSdk(options: NativeSdkOptions): PromiseLike<boolean>;
     closeNativeSdk(): PromiseLike<void>;
     sendEnvelope(envelope: Envelope): Promise<void>;
     captureScreenshot(): Promise<Screenshot[] | null>;
@@ -63,6 +67,8 @@ interface SentryNativeWrapper {
      */
     fetchNativeStackFramesBy(instructionsAddr: number[]): NativeStackFrames | null;
     initNativeReactNavigationNewFrameTracking(): Promise<void>;
+    captureReplay(isHardCrash: boolean): Promise<string | null>;
+    getCurrentReplayId(): string | null;
 }
 /**
  * Our internal interface for calling native functions