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

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.m

@@ -3,4 +3,4 @@
 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.6.0";
+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.6.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.53.0",
+    "@sentry/browser": "8.54.0",
     "@sentry/cli": "2.41.1",
-    "@sentry/core": "8.53.0",
-    "@sentry/react": "8.53.0",
-    "@sentry/types": "8.53.0",
-    "@sentry/utils": "8.53.0"
+    "@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.53.0",
-    "@sentry-internal/eslint-plugin-sdk": "8.53.0",
-    "@sentry-internal/typescript": "8.53.0",
-    "@sentry/wizard": "3.39.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

package/sentry.gradle

@@ -3,7 +3,7 @@ import org.apache.tools.ant.taskdefs.condition.Os
 import java.util.regex.Matcher
 import java.util.regex.Pattern
 
-project.ext.shouldSentryAutoUploadNative = { -> 
+project.ext.shouldSentryAutoUploadNative = { ->
   return System.getenv('SENTRY_DISABLE_NATIVE_DEBUG_UPLOAD') != 'true'
 }
 
@@ -15,9 +15,60 @@ project.ext.shouldSentryAutoUpload = { ->
   return shouldSentryAutoUploadGeneral() && shouldSentryAutoUploadNative()
 }
 
+project.ext.shouldCopySentryOptionsFile = { -> // If not set, default to true
+    return System.getenv('SENTRY_COPY_OPTIONS_FILE') != 'false'
+}
+
 def config = project.hasProperty("sentryCli") ? project.sentryCli : [];
 
+def configFile = "sentry.options.json" // Sentry condiguration file
+def androidAssetsDir = new File("$rootDir/app/src/main/assets") // Path to Android assets folder
+
+tasks.register("copySentryJsonConfiguration") {
+    onlyIf { shouldCopySentryOptionsFile() }
+    doLast {
+        def appRoot = project.rootDir.parentFile ?: project.rootDir
+        def sentryOptionsFile = new File(appRoot, configFile)
+        if (sentryOptionsFile.exists()) {
+            if (!androidAssetsDir.exists()) {
+                androidAssetsDir.mkdirs()
+            }
+
+            copy {
+                from sentryOptionsFile
+                into androidAssetsDir
+                rename { String fileName -> configFile }
+            }
+            logger.lifecycle("Copied ${configFile} to Android assets")
+        } else {
+            logger.warn("${configFile} not found in app root (${appRoot})")
+        }
+    }
+}
+
+tasks.register("cleanupTemporarySentryJsonConfiguration") {
+    onlyIf { shouldCopySentryOptionsFile() }
+    doLast {
+        def sentryOptionsFile = new File(androidAssetsDir, configFile)
+        if (sentryOptionsFile.exists()) {
+            logger.lifecycle("Deleting temporary file: ${sentryOptionsFile.path}")
+            sentryOptionsFile.delete()
+        }
+    }
+}
+
 gradle.projectsEvaluated {
+    // Add a task that copies the sentry.options.json file before the build starts
+    tasks.named("preBuild").configure {
+        dependsOn("copySentryJsonConfiguration")
+    }
+    // Cleanup sentry.options.json from assets after the build
+    tasks.matching { task ->
+        task.name == "build" || task.name.startsWith("assemble") || task.name.startsWith("install")
+    }.configureEach {
+        finalizedBy("cleanupTemporarySentryJsonConfiguration")
+    }
+
     def releases = extractReleasesInfo()
 
     if (config.flavorAware && config.sentryProperties) {

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

@@ -1,6 +1,7 @@
 /// <reference types="react-native" />
 import type { InternalGlobal } from '@sentry/core';
 import type { ErrorUtils } from 'react-native/types';
+import type { ReactNativeOptions } from '../options';
 import type { ExpoGlobalObject } from './expoglobalobject';
 /** Internal Global object interface with common and Sentry specific properties */
 export interface ReactNativeInternalGlobal extends InternalGlobal {
@@ -23,6 +24,7 @@ export interface ReactNativeInternalGlobal extends InternalGlobal {
     __BUNDLE_START_TIME__?: number;
     nativePerformanceNow?: () => number;
     TextEncoder?: TextEncoder;
+    __SENTRY_OPTIONS__?: ReactNativeOptions;
 }
 type TextEncoder = {
     new (): TextEncoder;

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