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

package/ios/RNSentry.mm

@@ -49,7 +49,6 @@
 #    import "RNSentryRNSScreen.h"
 #endif
 
-#import "RNSentryStart.h"
 #import "RNSentryVersion.h"
 
 @interface
@@ -64,6 +63,7 @@ SentrySDK (RNSentry)
 static bool hasFetchedAppStart;
 
 @implementation RNSentry {
+    bool sentHybridSdkDidBecomeActive;
     bool hasListeners;
     RNSentryTimeToDisplay *_timeToDisplay;
 }
@@ -94,14 +94,181 @@ RCT_EXPORT_METHOD(initNativeSdk
                   : (RCTPromiseRejectBlock)reject)
 {
     NSError *error = nil;
-    [RNSentryStart startWithOptions:options error:&error];
+    SentryOptions *sentryOptions = [self createOptionsWithDictionary:options error:&error];
     if (error != nil) {
         reject(@"SentryReactNative", error.localizedDescription, error);
         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];
+
+    [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"];
+
+#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: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;
+}
+
 RCT_EXPORT_METHOD(initNativeReactNavigationNewFrameTracking
                   : (RCTPromiseResolveBlock)resolve rejecter
                   : (RCTPromiseRejectBlock)reject)
@@ -474,26 +641,50 @@ RCT_EXPORT_METHOD(fetchViewHierarchy
 RCT_EXPORT_METHOD(setUser : (NSDictionary *)userKeys otherUserKeys : (NSDictionary *)userDataKeys)
 {
     [SentrySDK configureScope:^(SentryScope *_Nonnull scope) {
-        if (nil == userKeys && nil == userDataKeys) {
-            [scope setUser:nil];
-        } else {
-            SentryUser *userInstance = [[SentryUser alloc] init];
-
-            if (nil != userKeys) {
-                [userInstance setUserId:userKeys[@"id"]];
-                [userInstance setIpAddress:userKeys[@"ip_address"]];
-                [userInstance setEmail:userKeys[@"email"]];
-                [userInstance setUsername:userKeys[@"username"]];
-                [userInstance setSegment:userKeys[@"segment"]];
-            }
+        [scope setUser:[RNSentry userFrom:userKeys otherUserKeys:userDataKeys]];
+    }];
+}
 
-            if (nil != userDataKeys) {
-                [userInstance setData:userDataKeys];
-            }
++ (SentryUser *_Nullable)userFrom:(NSDictionary *)userKeys
+                    otherUserKeys:(NSDictionary *)userDataKeys
+{
+    // we can safely ignore userDataKeys since if original JS user was null userKeys will be null
+    if ([userKeys isKindOfClass:NSDictionary.class]) {
+        SentryUser *userInstance = [[SentryUser alloc] init];
 
-            [scope setUser:userInstance];
+        id userId = [userKeys valueForKey:@"id"];
+        if ([userId isKindOfClass:NSString.class]) {
+            [userInstance setUserId:userId];
         }
-    }];
+        id ipAddress = [userKeys valueForKey:@"ip_address"];
+        if ([ipAddress isKindOfClass:NSString.class]) {
+            [userInstance setIpAddress:ipAddress];
+        }
+        id email = [userKeys valueForKey:@"email"];
+        if ([email isKindOfClass:NSString.class]) {
+            [userInstance setEmail:email];
+        }
+        id username = [userKeys valueForKey:@"username"];
+        if ([username isKindOfClass:NSString.class]) {
+            [userInstance setUsername:username];
+        }
+        id segment = [userKeys valueForKey:@"segment"];
+        if ([segment isKindOfClass:NSString.class]) {
+            [userInstance setSegment:segment];
+        }
+
+        if ([userDataKeys isKindOfClass:NSDictionary.class]) {
+            [userInstance setData:userDataKeys];
+        }
+
+        return userInstance;
+    }
+
+    if (![[NSNull null] isEqual:userKeys] && nil != userKeys) {
+        NSLog(@"[RNSentry] Method setUser received unexpected type of userKeys.");
+    }
+
+    return nil;
 }
 
 RCT_EXPORT_METHOD(addBreadcrumb : (NSDictionary *)breadcrumb)

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.7.0-alpha.0";
+NSString *const REACT_NATIVE_SDK_PACKAGE_VERSION = @"6.8.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.7.0-alpha.0",
+  "version": "6.8.0",
   "description": "Official Sentry SDK for react-native",
   "typings": "dist/js/index.d.ts",
   "types": "dist/js/index.d.ts",
@@ -65,9 +65,9 @@
     "react-native": ">=0.65.0"
   },
   "dependencies": {
-    "@sentry/babel-plugin-component-annotate": "2.20.1",
+    "@sentry/babel-plugin-component-annotate": "3.2.0",
     "@sentry/browser": "8.54.0",
-    "@sentry/cli": "2.41.1",
+    "@sentry/cli": "2.42.1",
     "@sentry/core": "8.54.0",
     "@sentry/react": "8.54.0",
     "@sentry/types": "8.54.0",
@@ -77,13 +77,13 @@
     "@babel/core": "^7.25.2",
     "@expo/metro-config": "0.19.5",
     "@mswjs/interceptors": "^0.25.15",
-    "@react-native/babel-preset": "0.76.3",
+    "@react-native/babel-preset": "0.77.1",
     "@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",
+    "@sentry/wizard": "3.42.0",
     "@testing-library/react-native": "^12.7.2",
-    "@types/jest": "^29.5.3",
+    "@types/jest": "^29.5.13",
     "@types/node": "^20.9.3",
     "@types/react": "^18.2.64",
     "@types/uglify-js": "^3.17.2",
@@ -91,7 +91,7 @@
     "@types/xmlhttprequest": "^1.8.2",
     "@typescript-eslint/eslint-plugin": "^5.48.0",
     "@typescript-eslint/parser": "^5.48.0",
-    "babel-jest": "^29.6.2",
+    "babel-jest": "^29.6.3",
     "babel-plugin-module-resolver": "^5.0.0",
     "babel-preset-fbjs": "^3.4.0",
     "downlevel-dts": "^0.11.0",
@@ -107,7 +107,7 @@
     "metro": "0.81.0",
     "prettier": "^2.0.5",
     "react": "18.3.1",
-    "react-native": "0.76.3",
+    "react-native": "0.77.1",
     "react-test-renderer": "^18.3.1",
     "rimraf": "^4.1.1",
     "ts-jest": "^29.1.1",

package/plugin/build/withSentry.d.ts

@@ -1,9 +1,11 @@
 import type { ConfigPlugin } from 'expo/config-plugins';
+import type { SentryAndroidGradlePluginOptions } from './withSentryAndroidGradlePlugin';
 interface PluginProps {
     organization?: string;
     project?: string;
     authToken?: string;
     url?: string;
+    experimental_android?: SentryAndroidGradlePluginOptions;
 }
 export declare function getSentryProperties(props: PluginProps | void): string | null;
 declare const withSentry: ConfigPlugin<void | PluginProps>;

package/plugin/build/withSentry.js

@@ -4,6 +4,7 @@ exports.withSentry = exports.getSentryProperties = void 0;
 const config_plugins_1 = require("expo/config-plugins");
 const utils_1 = require("./utils");
 const withSentryAndroid_1 = require("./withSentryAndroid");
+const withSentryAndroidGradlePlugin_1 = require("./withSentryAndroidGradlePlugin");
 const withSentryIOS_1 = require("./withSentryIOS");
 const withSentryPlugin = (config, props) => {
     const sentryProperties = getSentryProperties(props);
@@ -19,6 +20,15 @@ const withSentryPlugin = (config, props) => {
         catch (e) {
             (0, utils_1.warnOnce)(`There was a problem with configuring your native Android project: ${e}`);
         }
+        // if `enableAndroidGradlePlugin` is provided configure the Sentry Android Gradle Plugin
+        if (props?.experimental_android && props?.experimental_android?.enableAndroidGradlePlugin) {
+            try {
+                cfg = (0, withSentryAndroidGradlePlugin_1.withSentryAndroidGradlePlugin)(cfg, props.experimental_android);
+            }
+            catch (e) {
+                (0, utils_1.warnOnce)(`There was a problem with configuring Sentry Android Gradle Plugin: ${e}`);
+            }
+        }
         try {
             cfg = (0, withSentryIOS_1.withSentryIOS)(cfg, sentryProperties);
         }

package/plugin/build/withSentryAndroidGradlePlugin.d.ts

@@ -0,0 +1,15 @@
+export interface SentryAndroidGradlePluginOptions {
+    enableAndroidGradlePlugin?: boolean;
+    includeProguardMapping?: boolean;
+    dexguardEnabled?: boolean;
+    autoUploadNativeSymbols?: boolean;
+    autoUploadProguardMapping?: boolean;
+    uploadNativeSymbols?: boolean;
+    includeNativeSources?: boolean;
+    includeSourceContext?: boolean;
+}
+/**
+ * Adds the Sentry Android Gradle Plugin to the project.
+ * https://docs.sentry.io/platforms/react-native/manual-setup/manual-setup/#enable-sentry-agp
+ */
+export declare function withSentryAndroidGradlePlugin(config: any, { includeProguardMapping, dexguardEnabled, autoUploadProguardMapping, uploadNativeSymbols, autoUploadNativeSymbols, includeNativeSources, includeSourceContext, }?: SentryAndroidGradlePluginOptions): any;

package/plugin/build/withSentryAndroidGradlePlugin.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withSentryAndroidGradlePlugin = void 0;
+const config_plugins_1 = require("@expo/config-plugins");
+const utils_1 = require("./utils");
+/**
+ * Adds the Sentry Android Gradle Plugin to the project.
+ * https://docs.sentry.io/platforms/react-native/manual-setup/manual-setup/#enable-sentry-agp
+ */
+function withSentryAndroidGradlePlugin(config, { includeProguardMapping = true, dexguardEnabled = false, autoUploadProguardMapping = true, uploadNativeSymbols = true, autoUploadNativeSymbols = true, includeNativeSources = true, includeSourceContext = false, } = {}) {
+    const version = '4.14.1';
+    // Modify android/build.gradle
+    const withSentryProjectBuildGradle = (config) => {
+        return (0, config_plugins_1.withProjectBuildGradle)(config, (projectBuildGradle) => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            if (!projectBuildGradle.modResults || !projectBuildGradle.modResults.contents) {
+                (0, utils_1.warnOnce)('android/build.gradle content is missing or undefined.');
+                return config;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            if (projectBuildGradle.modResults.language !== 'groovy') {
+                (0, utils_1.warnOnce)('Cannot configure Sentry in android/build.gradle because it is not in Groovy.');
+                return config;
+            }
+            const dependency = `classpath("io.sentry:sentry-android-gradle-plugin:${version}")`;
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            if (projectBuildGradle.modResults.contents.includes(dependency)) {
+                (0, utils_1.warnOnce)('sentry-android-gradle-plugin dependency in already in android/build.gradle.');
+                return config;
+            }
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                const updatedContents = projectBuildGradle.modResults.contents.replace(/dependencies\s*{/, `dependencies {\n        ${dependency}`);
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                if (updatedContents === projectBuildGradle.modResults.contents) {
+                    (0, utils_1.warnOnce)('Failed to inject the dependency. Could not find `dependencies` in build.gradle.');
+                }
+                else {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                    projectBuildGradle.modResults.contents = updatedContents;
+                }
+            }
+            catch (error) {
+                (0, utils_1.warnOnce)(`An error occurred while trying to modify build.gradle`);
+            }
+            return projectBuildGradle;
+        });
+    };
+    // Modify android/app/build.gradle
+    const withSentryAppBuildGradle = (config) => {
+        return (0, config_plugins_1.withAppBuildGradle)(config, (config) => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            if (config.modResults.language !== 'groovy') {
+                (0, utils_1.warnOnce)('Cannot configure Sentry in android/app/build.gradle because it is not in Groovy.');
+                return config;
+            }
+            const sentryPlugin = `apply plugin: "io.sentry.android.gradle"`;
+            const sentryConfig = `
+  sentry {
+      autoUploadProguardMapping = ${autoUploadProguardMapping}
+      includeProguardMapping = ${includeProguardMapping}
+      dexguardEnabled = ${dexguardEnabled}
+      uploadNativeSymbols = ${uploadNativeSymbols}
+      autoUploadNativeSymbols = ${autoUploadNativeSymbols}
+      includeNativeSources = ${includeNativeSources}
+      includeSourceContext = ${includeSourceContext}
+      tracingInstrumentation {
+          enabled = false
+      }
+      autoInstallation {
+          enabled = false
+      }
+  }`;
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            let contents = config.modResults.contents;
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            if (!contents.includes(sentryPlugin)) {
+                contents = `${sentryPlugin}\n${contents}`;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            if (!contents.includes('sentry {')) {
+                contents = `${contents}\n${sentryConfig}`;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            config.modResults.contents = contents;
+            return config;
+        });
+    };
+    return withSentryAppBuildGradle(withSentryProjectBuildGradle(config));
+}
+exports.withSentryAndroidGradlePlugin = withSentryAndroidGradlePlugin;

package/scripts/collect-modules.sh

@@ -28,7 +28,7 @@ if [[ -n "$NODE_BINARY" ]]; then
   nodePath="$NODE_BINARY"
 fi
 
-thisFilePath=$(dirname $0)
+thisFilePath=$(dirname "$0")
 collectModulesScript="$thisFilePath/../dist/js/tools/collectModules.js"
 
 destination="$CONFIGURATION_BUILD_DIR/$UNLOCALIZED_RESOURCES_FOLDER_PATH"
@@ -44,11 +44,11 @@ else
   modulesPaths="$MODULES_PATHS"
 fi
 
-type $nodePath >/dev/null 2>&1 || {
-  echo >&2 "error: $nodePath not found! Modules won't be collected." \
+if ! command -v "$nodePath" >/dev/null 2>&1; then
+  echo "[sentry/collect-modules.sh] $nodePath not found! Modules won't be collected." \
     "Please export NODE_BINARY in 'Build Phase' - 'Bundle React Native code and images'" \
     "to an absolute path of your node binary. Check your node path by 'which node'."
   exit 0 # Don't fail the build but inform about the problem
-}
+fi
 
-$nodePath "$collectModulesScript" "$sourceMap" "$modulesOutput" "$modulesPaths"
+"$nodePath" "$collectModulesScript" "$sourceMap" "$modulesOutput" "$modulesPaths"

package/scripts/sentry-xcode.sh

@@ -51,22 +51,3 @@ 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,60 +15,9 @@ 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,7 +1,6 @@
 /// <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 {
@@ -24,7 +23,6 @@ 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.7.0-alpha.0";
+export declare const SDK_VERSION = "6.8.0";
 //# sourceMappingURL=version.d.ts.map

package/android/src/main/java/io/sentry/react/RNSentryCompositeOptionsConfiguration.java

@@ -1,25 +0,0 @@
-package io.sentry.react;
-
-import io.sentry.Sentry.OptionsConfiguration;
-import io.sentry.android.core.SentryAndroidOptions;
-import java.util.List;
-import org.jetbrains.annotations.NotNull;
-
-class RNSentryCompositeOptionsConfiguration implements OptionsConfiguration<SentryAndroidOptions> {
-  private final @NotNull List<OptionsConfiguration<SentryAndroidOptions>> configurations;
-
-  @SafeVarargs
-  protected RNSentryCompositeOptionsConfiguration(
-      @NotNull OptionsConfiguration<SentryAndroidOptions>... configurations) {
-    this.configurations = List.of(configurations);
-  }
-
-  @Override
-  public void configure(@NotNull SentryAndroidOptions options) {
-    for (OptionsConfiguration<SentryAndroidOptions> configuration : configurations) {
-      if (configuration != null) {
-        configuration.configure(options);
-      }
-    }
-  }
-}