fix(replay): Do not capture replay for cached events (#4474)

* fix(replay): Do not capture replay for cached events

* Changelog

* Formatting

* Wording

* Still caputre replay for outbox events

Author: romtsn

CHANGELOG.md

@@ -11,6 +11,7 @@
     - This should reduce ANRs seen with this class in the stack trace for Android 14 and above
 - Pre-load modules on a background thread upon SDK init ([#4348](https://github.com/getsentry/sentry-java/pull/4348))
 - Session Replay: Fix inconsistent `segment_id` ([#4471](https://github.com/getsentry/sentry-java/pull/4471))
+- Session Replay: Do not capture current replay for cached events from the past ([#4474](https://github.com/getsentry/sentry-java/pull/4474))
 
 ## 7.22.5
 

sentry/src/main/java/io/sentry/SentryClient.java

@@ -3,7 +3,9 @@
 import io.sentry.clientreport.DiscardReason;
 import io.sentry.exception.SentryEnvelopeException;
 import io.sentry.hints.AbnormalExit;
+import io.sentry.hints.ApplyScopeData;
 import io.sentry.hints.Backfillable;
+import io.sentry.hints.Cached;
 import io.sentry.hints.DiskFlushNotification;
 import io.sentry.hints.TransactionEnd;
 import io.sentry.metrics.EncodedMetrics;
@@ -198,9 +200,12 @@ private boolean shouldApplyScopeData(final @NotNull CheckIn event, final @NotNul
     }
 
     final boolean isBackfillable = HintUtils.hasType(hint, Backfillable.class);
-    // if event is backfillable we don't wanna trigger capture replay, because it's an event from
-    // the past
-    if (event != null && !isBackfillable && (event.isErrored() || event.isCrashed())) {
+    final boolean isCached =
+        HintUtils.hasType(hint, Cached.class) && !HintUtils.hasType(hint, ApplyScopeData.class);
+    // if event is backfillable or cached we don't wanna trigger capture replay, because it's
+    // an event from the past. If it's cached, but with ApplyScopeData, it comes from the outbox
+    // folder and we still want to capture replay (e.g. a native captureException error)
+    if (event != null && !isBackfillable && !isCached && (event.isErrored() || event.isCrashed())) {
       options.getReplayController().captureReplay(event.isCrashed());
     }
 

sentry/src/test/java/io/sentry/SentryClientTest.kt

@@ -2800,6 +2800,52 @@ class SentryClientTest {
         assertFalse(called)
     }
 
+    @Test
+    fun `does not captureReplay for cached events`() {
+        var called = false
+        fixture.sentryOptions.setReplayController(object : ReplayController by NoOpReplayController.getInstance() {
+            override fun captureReplay(isTerminating: Boolean?) {
+                called = true
+            }
+        })
+        val sut = fixture.getSut()
+
+        sut.captureEvent(
+            SentryEvent().apply {
+                exceptions = listOf(
+                    SentryException().apply {
+                        mechanism = Mechanism().apply { isHandled = false }
+                    }
+                )
+            },
+            HintUtils.createWithTypeCheckHint(CachedHint())
+        )
+        assertFalse(called)
+    }
+
+    @Test
+    fun `captures replay for cached events with apply scope`() {
+        var called = false
+        fixture.sentryOptions.setReplayController(object : ReplayController by NoOpReplayController.getInstance() {
+            override fun captureReplay(isTerminating: Boolean?) {
+                called = true
+            }
+        })
+        val sut = fixture.getSut()
+
+        sut.captureEvent(
+            SentryEvent().apply {
+                exceptions = listOf(
+                    SentryException().apply {
+                        mechanism = Mechanism().apply { isHandled = false }
+                    }
+                )
+            },
+            HintUtils.createWithTypeCheckHint(CachedWithApplyScopeHint())
+        )
+        assertTrue(called)
+    }
+
     @Test
     fun `when beforeSendReplay is set, callback is invoked`() {
         var invoked = false
@@ -3123,6 +3169,10 @@ class SentryClientTest {
     private class BackfillableHint : Backfillable {
         override fun shouldEnrich(): Boolean = false
     }
+
+    private class CachedHint : Cached
+
+    private class CachedWithApplyScopeHint : Cached, ApplyScopeData
 }
 
 class DropEverythingEventProcessor : EventProcessor {