@sentry/react-native 7.11.0 → 8.0.0-alpha.0

package/RNSentry.podspec

@@ -42,11 +42,15 @@ 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', 'ios/RNSentryStart.h', 'ios/RNSentryVersion.h', 'ios/RNSentryBreadcrumb.h', 'ios/RNSentryReplay.h', 'ios/RNSentryReplayBreadcrumbConverter.h', 'ios/Replay/RNSentryReplayMask.h', 'ios/Replay/RNSentryReplayUnmask.h', 'ios/RNSentryTimeToDisplay.h'
 
   s.compiler_flags = other_cflags
 
-  s.dependency 'Sentry/HybridSDK', '8.58.0'
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES'
+  }
+
+  s.dependency 'Sentry/HybridSDK', '9.1.0'
 
   if defined? install_modules_dependencies
     # Default React Native dependencies for 0.71 and above (new and legacy architecture)
@@ -56,10 +60,10 @@ Pod::Spec.new do |s|
 
     if is_new_arch_enabled then
       # New Architecture on React Native 0.70 and older
-      s.pod_target_xcconfig = {
+      s.pod_target_xcconfig.merge!({
           "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
           "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
-      }
+      })
 
       s.dependency "React-RCTFabric" # Required for Fabric Components (like RCTViewComponentView)
       s.dependency "React-Codegen"

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

@@ -23,41 +23,27 @@ import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReadableArray;
 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 io.sentry.Breadcrumb;
 import io.sentry.ILogger;
 import io.sentry.IScope;
 import io.sentry.ISentryExecutorService;
 import io.sentry.ISerializer;
-import io.sentry.Integration;
-import io.sentry.ProfileLifecycle;
 import io.sentry.ScopesAdapter;
-import io.sentry.ScreenshotStrategyType;
 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.SentryReplayOptions.SentryReplayQuality;
-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;
@@ -67,12 +53,8 @@ import io.sentry.android.core.performance.AppStartMetrics;
 import io.sentry.protocol.Geo;
 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.RNSentryReplayFragmentLifecycleTracer;
-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;
@@ -93,10 +75,8 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Locale;
 import java.util.Map;
 import java.util.Properties;
-import java.util.Set;
 import java.util.concurrent.CountDownLatch;
 import java.util.regex.Pattern;
 import org.jetbrains.annotations.NotNull;
@@ -185,30 +165,13 @@ public class RNSentryModuleImpl {
     }
   }
 
-  private void initFragmentReplayTracking() {
-    final RNSentryReplayFragmentLifecycleTracer fragmentLifecycleTracer =
-        new RNSentryReplayFragmentLifecycleTracer(logger);
-
-    final @Nullable Activity currentActivity = getCurrentActivity();
-    if (!(currentActivity instanceof FragmentActivity)) {
-      return;
-    }
-
-    final @NotNull FragmentActivity fragmentActivity = (FragmentActivity) currentActivity;
-    final @Nullable FragmentManager supportFragmentManager =
-        fragmentActivity.getSupportFragmentManager();
-    if (supportFragmentManager != null) {
-      supportFragmentManager.registerFragmentLifecycleCallbacks(fragmentLifecycleTracer, true);
-    }
-  }
-
   public void initNativeReactNavigationNewFrameTracking(Promise promise) {
     this.initFragmentInitialFrameTracking();
   }
 
   public void initNativeSdk(final ReadableMap rnOptions, Promise promise) {
-    SentryAndroid.init(
-        getApplicationContext(), options -> getSentryAndroidOptions(options, rnOptions, logger));
+    RNSentryStart.startWithOptions(
+        getApplicationContext(), rnOptions, getCurrentActivity(), logger);
 
     promise.resolve(true);
   }
@@ -224,320 +187,6 @@ public class RNSentryModuleImpl {
     return context;
   }
 
-  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("enabled")) {
-      options.setEnabled(rnOptions.getBoolean("enabled"));
-    }
-    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("enableLogs")) {
-      options.getLogs().setEnabled(rnOptions.getBoolean("enableLogs"));
-    }
-    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);
-    // Check if the replay integration is available on the classpath. It's already
-    // kept from R8
-    // shrinking by sentry-android-core
-    final boolean isReplayAvailable =
-        loadClass.isClassAvailable("io.sentry.android.replay.ReplayIntegration", logger);
-    if (isReplayEnabled(replayOptions) && isReplayAvailable) {
-      options.getReplayController().setBreadcrumbConverter(new RNSentryReplayBreadcrumbConverter());
-      initFragmentReplayTracking();
-    }
-
-    // Configure Android UI Profiling
-    configureAndroidProfiling(options, rnOptions);
-
-    // 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);
-
-    trySetIgnoreErrors(options, rnOptions);
-
-    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_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("replaysSessionQuality")) {
-      final String qualityString = rnOptions.getString("replaysSessionQuality");
-      final SentryReplayQuality quality = parseReplayQuality(qualityString);
-      androidReplayOptions.setQuality(quality);
-    }
-
-    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
-    }
-
-    if (rnMobileReplayOptions.hasKey("screenshotStrategy")) {
-      final String screenshotStrategyString = rnMobileReplayOptions.getString("screenshotStrategy");
-      final ScreenshotStrategyType screenshotStrategy =
-          parseScreenshotStrategy(screenshotStrategyString);
-      androidReplayOptions.setScreenshotStrategy(screenshotStrategy);
-    }
-
-    androidReplayOptions.setMaskViewContainerClass(RNSentryReplayMask.class.getName());
-    androidReplayOptions.setUnmaskViewContainerClass(RNSentryReplayUnmask.class.getName());
-
-    return androidReplayOptions;
-  }
-
-  private ScreenshotStrategyType parseScreenshotStrategy(@Nullable String strategyString) {
-    if (strategyString == null) {
-      return ScreenshotStrategyType.PIXEL_COPY;
-    }
-
-    switch (strategyString.toLowerCase(Locale.ROOT)) {
-      case "canvas":
-        return ScreenshotStrategyType.CANVAS;
-      default:
-        return ScreenshotStrategyType.PIXEL_COPY;
-    }
-  }
-
-  private SentryReplayQuality parseReplayQuality(@Nullable String qualityString) {
-    if (qualityString == null) {
-      return SentryReplayQuality.MEDIUM;
-    }
-
-    switch (qualityString.toLowerCase(Locale.ROOT)) {
-      case "low":
-        return SentryReplayQuality.LOW;
-      case "medium":
-        return SentryReplayQuality.MEDIUM;
-      case "high":
-        return SentryReplayQuality.HIGH;
-      default:
-        return SentryReplayQuality.MEDIUM;
-    }
-  }
-
-  private void configureAndroidProfiling(
-      @NotNull SentryAndroidOptions options, @NotNull ReadableMap rnOptions) {
-    if (!rnOptions.hasKey("_experiments")) {
-      return;
-    }
-
-    @Nullable final ReadableMap experiments = rnOptions.getMap("_experiments");
-    if (experiments == null || !experiments.hasKey("androidProfilingOptions")) {
-      return;
-    }
-
-    @Nullable
-    final ReadableMap androidProfilingOptions = experiments.getMap("androidProfilingOptions");
-    if (androidProfilingOptions == null) {
-      return;
-    }
-
-    // Set profile session sample rate
-    if (androidProfilingOptions.hasKey("profileSessionSampleRate")) {
-      final double profileSessionSampleRate =
-          androidProfilingOptions.getDouble("profileSessionSampleRate");
-      options.setProfileSessionSampleRate(profileSessionSampleRate);
-      logger.log(
-          SentryLevel.INFO,
-          String.format(
-              "Android UI Profiling profileSessionSampleRate set to: %.2f",
-              profileSessionSampleRate));
-    }
-
-    // Set profiling lifecycle mode
-    if (androidProfilingOptions.hasKey("lifecycle")) {
-      final String lifecycle = androidProfilingOptions.getString("lifecycle");
-      if ("manual".equalsIgnoreCase(lifecycle)) {
-        options.setProfileLifecycle(ProfileLifecycle.MANUAL);
-        logger.log(SentryLevel.INFO, "Android UI Profile Lifecycle set to MANUAL");
-      } else if ("trace".equalsIgnoreCase(lifecycle)) {
-        options.setProfileLifecycle(ProfileLifecycle.TRACE);
-        logger.log(SentryLevel.INFO, "Android UI Profile Lifecycle set to TRACE");
-      }
-    }
-
-    // Set start on app start
-    if (androidProfilingOptions.hasKey("startOnAppStart")) {
-      final boolean startOnAppStart = androidProfilingOptions.getBoolean("startOnAppStart");
-      options.setStartProfilerOnAppStart(startOnAppStart);
-      logger.log(
-          SentryLevel.INFO,
-          String.format("Android UI Profiling startOnAppStart set to %b", startOnAppStart));
-    }
-  }
-
   public void crash() {
     throw new RuntimeException("TEST - Sentry Client Crash (only works in release mode)");
   }
@@ -1276,51 +925,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) {
-      Set<SentryPackage> sentryPackages = sdk.getPackageSet();
-      if (sentryPackages != null) {
-        for (SentryPackage sentryPackage : sentryPackages) {
-          eventSdk.addPackage(sentryPackage.getName(), sentryPackage.getVersion());
-        }
-      }
-
-      Set<String> integrations = sdk.getIntegrationSet();
-      if (integrations != null) {
-        for (String integration : integrations) {
-          eventSdk.addIntegration(integration);
-        }
-      }
-
-      event.setSdk(eventSdk);
-    }
-  }
-
   private boolean checkAndroidXAvailability() {
     try {
       Class.forName("androidx.core.app.FrameMetricsAggregator");