@sentry/react-native 7.12.0 → 8.0.0-beta.0

package/ios/RNSentryStart.m

@@ -0,0 +1,228 @@
+#import "RNSentryStart.h"
+#import "RNSentryExperimentalOptions.h"
+#import "RNSentryReplay.h"
+#import "RNSentryVersion.h"
+
+#import <Sentry/PrivateSentrySDKOnly.h>
+#import <Sentry/Sentry.h>
+@import Sentry;
+
+@implementation RNSentryStart
+
++ (void)startWithOptions:(NSDictionary *_Nonnull)javascriptOptions
+                   error:(NSError *_Nullable *_Nullable)errorPointer
+{
+    SentryOptions *options = [self createOptionsWithDictionary:javascriptOptions
+                                                         error:errorPointer];
+    [self updateWithReactDefaults:options];
+    [self updateWithReactFinals:options];
+    [self startWithOptions:options];
+}
+
++ (void)startWithOptions:(SentryOptions *)options NS_SWIFT_NAME(start(options:))
+{
+    NSString *sdkVersion = [PrivateSentrySDKOnly getSdkVersionString];
+    [PrivateSentrySDKOnly setSdkName:NATIVE_SDK_NAME andVersionString:sdkVersion];
+    [PrivateSentrySDKOnly addSdkPackage:REACT_NATIVE_SDK_PACKAGE_NAME
+                                version:REACT_NATIVE_SDK_PACKAGE_VERSION];
+
+    [SentrySDK startWithOptions:options];
+
+#if SENTRY_TARGET_REPLAY_SUPPORTED
+    [RNSentryReplay postInit];
+#endif
+
+    [self postDidBecomeActiveNotification];
+}
+
++ (SentryOptions *_Nullable)createOptionsWithDictionary:(NSDictionary *_Nonnull)options
+                                                  error:(NSError *_Nonnull *_Nonnull)errorPointer
+{
+    NSMutableDictionary *mutableOptions = [options mutableCopy];
+
+#if SENTRY_TARGET_REPLAY_SUPPORTED
+    BOOL isSessionReplayEnabled = [RNSentryReplay updateOptions:mutableOptions];
+#else
+    BOOL isSessionReplayEnabled = NO;
+#endif
+
+    SentryOptions *sentryOptions = [PrivateSentrySDKOnly optionsWithDictionary:mutableOptions
+                                                              didFailWithError:errorPointer];
+    if (*errorPointer != nil) {
+        return nil;
+    }
+
+    // Exclude Dev Server and Sentry Dsn request from Breadcrumbs
+    NSString *dsn = [self getURLFromDSN:[mutableOptions valueForKey:@"dsn"]];
+    // TODO: For Auto Init from JS dev server is resolved automatically, for init from options file
+    // dev server has to be specified manually
+    NSString *devServerUrl = [mutableOptions valueForKey:@"devServerUrl"];
+    sentryOptions.beforeBreadcrumb
+        = ^SentryBreadcrumb *_Nullable(SentryBreadcrumb *_Nonnull breadcrumb)
+    {
+        NSString *url = breadcrumb.data[@"url"] ?: @"";
+
+        if ([@"http" isEqualToString:breadcrumb.type]
+            && ((dsn != nil && [url hasPrefix:dsn])
+                || (devServerUrl != nil && [url hasPrefix:devServerUrl]))) {
+            return nil;
+        }
+        return breadcrumb;
+    };
+
+    // JS options.enableNativeCrashHandling equals to native options.enableCrashHandler
+    if ([mutableOptions valueForKey:@"enableNativeCrashHandling"] != nil) {
+        BOOL enableNativeCrashHandling = [mutableOptions[@"enableNativeCrashHandling"] boolValue];
+
+        if (!enableNativeCrashHandling) {
+            sentryOptions.enableCrashHandler = NO;
+        }
+    }
+
+    // Set spotlight option
+    if ([mutableOptions valueForKey:@"spotlight"] != nil) {
+        id spotlightValue = [mutableOptions valueForKey:@"spotlight"];
+        if ([spotlightValue isKindOfClass:[NSString class]]) {
+            NSLog(@"Using Spotlight on address: %@", spotlightValue);
+            sentryOptions.enableSpotlight = true;
+            sentryOptions.spotlightUrl = spotlightValue;
+        } else if ([spotlightValue isKindOfClass:[NSNumber class]]) {
+            sentryOptions.enableSpotlight = [spotlightValue boolValue];
+            // TODO: For Auto init from JS set automatically for init from options file have to be
+            // set manually
+            id defaultSpotlightUrl = [mutableOptions valueForKey:@"defaultSidecarUrl"];
+            if (defaultSpotlightUrl != nil) {
+                sentryOptions.spotlightUrl = defaultSpotlightUrl;
+            }
+        }
+    }
+
+    if (isSessionReplayEnabled) {
+        [RNSentryExperimentalOptions setEnableSessionReplayInUnreliableEnvironment:YES
+                                                                     sentryOptions:sentryOptions];
+    }
+
+    return sentryOptions;
+}
+
+/**
+ * This function updates the options with RNSentry defaults. These default can be
+ * overwritten by users during manual native initialization.
+ */
++ (void)updateWithReactDefaults:(SentryOptions *)options
+{
+    // Failed requests are captured only in JS to avoid duplicates
+    options.enableCaptureFailedRequests = NO;
+
+    // Tracing is only enabled in JS to avoid duplicate navigation spans
+    options.tracesSampleRate = nil;
+    options.tracesSampler = nil;
+    // Note: enableTracing property is deprecated in Sentry Cocoa SDK v7
+    // Tracing is disabled by setting tracesSampleRate and tracesSampler to nil
+}
+
+/**
+ * This function updates options with changes RNSentry users should not change
+ * and so this is applied after the configureOptions callback during manual native initialization.
+ */
++ (void)updateWithReactFinals:(SentryOptions *)options
+{
+    SentryBeforeSendEventCallback userBeforeSend = options.beforeSend;
+    options.beforeSend = ^SentryEvent *(SentryEvent *event) {
+        // Unhandled JS Exception are processed by the SDK on JS layer
+        // To avoid duplicates we drop them in the native SDKs
+        if (nil != event.exceptions.firstObject.type &&
+            [event.exceptions.firstObject.type rangeOfString:@"Unhandled JS Exception"].location
+                != NSNotFound) {
+            return nil;
+        }
+
+        [self setEventOriginTag:event];
+        if (userBeforeSend == nil) {
+            return event;
+        } else {
+            return userBeforeSend(event);
+        }
+    };
+
+    // App Start Hybrid mode doesn't wait for didFinishLaunchNotification and the
+    // didBecomeVisibleNotification as they will be missed when auto initializing from JS
+    // App Start measurements are created right after the tracking starts
+    PrivateSentrySDKOnly.appStartMeasurementHybridSDKMode = options.enableAutoPerformanceTracing;
+#if TARGET_OS_IPHONE || TARGET_OS_MACCATALYST
+    // Frames Tracking Hybrid Mode ensures tracking
+    // is enabled without tracing enabled in the native SDK
+    PrivateSentrySDKOnly.framesTrackingMeasurementHybridSDKMode
+        = options.enableAutoPerformanceTracing;
+#endif
+}
+
++ (void)setEventOriginTag:(SentryEvent *)event
+{
+    if (event.sdk != nil) {
+        NSString *sdkName = event.sdk[@"name"];
+
+        // If the event is from react native, it gets set
+        // there and we do not handle it here.
+        if ([sdkName isEqual:NATIVE_SDK_NAME]) {
+            [self setEventEnvironmentTag:event origin:@"ios" environment:@"native"];
+        }
+    }
+}
+
++ (void)setEventEnvironmentTag:(SentryEvent *)event
+                        origin:(NSString *)origin
+                   environment:(NSString *)environment
+{
+    NSMutableDictionary *newTags = [NSMutableDictionary new];
+
+    if (nil != event.tags && [event.tags count] > 0) {
+        [newTags addEntriesFromDictionary:event.tags];
+    }
+    if (nil != origin) {
+        [newTags setValue:origin forKey:@"event.origin"];
+    }
+    if (nil != environment) {
+        [newTags setValue:environment forKey:@"event.environment"];
+    }
+
+    event.tags = newTags;
+}
+
++ (NSString *_Nullable)getURLFromDSN:(NSString *)dsn
+{
+    NSURL *url = [NSURL URLWithString:dsn];
+    if (!url) {
+        return nil;
+    }
+    return [NSString stringWithFormat:@"%@://%@", url.scheme, url.host];
+}
+
+static bool sentHybridSdkDidBecomeActive = NO;
+
++ (void)postDidBecomeActiveNotification
+{
+#if TARGET_OS_IPHONE || TARGET_OS_MACCATALYST
+    BOOL appIsActive =
+        [[UIApplication sharedApplication] applicationState] == UIApplicationStateActive;
+#else
+    BOOL appIsActive = [[NSApplication sharedApplication] isActive];
+#endif
+
+    // If the app is active/in foreground, and we have not sent the SentryHybridSdkDidBecomeActive
+    // notification, send it.
+    if (appIsActive && !sentHybridSdkDidBecomeActive
+        && (PrivateSentrySDKOnly.options.enableAutoSessionTracking
+            || PrivateSentrySDKOnly.options.enableWatchdogTerminationTracking)) {
+        // Updates Native App State Manager
+        // https://github.com/getsentry/sentry-cocoa/blob/888a145b144b8077e03151a886520f332e47e297/Sources/Sentry/SentryAppStateManager.m#L136
+        // Triggers Session Tracker
+        // https://github.com/getsentry/sentry-cocoa/blob/888a145b144b8077e03151a886520f332e47e297/Sources/Sentry/SentrySessionTracker.m#L144
+        [[NSNotificationCenter defaultCenter] postNotificationName:@"SentryHybridSdkDidBecomeActive"
+                                                            object:nil];
+
+        sentHybridSdkDidBecomeActive = true;
+    }
+}
+
+@end

package/ios/RNSentryVersion.m

@@ -3,4 +3,4 @@
 NSString *const NATIVE_SDK_NAME = @"sentry.cocoa.react-native";
 NSString *const REACT_NATIVE_SDK_NAME = @"sentry.javascript.react-native";
 NSString *const REACT_NATIVE_SDK_PACKAGE_NAME = @"npm:@sentry/react-native";
-NSString *const REACT_NATIVE_SDK_PACKAGE_VERSION = @"7.12.0";
+NSString *const REACT_NATIVE_SDK_PACKAGE_VERSION = @"8.0.0-beta.0";

package/ios/SentrySDKWrapper.m

@@ -35,8 +35,8 @@
                                          error:(NSError *__autoreleasing *)errorPointer
 {
     NSString *dsn = [self getURLFromDSN:[options valueForKey:@"dsn"]];
-    SentryOptions *sentryOptions = [SentryOptionsInternal initWithDict:options
-                                                      didFailWithError:errorPointer];
+    SentryOptions *sentryOptions = [PrivateSentrySDKOnly optionsWithDictionary:options
+                                                              didFailWithError:errorPointer];
     if (*errorPointer != nil) {
         return nil;
     }

package/ios/SentryScreenFramesWrapper.h

@@ -0,0 +1,14 @@
+#import <Foundation/Foundation.h>
+
+#if TARGET_OS_IPHONE || TARGET_OS_MACCATALYST
+
+@interface SentryScreenFramesWrapper : NSObject
+
++ (BOOL)canTrackFrames;
++ (NSNumber *)totalFrames;
++ (NSNumber *)frozenFrames;
++ (NSNumber *)slowFrames;
+
+@end
+
+#endif // TARGET_OS_IPHONE || TARGET_OS_MACCATALYST

package/ios/SentryScreenFramesWrapper.m

@@ -0,0 +1,39 @@
+#import "SentryScreenFramesWrapper.h"
+@import Sentry;
+
+#if TARGET_OS_IPHONE || TARGET_OS_MACCATALYST
+
+@implementation SentryScreenFramesWrapper
+
++ (BOOL)canTrackFrames
+{
+    return PrivateSentrySDKOnly.currentScreenFrames != nil;
+}
+
++ (NSNumber *)totalFrames
+{
+    if (![self canTrackFrames]) {
+        return nil;
+    }
+    return [NSNumber numberWithLong:PrivateSentrySDKOnly.currentScreenFrames.total];
+}
+
++ (NSNumber *)frozenFrames
+{
+    if (![self canTrackFrames]) {
+        return nil;
+    }
+    return [NSNumber numberWithLong:PrivateSentrySDKOnly.currentScreenFrames.frozen];
+}
+
++ (NSNumber *)slowFrames
+{
+    if (![self canTrackFrames]) {
+        return nil;
+    }
+    return [NSNumber numberWithLong:PrivateSentrySDKOnly.currentScreenFrames.slow];
+}
+
+@end
+
+#endif // TARGET_OS_IPHONE || TARGET_OS_MACCATALYST

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": "7.12.0",
+  "version": "8.0.0-beta.0",
   "description": "Official Sentry SDK for react-native",
   "typings": "dist/js/index.d.ts",
   "types": "dist/js/index.d.ts",
@@ -70,7 +70,7 @@
   "dependencies": {
     "@sentry/babel-plugin-component-annotate": "4.9.0",
     "@sentry/browser": "10.38.0",
-    "@sentry/cli": "2.58.4",
+    "@sentry/cli": "3.1.0",
     "@sentry/core": "10.38.0",
     "@sentry/react": "10.38.0",
     "@sentry/types": "10.38.0"

package/plugin/build/logger.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Log a warning message only once per run.
+ * This is used to avoid spamming the console with the same message.
+ */
+export declare function warnOnce(message: string): void;
+/**
+ * Prefix message with `› [value]`.
+ *
+ * Example:
+ * ```
+ * › [@sentry/react-native/expo] This is a warning message
+ * ```
+ */
+export declare function prefix(value: string): string;
+/**
+ * The same as `chalk.yellow`
+ * This code is part of the SDK, we don't want to introduce a dependency on `chalk` just for this.
+ */
+export declare function yellow(message: string): string;
+/**
+ * The same as `chalk.bold`
+ * This code is part of the SDK, we don't want to introduce a dependency on `chalk` just for this.
+ */
+export declare function bold(message: string): string;

package/plugin/build/logger.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bold = exports.yellow = exports.prefix = exports.warnOnce = void 0;
+const warningMap = new Map();
+/**
+ * Log a warning message only once per run.
+ * This is used to avoid spamming the console with the same message.
+ */
+function warnOnce(message) {
+    if (!warningMap.has(message)) {
+        warningMap.set(message, true);
+        // eslint-disable-next-line no-console
+        console.warn(yellow(prefix(message)));
+    }
+}
+exports.warnOnce = warnOnce;
+/**
+ * Prefix message with `› [value]`.
+ *
+ * Example:
+ * ```
+ * › [@sentry/react-native/expo] This is a warning message
+ * ```
+ */
+function prefix(value) {
+    return `› ${bold('[@sentry/react-native/expo]')} ${value}`;
+}
+exports.prefix = prefix;
+/**
+ * The same as `chalk.yellow`
+ * This code is part of the SDK, we don't want to introduce a dependency on `chalk` just for this.
+ */
+function yellow(message) {
+    return `\x1b[33m${message}\x1b[0m`;
+}
+exports.yellow = yellow;
+/**
+ * The same as `chalk.bold`
+ * This code is part of the SDK, we don't want to introduce a dependency on `chalk` just for this.
+ */
+function bold(message) {
+    return `\x1b[1m${message}\x1b[22m`;
+}
+exports.bold = bold;

package/plugin/build/utils.d.ts

@@ -1,19 +1 @@
 export declare function writeSentryPropertiesTo(filepath: string, sentryProperties: string): void;
-declare const sdkPackage: {
-    name: string;
-    version: string;
-};
-declare const SDK_PACKAGE_NAME: string;
-export declare function warnOnce(message: string): void;
-export declare function logPrefix(): string;
-/**
- * The same as `chalk.yellow`
- * This code is part of the SDK, we don't want to introduce a dependency on `chalk` just for this.
- */
-export declare function yellow(message: string): string;
-/**
- * The same as `chalk.bold`
- * This code is part of the SDK, we don't want to introduce a dependency on `chalk` just for this.
- */
-export declare function bold(message: string): string;
-export { sdkPackage, SDK_PACKAGE_NAME };

package/plugin/build/utils.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SDK_PACKAGE_NAME = exports.sdkPackage = exports.bold = exports.yellow = exports.logPrefix = exports.warnOnce = exports.writeSentryPropertiesTo = void 0;
+exports.writeSentryPropertiesTo = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 function writeSentryPropertiesTo(filepath, sentryProperties) {
@@ -33,36 +33,3 @@ function writeSentryPropertiesTo(filepath, sentryProperties) {
     fs.writeFileSync(path.resolve(filepath, 'sentry.properties'), sentryProperties);
 }
 exports.writeSentryPropertiesTo = writeSentryPropertiesTo;
-const sdkPackage = require('../../package.json');
-exports.sdkPackage = sdkPackage;
-const SDK_PACKAGE_NAME = `${sdkPackage.name}/expo`;
-exports.SDK_PACKAGE_NAME = SDK_PACKAGE_NAME;
-const warningMap = new Map();
-function warnOnce(message) {
-    if (!warningMap.has(message)) {
-        warningMap.set(message, true);
-        // eslint-disable-next-line no-console
-        console.warn(yellow(`${logPrefix()} ${message}`));
-    }
-}
-exports.warnOnce = warnOnce;
-function logPrefix() {
-    return `› ${bold('[@sentry/react-native/expo]')}`;
-}
-exports.logPrefix = logPrefix;
-/**
- * The same as `chalk.yellow`
- * This code is part of the SDK, we don't want to introduce a dependency on `chalk` just for this.
- */
-function yellow(message) {
-    return `\x1b[33m${message}\x1b[0m`;
-}
-exports.yellow = yellow;
-/**
- * The same as `chalk.bold`
- * This code is part of the SDK, we don't want to introduce a dependency on `chalk` just for this.
- */
-function bold(message) {
-    return `\x1b[1m${message}\x1b[22m`;
-}
-exports.bold = bold;

package/plugin/build/version.d.ts

@@ -0,0 +1,2 @@
+export declare const PLUGIN_NAME: string;
+export declare const PLUGIN_VERSION: string;

package/plugin/build/version.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_VERSION = exports.PLUGIN_NAME = void 0;
+const packageJson = require('../../package.json');
+exports.PLUGIN_NAME = `${packageJson.name}/expo`;
+exports.PLUGIN_VERSION = packageJson.version;

package/plugin/build/withSentry.d.ts

@@ -5,6 +5,7 @@ interface PluginProps {
     project?: string;
     authToken?: string;
     url?: string;
+    useNativeInit?: boolean;
     experimental_android?: SentryAndroidGradlePluginOptions;
 }
 export declare function getSentryProperties(props: PluginProps | void): string | null;

package/plugin/build/withSentry.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withSentry = exports.getSentryProperties = void 0;
 const config_plugins_1 = require("expo/config-plugins");
-const utils_1 = require("./utils");
+const logger_1 = require("./logger");
+const version_1 = require("./version");
 const withSentryAndroid_1 = require("./withSentryAndroid");
 const withSentryAndroidGradlePlugin_1 = require("./withSentryAndroidGradlePlugin");
 const withSentryIOS_1 = require("./withSentryIOS");
@@ -15,10 +16,10 @@ const withSentryPlugin = (config, props) => {
     let cfg = config;
     if (sentryProperties !== null) {
         try {
-            cfg = (0, withSentryAndroid_1.withSentryAndroid)(cfg, sentryProperties);
+            cfg = (0, withSentryAndroid_1.withSentryAndroid)(cfg, { sentryProperties, useNativeInit: props?.useNativeInit });
         }
         catch (e) {
-            (0, utils_1.warnOnce)(`There was a problem with configuring your native Android project: ${e}`);
+            (0, logger_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) {
@@ -26,14 +27,14 @@ const withSentryPlugin = (config, props) => {
                 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}`);
+                (0, logger_1.warnOnce)(`There was a problem with configuring Sentry Android Gradle Plugin: ${e}`);
             }
         }
         try {
-            cfg = (0, withSentryIOS_1.withSentryIOS)(cfg, sentryProperties);
+            cfg = (0, withSentryIOS_1.withSentryIOS)(cfg, { sentryProperties, useNativeInit: props?.useNativeInit });
         }
         catch (e) {
-            (0, utils_1.warnOnce)(`There was a problem with configuring your native iOS project: ${e}`);
+            (0, logger_1.warnOnce)(`There was a problem with configuring your native iOS project: ${e}`);
         }
     }
     return cfg;
@@ -47,12 +48,12 @@ function getSentryProperties(props) {
     // eslint-disable-next-line no-prototype-builtins
     const missingProperties = ['organization', 'project'].filter(each => !props?.hasOwnProperty(each));
     if (missingProperties.length) {
-        const missingPropertiesString = (0, utils_1.bold)(missingProperties.join(', '));
+        const missingPropertiesString = (0, logger_1.bold)(missingProperties.join(', '));
         const warningMessage = `Missing config for ${missingPropertiesString}. Environment variables will be used as a fallback during the build. https://docs.sentry.io/platforms/react-native/manual-setup/`;
-        (0, utils_1.warnOnce)(warningMessage);
+        (0, logger_1.warnOnce)(warningMessage);
     }
     if (authToken) {
-        (0, utils_1.warnOnce)(`Detected unsecure use of 'authToken' in Sentry plugin configuration. To avoid exposing the token use ${(0, utils_1.bold)('SENTRY_AUTH_TOKEN')} environment variable instead. https://docs.sentry.io/platforms/react-native/manual-setup/`);
+        (0, logger_1.warnOnce)(`Detected unsecure use of 'authToken' in Sentry plugin configuration. To avoid exposing the token use ${(0, logger_1.bold)('SENTRY_AUTH_TOKEN')} environment variable instead. https://docs.sentry.io/platforms/react-native/manual-setup/`);
     }
     return `defaults.url=${url}
 ${organization ? `defaults.org=${organization}` : missingOrgMessage}
@@ -61,5 +62,5 @@ ${authToken ? `${existingAuthTokenMessage}\nauth.token=${authToken}` : missingAu
 }
 exports.getSentryProperties = getSentryProperties;
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-const withSentry = (0, config_plugins_1.createRunOncePlugin)(withSentryPlugin, utils_1.sdkPackage.name, utils_1.sdkPackage.version);
+const withSentry = (0, config_plugins_1.createRunOncePlugin)(withSentryPlugin, version_1.PLUGIN_NAME, version_1.PLUGIN_VERSION);
 exports.withSentry = withSentry;

package/plugin/build/withSentryAndroid.d.ts

@@ -1,7 +1,12 @@
+import type { ExpoConfig } from '@expo/config-types';
 import type { ConfigPlugin } from 'expo/config-plugins';
-export declare const withSentryAndroid: ConfigPlugin<string>;
+export declare const withSentryAndroid: ConfigPlugin<{
+    sentryProperties: string;
+    useNativeInit: boolean | undefined;
+}>;
 /**
  * Writes to projectDirectory/android/app/build.gradle,
  * adding the relevant @sentry/react-native script.
  */
 export declare function modifyAppBuildGradle(buildGradle: string): string;
+export declare function modifyMainApplication(config: ExpoConfig): ExpoConfig;

package/plugin/build/withSentryAndroid.js

@@ -23,21 +23,23 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.modifyAppBuildGradle = exports.withSentryAndroid = void 0;
+exports.modifyMainApplication = exports.modifyAppBuildGradle = exports.withSentryAndroid = void 0;
 const config_plugins_1 = require("expo/config-plugins");
 const path = __importStar(require("path"));
+const logger_1 = require("./logger");
 const utils_1 = require("./utils");
-const withSentryAndroid = (config, sentryProperties) => {
-    const cfg = (0, config_plugins_1.withAppBuildGradle)(config, appBuildGradle => {
-        if (appBuildGradle.modResults.language === 'groovy') {
-            appBuildGradle.modResults.contents = modifyAppBuildGradle(appBuildGradle.modResults.contents);
+const withSentryAndroid = (config, { sentryProperties, useNativeInit = false }) => {
+    const appBuildGradleCfg = (0, config_plugins_1.withAppBuildGradle)(config, config => {
+        if (config.modResults.language === 'groovy') {
+            config.modResults.contents = modifyAppBuildGradle(config.modResults.contents);
         }
         else {
             throw new Error('Cannot configure Sentry in the app gradle because the build.gradle is not groovy');
         }
-        return appBuildGradle;
+        return config;
     });
-    return (0, config_plugins_1.withDangerousMod)(cfg, [
+    const mainApplicationCfg = useNativeInit ? modifyMainApplication(appBuildGradleCfg) : appBuildGradleCfg;
+    return (0, config_plugins_1.withDangerousMod)(mainApplicationCfg, [
         'android',
         dangerousMod => {
             (0, utils_1.writeSentryPropertiesTo)(path.resolve(dangerousMod.modRequest.projectRoot, 'android'), sentryProperties);
@@ -59,10 +61,52 @@ function modifyAppBuildGradle(buildGradle) {
     // See: https://github.com/getsentry/sentry-wizard/blob/e9b4522f27a852069c862bd458bdf9b07cab6e33/lib/Steps/Integrations/ReactNative.ts#L232
     const pattern = /^android {/m;
     if (!buildGradle.match(pattern)) {
-        (0, utils_1.warnOnce)('Could not find `^android {` in `android/app/build.gradle`. Please open a bug report at https://github.com/getsentry/sentry-react-native.');
+        (0, logger_1.warnOnce)('Could not find `^android {` in `android/app/build.gradle`. Please open a bug report at https://github.com/getsentry/sentry-react-native.');
         return buildGradle;
     }
     const applyFrom = `apply from: new File(${resolveSentryReactNativePackageJsonPath}, "sentry.gradle")`;
     return buildGradle.replace(pattern, match => `${applyFrom}\n\n${match}`);
 }
 exports.modifyAppBuildGradle = modifyAppBuildGradle;
+function modifyMainApplication(config) {
+    return (0, config_plugins_1.withMainApplication)(config, config => {
+        if (!config.modResults?.path) {
+            (0, logger_1.warnOnce)("Can't add 'RNSentrySDK.init' to Android MainApplication, because the file was not found.");
+            return config;
+        }
+        const fileName = path.basename(config.modResults.path);
+        if (config.modResults.contents.includes('RNSentrySDK.init')) {
+            (0, logger_1.warnOnce)(`Your '${fileName}' already contains 'RNSentrySDK.init', the native code won't be updated.`);
+            return config;
+        }
+        if (config.modResults.language === 'java') {
+            // Add RNSentrySDK.init
+            const originalContents = config.modResults.contents;
+            config.modResults.contents = config.modResults.contents.replace(/(super\.onCreate\(\)[;\n]*)([ \t]*)/, '$1\n$2RNSentrySDK.init(this);\n$2');
+            if (config.modResults.contents === originalContents) {
+                (0, logger_1.warnOnce)(`Failed to insert 'RNSentrySDK.init' in '${fileName}'.`);
+            }
+            else if (!config.modResults.contents.includes('import io.sentry.react.RNSentrySDK;')) {
+                // Insert import statement after package declaration
+                config.modResults.contents = config.modResults.contents.replace(/(package .*;\n\n?)/, '$1import io.sentry.react.RNSentrySDK;\n');
+            }
+        }
+        else if (config.modResults.language === 'kt') {
+            // Add RNSentrySDK.init
+            const originalContents = config.modResults.contents;
+            config.modResults.contents = config.modResults.contents.replace(/(super\.onCreate\(\)[;\n]*)([ \t]*)/, '$1\n$2RNSentrySDK.init(this)\n$2');
+            if (config.modResults.contents === originalContents) {
+                (0, logger_1.warnOnce)(`Failed to insert 'RNSentrySDK.init' in '${fileName}'.`);
+            }
+            else if (!config.modResults.contents.includes('import io.sentry.react.RNSentrySDK')) {
+                // Insert import statement after package declaration
+                config.modResults.contents = config.modResults.contents.replace(/(package .*\n\n?)/, '$1import io.sentry.react.RNSentrySDK\n');
+            }
+        }
+        else {
+            (0, logger_1.warnOnce)(`Unsupported language '${config.modResults.language}' detected in '${fileName}', the native code won't be updated.`);
+        }
+        return config;
+    });
+}
+exports.modifyMainApplication = modifyMainApplication;

package/plugin/build/withSentryAndroidGradlePlugin.d.ts

@@ -9,7 +9,7 @@ export interface SentryAndroidGradlePluginOptions {
     includeNativeSources?: boolean;
     includeSourceContext?: boolean;
 }
-export declare const sentryAndroidGradlePluginVersion = "5.12.2";
+export declare const sentryAndroidGradlePluginVersion = "6.0.0";
 /**
  * Adds the Sentry Android Gradle Plugin to the project.
  * https://docs.sentry.io/platforms/react-native/manual-setup/manual-setup/#enable-sentry-agp