Merge branch 'main' into v8

# Conflicts:
#	CHANGELOG.md
#	packages/core/android/src/main/java/io/sentry/react/RNSentryModuleImpl.java

Author: antonis

CHANGELOG.md

@@ -10,6 +10,19 @@
 
 ### Features
 
+- Extends the experimental support of UI profiling to iOS ([#5611](https://github.com/getsentry/sentry-react-native/pull/5611))
+  ```js
+  Sentry.init({
+    _experiments: {
+      profilingOptions: {
+        profileSessionSampleRate: 1.0,
+        lifecycle: 'trace', // or 'manual'
+        startOnAppStart: true,
+      },
+    },
+  });
+  ```
+  - Note that the `androidProfilingOptions` key is now deprecated, and `profilingOptions` should be used instead
 - Add performance tracking for Expo Router route prefetching ([#5606](https://github.com/getsentry/sentry-react-native/pull/5606))
   - New `wrapExpoRouter` utility to instrument manual `prefetch()` calls with performance spans
   - New `enablePrefetchTracking` option for `reactNavigationIntegration` to automatically track PRELOAD actions
@@ -31,6 +44,10 @@
   });
   ```
 
+### Fixes
+
+- Fix `SENTRY_ALLOW_FAILURE` environment variable not being respected in Xcode build scripts ([#5616](https://github.com/getsentry/sentry-react-native/pull/5616))
+
 ### Dependencies
 
 - Bump Cocoa SDK from v9.1.0 to v9.3.0 ([#5515](https://github.com/getsentry/sentry-react-native/pull/5515))

dev-packages/e2e-tests/patch-scripts/rn.patch.app.js

@@ -27,9 +27,7 @@ Sentry.init({
   release: '${SENTRY_RELEASE}',
   dist: '${SENTRY_DIST}',
   dsn: 'https://1df17bd4e543fdb31351dee1768bb679@o447951.ingest.sentry.io/5428561',
-  _experiments: {
-    replaysOnErrorSampleRate: LaunchArguments.value().replaysOnErrorSampleRate,
-  },
+  replaysOnErrorSampleRate: LaunchArguments.value().replaysOnErrorSampleRate,
   integrations: [
     Sentry.mobileReplayIntegration(),
     Sentry.feedbackIntegration({

packages/core/android/src/main/java/io/sentry/react/RNSentryStart.java

@@ -205,65 +205,61 @@ private static void configureAndroidProfiling(
     }
 
     @Nullable final ReadableMap experiments = rnOptions.getMap("_experiments");
-    if (experiments == null || !experiments.hasKey("androidProfilingOptions")) {
+    if (experiments == null || !experiments.hasKey("profilingOptions")) {
       return;
     }
 
-    @Nullable
-    final ReadableMap androidProfilingOptions = experiments.getMap("androidProfilingOptions");
-    if (androidProfilingOptions == null) {
+    @Nullable final ReadableMap profilingOptions = experiments.getMap("profilingOptions");
+    if (profilingOptions == null) {
       return;
     }
 
     // Set profile session sample rate
-    if (androidProfilingOptions.hasKey("profileSessionSampleRate")) {
-      if (androidProfilingOptions.getType("profileSessionSampleRate") == ReadableType.Number) {
+    if (profilingOptions.hasKey("profileSessionSampleRate")) {
+      if (profilingOptions.getType("profileSessionSampleRate") == ReadableType.Number) {
         final double profileSessionSampleRate =
-            androidProfilingOptions.getDouble("profileSessionSampleRate");
+            profilingOptions.getDouble("profileSessionSampleRate");
         options.setProfileSessionSampleRate(profileSessionSampleRate);
         logger.log(
             SentryLevel.INFO,
             String.format(
-                "Android UI Profiling profileSessionSampleRate set to: %.2f",
-                profileSessionSampleRate));
+                "UI Profiling profileSessionSampleRate set to: %.2f", profileSessionSampleRate));
       } else {
         logger.log(
             SentryLevel.WARNING,
-            "Android UI Profiling profileSessionSampleRate must be a number, ignoring invalid"
-                + " value");
+            "UI Profiling profileSessionSampleRate must be a number, ignoring invalid value");
       }
     }
 
     // Set profiling lifecycle mode
-    if (androidProfilingOptions.hasKey("lifecycle")) {
-      if (androidProfilingOptions.getType("lifecycle") == ReadableType.String) {
-        final String lifecycle = androidProfilingOptions.getString("lifecycle");
+    if (profilingOptions.hasKey("lifecycle")) {
+      if (profilingOptions.getType("lifecycle") == ReadableType.String) {
+        final String lifecycle = profilingOptions.getString("lifecycle");
         if ("manual".equalsIgnoreCase(lifecycle)) {
           options.setProfileLifecycle(ProfileLifecycle.MANUAL);
-          logger.log(SentryLevel.INFO, "Android UI Profile Lifecycle set to MANUAL");
+          logger.log(SentryLevel.INFO, "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");
+          logger.log(SentryLevel.INFO, "UI Profile Lifecycle set to TRACE");
         }
       } else {
         logger.log(
-            SentryLevel.WARNING,
-            "Android UI Profiling lifecycle must be a string, ignoring invalid value");
+            SentryLevel.WARNING, "UI Profiling lifecycle must be a string, ignoring invalid value");
       }
     }
 
     // Set start on app start
-    if (androidProfilingOptions.hasKey("startOnAppStart")) {
-      if (androidProfilingOptions.getType("startOnAppStart") == ReadableType.Boolean) {
-        final boolean startOnAppStart = androidProfilingOptions.getBoolean("startOnAppStart");
+    if (profilingOptions.hasKey("startOnAppStart")) {
+      if (profilingOptions.getType("startOnAppStart") == ReadableType.Boolean) {
+        final boolean startOnAppStart = profilingOptions.getBoolean("startOnAppStart");
         options.setStartProfilerOnAppStart(startOnAppStart);
         logger.log(
             SentryLevel.INFO,
-            String.format("Android UI Profiling startOnAppStart set to %b", startOnAppStart));
+            String.format("UI Profiling startOnAppStart set to %b", startOnAppStart));
       } else {
         logger.log(
             SentryLevel.WARNING,
-            "Android UI Profiling startOnAppStart must be a boolean, ignoring invalid value");
+            "UI Profiling startOnAppStart must be a boolean, ignoring invalid value");
       }
     }
   }

packages/core/ios/RNSentryExperimentalOptions.h

@@ -37,6 +37,14 @@ NS_ASSUME_NONNULL_BEGIN
 + (void)setEnableSessionReplayInUnreliableEnvironment:(BOOL)enabled
                                         sentryOptions:(SentryOptions *)sentryOptions;
 
+/**
+ * Configures iOS UI profiling options on SentryOptions
+ * @param profilingOptions Dictionary containing profiling configuration
+ * @param sentryOptions The SentryOptions instance to configure
+ */
++ (void)configureProfilingWithOptions:(NSDictionary *)profilingOptions
+                        sentryOptions:(SentryOptions *)sentryOptions;
+
 @end
 
 NS_ASSUME_NONNULL_END

packages/core/ios/RNSentryExperimentalOptions.m

@@ -1,4 +1,5 @@
 #import "RNSentryExperimentalOptions.h"
+#import <Sentry/SentryProfilingConditionals.h>
 @import Sentry;
 
 @implementation RNSentryExperimentalOptions
@@ -36,4 +37,45 @@ + (void)setEnableSessionReplayInUnreliableEnvironment:(BOOL)enabled
     sentryOptions.experimental.enableSessionReplayInUnreliableEnvironment = enabled;
 }
 
++ (void)configureProfilingWithOptions:(NSDictionary *)profilingOptions
+                        sentryOptions:(SentryOptions *)sentryOptions
+{
+#if SENTRY_TARGET_PROFILING_SUPPORTED
+    if (sentryOptions == nil || profilingOptions == nil) {
+        return;
+    }
+
+    sentryOptions.configureProfiling = ^(SentryProfileOptions *_Nonnull profiling) {
+        // Set session sample rate
+        id profileSessionSampleRate = profilingOptions[@"profileSessionSampleRate"];
+        if (profileSessionSampleRate != nil &&
+            [profileSessionSampleRate isKindOfClass:[NSNumber class]]) {
+            profiling.sessionSampleRate = [profileSessionSampleRate floatValue];
+            NSLog(@"Sentry: UI Profiling sessionSampleRate set to: %.2f",
+                profiling.sessionSampleRate);
+        }
+
+        // Set lifecycle mode
+        NSString *lifecycle = profilingOptions[@"lifecycle"];
+        if ([lifecycle isKindOfClass:[NSString class]]) {
+            if ([lifecycle caseInsensitiveCompare:@"manual"] == NSOrderedSame) {
+                profiling.lifecycle = SentryProfileLifecycleManual;
+                NSLog(@"Sentry: UI Profiling Lifecycle set to MANUAL");
+            } else if ([lifecycle caseInsensitiveCompare:@"trace"] == NSOrderedSame) {
+                profiling.lifecycle = SentryProfileLifecycleTrace;
+                NSLog(@"Sentry: UI Profiling Lifecycle set to TRACE");
+            }
+        }
+
+        // Set profile app starts
+        id startOnAppStart = profilingOptions[@"startOnAppStart"];
+        if (startOnAppStart != nil && [startOnAppStart isKindOfClass:[NSNumber class]]) {
+            profiling.profileAppStarts = [startOnAppStart boolValue];
+            NSLog(@"Sentry: UI Profiling profileAppStarts set to %@",
+                profiling.profileAppStarts ? @"YES" : @"NO");
+        }
+    };
+#endif
+}
+
 @end

packages/core/ios/SentrySDKWrapper.m

@@ -106,6 +106,13 @@ + (SentryOptions *)createOptionsWithDictionary:(NSDictionary *)options
             [experiments[@"enableUnhandledCPPExceptionsV2"] boolValue];
         [RNSentryExperimentalOptions setEnableUnhandledCPPExceptionsV2:enableUnhandledCPPExceptions
                                                          sentryOptions:sentryOptions];
+
+        // Configure iOS UI Profiling
+        NSDictionary *profilingOptions = experiments[@"profilingOptions"];
+        if (profilingOptions != nil && [profilingOptions isKindOfClass:[NSDictionary class]]) {
+            [RNSentryExperimentalOptions configureProfilingWithOptions:profilingOptions
+                                                         sentryOptions:sentryOptions];
+        }
     }
 
     if (isSessionReplayEnabled) {

packages/core/scripts/sentry-xcode-debug-files.sh

@@ -70,11 +70,17 @@ else
   # 'warning:' triggers a warning in Xcode, 'error:' triggers an error
   set +x +e # disable printing commands otherwise we might print `error:` by accident and allow continuing on error
   SENTRY_UPLOAD_COMMAND_OUTPUT=$(/bin/sh -c "\"$LOCAL_NODE_BINARY\" $UPLOAD_DEBUG_FILES" 2>&1)
-  if [ $? -eq 0 ]; then
+  UPLOAD_EXIT_CODE=$?
+  if [ $UPLOAD_EXIT_CODE -eq 0 ]; then
     echo "$SENTRY_UPLOAD_COMMAND_OUTPUT" | awk '{print "output: sentry-cli - " $0}'
   else
-    echo "error: sentry-cli - To disable native debug files auto upload, set SENTRY_DISABLE_AUTO_UPLOAD=true in your environment variables. Or to allow failing upload, set SENTRY_ALLOW_FAILURE=true"
-    echo "error: sentry-cli - $SENTRY_UPLOAD_COMMAND_OUTPUT"
+    if [ "$SENTRY_ALLOW_FAILURE" == true ]; then
+      echo "warning: sentry-cli - Debug files upload failed, but continuing build because SENTRY_ALLOW_FAILURE=true"
+      echo "warning: sentry-cli - $SENTRY_UPLOAD_COMMAND_OUTPUT"
+    else
+      echo "error: sentry-cli - To disable native debug files auto upload, set SENTRY_DISABLE_AUTO_UPLOAD=true in your environment variables. Or to allow failing upload, set SENTRY_ALLOW_FAILURE=true"
+      echo "error: sentry-cli - $SENTRY_UPLOAD_COMMAND_OUTPUT"
+    fi
   fi
   set -x -e # re-enable
 fi

packages/core/scripts/sentry-xcode.sh

@@ -56,9 +56,14 @@ if [ "$SENTRY_DISABLE_AUTO_UPLOAD" != true ]; then
   if [ $? -eq 0 ]; then
     echo "$SENTRY_XCODE_COMMAND_OUTPUT" | awk '{print "output: sentry-cli - " $0}'
   else
-    echo "error: sentry-cli - To disable source maps auto upload, set SENTRY_DISABLE_AUTO_UPLOAD=true in your environment variables. Or to allow failing upload, set SENTRY_ALLOW_FAILURE=true"
-    echo "error: sentry-cli - $SENTRY_XCODE_COMMAND_OUTPUT"
-    exitCode=1
+    if [ "$SENTRY_ALLOW_FAILURE" == true ]; then
+      echo "warning: sentry-cli - Source maps upload failed, but continuing build because SENTRY_ALLOW_FAILURE=true"
+      echo "warning: sentry-cli - $SENTRY_XCODE_COMMAND_OUTPUT"
+    else
+      echo "error: sentry-cli - To disable source maps auto upload, set SENTRY_DISABLE_AUTO_UPLOAD=true in your environment variables. Or to allow failing upload, set SENTRY_ALLOW_FAILURE=true"
+      echo "error: sentry-cli - $SENTRY_XCODE_COMMAND_OUTPUT"
+      exitCode=1
+    fi
   fi
   set -x -e # re-enable
 else

packages/core/src/js/client.ts

@@ -224,7 +224,8 @@ export class ReactNativeClient extends Client<ReactNativeClientOptions> {
         'options' in this._integrations[MOBILE_REPLAY_INTEGRATION_NAME]
           ? (this._integrations[MOBILE_REPLAY_INTEGRATION_NAME] as ReturnType<typeof mobileReplayIntegration>).options
           : undefined,
-      androidProfilingOptions: this._options._experiments?.androidProfilingOptions,
+      profilingOptions:
+        this._options._experiments?.profilingOptions ?? this._options._experiments?.androidProfilingOptions,
     })
       .then(
         (result: boolean) => {

packages/core/src/js/options.ts

@@ -294,16 +294,26 @@ export interface BaseReactNativeOptions {
      */
     enableUnhandledCPPExceptionsV2?: boolean;
 
+    /**
+     * Configuration options for UI profiling.
+     * It supports two modes: `manual` and `trace`.
+     * - In `trace` mode, the profiler runs based on active sampled spans.
+     * - In `manual` mode, profiling is controlled via start/stop API calls.
+     *
+     * @experimental
+     */
+    profilingOptions?: ProfilingOptions;
+
     /**
      * Configuration options for Android UI profiling.
-     * UI profiling supports two modes: `manual` and `trace`.
+     * It supports two modes: `manual` and `trace`.
      * - In `trace` mode, the profiler runs based on active sampled spans.
      * - In `manual` mode, profiling is controlled via start/stop API calls.
      *
      * @experimental
-     * @platform android
+     * @deprecated Use `profilingOptions` instead. This option will be removed in the next major version.
      */
-    androidProfilingOptions?: AndroidProfilingOptions;
+    androidProfilingOptions?: ProfilingOptions;
   };
 
   /**
@@ -342,19 +352,18 @@ export interface BaseReactNativeOptions {
 export type SentryReplayQuality = 'low' | 'medium' | 'high';
 
 /**
- * Android UI profiling lifecycle modes.
+ * UI profiling lifecycle modes.
  * - `trace`: Profiler runs based on active sampled spans
  * - `manual`: Profiler is controlled manually via start/stop API calls
  */
-export type AndroidProfilingLifecycle = 'trace' | 'manual';
+export type ProfilingLifecycle = 'trace' | 'manual';
 
 /**
- * Configuration options for Android UI profiling.
+ * Configuration options for UI profiling.
  *
  * @experimental
- * @platform android
  */
-export interface AndroidProfilingOptions {
+export interface ProfilingOptions {
   /**
    * Sample rate for profiling sessions.
    * This is evaluated once per session and determines if profiling should be enabled for that session.
@@ -369,9 +378,9 @@ export interface AndroidProfilingOptions {
    * - `trace`: Profiler runs while there is at least one active sampled span
    * - `manual`: Profiler is controlled manually via Sentry.profiler.startProfiler/stopProfiler
    *
-   * @default 'trace'
+   * @default 'manual'
    */
-  lifecycle?: AndroidProfilingLifecycle;
+  lifecycle?: ProfilingLifecycle;
 
   /**
    * Enable profiling on app start.