Merge branch 'main' into fix/e2e-stable-checks

Author: antonis

CHANGELOG.md

@@ -10,6 +10,8 @@
 
 ### Fixes
 
+- Session replay will no longer start recording when an event was ignored or dropped. ([#5885](https://github.com/getsentry/sentry-react-native/pull/5885))
+- Capture native exceptions consumed by Expo's bridgeless error handling on Android ([#5871](https://github.com/getsentry/sentry-react-native/pull/5871))
 - Fix SIGABRT crash on launch when `mobileReplayIntegration` is not configured and iOS deployment target >= 16.0 ([#5858](https://github.com/getsentry/sentry-react-native/pull/5858))
 - Reduce `reactNavigationIntegration` performance overhead ([#5840](https://github.com/getsentry/sentry-react-native/pull/5840), [#5842](https://github.com/getsentry/sentry-react-native/pull/5842), [#5849](https://github.com/getsentry/sentry-react-native/pull/5849))
 - Fix duplicated breadcrumbs on Android ([#5841](https://github.com/getsentry/sentry-react-native/pull/5841))

packages/core/.npmignore

@@ -37,3 +37,4 @@
 !/expo.d.ts
 !/app.plugin.js
 !/plugin/build/**/*
+!/expo-module.config.json

packages/core/RNSentryAndroidTester/app/build.gradle

@@ -37,9 +37,12 @@ android {
     }
 }
 
+android.sourceSets.main.java.srcDirs += ['../../android/expo-handler/src/main/java']
+
 dependencies {
     implementation project(':RNSentry')
     implementation 'com.facebook.react:react-android:0.72.0'
+    implementation files('../../android/libs/expo-stubs.jar')
     implementation 'androidx.core:core-ktx:1.7.0'
     implementation 'androidx.appcompat:appcompat:1.4.1'
     implementation 'com.google.android.material:material:1.5.0'

packages/core/RNSentryAndroidTester/app/src/test/java/io/sentry/react/expo/SentryReactNativeHostHandlerTest.kt

@@ -0,0 +1,96 @@
+package io.sentry.react.expo
+
+import io.sentry.Sentry
+import io.sentry.exception.ExceptionMechanismException
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.mockito.MockedStatic
+import org.mockito.Mockito.mockStatic
+import org.mockito.kotlin.any
+import org.mockito.kotlin.argumentCaptor
+import org.mockito.kotlin.never
+import org.mockito.kotlin.verify
+
+@RunWith(JUnit4::class)
+class SentryReactNativeHostHandlerTest {
+    private var sentryMock: MockedStatic<Sentry>? = null
+
+    @After
+    fun tearDown() {
+        sentryMock?.close()
+    }
+
+    @Test
+    fun `does not capture when in developer support mode`() {
+        sentryMock =
+            mockStatic(Sentry::class.java).also {
+                it.`when`<Boolean> { Sentry.isEnabled() }.thenReturn(true)
+            }
+
+        val handler = SentryReactNativeHostHandler()
+        handler.onReactInstanceException(true, RuntimeException("test"))
+
+        sentryMock!!.verify({ Sentry.captureException(any()) }, never())
+    }
+
+    @Test
+    fun `does not capture when sentry is not enabled`() {
+        sentryMock =
+            mockStatic(Sentry::class.java).also {
+                it.`when`<Boolean> { Sentry.isEnabled() }.thenReturn(false)
+            }
+
+        val handler = SentryReactNativeHostHandler()
+        handler.onReactInstanceException(false, RuntimeException("test"))
+
+        sentryMock!!.verify({ Sentry.captureException(any()) }, never())
+    }
+
+    @Test
+    fun `captures exception with unhandled mechanism when sentry is enabled`() {
+        sentryMock =
+            mockStatic(Sentry::class.java).also {
+                it.`when`<Boolean> { Sentry.isEnabled() }.thenReturn(true)
+            }
+
+        val handler = SentryReactNativeHostHandler()
+        val originalException = IllegalStateException("Fabric crash")
+
+        handler.onReactInstanceException(false, originalException)
+
+        val captor = argumentCaptor<Throwable>()
+        sentryMock!!.verify { Sentry.captureException(captor.capture()) }
+
+        val captured = captor.firstValue
+        assertTrue(
+            "Expected ExceptionMechanismException but got ${captured::class.java}",
+            captured is ExceptionMechanismException,
+        )
+
+        val mechanismException = captured as ExceptionMechanismException
+        val mechanism = mechanismException.exceptionMechanism
+        assertEquals("expoReactHost", mechanism.type)
+        assertFalse("Mechanism should be unhandled", mechanism.isHandled!!)
+        assertEquals(originalException, mechanismException.throwable)
+        assertNotNull(mechanismException.thread)
+    }
+
+    @Test
+    fun `does not throw when sentry capture fails`() {
+        sentryMock =
+            mockStatic(Sentry::class.java).also {
+                it.`when`<Boolean> { Sentry.isEnabled() }.thenReturn(true)
+                it.`when`<Any> { Sentry.captureException(any()) }.thenThrow(RuntimeException("Sentry internal error"))
+            }
+
+        val handler = SentryReactNativeHostHandler()
+        // Should not throw
+        handler.onReactInstanceException(false, IllegalStateException("test"))
+    }
+}

packages/core/android/expo-handler/build.gradle

@@ -0,0 +1,20 @@
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion 31
+    namespace = "io.sentry.react.expo"
+
+    defaultConfig {
+        minSdkVersion 21
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+}
+
+dependencies {
+    compileOnly project(':expo-modules-core')
+    compileOnly 'io.sentry:sentry-android:8.36.0'
+}

packages/core/android/expo-handler/src/main/java/io/sentry/react/expo/SentryExpoPackage.java

@@ -0,0 +1,22 @@
+package io.sentry.react.expo;
+
+import android.content.Context;
+import expo.modules.core.interfaces.Package;
+import expo.modules.core.interfaces.ReactNativeHostHandler;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Expo package that registers {@link SentryReactNativeHostHandler} to capture native exceptions
+ * swallowed by Expo's bridgeless error handling.
+ *
+ * <p>This package is auto-discovered by Expo's autolinking system when {@code @sentry/react-native}
+ * is installed in an Expo project. It is not used in non-Expo React Native projects.
+ */
+public class SentryExpoPackage implements Package {
+
+  @Override
+  public List<? extends ReactNativeHostHandler> createReactNativeHostHandlers(Context context) {
+    return Collections.singletonList(new SentryReactNativeHostHandler());
+  }
+}

packages/core/android/expo-handler/src/main/java/io/sentry/react/expo/SentryReactNativeHostHandler.java

@@ -0,0 +1,48 @@
+package io.sentry.react.expo;
+
+import androidx.annotation.NonNull;
+import expo.modules.core.interfaces.ReactNativeHostHandler;
+import io.sentry.Sentry;
+import io.sentry.exception.ExceptionMechanismException;
+import io.sentry.protocol.Mechanism;
+
+/**
+ * Captures native Android exceptions that are routed through Expo's {@code
+ * ExpoReactHostDelegate.handleInstanceException}.
+ *
+ * <p>On Expo SDK 53+, certain native exceptions (e.g., IllegalStateException from Fabric's
+ * SurfaceMountingManager) are caught by React Native and routed to {@code handleInstanceException}.
+ * Expo's implementation iterates registered host handlers but does not rethrow, so the exception
+ * never reaches Java's {@code UncaughtExceptionHandler} which Sentry relies on for crash capture.
+ *
+ * <p>This handler captures those exceptions directly via {@code Sentry.captureException} with an
+ * unhandled mechanism, ensuring they appear as crashes in Sentry.
+ */
+public class SentryReactNativeHostHandler implements ReactNativeHostHandler {
+
+  private static final String MECHANISM_TYPE = "expoReactHost";
+
+  @Override
+  public void onReactInstanceException(boolean useDeveloperSupport, @NonNull Exception exception) {
+    if (useDeveloperSupport) {
+      return;
+    }
+
+    if (!Sentry.isEnabled()) {
+      return;
+    }
+
+    try { // NOPMD - We don't want to crash in any case
+      final Mechanism mechanism = new Mechanism();
+      mechanism.setType(MECHANISM_TYPE);
+      mechanism.setHandled(false);
+
+      final ExceptionMechanismException mechanismException =
+          new ExceptionMechanismException(mechanism, exception, Thread.currentThread());
+
+      Sentry.captureException(mechanismException);
+    } catch (Throwable ignored) { // NOPMD - We don't want to crash in any case
+      // ignore
+    }
+  }
+}

packages/core/android/expo-stubs/README.md

@@ -0,0 +1,7 @@
+This module provides stubs for `expo-modules-core` interfaces (`Package` and `ReactNativeHostHandler`) needed to compile the Expo handler tests in `RNSentryAndroidTester`.
+
+The Expo handler (`android/expo-handler/`) registers a `ReactNativeHostHandler` that captures native exceptions swallowed by Expo's bridgeless error handling (`ExpoReactHostDelegate.handleInstanceException`). In Expo projects, the handler is compiled against the real `expo-modules-core` project. For unit testing in `RNSentryAndroidTester` (which doesn't have Expo), these stubs provide the interfaces at compile time.
+
+## Updating the stubs
+
+To update the stubs, just run `yarn build` from the root of the repo and it will recompile the classes and put them under `packages/core/android/libs/expo-stubs.jar`. Check this newly generated `.jar` in and push.

packages/core/android/expo-stubs/build.gradle

@@ -0,0 +1,23 @@
+allprojects {
+  repositories {
+    mavenCentral()
+    google()
+  }
+}
+
+apply plugin: 'java-library'
+
+java {
+  sourceCompatibility = JavaVersion.VERSION_1_8
+  targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+tasks.named('jar', Jar) {
+  archiveBaseName.set('expo-stubs')
+  archiveVersion.set('')
+  destinationDirectory.set(file("$rootDir/../libs"))
+}
+
+dependencies {
+  compileOnly 'com.google.android:android:4.1.1.4'
+}