@sentry/react-native 6.7.0-alpha.0 → 6.7.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)

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.7.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.7.0",
   "description": "Official Sentry SDK for react-native",
   "typings": "dist/js/index.d.ts",
   "types": "dist/js/index.d.ts",
@@ -65,7 +65,7 @@
     "react-native": ">=0.65.0"
   },
   "dependencies": {
-    "@sentry/babel-plugin-component-annotate": "2.20.1",
+    "@sentry/babel-plugin-component-annotate": "3.1.2",
     "@sentry/browser": "8.54.0",
     "@sentry/cli": "2.41.1",
     "@sentry/core": "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.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/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.0",
     "react-test-renderer": "^18.3.1",
     "rimraf": "^4.1.1",
     "ts-jest": "^29.1.1",

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.7.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);
-      }
-    }
-  }
-}

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

@@ -1,76 +0,0 @@
-package io.sentry.react;
-
-import com.facebook.react.bridge.JavaOnlyArray;
-import com.facebook.react.bridge.JavaOnlyMap;
-import com.facebook.react.bridge.WritableArray;
-import com.facebook.react.bridge.WritableMap;
-import io.sentry.ILogger;
-import io.sentry.SentryLevel;
-import io.sentry.android.core.AndroidLogger;
-import java.util.Iterator;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.json.JSONArray;
-import org.json.JSONException;
-import org.json.JSONObject;
-
-final class RNSentryJsonConverter {
-  public static final String NAME = "RNSentry.RNSentryJsonConverter";
-
-  private static final ILogger logger = new AndroidLogger(NAME);
-
-  private RNSentryJsonConverter() {
-    throw new AssertionError("Utility class should not be instantiated");
-  }
-
-  @Nullable
-  static WritableMap convertToWritable(@NotNull JSONObject jsonObject) {
-    try {
-      WritableMap writableMap = new JavaOnlyMap();
-      Iterator<String> iterator = jsonObject.keys();
-      while (iterator.hasNext()) {
-        String key = iterator.next();
-        Object value = jsonObject.get(key);
-        if (value instanceof Float || value instanceof Double) {
-          writableMap.putDouble(key, jsonObject.getDouble(key));
-        } else if (value instanceof Number) {
-          writableMap.putInt(key, jsonObject.getInt(key));
-        } else if (value instanceof String) {
-          writableMap.putString(key, jsonObject.getString(key));
-        } else if (value instanceof JSONObject) {
-          writableMap.putMap(key, convertToWritable(jsonObject.getJSONObject(key)));
-        } else if (value instanceof JSONArray) {
-          writableMap.putArray(key, convertToWritable(jsonObject.getJSONArray(key)));
-        } else if (value == JSONObject.NULL) {
-          writableMap.putNull(key);
-        }
-      }
-      return writableMap;
-    } catch (JSONException e) {
-      logger.log(SentryLevel.ERROR, "Error parsing json object:" + e.getMessage());
-      return null;
-    }
-  }
-
-  @NotNull
-  static WritableArray convertToWritable(@NotNull JSONArray jsonArray) throws JSONException {
-    WritableArray writableArray = new JavaOnlyArray();
-    for (int i = 0; i < jsonArray.length(); i++) {
-      Object value = jsonArray.get(i);
-      if (value instanceof Float || value instanceof Double) {
-        writableArray.pushDouble(jsonArray.getDouble(i));
-      } else if (value instanceof Number) {
-        writableArray.pushInt(jsonArray.getInt(i));
-      } else if (value instanceof String) {
-        writableArray.pushString(jsonArray.getString(i));
-      } else if (value instanceof JSONObject) {
-        writableArray.pushMap(convertToWritable(jsonArray.getJSONObject(i)));
-      } else if (value instanceof JSONArray) {
-        writableArray.pushArray(convertToWritable(jsonArray.getJSONArray(i)));
-      } else if (value == JSONObject.NULL) {
-        writableArray.pushNull();
-      }
-    }
-    return writableArray;
-  }
-}

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

@@ -1,41 +0,0 @@
-package io.sentry.react;
-
-import android.content.Context;
-import io.sentry.ILogger;
-import io.sentry.SentryLevel;
-import java.io.BufferedReader;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.json.JSONObject;
-
-final class RNSentryJsonUtils {
-  private RNSentryJsonUtils() {
-    throw new AssertionError("Utility class should not be instantiated");
-  }
-
-  static @Nullable JSONObject getOptionsFromConfigurationFile(
-      @NotNull Context context, @NotNull String fileName, @NotNull ILogger logger) {
-    try (InputStream inputStream = context.getAssets().open(fileName);
-        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream))) {
-
-      StringBuilder stringBuilder = new StringBuilder();
-      String line;
-      while ((line = reader.readLine()) != null) {
-        stringBuilder.append(line);
-      }
-      String configFileContent = stringBuilder.toString();
-      return new JSONObject(configFileContent);
-
-    } catch (Exception e) {
-      logger.log(
-          SentryLevel.ERROR,
-          "Failed to read configuration file. Please make sure "
-              + fileName
-              + " exists in the root of your project.",
-          e);
-      return null;
-    }
-  }
-}

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

@@ -1,68 +0,0 @@
-package io.sentry.react;
-
-import android.content.Context;
-import com.facebook.react.bridge.ReadableMap;
-import io.sentry.ILogger;
-import io.sentry.Sentry;
-import io.sentry.SentryLevel;
-import io.sentry.android.core.AndroidLogger;
-import io.sentry.android.core.SentryAndroidOptions;
-import org.jetbrains.annotations.NotNull;
-import org.json.JSONObject;
-
-public final class RNSentrySDK {
-  private static final String CONFIGURATION_FILE = "sentry.options.json";
-  private static final String NAME = "RNSentrySDK";
-
-  private static final ILogger logger = new AndroidLogger(NAME);
-
-  private RNSentrySDK() {
-    throw new AssertionError("Utility class should not be instantiated");
-  }
-
-  static void init(
-      @NotNull final Context context,
-      @NotNull Sentry.OptionsConfiguration<SentryAndroidOptions> configuration,
-      @NotNull String configurationFile,
-      @NotNull ILogger logger) {
-    try {
-      JSONObject jsonObject =
-          RNSentryJsonUtils.getOptionsFromConfigurationFile(context, configurationFile, logger);
-      if (jsonObject == null) {
-        RNSentryStart.startWithConfiguration(context, configuration);
-        return;
-      }
-      ReadableMap rnOptions = RNSentryJsonConverter.convertToWritable(jsonObject);
-      if (rnOptions == null) {
-        RNSentryStart.startWithConfiguration(context, configuration);
-        return;
-      }
-      RNSentryStart.startWithOptions(context, rnOptions, configuration, logger);
-    } catch (Exception e) {
-      logger.log(
-          SentryLevel.ERROR, "Failed to start Sentry with options from configuration file.", e);
-      throw new RuntimeException("Failed to initialize Sentry's React Native SDK", e);
-    }
-  }
-
-  /**
-   * @experimental Start the Native Android SDK with the provided configuration options. Uses as a
-   *     base configurations the `sentry.options.json` configuration file if it exists.
-   * @param context Android Context
-   * @param configuration configuration options
-   */
-  public static void init(
-      @NotNull final Context context,
-      @NotNull Sentry.OptionsConfiguration<SentryAndroidOptions> configuration) {
-    init(context, configuration, CONFIGURATION_FILE, logger);
-  }
-
-  /**
-   * @experimental Start the Native Android SDK with options from `sentry.options.json`
-   *     configuration file.
-   * @param context Android Context
-   */
-  public static void init(@NotNull final Context context) {
-    init(context, options -> {}, CONFIGURATION_FILE, logger);
-  }
-}