@sentry/react-native 7.5.0 → 7.7.0

package/ios/SentrySDKWrapper.m

@@ -1,4 +1,6 @@
 #import "SentrySDKWrapper.h"
+#import "RNSentryExperimentalOptions.h"
+#import "RNSentryVersion.h"
 @import Sentry;
 
 @implementation SentrySDKWrapper
@@ -28,4 +30,137 @@
     [SentrySDK configureScope:callback];
 }
 
++ (SentryOptions *)createOptionsWithDictionary:(NSDictionary *)options
+                        isSessionReplayEnabled:(BOOL)isSessionReplayEnabled
+                                         error:(NSError *__autoreleasing *)errorPointer
+{
+    NSString *dsn = [self getURLFromDSN:[options valueForKey:@"dsn"]];
+    SentryOptions *sentryOptions = [SentryOptionsInternal initWithDict:options
+                                                      didFailWithError:errorPointer];
+    if (*errorPointer != nil) {
+        return nil;
+    }
+
+    // Exclude Dev Server and Sentry Dsn request from Breadcrumbs
+    NSString *devServerUrl = [options valueForKey:@"devServerUrl"];
+    sentryOptions.beforeBreadcrumb
+        = ^SentryBreadcrumb *_Nullable(SentryBreadcrumb *_Nonnull breadcrumb)
+    {
+        NSString *url = breadcrumb.data[@"url"] ?: @"";
+
+        if ([@"http" isEqualToString:breadcrumb.type]
+            && ((dsn != nil && [url hasPrefix:dsn])
+                || (devServerUrl != nil && [url hasPrefix:devServerUrl]))) {
+            return nil;
+        }
+        return breadcrumb;
+    };
+
+    if ([options valueForKey:@"enableNativeCrashHandling"] != nil) {
+        BOOL enableNativeCrashHandling = [options[@"enableNativeCrashHandling"] boolValue];
+
+        if (!enableNativeCrashHandling) {
+            sentryOptions.enableCrashHandler = NO;
+        }
+    }
+
+    // Set spotlight option
+    if ([options valueForKey:@"spotlight"] != nil) {
+        id spotlightValue = [options valueForKey:@"spotlight"];
+        if ([spotlightValue isKindOfClass:[NSString class]]) {
+            NSLog(@"Using Spotlight on address: %@", spotlightValue);
+            sentryOptions.enableSpotlight = true;
+            sentryOptions.spotlightUrl = spotlightValue;
+        } else if ([spotlightValue isKindOfClass:[NSNumber class]]) {
+            sentryOptions.enableSpotlight = [spotlightValue boolValue];
+            id defaultSpotlightUrl = [options valueForKey:@"defaultSidecarUrl"];
+            if (defaultSpotlightUrl != nil) {
+                sentryOptions.spotlightUrl = defaultSpotlightUrl;
+            }
+        }
+    }
+
+    if ([options valueForKey:@"enableLogs"] != nil) {
+        id enableLogsValue = [options valueForKey:@"enableLogs"];
+        if ([enableLogsValue isKindOfClass:[NSNumber class]]) {
+            [RNSentryExperimentalOptions setEnableLogs:[enableLogsValue boolValue]
+                                         sentryOptions:sentryOptions];
+        }
+    }
+
+    // Enable the App start and Frames tracking measurements
+    if ([options valueForKey:@"enableAutoPerformanceTracing"] != nil) {
+        BOOL enableAutoPerformanceTracing = [options[@"enableAutoPerformanceTracing"] boolValue];
+        PrivateSentrySDKOnly.appStartMeasurementHybridSDKMode = enableAutoPerformanceTracing;
+#if TARGET_OS_IPHONE || TARGET_OS_MACCATALYST
+        PrivateSentrySDKOnly.framesTrackingMeasurementHybridSDKMode = enableAutoPerformanceTracing;
+#endif
+    }
+
+    // Failed requests can only be enabled in one SDK to avoid duplicates
+    sentryOptions.enableCaptureFailedRequests = NO;
+
+    NSDictionary *experiments = options[@"_experiments"];
+    if (experiments != nil && [experiments isKindOfClass:[NSDictionary class]]) {
+        BOOL enableUnhandledCPPExceptions =
+            [experiments[@"enableUnhandledCPPExceptionsV2"] boolValue];
+        [RNSentryExperimentalOptions setEnableUnhandledCPPExceptionsV2:enableUnhandledCPPExceptions
+                                                         sentryOptions:sentryOptions];
+    }
+
+    if (isSessionReplayEnabled) {
+        [RNSentryExperimentalOptions setEnableSessionReplayInUnreliableEnvironment:YES
+                                                                     sentryOptions:sentryOptions];
+    }
+    return sentryOptions;
+}
+
++ (NSString *_Nullable)getURLFromDSN:(NSString *)dsn
+{
+    NSURL *url = [NSURL URLWithString:dsn];
+    if (!url) {
+        return nil;
+    }
+    return [NSString stringWithFormat:@"%@://%@", url.scheme, url.host];
+}
+
++ (void)setupWithDictionary:(NSDictionary *_Nonnull)options
+     isSessionReplayEnabled:(BOOL)isSessionReplayEnabled
+                      error:(NSError *_Nonnull *_Nonnull)errorPointer
+{
+    SentryOptions *sentryOptions = [self createOptionsWithDictionary:options
+                                              isSessionReplayEnabled:isSessionReplayEnabled
+                                                               error:errorPointer];
+    if (!options) {
+        return;
+    }
+
+    NSString *sdkVersion = [PrivateSentrySDKOnly getSdkVersionString];
+    [PrivateSentrySDKOnly setSdkName:NATIVE_SDK_NAME andVersionString:sdkVersion];
+    [PrivateSentrySDKOnly addSdkPackage:REACT_NATIVE_SDK_PACKAGE_NAME
+                                version:REACT_NATIVE_SDK_PACKAGE_VERSION];
+
+    [SentrySDKWrapper startWithOptions:sentryOptions];
+}
+
++ (BOOL)debug
+{
+    return PrivateSentrySDKOnly.options.debug;
+}
+
++ (NSString *)releaseName
+{
+    return PrivateSentrySDKOnly.options.releaseName;
+}
+
++ (BOOL)enableAutoSessionTracking
+{
+    return PrivateSentrySDKOnly.options.enableAutoSessionTracking;
+}
+
++ (BOOL)enableWatchdogTerminationTracking
+{
+    return PrivateSentrySDKOnly.options.enableWatchdogTerminationTracking;
+}
+
 @end

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": "7.5.0",
+  "version": "7.7.0",
   "description": "Official Sentry SDK for react-native",
   "typings": "dist/js/index.d.ts",
   "types": "dist/js/index.d.ts",
@@ -68,22 +68,22 @@
     "react-native": ">=0.65.0"
   },
   "dependencies": {
-    "@sentry/babel-plugin-component-annotate": "4.6.0",
-    "@sentry/browser": "10.22.0",
-    "@sentry/cli": "2.57.0",
-    "@sentry/core": "10.22.0",
-    "@sentry/react": "10.22.0",
-    "@sentry/types": "10.22.0"
+    "@sentry/babel-plugin-component-annotate": "4.6.1",
+    "@sentry/browser": "10.26.0",
+    "@sentry/cli": "2.58.2",
+    "@sentry/core": "10.26.0",
+    "@sentry/react": "10.26.0",
+    "@sentry/types": "10.26.0"
   },
   "devDependencies": {
     "@babel/core": "^7.26.7",
     "@expo/metro-config": "~0.20.0",
     "@mswjs/interceptors": "^0.25.15",
     "@react-native/babel-preset": "0.80.0",
-    "@sentry-internal/eslint-config-sdk": "10.22.0",
-    "@sentry-internal/eslint-plugin-sdk": "10.22.0",
-    "@sentry-internal/typescript": "10.22.0",
-    "@sentry/wizard": "6.6.0",
+    "@sentry-internal/eslint-config-sdk": "10.26.0",
+    "@sentry-internal/eslint-plugin-sdk": "10.26.0",
+    "@sentry-internal/typescript": "10.26.0",
+    "@sentry/wizard": "6.7.0",
     "@testing-library/react-native": "^13.2.2",
     "@types/jest": "^29.5.13",
     "@types/node": "^20.9.3",

package/plugin/build/withSentryAndroidGradlePlugin.d.ts

@@ -9,7 +9,7 @@ export interface SentryAndroidGradlePluginOptions {
     includeNativeSources?: boolean;
     includeSourceContext?: boolean;
 }
-export declare const sentryAndroidGradlePluginVersion = "5.12.1";
+export declare const sentryAndroidGradlePluginVersion = "5.12.2";
 /**
  * Adds the Sentry Android Gradle Plugin to the project.
  * https://docs.sentry.io/platforms/react-native/manual-setup/manual-setup/#enable-sentry-agp

package/plugin/build/withSentryAndroidGradlePlugin.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.withSentryAndroidGradlePlugin = exports.sentryAndroidGradlePluginVersion = void 0;
 const config_plugins_1 = require("@expo/config-plugins");
 const utils_1 = require("./utils");
-exports.sentryAndroidGradlePluginVersion = '5.12.1';
+exports.sentryAndroidGradlePluginVersion = '5.12.2';
 /**
  * Adds the Sentry Android Gradle Plugin to the project.
  * https://docs.sentry.io/platforms/react-native/manual-setup/manual-setup/#enable-sentry-agp

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

@@ -273,6 +273,15 @@ export interface BaseReactNativeOptions {
      * @default false
      */
     propagateTraceparent?: boolean;
+    /**
+     * Controls which log origin is captured when `enableLogs` is set to true.
+     * 'all' will log all origins.
+     * 'js' will capture only JavaScript logs.
+     * 'native' will capture only native logs.
+     *
+     * @default 'all'
+     */
+    logsOrigin?: 'all' | 'js' | 'native';
 }
 export type SentryReplayQuality = 'low' | 'medium' | 'high';
 export interface ReactNativeTransportOptions extends BrowserTransportOptions {

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

@@ -1,4 +1,4 @@
-import type { Integration } from '@sentry/core';
+import type { Event, EventHint, Integration } from '@sentry/core';
 export declare const MOBILE_REPLAY_INTEGRATION_NAME = "MobileReplay";
 /**
  * Screenshot strategy type for Android Session Replay.
@@ -78,9 +78,19 @@ export interface MobileReplayOptions {
      * @platform android
      */
     screenshotStrategy?: ScreenshotStrategy;
+    /**
+     * Callback to determine if a replay should be captured for a specific error.
+     * When this callback returns `false`, no replay will be captured for the error.
+     * This callback is only called when an error occurs and `replaysOnErrorSampleRate` is set.
+     *
+     * @param event The error event
+     * @param hint Additional event information
+     * @returns `false` to skip capturing a replay for this error, `true` or `undefined` to proceed with sampling
+     */
+    beforeErrorSampling?: (event: Event, hint: EventHint) => boolean;
 }
 type MobileReplayIntegration = Integration & {
-    options: Required<MobileReplayOptions>;
+    options: MobileReplayOptions;
     getReplayId: () => string | null;
 };
 /**

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

@@ -5,6 +5,15 @@ import type { Client, Span } from '@sentry/core';
 export declare function onThisSpanEnd(client: Client, span: Span, callback: (span: Span) => void): void;
 export declare const adjustTransactionDuration: (client: Client, span: Span, maxDurationMs: number) => void;
 export declare const ignoreEmptyBackNavigation: (client: Client | undefined, span: Span | undefined) => void;
+/**
+ * Discards empty "Route Change" transactions that never received route information.
+ * This happens when navigation library emits a route change event but getCurrentRoute() returns undefined.
+ * Such transactions don't contain any useful information and should not be sent to Sentry.
+ *
+ * This function must be called with a reference tracker function that can check if the span
+ * was cleared from the integration's tracking (indicating it went through the state listener).
+ */
+export declare const ignoreEmptyRouteChangeTransactions: (client: Client | undefined, span: Span | undefined, defaultNavigationSpanName: string, isSpanStillTracked: () => boolean) => void;
 /**
  * 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.

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

@@ -16,7 +16,24 @@ export declare const defaultIdleOptions: {
      */
     idleTimeout: number;
 };
-export declare const startIdleNavigationSpan: (startSpanOption: StartSpanOptions, { finalTimeout, idleTimeout, }?: Partial<typeof defaultIdleOptions>) => Span | undefined;
+export declare const startIdleNavigationSpan: (startSpanOption: StartSpanOptions, { finalTimeout, idleTimeout, isAppRestart, }?: Partial<{
+    /**
+     * The time that has to pass without any span being created.
+     * If this time is exceeded, the idle span will finish.
+     *
+     * @default 1_000 (ms)
+     */
+    finalTimeout: number;
+    /**
+     * The max. time an idle span may run.
+     * If this time is exceeded, the idle span will finish no matter what.
+     *
+     * @default 60_0000 (ms)
+     */
+    idleTimeout: number;
+}> & {
+    isAppRestart?: boolean | undefined;
+}) => Span | undefined;
 /**
  * Starts an idle span from `@sentry/core` with React Native application
  * context awareness.

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 = "7.5.0";
+export declare const SDK_VERSION = "7.7.0";
 //# sourceMappingURL=version.d.ts.map