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

package/RNSentry.podspec

@@ -33,11 +33,11 @@ Pod::Spec.new do |s|
   s.preserve_paths = '*.js'
 
   s.source_files = 'ios/**/*.{h,m,mm}'
-  s.public_header_files = 'ios/RNSentry.h'
+  s.public_header_files = 'ios/RNSentry.h', 'ios/RNSentrySDK.h'
 
   s.compiler_flags = other_cflags
 
-  s.dependency 'Sentry/HybridSDK', '8.43.0'
+  s.dependency 'Sentry/HybridSDK', '8.44.0'
 
   if defined? install_modules_dependencies
     # Default React Native dependencies for 0.71 and above (new and legacy architecture)

package/android/build.gradle

@@ -54,5 +54,5 @@ android {
 
 dependencies {
     implementation 'com.facebook.react:react-native:+'
-    api 'io.sentry:sentry-android:7.20.0'
+    api 'io.sentry:sentry-android:7.20.1'
 }

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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,41 @@
+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/RNSentryModuleImpl.java

@@ -20,13 +20,11 @@ import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
-import com.facebook.react.bridge.ReadableType;
 import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeArray;
 import com.facebook.react.bridge.WritableNativeMap;
-import com.facebook.react.common.JavascriptException;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 import io.sentry.Breadcrumb;
 import io.sentry.HubAdapter;
@@ -34,25 +32,16 @@ import io.sentry.ILogger;
 import io.sentry.IScope;
 import io.sentry.ISentryExecutorService;
 import io.sentry.ISerializer;
-import io.sentry.Integration;
 import io.sentry.Sentry;
 import io.sentry.SentryDate;
 import io.sentry.SentryDateProvider;
-import io.sentry.SentryEvent;
 import io.sentry.SentryExecutorService;
 import io.sentry.SentryLevel;
 import io.sentry.SentryOptions;
-import io.sentry.SentryReplayOptions;
-import io.sentry.UncaughtExceptionHandlerIntegration;
 import io.sentry.android.core.AndroidLogger;
 import io.sentry.android.core.AndroidProfiler;
-import io.sentry.android.core.AnrIntegration;
-import io.sentry.android.core.BuildConfig;
 import io.sentry.android.core.BuildInfoProvider;
-import io.sentry.android.core.CurrentActivityHolder;
 import io.sentry.android.core.InternalSentrySdk;
-import io.sentry.android.core.NdkIntegration;
-import io.sentry.android.core.SentryAndroid;
 import io.sentry.android.core.SentryAndroidDateProvider;
 import io.sentry.android.core.SentryAndroidOptions;
 import io.sentry.android.core.ViewHierarchyEventProcessor;
@@ -61,11 +50,8 @@ import io.sentry.android.core.internal.util.SentryFrameMetricsCollector;
 import io.sentry.android.core.performance.AppStartMetrics;
 import io.sentry.protocol.SdkVersion;
 import io.sentry.protocol.SentryId;
-import io.sentry.protocol.SentryPackage;
 import io.sentry.protocol.User;
 import io.sentry.protocol.ViewHierarchy;
-import io.sentry.react.replay.RNSentryReplayMask;
-import io.sentry.react.replay.RNSentryReplayUnmask;
 import io.sentry.util.DebugMetaPropertiesApplier;
 import io.sentry.util.FileUtils;
 import io.sentry.util.JsonSerializationUtils;
@@ -77,8 +63,6 @@ import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
 import java.io.InputStream;
-import java.net.URI;
-import java.net.URISyntaxException;
 import java.nio.charset.Charset;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -178,216 +162,12 @@ public class RNSentryModuleImpl {
   }
 
   public void initNativeSdk(final ReadableMap rnOptions, Promise promise) {
-    SentryAndroid.init(
-        this.getReactApplicationContext(),
-        options -> getSentryAndroidOptions(options, rnOptions, logger));
+    RNSentryStart.startWithOptions(
+        this.getReactApplicationContext(), rnOptions, getCurrentActivity(), logger);
 
     promise.resolve(true);
   }
 
-  protected void getSentryAndroidOptions(
-      @NotNull SentryAndroidOptions options, @NotNull ReadableMap rnOptions, ILogger logger) {
-    @Nullable SdkVersion sdkVersion = options.getSdkVersion();
-    if (sdkVersion == null) {
-      sdkVersion = new SdkVersion(RNSentryVersion.ANDROID_SDK_NAME, BuildConfig.VERSION_NAME);
-    } else {
-      sdkVersion.setName(RNSentryVersion.ANDROID_SDK_NAME);
-    }
-    sdkVersion.addPackage(
-        RNSentryVersion.REACT_NATIVE_SDK_PACKAGE_NAME,
-        RNSentryVersion.REACT_NATIVE_SDK_PACKAGE_VERSION);
-
-    options.setSentryClientName(sdkVersion.getName() + "/" + sdkVersion.getVersion());
-    options.setNativeSdkName(RNSentryVersion.NATIVE_SDK_NAME);
-    options.setSdkVersion(sdkVersion);
-
-    if (rnOptions.hasKey("debug") && rnOptions.getBoolean("debug")) {
-      options.setDebug(true);
-    }
-    if (rnOptions.hasKey("dsn") && rnOptions.getString("dsn") != null) {
-      String dsn = rnOptions.getString("dsn");
-      logger.log(SentryLevel.INFO, String.format("Starting with DSN: '%s'", dsn));
-      options.setDsn(dsn);
-    } else {
-      // SentryAndroid needs an empty string fallback for the dsn.
-      options.setDsn("");
-    }
-    if (rnOptions.hasKey("sampleRate")) {
-      options.setSampleRate(rnOptions.getDouble("sampleRate"));
-    }
-    if (rnOptions.hasKey("sendClientReports")) {
-      options.setSendClientReports(rnOptions.getBoolean("sendClientReports"));
-    }
-    if (rnOptions.hasKey("maxBreadcrumbs")) {
-      options.setMaxBreadcrumbs(rnOptions.getInt("maxBreadcrumbs"));
-    }
-    if (rnOptions.hasKey("maxCacheItems")) {
-      options.setMaxCacheItems(rnOptions.getInt("maxCacheItems"));
-    }
-    if (rnOptions.hasKey("environment") && rnOptions.getString("environment") != null) {
-      options.setEnvironment(rnOptions.getString("environment"));
-    }
-    if (rnOptions.hasKey("release") && rnOptions.getString("release") != null) {
-      options.setRelease(rnOptions.getString("release"));
-    }
-    if (rnOptions.hasKey("dist") && rnOptions.getString("dist") != null) {
-      options.setDist(rnOptions.getString("dist"));
-    }
-    if (rnOptions.hasKey("enableAutoSessionTracking")) {
-      options.setEnableAutoSessionTracking(rnOptions.getBoolean("enableAutoSessionTracking"));
-    }
-    if (rnOptions.hasKey("sessionTrackingIntervalMillis")) {
-      options.setSessionTrackingIntervalMillis(rnOptions.getInt("sessionTrackingIntervalMillis"));
-    }
-    if (rnOptions.hasKey("shutdownTimeout")) {
-      options.setShutdownTimeoutMillis(rnOptions.getInt("shutdownTimeout"));
-    }
-    if (rnOptions.hasKey("enableNdkScopeSync")) {
-      options.setEnableScopeSync(rnOptions.getBoolean("enableNdkScopeSync"));
-    }
-    if (rnOptions.hasKey("attachStacktrace")) {
-      options.setAttachStacktrace(rnOptions.getBoolean("attachStacktrace"));
-    }
-    if (rnOptions.hasKey("attachThreads")) {
-      // JS use top level stacktrace and android attaches Threads which hides them so
-      // by default we hide.
-      options.setAttachThreads(rnOptions.getBoolean("attachThreads"));
-    }
-    if (rnOptions.hasKey("attachScreenshot")) {
-      options.setAttachScreenshot(rnOptions.getBoolean("attachScreenshot"));
-    }
-    if (rnOptions.hasKey("attachViewHierarchy")) {
-      options.setAttachViewHierarchy(rnOptions.getBoolean("attachViewHierarchy"));
-    }
-    if (rnOptions.hasKey("sendDefaultPii")) {
-      options.setSendDefaultPii(rnOptions.getBoolean("sendDefaultPii"));
-    }
-    if (rnOptions.hasKey("maxQueueSize")) {
-      options.setMaxQueueSize(rnOptions.getInt("maxQueueSize"));
-    }
-    if (rnOptions.hasKey("enableNdk")) {
-      options.setEnableNdk(rnOptions.getBoolean("enableNdk"));
-    }
-    if (rnOptions.hasKey("spotlight")) {
-      if (rnOptions.getType("spotlight") == ReadableType.Boolean) {
-        options.setEnableSpotlight(rnOptions.getBoolean("spotlight"));
-        options.setSpotlightConnectionUrl(rnOptions.getString("defaultSidecarUrl"));
-      } else if (rnOptions.getType("spotlight") == ReadableType.String) {
-        options.setEnableSpotlight(true);
-        options.setSpotlightConnectionUrl(rnOptions.getString("spotlight"));
-      }
-    }
-
-    SentryReplayOptions replayOptions = getReplayOptions(rnOptions);
-    options.setSessionReplay(replayOptions);
-    if (isReplayEnabled(replayOptions)) {
-      options.getReplayController().setBreadcrumbConverter(new RNSentryReplayBreadcrumbConverter());
-    }
-
-    // Exclude Dev Server and Sentry Dsn request from Breadcrumbs
-    String dsn = getURLFromDSN(rnOptions.getString("dsn"));
-    String devServerUrl = rnOptions.getString("devServerUrl");
-    options.setBeforeBreadcrumb(
-        (breadcrumb, hint) -> {
-          Object urlObject = breadcrumb.getData("url");
-          String url = urlObject instanceof String ? (String) urlObject : "";
-          if ("http".equals(breadcrumb.getType())
-              && ((dsn != null && url.startsWith(dsn))
-                  || (devServerUrl != null && url.startsWith(devServerUrl)))) {
-            return null;
-          }
-          return breadcrumb;
-        });
-
-    // React native internally throws a JavascriptException.
-    // we want to ignore it on the native side to avoid sending it twice.
-    options.addIgnoredExceptionForType(JavascriptException.class);
-
-    options.setBeforeSend(
-        (event, hint) -> {
-          setEventOriginTag(event);
-          addPackages(event, options.getSdkVersion());
-
-          return event;
-        });
-
-    if (rnOptions.hasKey("enableNativeCrashHandling")
-        && !rnOptions.getBoolean("enableNativeCrashHandling")) {
-      final List<Integration> integrations = options.getIntegrations();
-      for (final Integration integration : integrations) {
-        if (integration instanceof UncaughtExceptionHandlerIntegration
-            || integration instanceof AnrIntegration
-            || integration instanceof NdkIntegration) {
-          integrations.remove(integration);
-        }
-      }
-    }
-    logger.log(
-        SentryLevel.INFO, String.format("Native Integrations '%s'", options.getIntegrations()));
-
-    final CurrentActivityHolder currentActivityHolder = CurrentActivityHolder.getInstance();
-    final Activity currentActivity = getCurrentActivity();
-    if (currentActivity != null) {
-      currentActivityHolder.setActivity(currentActivity);
-    }
-  }
-
-  private boolean isReplayEnabled(SentryReplayOptions replayOptions) {
-    return replayOptions.getSessionSampleRate() != null
-        || replayOptions.getOnErrorSampleRate() != null;
-  }
-
-  private SentryReplayOptions getReplayOptions(@NotNull ReadableMap rnOptions) {
-    final SdkVersion replaySdkVersion =
-        new SdkVersion(
-            RNSentryVersion.REACT_NATIVE_SDK_PACKAGE_NAME,
-            RNSentryVersion.REACT_NATIVE_SDK_PACKAGE_VERSION);
-    @NotNull
-    final SentryReplayOptions androidReplayOptions =
-        new SentryReplayOptions(false, replaySdkVersion);
-
-    if (!(rnOptions.hasKey("replaysSessionSampleRate")
-        || rnOptions.hasKey("replaysOnErrorSampleRate"))) {
-      return androidReplayOptions;
-    }
-
-    androidReplayOptions.setSessionSampleRate(
-        rnOptions.hasKey("replaysSessionSampleRate")
-            ? rnOptions.getDouble("replaysSessionSampleRate")
-            : null);
-    androidReplayOptions.setOnErrorSampleRate(
-        rnOptions.hasKey("replaysOnErrorSampleRate")
-            ? rnOptions.getDouble("replaysOnErrorSampleRate")
-            : null);
-
-    if (!rnOptions.hasKey("mobileReplayOptions")) {
-      return androidReplayOptions;
-    }
-    @Nullable final ReadableMap rnMobileReplayOptions = rnOptions.getMap("mobileReplayOptions");
-    if (rnMobileReplayOptions == null) {
-      return androidReplayOptions;
-    }
-
-    androidReplayOptions.setMaskAllText(
-        !rnMobileReplayOptions.hasKey("maskAllText")
-            || rnMobileReplayOptions.getBoolean("maskAllText"));
-    androidReplayOptions.setMaskAllImages(
-        !rnMobileReplayOptions.hasKey("maskAllImages")
-            || rnMobileReplayOptions.getBoolean("maskAllImages"));
-
-    final boolean redactVectors =
-        !rnMobileReplayOptions.hasKey("maskAllVectors")
-            || rnMobileReplayOptions.getBoolean("maskAllVectors");
-    if (redactVectors) {
-      androidReplayOptions.addMaskViewClass("com.horcrux.svg.SvgView"); // react-native-svg
-    }
-
-    androidReplayOptions.setMaskViewContainerClass(RNSentryReplayMask.class.getName());
-    androidReplayOptions.setUnmaskViewContainerClass(RNSentryReplayUnmask.class.getName());
-
-    return androidReplayOptions;
-  }
-
   public void crash() {
     throw new RuntimeException("TEST - Sentry Client Crash (only works in release mode)");
   }
@@ -974,51 +754,6 @@ public class RNSentryModuleImpl {
     promise.resolve(Sentry.isCrashedLastRun());
   }
 
-  private void setEventOriginTag(SentryEvent event) {
-    // We hardcode native-java as only java events are processed by the Android SDK.
-    SdkVersion sdk = event.getSdk();
-    if (sdk != null) {
-      switch (sdk.getName()) {
-        case RNSentryVersion.NATIVE_SDK_NAME:
-          setEventEnvironmentTag(event, "native");
-          break;
-        case RNSentryVersion.ANDROID_SDK_NAME:
-          setEventEnvironmentTag(event, "java");
-          break;
-        default:
-          break;
-      }
-    }
-  }
-
-  private void setEventEnvironmentTag(SentryEvent event, String environment) {
-    event.setTag("event.origin", "android");
-    event.setTag("event.environment", environment);
-  }
-
-  private void addPackages(SentryEvent event, SdkVersion sdk) {
-    SdkVersion eventSdk = event.getSdk();
-    if (eventSdk != null
-        && "sentry.javascript.react-native".equals(eventSdk.getName())
-        && sdk != null) {
-      List<SentryPackage> sentryPackages = sdk.getPackages();
-      if (sentryPackages != null) {
-        for (SentryPackage sentryPackage : sentryPackages) {
-          eventSdk.addPackage(sentryPackage.getName(), sentryPackage.getVersion());
-        }
-      }
-
-      List<String> integrations = sdk.getIntegrations();
-      if (integrations != null) {
-        for (String integration : integrations) {
-          eventSdk.addIntegration(integration);
-        }
-      }
-
-      event.setSdk(eventSdk);
-    }
-  }
-
   private boolean checkAndroidXAvailability() {
     try {
       Class.forName("androidx.core.app.FrameMetricsAggregator");
@@ -1032,17 +767,4 @@ public class RNSentryModuleImpl {
   private boolean isFrameMetricsAggregatorAvailable() {
     return androidXAvailable && frameMetricsAggregator != null;
   }
-
-  public static @Nullable String getURLFromDSN(@Nullable String dsn) {
-    if (dsn == null) {
-      return null;
-    }
-    URI uri = null;
-    try {
-      uri = new URI(dsn);
-    } catch (URISyntaxException e) {
-      return null;
-    }
-    return uri.getScheme() + "://" + uri.getHost();
-  }
 }

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

@@ -0,0 +1,68 @@
+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);
+  }
+}