@sentry/react-native 6.5.0 → 6.7.0-alpha.0

package/ios/RNSentry.mm

@@ -49,6 +49,9 @@
 #    import "RNSentryRNSScreen.h"
 #endif
 
+#import "RNSentryStart.h"
+#import "RNSentryVersion.h"
+
 @interface
 SentrySDK (RNSentry)
 
@@ -60,10 +63,7 @@ SentrySDK (RNSentry)
 
 static bool hasFetchedAppStart;
 
-static NSString *const nativeSdkName = @"sentry.cocoa.react-native";
-
 @implementation RNSentry {
-    bool sentHybridSdkDidBecomeActive;
     bool hasListeners;
     RNSentryTimeToDisplay *_timeToDisplay;
 }
@@ -78,6 +78,14 @@ static NSString *const nativeSdkName = @"sentry.cocoa.react-native";
     return YES;
 }
 
+- (instancetype)init
+{
+    if (self = [super init]) {
+        _timeToDisplay = [[RNSentryTimeToDisplay alloc] init];
+    }
+    return self;
+}
+
 RCT_EXPORT_MODULE()
 
 RCT_EXPORT_METHOD(initNativeSdk
@@ -86,181 +94,14 @@ RCT_EXPORT_METHOD(initNativeSdk
                   : (RCTPromiseRejectBlock)reject)
 {
     NSError *error = nil;
-    SentryOptions *sentryOptions = [self createOptionsWithDictionary:options error:&error];
+    [RNSentryStart startWithOptions:options error:&error];
     if (error != nil) {
         reject(@"SentryReactNative", error.localizedDescription, error);
         return;
     }
-
-    NSString *sdkVersion = [PrivateSentrySDKOnly getSdkVersionString];
-    [PrivateSentrySDKOnly setSdkName:nativeSdkName andVersionString:sdkVersion];
-
-    [SentrySDK startWithOptions:sentryOptions];
-
-#if TARGET_OS_IPHONE || TARGET_OS_MACCATALYST
-    BOOL appIsActive =
-        [[UIApplication sharedApplication] applicationState] == UIApplicationStateActive;
-#else
-    BOOL appIsActive = [[NSApplication sharedApplication] isActive];
-#endif
-
-    // If the app is active/in foreground, and we have not sent the SentryHybridSdkDidBecomeActive
-    // notification, send it.
-    if (appIsActive && !sentHybridSdkDidBecomeActive
-        && (PrivateSentrySDKOnly.options.enableAutoSessionTracking
-            || PrivateSentrySDKOnly.options.enableWatchdogTerminationTracking)) {
-        [[NSNotificationCenter defaultCenter] postNotificationName:@"SentryHybridSdkDidBecomeActive"
-                                                            object:nil];
-
-        sentHybridSdkDidBecomeActive = true;
-    }
-
-#if SENTRY_TARGET_REPLAY_SUPPORTED
-    [RNSentryReplay postInit];
-#endif
-
     resolve(@YES);
 }
 
-- (SentryOptions *_Nullable)createOptionsWithDictionary:(NSDictionary *_Nonnull)options
-                                                  error:(NSError *_Nonnull *_Nonnull)errorPointer
-{
-    SentryBeforeSendEventCallback beforeSend = ^SentryEvent *(SentryEvent *event)
-    {
-        // We don't want to send an event after startup that came from a Unhandled JS Exception of
-        // react native Because we sent it already before the app crashed.
-        if (nil != event.exceptions.firstObject.type &&
-            [event.exceptions.firstObject.type rangeOfString:@"Unhandled JS Exception"].location
-                != NSNotFound) {
-            return nil;
-        }
-
-        [self setEventOriginTag:event];
-
-        return event;
-    };
-
-    NSMutableDictionary *mutableOptions = [options mutableCopy];
-    [mutableOptions setValue:beforeSend forKey:@"beforeSend"];
-
-    // remove performance traces sample rate and traces sampler since we don't want to synchronize
-    // these configurations to the Native SDKs. The user could tho initialize the SDK manually and
-    // set themselves.
-    [mutableOptions removeObjectForKey:@"tracesSampleRate"];
-    [mutableOptions removeObjectForKey:@"tracesSampler"];
-    [mutableOptions removeObjectForKey:@"enableTracing"];
-
-    _timeToDisplay = [[RNSentryTimeToDisplay alloc] init];
-
-#if SENTRY_TARGET_REPLAY_SUPPORTED
-    [RNSentryReplay updateOptions:mutableOptions];
-#endif
-
-    SentryOptions *sentryOptions = [[SentryOptions alloc] initWithDict:mutableOptions
-                                                      didFailWithError:errorPointer];
-    if (*errorPointer != nil) {
-        return nil;
-    }
-
-    // Exclude Dev Server and Sentry Dsn request from Breadcrumbs
-    NSString *dsn = [self getURLFromDSN:[mutableOptions valueForKey:@"dsn"]];
-    NSString *devServerUrl = [mutableOptions 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 ([mutableOptions valueForKey:@"enableNativeCrashHandling"] != nil) {
-        BOOL enableNativeCrashHandling = [mutableOptions[@"enableNativeCrashHandling"] boolValue];
-
-        if (!enableNativeCrashHandling) {
-            NSMutableArray *integrations = sentryOptions.integrations.mutableCopy;
-            [integrations removeObject:@"SentryCrashIntegration"];
-            sentryOptions.integrations = integrations;
-        }
-    }
-
-    // Set spotlight option
-    if ([mutableOptions valueForKey:@"spotlight"] != nil) {
-        id spotlightValue = [mutableOptions 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 = [mutableOptions valueForKey:@"defaultSidecarUrl"];
-            if (defaultSpotlightUrl != nil) {
-                sentryOptions.spotlightUrl = defaultSpotlightUrl;
-            }
-        }
-    }
-
-    // Enable the App start and Frames tracking measurements
-    if ([mutableOptions valueForKey:@"enableAutoPerformanceTracing"] != nil) {
-        BOOL enableAutoPerformanceTracing =
-            [mutableOptions[@"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;
-
-    return sentryOptions;
-}
-
-- (NSString *_Nullable)getURLFromDSN:(NSString *)dsn
-{
-    NSURL *url = [NSURL URLWithString:dsn];
-    if (!url) {
-        return nil;
-    }
-    return [NSString stringWithFormat:@"%@://%@", url.scheme, url.host];
-}
-
-- (void)setEventOriginTag:(SentryEvent *)event
-{
-    if (event.sdk != nil) {
-        NSString *sdkName = event.sdk[@"name"];
-
-        // If the event is from react native, it gets set
-        // there and we do not handle it here.
-        if ([sdkName isEqual:nativeSdkName]) {
-            [self setEventEnvironmentTag:event origin:@"ios" environment:@"native"];
-        }
-    }
-}
-
-- (void)setEventEnvironmentTag:(SentryEvent *)event
-                        origin:(NSString *)origin
-                   environment:(NSString *)environment
-{
-    NSMutableDictionary *newTags = [NSMutableDictionary new];
-
-    if (nil != event.tags && [event.tags count] > 0) {
-        [newTags addEntriesFromDictionary:event.tags];
-    }
-    if (nil != origin) {
-        [newTags setValue:origin forKey:@"event.origin"];
-    }
-    if (nil != environment) {
-        [newTags setValue:environment forKey:@"event.environment"];
-    }
-
-    event.tags = newTags;
-}
-
 RCT_EXPORT_METHOD(initNativeReactNavigationNewFrameTracking
                   : (RCTPromiseResolveBlock)resolve rejecter
                   : (RCTPromiseRejectBlock)reject)

package/ios/RNSentryReplay.mm

@@ -1,5 +1,6 @@
 #import "RNSentryReplay.h"
 #import "RNSentryReplayBreadcrumbConverterHelper.h"
+#import "RNSentryVersion.h"
 #import "React/RCTTextView.h"
 #import "Replay/RNSentryReplayMask.h"
 #import "Replay/RNSentryReplayUnmask.h"
@@ -27,6 +28,8 @@
         @"maskAllImages" : replayOptions[@"maskAllImages"] ?: [NSNull null],
         @"maskAllText" : replayOptions[@"maskAllText"] ?: [NSNull null],
         @"maskedViewClasses" : [RNSentryReplay getReplayRNRedactClasses:replayOptions],
+        @"sdkInfo" :
+            @ { @"name" : REACT_NATIVE_SDK_NAME, @"version" : REACT_NATIVE_SDK_PACKAGE_VERSION }
     }
                forKey:@"sessionReplay"];
 }

package/ios/RNSentrySDK.h

@@ -0,0 +1,31 @@
+#import <Sentry/Sentry.h>
+
+@interface RNSentrySDK : NSObject
+SENTRY_NO_INIT
+
+/**
+ * @experimental
+ * Inits and configures Sentry for React Native applications using `sentry.options.json`
+ * configuration file.
+ *
+ * @discussion Call this method on the main thread. When calling it from a background thread, the
+ * SDK starts on the main thread async.
+ */
++ (void)start;
+
+/**
+ * @experimental
+ * Inits and configures Sentry for React Native applicationsusing `sentry.options.json`
+ * configuration file and `configureOptions` callback.
+ *
+ * The `configureOptions` callback can overwrite the config file options
+ * and add non-serializable items to the options object.
+ *
+ * @discussion Call this method on the main thread. When calling it from a background thread, the
+ * SDK starts on the main thread async.
+ */
++ (void)startWithConfigureOptions:
+    (void (^_Nullable)(SentryOptions *_Nonnull options))configureOptions
+    NS_SWIFT_NAME(start(configureOptions:));
+
+@end

package/ios/RNSentrySDK.m

@@ -0,0 +1,71 @@
+#import "RNSentrySDK.h"
+#import "RNSentryStart.h"
+
+static NSString *SENTRY_OPTIONS_RESOURCE_NAME = @"sentry.options";
+static NSString *SENTRY_OPTIONS_RESOURCE_TYPE = @"json";
+
+@implementation RNSentrySDK
+
++ (void)start
+{
+    [self startWithConfigureOptions:nil];
+}
+
++ (void)startWithConfigureOptions:(void (^)(SentryOptions *options))configureOptions
+{
+    NSString *path = [[NSBundle mainBundle] pathForResource:SENTRY_OPTIONS_RESOURCE_NAME
+                                                     ofType:SENTRY_OPTIONS_RESOURCE_TYPE];
+
+    [self start:path configureOptions:configureOptions];
+}
+
++ (void)start:(NSString *)path configureOptions:(void (^)(SentryOptions *options))configureOptions
+{
+    NSError *readError = nil;
+    NSError *parseError = nil;
+    NSError *optionsError = nil;
+
+    NSData *_Nullable content = nil;
+    if (path != nil) {
+        content = [NSData dataWithContentsOfFile:path options:0 error:&readError];
+    }
+
+    NSDictionary *dict = nil;
+    if (content != nil) {
+        dict = [NSJSONSerialization JSONObjectWithData:content options:0 error:&parseError];
+    }
+
+    if (readError != nil) {
+        NSLog(@"[RNSentry] Failed to load options from %@, with error: %@", path,
+            readError.localizedDescription);
+    }
+
+    if (parseError != nil) {
+        NSLog(@"[RNSentry] Failed to parse JSON from %@, with error: %@", path,
+            parseError.localizedDescription);
+    }
+
+    SentryOptions *options = nil;
+    if (dict != nil) {
+        options = [RNSentryStart createOptionsWithDictionary:dict error:&optionsError];
+    }
+
+    if (optionsError != nil) {
+        NSLog(@"[RNSentry] Failed to parse options from %@, with error: %@", path,
+            optionsError.localizedDescription);
+    }
+
+    if (options == nil) {
+        // Fallback in case that options file could not be parsed.
+        options = [[SentryOptions alloc] init];
+    }
+
+    [RNSentryStart updateWithReactDefaults:options];
+    if (configureOptions != nil) {
+        configureOptions(options);
+    }
+    [RNSentryStart updateWithReactFinals:options];
+    [RNSentryStart startWithOptions:options];
+}
+
+@end

package/ios/RNSentryStart.h

@@ -0,0 +1,26 @@
+#import <Sentry/SentryDefines.h>
+#import <Sentry/SentryOptions.h>
+
+@interface RNSentryStart : NSObject
+SENTRY_NO_INIT
+
++ (void)startWithOptions:(NSDictionary *_Nonnull)javascriptOptions
+                   error:(NSError *_Nullable *_Nullable)errorPointer;
+
++ (SentryOptions *_Nullable)createOptionsWithDictionary:(NSDictionary *_Nonnull)options
+                                                  error:(NSError *_Nonnull *_Nonnull)errorPointer;
+
++ (void)updateWithReactDefaults:(SentryOptions *)options;
++ (void)updateWithReactFinals:(SentryOptions *)options;
+
+/**
+ * @experimental
+ * Inits and configures Sentry for React Native applications. Make sure to
+ * set a valid DSN.
+ *
+ * @discussion Call this method on the main thread. When calling it from a background thread, the
+ * SDK starts on the main thread async.
+ */
++ (void)startWithOptions:(SentryOptions *)options NS_SWIFT_NAME(start(options:));
+
+@end

package/ios/RNSentryStart.m

@@ -0,0 +1,222 @@
+#import "RNSentryStart.h"
+#import "RNSentryReplay.h"
+#import "RNSentryVersion.h"
+
+#import <Sentry/PrivateSentrySDKOnly.h>
+#import <Sentry/Sentry.h>
+#import <Sentry/SentryOptions+HybridSDKs.h>
+
+@implementation RNSentryStart
+
++ (void)startWithOptions:(NSDictionary *_Nonnull)javascriptOptions
+                   error:(NSError *_Nullable *_Nullable)errorPointer
+{
+    SentryOptions *options = [self createOptionsWithDictionary:javascriptOptions
+                                                         error:errorPointer];
+    [self updateWithReactDefaults:options];
+    [self updateWithReactFinals:options];
+    [self startWithOptions:options];
+}
+
++ (void)startWithOptions:(SentryOptions *)options NS_SWIFT_NAME(start(options:))
+{
+    NSString *sdkVersion = [PrivateSentrySDKOnly getSdkVersionString];
+    [PrivateSentrySDKOnly setSdkName:NATIVE_SDK_NAME andVersionString:sdkVersion];
+    [PrivateSentrySDKOnly addSdkPackage:REACT_NATIVE_SDK_PACKAGE_NAME
+                                version:REACT_NATIVE_SDK_PACKAGE_VERSION];
+
+    [SentrySDK startWithOptions:options];
+
+#if SENTRY_TARGET_REPLAY_SUPPORTED
+    [RNSentryReplay postInit];
+#endif
+
+    [self postDidBecomeActiveNotification];
+}
+
++ (SentryOptions *_Nullable)createOptionsWithDictionary:(NSDictionary *_Nonnull)options
+                                                  error:(NSError *_Nonnull *_Nonnull)errorPointer
+{
+    NSMutableDictionary *mutableOptions = [options mutableCopy];
+
+#if SENTRY_TARGET_REPLAY_SUPPORTED
+    [RNSentryReplay updateOptions:mutableOptions];
+#endif
+
+    SentryOptions *sentryOptions = [[SentryOptions alloc] initWithDict:mutableOptions
+                                                      didFailWithError:errorPointer];
+    if (*errorPointer != nil) {
+        return nil;
+    }
+
+    // Exclude Dev Server and Sentry Dsn request from Breadcrumbs
+    NSString *dsn = [self getURLFromDSN:[mutableOptions valueForKey:@"dsn"]];
+    // TODO: For Auto Init from JS dev server is resolved automatically, for init from options file
+    // dev server has to be specified manually
+    NSString *devServerUrl = [mutableOptions 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;
+    };
+
+    // JS options.enableNativeCrashHandling equals to native options.enableCrashHandler
+    if ([mutableOptions valueForKey:@"enableNativeCrashHandling"] != nil) {
+        BOOL enableNativeCrashHandling = [mutableOptions[@"enableNativeCrashHandling"] boolValue];
+
+        if (!enableNativeCrashHandling) {
+            NSMutableArray *integrations = sentryOptions.integrations.mutableCopy;
+            [integrations removeObject:@"SentryCrashIntegration"];
+            sentryOptions.integrations = integrations;
+        }
+    }
+
+    // Set spotlight option
+    if ([mutableOptions valueForKey:@"spotlight"] != nil) {
+        id spotlightValue = [mutableOptions 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];
+            // TODO: For Auto init from JS set automatically for init from options file have to be
+            // set manually
+            id defaultSpotlightUrl = [mutableOptions valueForKey:@"defaultSidecarUrl"];
+            if (defaultSpotlightUrl != nil) {
+                sentryOptions.spotlightUrl = defaultSpotlightUrl;
+            }
+        }
+    }
+
+    return sentryOptions;
+}
+
+/**
+ * This function updates the options with RNSentry defaults. These default can be
+ * overwritten by users during manual native initialization.
+ */
++ (void)updateWithReactDefaults:(SentryOptions *)options
+{
+    // Failed requests are captured only in JS to avoid duplicates
+    options.enableCaptureFailedRequests = NO;
+
+    // Tracing is only enabled in JS to avoid duplicate navigation spans
+    options.tracesSampleRate = nil;
+    options.tracesSampler = nil;
+    options.enableTracing = NO;
+}
+
+/**
+ * This function updates options with changes RNSentry users should not change
+ * and so this is applied after the configureOptions callback during manual native initialization.
+ */
++ (void)updateWithReactFinals:(SentryOptions *)options
+{
+    SentryBeforeSendEventCallback userBeforeSend = options.beforeSend;
+    options.beforeSend = ^SentryEvent *(SentryEvent *event)
+    {
+        // Unhandled JS Exception are processed by the SDK on JS layer
+        // To avoid duplicates we drop them in the native SDKs
+        if (nil != event.exceptions.firstObject.type &&
+            [event.exceptions.firstObject.type rangeOfString:@"Unhandled JS Exception"].location
+                != NSNotFound) {
+            return nil;
+        }
+
+        [self setEventOriginTag:event];
+        if (userBeforeSend == nil) {
+            return event;
+        } else {
+            return userBeforeSend(event);
+        }
+    };
+
+    // App Start Hybrid mode doesn't wait for didFinishLaunchNotification and the
+    // didBecomeVisibleNotification as they will be missed when auto initializing from JS
+    // App Start measurements are created right after the tracking starts
+    PrivateSentrySDKOnly.appStartMeasurementHybridSDKMode = options.enableAutoPerformanceTracing;
+#if TARGET_OS_IPHONE || TARGET_OS_MACCATALYST
+    // Frames Tracking Hybrid Mode ensures tracking
+    // is enabled without tracing enabled in the native SDK
+    PrivateSentrySDKOnly.framesTrackingMeasurementHybridSDKMode
+        = options.enableAutoPerformanceTracing;
+#endif
+}
+
++ (void)setEventOriginTag:(SentryEvent *)event
+{
+    if (event.sdk != nil) {
+        NSString *sdkName = event.sdk[@"name"];
+
+        // If the event is from react native, it gets set
+        // there and we do not handle it here.
+        if ([sdkName isEqual:NATIVE_SDK_NAME]) {
+            [self setEventEnvironmentTag:event origin:@"ios" environment:@"native"];
+        }
+    }
+}
+
++ (void)setEventEnvironmentTag:(SentryEvent *)event
+                        origin:(NSString *)origin
+                   environment:(NSString *)environment
+{
+    NSMutableDictionary *newTags = [NSMutableDictionary new];
+
+    if (nil != event.tags && [event.tags count] > 0) {
+        [newTags addEntriesFromDictionary:event.tags];
+    }
+    if (nil != origin) {
+        [newTags setValue:origin forKey:@"event.origin"];
+    }
+    if (nil != environment) {
+        [newTags setValue:environment forKey:@"event.environment"];
+    }
+
+    event.tags = newTags;
+}
+
++ (NSString *_Nullable)getURLFromDSN:(NSString *)dsn
+{
+    NSURL *url = [NSURL URLWithString:dsn];
+    if (!url) {
+        return nil;
+    }
+    return [NSString stringWithFormat:@"%@://%@", url.scheme, url.host];
+}
+
+static bool sentHybridSdkDidBecomeActive = NO;
+
++ (void)postDidBecomeActiveNotification
+{
+#if TARGET_OS_IPHONE || TARGET_OS_MACCATALYST
+    BOOL appIsActive =
+        [[UIApplication sharedApplication] applicationState] == UIApplicationStateActive;
+#else
+    BOOL appIsActive = [[NSApplication sharedApplication] isActive];
+#endif
+
+    // If the app is active/in foreground, and we have not sent the SentryHybridSdkDidBecomeActive
+    // notification, send it.
+    if (appIsActive && !sentHybridSdkDidBecomeActive
+        && (PrivateSentrySDKOnly.options.enableAutoSessionTracking
+            || PrivateSentrySDKOnly.options.enableWatchdogTerminationTracking)) {
+        // Updates Native App State Manager
+        // https://github.com/getsentry/sentry-cocoa/blob/888a145b144b8077e03151a886520f332e47e297/Sources/Sentry/SentryAppStateManager.m#L136
+        // Triggers Session Tracker
+        // https://github.com/getsentry/sentry-cocoa/blob/888a145b144b8077e03151a886520f332e47e297/Sources/Sentry/SentrySessionTracker.m#L144
+        [[NSNotificationCenter defaultCenter] postNotificationName:@"SentryHybridSdkDidBecomeActive"
+                                                            object:nil];
+
+        sentHybridSdkDidBecomeActive = true;
+    }
+}
+
+@end

package/ios/RNSentryVersion.h

@@ -0,0 +1,6 @@
+#import <Foundation/Foundation.h>
+
+extern NSString *const NATIVE_SDK_NAME;
+extern NSString *const REACT_NATIVE_SDK_NAME;
+extern NSString *const REACT_NATIVE_SDK_PACKAGE_NAME;
+extern NSString *const REACT_NATIVE_SDK_PACKAGE_VERSION;

package/ios/RNSentryVersion.m

@@ -0,0 +1,6 @@
+#import "RNSentryVersion.h"
+
+NSString *const NATIVE_SDK_NAME = @"sentry.cocoa.react-native";
+NSString *const REACT_NATIVE_SDK_NAME = @"sentry.javascript.react-native";
+NSString *const REACT_NATIVE_SDK_PACKAGE_NAME = @"npm:@sentry/react-native";
+NSString *const REACT_NATIVE_SDK_PACKAGE_VERSION = @"6.7.0-alpha.0";

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": "6.5.0",
+  "version": "6.7.0-alpha.0",
   "description": "Official Sentry SDK for react-native",
   "typings": "dist/js/index.d.ts",
   "types": "dist/js/index.d.ts",
@@ -66,22 +66,22 @@
   },
   "dependencies": {
     "@sentry/babel-plugin-component-annotate": "2.20.1",
-    "@sentry/browser": "8.47.0",
-    "@sentry/cli": "2.39.1",
-    "@sentry/core": "8.47.0",
-    "@sentry/react": "8.47.0",
-    "@sentry/types": "8.47.0",
-    "@sentry/utils": "8.47.0"
+    "@sentry/browser": "8.54.0",
+    "@sentry/cli": "2.41.1",
+    "@sentry/core": "8.54.0",
+    "@sentry/react": "8.54.0",
+    "@sentry/types": "8.54.0",
+    "@sentry/utils": "8.54.0"
   },
   "devDependencies": {
     "@babel/core": "^7.25.2",
     "@expo/metro-config": "0.19.5",
     "@mswjs/interceptors": "^0.25.15",
     "@react-native/babel-preset": "0.76.3",
-    "@sentry-internal/eslint-config-sdk": "8.47.0",
-    "@sentry-internal/eslint-plugin-sdk": "8.47.0",
-    "@sentry-internal/typescript": "8.47.0",
-    "@sentry/wizard": "3.37.0",
+    "@sentry-internal/eslint-config-sdk": "8.54.0",
+    "@sentry-internal/eslint-plugin-sdk": "8.54.0",
+    "@sentry-internal/typescript": "8.54.0",
+    "@sentry/wizard": "3.40.0",
     "@testing-library/react-native": "^12.7.2",
     "@types/jest": "^29.5.3",
     "@types/node": "^20.9.3",

package/scripts/sentry-xcode.sh

@@ -51,3 +51,22 @@ fi
 if [ -f "$SENTRY_COLLECT_MODULES" ]; then
   /bin/sh "$SENTRY_COLLECT_MODULES"
 fi
+
+SENTRY_OPTIONS_FILE_ERROR_MESSAGE_POSTFIX="Skipping options file copy. To disable this behavior, set SENTRY_COPY_OPTIONS_FILE=false in your environment variables."
+SENTRY_OPTIONS_FILE_NAME="sentry.options.json"
+SENTRY_OPTIONS_FILE_DESTINATION_PATH="$CONFIGURATION_BUILD_DIR/$UNLOCALIZED_RESOURCES_FOLDER_PATH/$SENTRY_OPTIONS_FILE_NAME"
+[ -z "$SENTRY_OPTIONS_FILE_PATH" ] && SENTRY_OPTIONS_FILE_PATH="$RN_PROJECT_ROOT/$SENTRY_OPTIONS_FILE_NAME"
+[ -z "$SENTRY_COPY_OPTIONS_FILE" ] && SENTRY_COPY_OPTIONS_FILE=true
+
+if [ "$SENTRY_COPY_OPTIONS_FILE" = true ]; then
+  if [[ -z "$CONFIGURATION_BUILD_DIR" ]]; then
+    echo "[Sentry] CONFIGURATION_BUILD_DIR is not set. $SENTRY_OPTIONS_FILE_ERROR_MESSAGE_POSTFIX" 1>&2
+  elif [[ -z "$UNLOCALIZED_RESOURCES_FOLDER_PATH" ]]; then
+    echo "[Sentry] UNLOCALIZED_RESOURCES_FOLDER_PATH is not set. $SENTRY_OPTIONS_FILE_ERROR_MESSAGE_POSTFIX" 1>&2
+  elif [ ! -f "$SENTRY_OPTIONS_FILE_PATH" ]; then
+    echo "[Sentry] $SENTRY_OPTIONS_FILE_PATH not found. $SENTRY_OPTIONS_FILE_ERROR_MESSAGE_POSTFIX" 1>&2
+  else
+    cp "$SENTRY_OPTIONS_FILE_PATH" "$SENTRY_OPTIONS_FILE_DESTINATION_PATH"
+    echo "[Sentry] Copied $SENTRY_OPTIONS_FILE_PATH to $SENTRY_OPTIONS_FILE_DESTINATION_PATH"
+  fi
+fi