feat(replay): fail fast on swallowed Compose masking errors in CI

Add an internal SentryReplayDebug.failFast switch (gated on the
io.sentry.replay.compose.fail-fast system property) that re-throws the
exceptions ComposeViewHierarchyNode normally swallows in fromComposeNode
and fromView. Enabled in the sentry-samples-android app so our
release/obfuscated builds running on real devices in CI crash instead of
silently degrading masking. Defaults off, so customers are unaffected.

Also guard the on-device ReplayTest against GitHub-hosted emulators,
which can't capture screenshots reliably.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: romtsn

sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/ReplayTest.kt

@@ -8,11 +8,23 @@ import kotlin.test.Test
 import leakcanary.LeakAssertions
 import leakcanary.LeakCanary
 import org.awaitility.kotlin.await
+import org.hamcrest.CoreMatchers.`is`
+import org.junit.Assume.assumeThat
+import org.junit.Before
 import shark.AndroidReferenceMatchers
 import shark.IgnoredReferenceMatcher
 import shark.ReferencePattern
 
 class ReplayTest : BaseUiTest() {
+  @Before
+  fun setup() {
+    // we can't run on GH actions emulator, because they don't allow capturing screenshots properly
+    @Suppress("KotlinConstantConditions")
+    assumeThat(BuildConfig.ENVIRONMENT != "github", `is`(true))
+    // crash on swallowed Compose masking errors (e.g. broken obfuscated internals) so regressions
+    // fail this on-device test instead of silently under-masking (see SentryReplayDebug)
+    System.setProperty("io.sentry.replay.compose.fail-fast", "true")
+  }
 
   @Test
   fun composeReplayDoesNotLeak() {

sentry-android-replay/src/main/java/io/sentry/android/replay/util/SentryReplayDebug.kt

@@ -0,0 +1,26 @@
+package io.sentry.android.replay.util
+
+/**
+ * Internal, undocumented escape hatch used to make Session Replay fail fast instead of silently
+ * degrading masking when an exception is swallowed (e.g. unsupported/obfuscated Compose internals).
+ *
+ * It is intended to be enabled only in our own sample/UI-test apps that run on real devices in CI
+ * (which are release/obfuscated builds, so [io.sentry.android.replay.BuildConfig.DEBUG] can't be
+ * used), so that regressions surface as crashes rather than under-masked replays. Customers should
+ * never set this.
+ *
+ * Enable via:
+ * ```
+ * System.setProperty("io.sentry.replay.compose.fail-fast", "true")
+ * ```
+ */
+internal object SentryReplayDebug {
+  private const val FAIL_FAST_PROPERTY = "io.sentry.replay.compose.fail-fast"
+
+  /**
+   * Read live (not cached) so it's only evaluated on the error path and unit tests can toggle it
+   * between cases.
+   */
+  val failFast: Boolean
+    get() = "true".equals(System.getProperty(FAIL_FAST_PROPERTY), ignoreCase = true)
+}

sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt

@@ -22,6 +22,7 @@ import io.sentry.SentryLevel
 import io.sentry.SentryMaskingOptions
 import io.sentry.android.replay.SentryReplayModifiers
 import io.sentry.android.replay.util.ComposeTextLayout
+import io.sentry.android.replay.util.SentryReplayDebug
 import io.sentry.android.replay.util.boundsInWindow
 import io.sentry.android.replay.util.findPainter
 import io.sentry.android.replay.util.findTextColor
@@ -147,6 +148,12 @@ internal object ComposeViewHierarchyNode {
         )
       }
 
+      // fail fast in our own sample/UI-test apps (see SentryReplayDebug), so regressions surface
+      // as crashes instead of silently degrading masking
+      if (SentryReplayDebug.failFast) {
+        throw t
+      }
+
       // If we're unable to retrieve the semantics configuration
       // we should play safe and mask the whole node.
       return GenericViewHierarchyNode(
@@ -291,6 +298,11 @@ internal object ComposeViewHierarchyNode {
         """
           .trimIndent(),
       )
+      // fail fast in our own sample/UI-test apps (see SentryReplayDebug), so regressions surface
+      // as crashes instead of silently skipping the whole Compose subtree (i.e. not masking it)
+      if (SentryReplayDebug.failFast) {
+        throw e
+      }
       return false
     }
 

sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MyApplication.java

@@ -9,6 +9,11 @@ public class MyApplication extends Application {
 
   @Override
   public void onCreate() {
+    // Make Session Replay fail fast instead of silently degrading masking when an exception is
+    // swallowed (e.g. unsupported/obfuscated Compose internals). This way regressions surface as
+    // crashes in our release/obfuscated builds that run on real devices in CI. Only meant for our
+    // own sample/UI-test apps, customers should never set this.
+    System.setProperty("io.sentry.replay.compose.fail-fast", "true");
     Sentry.startProfiler();
     strictMode();
     super.onCreate();