From 27b35e1241134b10682e48406ea96cbaa0d67ab7 Mon Sep 17 00:00:00 2001 From: Ioannis J Date: Wed, 18 Nov 2026 15:50:15 +0200 Subject: [PATCH 1/5] fix: drop replay debug keys while session replay is off --- .changeset/shy-badgers-wander.md | 6 + .../json/snapshots/batch-request.json | 27 +- posthog/src/main/java/com/posthog/PostHog.kt | 17 + .../posthog/internal/PostHogRemoteConfig.kt | 9 + .../src/test/java/com/posthog/PostHogTest.kt | 325 +++++++++++++++++- 5 files changed, 355 insertions(+), 29 deletions(-) create mode 100644 .changeset/shy-badgers-wander.md diff --git a/.changeset/shy-badgers-wander.md b/.changeset/shy-badgers-wander.md new file mode 100644 index 000000000..e97625b92 --- /dev/null +++ b/.changeset/shy-badgers-wander.md @@ -0,0 +1,6 @@ +--- +"posthog": patch +"posthog-android": patch +--- + +Stop sending `$sdk_debug_replay_*` and `$sdk_debug_session_start` on events while session replay is intentionally off (disabled in config, stopped by the app, or turned off remotely). `$recording_status` is still sent as `disabled`. Sampled-out and trigger-pending sessions are unchanged. diff --git a/posthog-android/src/test/resources/json/snapshots/batch-request.json b/posthog-android/src/test/resources/json/snapshots/batch-request.json index c9d3b3997..f06af5842 100644 --- a/posthog-android/src/test/resources/json/snapshots/batch-request.json +++ b/posthog-android/src/test/resources/json/snapshots/batch-request.json @@ -55,10 +55,7 @@ "$is_identified": false, "$process_person_profile": true, "$sdk_debug_pending_queue_size": "", - "$recording_status": "disabled", - "$sdk_debug_replay_event_trigger_status": "trigger_disabled", - "$sdk_debug_replay_linked_flag_trigger_status": "trigger_disabled", - "$sdk_debug_replay_internal_buffer_length": 0 + "$recording_status": "disabled" }, "timestamp": "2023-11-14T22:13:20.123Z", "uuid": "" @@ -101,12 +98,7 @@ "$is_identified": true, "$process_person_profile": true, "$sdk_debug_pending_queue_size": "", - "$recording_status": "disabled", - "$sdk_debug_replay_event_trigger_status": "trigger_disabled", - "$sdk_debug_replay_linked_flag_trigger_status": "trigger_disabled", - "$sdk_debug_replay_capture_mode": "wireframe", - "$sdk_debug_replay_internal_buffer_length": 0, - "$sdk_debug_session_start": 1700000000123 + "$recording_status": "disabled" }, "timestamp": "2023-11-14T22:13:20.123Z", "uuid": "" @@ -145,10 +137,7 @@ "$is_identified": true, "$process_person_profile": true, "$sdk_debug_pending_queue_size": "", - "$recording_status": "disabled", - "$sdk_debug_replay_event_trigger_status": "trigger_disabled", - "$sdk_debug_replay_linked_flag_trigger_status": "trigger_disabled", - "$sdk_debug_replay_internal_buffer_length": 0 + "$recording_status": "disabled" }, "timestamp": "2023-11-14T22:13:20.123Z", "uuid": "" @@ -194,10 +183,7 @@ "$is_identified": true, "$process_person_profile": true, "$sdk_debug_pending_queue_size": "", - "$recording_status": "disabled", - "$sdk_debug_replay_event_trigger_status": "trigger_disabled", - "$sdk_debug_replay_linked_flag_trigger_status": "trigger_disabled", - "$sdk_debug_replay_internal_buffer_length": 0 + "$recording_status": "disabled" }, "timestamp": "2023-11-14T22:13:20.123Z", "uuid": "" @@ -295,10 +281,7 @@ "$is_identified": true, "$process_person_profile": true, "$sdk_debug_pending_queue_size": "", - "$recording_status": "disabled", - "$sdk_debug_replay_event_trigger_status": "trigger_disabled", - "$sdk_debug_replay_linked_flag_trigger_status": "trigger_disabled", - "$sdk_debug_replay_internal_buffer_length": 0 + "$recording_status": "disabled" }, "timestamp": "2023-11-14T22:13:20.123Z", "uuid": "" diff --git a/posthog/src/main/java/com/posthog/PostHog.kt b/posthog/src/main/java/com/posthog/PostHog.kt index dd7a1dbe3..8a1e99588 100644 --- a/posthog/src/main/java/com/posthog/PostHog.kt +++ b/posthog/src/main/java/com/posthog/PostHog.kt @@ -872,6 +872,15 @@ public class PostHog private constructor( if (timestamp != null && managerStart > 0 && timestamp.time < managerStart) { return props } + if (isSessionReplayIntentionallyOff()) { + props["\$recording_status"] = "disabled" + try { + queue?.size?.let { props["\$sdk_debug_pending_queue_size"] = it } + } catch (e: Throwable) { + props["\$sdk_debug_error_capturing_properties"] = e.toString().take(MAX_DEBUG_ERROR_LENGTH) + } + return props + } val claimed = claimReplayDebugBundle() // Guarded separately from the session and queue keys below: those come from the session // manager and the queue, not from replay, so a handler that throws must not suppress them. @@ -2607,6 +2616,14 @@ public class PostHog private constructor( return config?.sessionReplay == true } + // Not off while sampled out, awaiting remote config, or waiting on a trigger: those keys explain + // why replay isn't recording. + private fun isSessionReplayIntentionallyOff(): Boolean { + return sessionReplayHandler == null || + !sessionReplayWanted || + remoteConfig?.isSessionRecordingRemotelyDisabled() == true + } + // this is used in cases where we know the session is already active // so we spare another locker private fun isSessionReplayFlagEnabled(): Boolean { diff --git a/posthog/src/main/java/com/posthog/internal/PostHogRemoteConfig.kt b/posthog/src/main/java/com/posthog/internal/PostHogRemoteConfig.kt index b941a52ed..023ae4111 100644 --- a/posthog/src/main/java/com/posthog/internal/PostHogRemoteConfig.kt +++ b/posthog/src/main/java/com/posthog/internal/PostHogRemoteConfig.kt @@ -181,6 +181,11 @@ public class PostHogRemoteConfig( @Volatile private var sessionRecordingMinimumDurationMs: Long? = null + // The last /config said replay is off (sessionRecording false, or mobile recordings quota limited). + // Kept across clear(), like the cached session replay config. + @Volatile + private var sessionRecordingRemotelyDisabled = false + init { preloadSessionRecordingConfig() preloadSurveys() @@ -329,8 +334,10 @@ public class PostHogRemoteConfig( Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts""", ) processSessionRecordingConfig(false) + sessionRecordingRemotelyDisabled = true } else { processSessionRecordingConfig(it.sessionRecording) + sessionRecordingRemotelyDisabled = it.sessionRecording == false } processSurveys(it.surveys) processErrorTrackingConfig(it.errorTracking) @@ -1395,6 +1402,8 @@ public class PostHogRemoteConfig( */ public fun hasRemoteConfigFetched(): Boolean = remoteConfigHasFetched.get() + internal fun isSessionRecordingRemotelyDisabled(): Boolean = sessionRecordingRemotelyDisabled + /** * Makes a sampling decision for session recording based on the sample rate * from remote config and the given session ID. diff --git a/posthog/src/test/java/com/posthog/PostHogTest.kt b/posthog/src/test/java/com/posthog/PostHogTest.kt index fd2904b54..b0de5d352 100644 --- a/posthog/src/test/java/com/posthog/PostHogTest.kt +++ b/posthog/src/test/java/com/posthog/PostHogTest.kt @@ -3874,7 +3874,8 @@ internal class PostHogTest { val http = mockHttp() val url = http.url("/") val integration = replayHandlerWithFullBundle() - val sut = getSut(url.toString(), preloadFeatureFlags = false, reloadFeatureFlags = false, integration = integration) + val sut = + getSut(url.toString(), sessionReplay = true, preloadFeatureFlags = false, reloadFeatureFlags = false, integration = integration) sut.startSession() sut.capture(EVENT) @@ -3911,7 +3912,8 @@ internal class PostHogTest { "\$sdk_debug_replay_capture_mode" to "wireframe", ) } - val sut = getSut(url.toString(), preloadFeatureFlags = false, reloadFeatureFlags = false, integration = integration) + val sut = + getSut(url.toString(), sessionReplay = true, preloadFeatureFlags = false, reloadFeatureFlags = false, integration = integration) sut.captureException(RuntimeException("boom")) @@ -3966,7 +3968,8 @@ internal class PostHogTest { "\$sdk_debug_replay_capture_mode" to "screenshot", ) } - val sut = getSut(url.toString(), preloadFeatureFlags = false, reloadFeatureFlags = false, integration = integration) + val sut = + getSut(url.toString(), sessionReplay = true, preloadFeatureFlags = false, reloadFeatureFlags = false, integration = integration) sut.capture(SDK_EVENT) @@ -3991,7 +3994,8 @@ internal class PostHogTest { PostHogSessionReplayHandlerFake(true).apply { debugProperties = mapOf("\$recording_status" to "active") } - val sut = getSut(url.toString(), preloadFeatureFlags = false, reloadFeatureFlags = false, integration = integration) + val sut = + getSut(url.toString(), sessionReplay = true, preloadFeatureFlags = false, reloadFeatureFlags = false, integration = integration) sut.register("\$recording_status", "registered") sut.capture(EVENT, properties = mapOf("\$recording_status" to "caller", "\$sdk_debug_pending_queue_size" to -1)) @@ -4047,7 +4051,8 @@ internal class PostHogTest { PostHogSessionReplayHandlerFake(true).apply { throwOnDebugProperties = true } - val sut = getSut(url.toString(), preloadFeatureFlags = false, reloadFeatureFlags = false, integration = integration) + val sut = + getSut(url.toString(), sessionReplay = true, preloadFeatureFlags = false, reloadFeatureFlags = false, integration = integration) sut.capture(SDK_EVENT) @@ -4102,8 +4107,299 @@ internal class PostHogTest { reloadFeatureFlags = false, integration = replayHandlerWithFullBundle(), beforeSend = beforeSend, + sessionReplay = true, ) + private fun assertReplayOffShape(props: Map) { + assertEquals("disabled", props["\$recording_status"]) + assertTrue( + props.keys.none { it.startsWith("\$sdk_debug_replay_") }, + "unexpected replay keys: ${props.keys.filter { it.startsWith("\$sdk_debug_replay_") }}", + ) + assertFalse(props.containsKey("\$sdk_debug_session_start")) + assertNotNull(props["\$sdk_debug_pending_queue_size"]) + } + + private fun assertReplayDebugKeysKept(props: Map) { + assertEquals("buffering", props["\$recording_status"]) + assertEquals("trigger_pending", props["\$sdk_debug_replay_event_trigger_status"]) + assertEquals("trigger_disabled", props["\$sdk_debug_replay_linked_flag_trigger_status"]) + assertNotNull(props["\$sdk_debug_replay_internal_buffer_length"]) + assertNotNull(props["\$sdk_debug_pending_queue_size"]) + } + + private fun replayRemoteConfigServer( + configBody: String, + release: CountDownLatch? = null, + ): MockWebServer { + val http = httpServers.create() + http.dispatcher = + object : Dispatcher() { + override fun dispatch(request: RecordedRequest): MockResponse { + if (request.path?.endsWith("/config") == true) { + release?.await() + return MockResponse().setBody(configBody) + } + return MockResponse().setBody("") + } + } + http.start() + return http + } + + private fun capturedBatchEvents(http: MockWebServer): List { + queueExecutor.shutdownAndAwaitTermination() + while (true) { + val request = assertNotNull(http.takeRequest(5, TimeUnit.SECONDS)) + if (request.path!!.contains("/batch")) { + return serializer.deserialize(request.body.unGzip().reader())!!.batch + } + } + } + + private fun replayRemoteConfigSut(http: MockWebServer): PostHogInterface = + getSut( + http.url("/").toString(), + preloadFeatureFlags = false, + integration = replayHandlerWithFullBundle(), + remoteConfig = true, + sessionReplay = true, + ).also { remoteConfigExecutor.shutdownAndAwaitTermination() } + + @Test + fun `replay disabled in config sends only recording status`() { + val http = mockHttp() + val sut = + getSut( + http.url("/").toString(), + flushAt = 2, + preloadFeatureFlags = false, + reloadFeatureFlags = false, + integration = replayHandlerWithFullBundle(), + ) + sut.startSession() + + sut.capture(EVENT) + sut.capture(SDK_EVENT) + + capturedEvents(http).forEach { assertReplayOffShape(it.properties!!) } + + sut.close() + } + + @Test + fun `explicit stopSessionReplay sends only recording status`() { + val http = mockHttp() + val sut = replayDebugSut(http, flushAt = 1) + sut.startSession() + sut.stopSessionReplay() + + sut.capture(SDK_EVENT) + + assertReplayOffShape(capturedEvents(http).first().properties!!) + + sut.close() + } + + @Test + fun `remote Boolean false sends only recording status`() { + val http = replayRemoteConfigServer("""{"sessionRecording": false}""") + val sut = replayRemoteConfigSut(http) + sut.startSession() + + sut.capture(SDK_EVENT) + + assertReplayOffShape(capturedBatchEvents(http).first().properties!!) + + sut.close() + } + + @Test + fun `quota limited sends only recording status`() { + val http = + replayRemoteConfigServer("""{"sessionRecording": {"endpoint": "/s/"}, "quotaLimited": ["mobile_recordings"]}""") + val sut = replayRemoteConfigSut(http) + sut.startSession() + + sut.capture(SDK_EVENT) + + assertReplayOffShape(capturedBatchEvents(http).first().properties!!) + + sut.close() + } + + @Test + fun `remote config without a sessionRecording key sends only recording status`() { + val http = replayRemoteConfigServer("""{"hasFeatureFlags": false}""") + val sut = replayRemoteConfigSut(http) + sut.startSession() + + sut.capture(SDK_EVENT) + + assertReplayOffShape(capturedBatchEvents(http).first().properties!!) + + sut.close() + } + + @Test + fun `no remote config yet keeps replay debug keys`() { + val http = mockHttp() + val sut = replayDebugSut(http, flushAt = 1) + sut.startSession() + + sut.capture(SDK_EVENT) + + assertReplayDebugKeysKept(capturedEvents(http).first().properties!!) + + sut.close() + } + + @Test + fun `sampled out session keeps replay debug keys`() { + val http = replayRemoteConfigServer("""{"sessionRecording": {"endpoint": "/s/", "sampleRate": 0}}""") + val sut = replayRemoteConfigSut(http) + sut.startSession() + + sut.capture(SDK_EVENT) + + assertReplayDebugKeysKept(capturedBatchEvents(http).first().properties!!) + + sut.close() + } + + @Test + fun `linked flag pending keeps replay debug keys`() { + val http = replayRemoteConfigServer("""{"sessionRecording": {"endpoint": "/s/", "linkedFlag": "replay-flag"}}""") + val sut = replayRemoteConfigSut(http) + sut.startSession() + + sut.capture(SDK_EVENT) + + assertReplayDebugKeysKept(capturedBatchEvents(http).first().properties!!) + + sut.close() + } + + @Test + fun `event trigger pending keeps replay debug keys`() { + val http = replayRemoteConfigServer("""{"sessionRecording": {"endpoint": "/s/", "eventTriggers": ["checkout"]}}""") + val sut = replayRemoteConfigSut(http) + sut.startSession() + + sut.capture(SDK_EVENT) + + assertReplayDebugKeysKept(capturedBatchEvents(http).first().properties!!) + + sut.close() + } + + @Test + fun `awaiting first remote config keeps replay debug keys`() { + val release = CountDownLatch(1) + val http = replayRemoteConfigServer("""{"sessionRecording": false}""", release) + val sut = + getSut( + http.url("/").toString(), + preloadFeatureFlags = false, + integration = replayHandlerWithFullBundle(), + remoteConfig = true, + sessionReplay = true, + ) + sut.startSession() + + try { + sut.capture(SDK_EVENT) + + val props = capturedBatchEvents(http).first().properties!! + assertReplayDebugKeysKept(props) + assertEquals("awaiting_remote_config", props["\$sdk_debug_replay_flush_hold_reason"]) + } finally { + release.countDown() + } + + sut.close() + } + + @Test + fun `manual start while sessionReplay false keeps replay debug keys`() { + val http = mockHttp() + val sut = + getSut( + http.url("/").toString(), + preloadFeatureFlags = false, + reloadFeatureFlags = false, + integration = replayHandlerWithFullBundle(), + ) + sut.startSession() + sut.startSessionReplay() + + sut.capture(SDK_EVENT) + + assertReplayDebugKeysKept(capturedEvents(http).first().properties!!) + + sut.close() + } + + @Test + fun `restart after stop restores replay debug keys`() { + val http = mockHttp() + val sut = replayDebugSut(http, flushAt = 2) + sut.startSession() + + sut.stopSessionReplay() + sut.capture(SDK_EVENT) + sut.startSessionReplay() + sut.capture(SDK_EVENT) + + val events = capturedEvents(http) + assertReplayOffShape(events[0].properties!!) + assertReplayDebugKeysKept(events[1].properties!!) + assertTrue(events[1].carriesReplayDebugBundle) + assertNotNull(events[1].properties!!["\$sdk_debug_session_start"]) + + sut.close() + } + + @Test + fun `optIn after optOut restores replay debug keys`() { + val http = mockHttp() + val sut = replayDebugSut(http, flushAt = 1) + sut.optOut() + sut.optIn() + sut.startSession() + + sut.capture(SDK_EVENT) + + assertReplayDebugKeysKept(capturedEvents(http).first().properties!!) + + sut.close() + } + + @Test + fun `off state does not consume the debug bundle window`() { + val http = mockHttp() + val clock = TestDateProvider(System.currentTimeMillis()) + val sut = replayDebugSut(http, flushAt = 3) + config.dateProvider = clock + sut.startSession() + + sut.stopSessionReplay() + sut.capture(SDK_EVENT) + clock.nowMs += 1_000 + sut.capture(SDK_EVENT) + clock.nowMs += 1_000 + sut.startSessionReplay() + sut.capture(SDK_EVENT) + + val events = capturedEvents(http) + assertEquals(listOf(false, false, true), events.map { it.carriesReplayDebugBundle }) + assertReplayOffShape(events[0].properties!!) + assertReplayOffShape(events[1].properties!!) + assertReplayDebugKeysKept(events[2].properties!!) + + sut.close() + } + @Test fun `replay debug bundle is attached at most once every 30 seconds while required keys stay on every event`() { val http = mockHttp() @@ -4400,6 +4696,7 @@ internal class PostHogTest { PostHogConfig(PROJECT_TOKEN, http.url("/").toString()).apply { storagePrefix = tmpDir.newFolder().absolutePath preloadFeatureFlags = false + sessionReplay = true addIntegration(replayHandlerWithFullBundle()) dateProvider = clock addBeforeSend { @@ -7102,7 +7399,14 @@ internal class PostHogTest { fun `session debug keys follow a caller-provided session id`() { val http = mockHttp() val url = http.url("/") - val sut = getSut(url.toString(), preloadFeatureFlags = false, reloadFeatureFlags = false) + val sut = + getSut( + url.toString(), + preloadFeatureFlags = false, + reloadFeatureFlags = false, + integration = PostHogSessionReplayHandlerFake(false), + sessionReplay = true, + ) sut.startSession() val managerStart = PostHogSessionManager.getSessionStartedAt() assertTrue(managerStart > 0) @@ -7173,7 +7477,14 @@ internal class PostHogTest { fun `a backdated event within the current session keeps the debug keys`() { val http = mockHttp() val url = http.url("/") - val sut = getSut(url.toString(), preloadFeatureFlags = false, reloadFeatureFlags = false) + val sut = + getSut( + url.toString(), + preloadFeatureFlags = false, + reloadFeatureFlags = false, + integration = PostHogSessionReplayHandlerFake(false), + sessionReplay = true, + ) sut.startSession() val start = PostHogSessionManager.getSessionStartedAt() From 82dd131455b3b3a76512807aec21c13838883754 Mon Sep 17 00:00:00 2001 From: Ioannis J Date: Wed, 18 Nov 2026 15:53:54 +0200 Subject: [PATCH 2/5] refactor: fold the replay-off gate into the debug property flow --- posthog/src/main/java/com/posthog/PostHog.kt | 15 ++++----------- 1 file changed, 4 insertions(+), 11 deletions(-) diff --git a/posthog/src/main/java/com/posthog/PostHog.kt b/posthog/src/main/java/com/posthog/PostHog.kt index 8a1e99588..d69db56da 100644 --- a/posthog/src/main/java/com/posthog/PostHog.kt +++ b/posthog/src/main/java/com/posthog/PostHog.kt @@ -872,20 +872,13 @@ public class PostHog private constructor( if (timestamp != null && managerStart > 0 && timestamp.time < managerStart) { return props } - if (isSessionReplayIntentionallyOff()) { - props["\$recording_status"] = "disabled" - try { - queue?.size?.let { props["\$sdk_debug_pending_queue_size"] = it } - } catch (e: Throwable) { - props["\$sdk_debug_error_capturing_properties"] = e.toString().take(MAX_DEBUG_ERROR_LENGTH) - } - return props - } - val claimed = claimReplayDebugBundle() + val replayOff = isSessionReplayIntentionallyOff() + val claimed = !replayOff && claimReplayDebugBundle() // Guarded separately from the session and queue keys below: those come from the session // manager and the queue, not from replay, so a handler that throws must not suppress them. try { - val replayProps = sessionReplayHandler?.debugProperties() ?: mapOf("\$recording_status" to "disabled") + val replayProps = + sessionReplayHandler?.takeUnless { replayOff }?.debugProperties() ?: mapOf("\$recording_status" to "disabled") if (claimed) { props.putAll(replayProps) } else { From 66c9562606e3a51b716a1cd5df0ea5e5883d3018 Mon Sep 17 00:00:00 2001 From: Ioannis J Date: Wed, 18 Nov 2026 18:12:17 +0200 Subject: [PATCH 3/5] test: cover remote replay off then on restoring the replay debug keys --- .../src/test/java/com/posthog/PostHogTest.kt | 68 +++++++++++++++++++ 1 file changed, 68 insertions(+) diff --git a/posthog/src/test/java/com/posthog/PostHogTest.kt b/posthog/src/test/java/com/posthog/PostHogTest.kt index b0de5d352..362c70c35 100644 --- a/posthog/src/test/java/com/posthog/PostHogTest.kt +++ b/posthog/src/test/java/com/posthog/PostHogTest.kt @@ -44,6 +44,7 @@ import java.util.concurrent.CopyOnWriteArrayList import java.util.concurrent.CountDownLatch import java.util.concurrent.Executors import java.util.concurrent.TimeUnit +import java.util.concurrent.atomic.AtomicInteger import java.util.concurrent.atomic.AtomicLong import kotlin.collections.get import kotlin.concurrent.thread @@ -4241,6 +4242,73 @@ internal class PostHogTest { sut.close() } + private fun sequencedRemoteConfigServer(vararg configBodies: String): MockWebServer { + val configCalls = AtomicInteger() + val http = httpServers.create() + http.dispatcher = + object : Dispatcher() { + override fun dispatch(request: RecordedRequest): MockResponse { + if (request.path?.endsWith("/config") == true) { + val index = configCalls.getAndIncrement().coerceAtMost(configBodies.lastIndex) + return MockResponse().setBody(configBodies[index]) + } + return MockResponse().setBody("") + } + } + http.start() + return http + } + + private fun reloadRemoteConfig(sut: PostHogInterface) { + config.remoteConfigHolder!!.loadRemoteConfig(sut.distinctId(), anonymousId = null, groups = null) + remoteConfigExecutor.awaitExecution() + } + + private fun assertRemoteOffThenOnRestoresReplayDebugKeys( + offConfig: String, + onConfig: String, + ) { + val http = sequencedRemoteConfigServer(offConfig, onConfig) + val sut = + getSut( + http.url("/").toString(), + flushAt = 2, + preloadFeatureFlags = false, + integration = replayHandlerWithFullBundle(), + remoteConfig = true, + sessionReplay = true, + ) + remoteConfigExecutor.awaitExecution() + sut.startSession() + + sut.capture(SDK_EVENT) + reloadRemoteConfig(sut) + sut.capture(SDK_EVENT) + + val events = capturedBatchEvents(http) + assertEquals(2, events.size) + assertReplayOffShape(events[0].properties!!) + assertReplayDebugKeysKept(events[1].properties!!) + + sut.close() + } + + @Test + fun `remote replay off then on restores replay debug keys`() { + assertRemoteOffThenOnRestoresReplayDebugKeys( + offConfig = """{"sessionRecording": false}""", + onConfig = """{"sessionRecording": {"endpoint": "/s/"}}""", + ) + } + + @Test + fun `lifted quota limit restores replay debug keys`() { + assertRemoteOffThenOnRestoresReplayDebugKeys( + offConfig = """{"sessionRecording": {"endpoint": "/s/"}, "quotaLimited": ["mobile_recordings"]}""", + onConfig = """{"sessionRecording": {"endpoint": "/s/"}}""", + ) + } + @Test fun `no remote config yet keeps replay debug keys`() { val http = mockHttp() From fdc49f5615d13ef01d067c96377c6369b5b6c08c Mon Sep 17 00:00:00 2001 From: Ioannis J Date: Wed, 18 Nov 2026 19:18:52 +0200 Subject: [PATCH 4/5] fix: keep replay debug keys while the recorder is running --- posthog/src/main/java/com/posthog/PostHog.kt | 7 ++-- .../src/test/java/com/posthog/PostHogTest.kt | 42 +++++++++++++++++++ 2 files changed, 46 insertions(+), 3 deletions(-) diff --git a/posthog/src/main/java/com/posthog/PostHog.kt b/posthog/src/main/java/com/posthog/PostHog.kt index d69db56da..d6eba5e51 100644 --- a/posthog/src/main/java/com/posthog/PostHog.kt +++ b/posthog/src/main/java/com/posthog/PostHog.kt @@ -2610,10 +2610,11 @@ public class PostHog private constructor( } // Not off while sampled out, awaiting remote config, or waiting on a trigger: those keys explain - // why replay isn't recording. + // why replay isn't recording. A flags reload can restart the recorder after an explicit stop, so a + // running recorder is never off. private fun isSessionReplayIntentionallyOff(): Boolean { - return sessionReplayHandler == null || - !sessionReplayWanted || + val handler = sessionReplayHandler ?: return true + return (!sessionReplayWanted && !handler.isActive()) || remoteConfig?.isSessionRecordingRemotelyDisabled() == true } diff --git a/posthog/src/test/java/com/posthog/PostHogTest.kt b/posthog/src/test/java/com/posthog/PostHogTest.kt index 362c70c35..7dd9754eb 100644 --- a/posthog/src/test/java/com/posthog/PostHogTest.kt +++ b/posthog/src/test/java/com/posthog/PostHogTest.kt @@ -4428,6 +4428,48 @@ internal class PostHogTest { sut.close() } + @Test + fun `flags reload restarting replay after stop restores replay debug keys`() { + val http = httpServers.create() + http.dispatcher = + object : Dispatcher() { + override fun dispatch(request: RecordedRequest): MockResponse { + val path = request.path.orEmpty() + return when { + path.endsWith("/config") -> MockResponse().setBody("""{"sessionRecording": {"endpoint": "/s/"}}""") + path.contains("/flags") -> MockResponse().setBody("""{"featureFlags": {}, "featureFlagPayloads": {}}""") + else -> MockResponse().setBody("") + } + } + } + http.start() + val handler = replayHandlerWithFullBundle() + val sut = + getSut( + http.url("/").toString(), + flushAt = 2, + preloadFeatureFlags = false, + integration = handler, + remoteConfig = true, + sessionReplay = true, + ) + remoteConfigExecutor.awaitExecution() + sut.startSession() + + sut.stopSessionReplay() + sut.capture(SDK_EVENT) + sut.reloadFeatureFlags() + remoteConfigExecutor.awaitExecution() + assertTrue(sut.isSessionReplayActive()) + sut.capture(SDK_EVENT) + + val events = capturedBatchEvents(http) + assertReplayOffShape(events[0].properties!!) + assertReplayDebugKeysKept(events[1].properties!!) + + sut.close() + } + @Test fun `optIn after optOut restores replay debug keys`() { val http = mockHttp() From e8809d3826890acd504c4cc5370801b9ab307c5a Mon Sep 17 00:00:00 2001 From: Ioannis J Date: Thu, 19 Nov 2026 09:46:07 +0200 Subject: [PATCH 5/5] fix: keep replay debug keys until a remotely disabled recorder stops --- posthog/src/main/java/com/posthog/PostHog.kt | 8 ++--- .../src/test/java/com/posthog/PostHogTest.kt | 29 +++++++++++++++++++ 2 files changed, 33 insertions(+), 4 deletions(-) diff --git a/posthog/src/main/java/com/posthog/PostHog.kt b/posthog/src/main/java/com/posthog/PostHog.kt index d6eba5e51..524a648b3 100644 --- a/posthog/src/main/java/com/posthog/PostHog.kt +++ b/posthog/src/main/java/com/posthog/PostHog.kt @@ -2610,12 +2610,12 @@ public class PostHog private constructor( } // Not off while sampled out, awaiting remote config, or waiting on a trigger: those keys explain - // why replay isn't recording. A flags reload can restart the recorder after an explicit stop, so a - // running recorder is never off. + // why replay isn't recording. A running recorder is never off: a flags reload can restart it after + // an explicit stop, and a remote off stops it only after the app's flags callback has run. private fun isSessionReplayIntentionallyOff(): Boolean { val handler = sessionReplayHandler ?: return true - return (!sessionReplayWanted && !handler.isActive()) || - remoteConfig?.isSessionRecordingRemotelyDisabled() == true + return !handler.isActive() && + (!sessionReplayWanted || remoteConfig?.isSessionRecordingRemotelyDisabled() == true) } // this is used in cases where we know the session is already active diff --git a/posthog/src/test/java/com/posthog/PostHogTest.kt b/posthog/src/test/java/com/posthog/PostHogTest.kt index 7dd9754eb..7a0b6adec 100644 --- a/posthog/src/test/java/com/posthog/PostHogTest.kt +++ b/posthog/src/test/java/com/posthog/PostHogTest.kt @@ -4229,6 +4229,35 @@ internal class PostHogTest { sut.close() } + @Test + fun `remote Boolean false keeps replay debug keys until the running recorder stops`() { + val http = replayRemoteConfigServer("""{"sessionRecording": false}""") + val handler = replayHandlerWithFullBundle() + val sut = + getSut( + http.url("/").toString(), + flushAt = 2, + preloadFeatureFlags = false, + integration = handler, + remoteConfig = true, + sessionReplay = true, + ) + remoteConfigExecutor.awaitExecution() + sut.startSession() + handler.start(resumeCurrent = false) + assertTrue(sut.isSessionReplayActive()) + + sut.capture(SDK_EVENT) + handler.stop() + sut.capture(SDK_EVENT) + + val events = capturedBatchEvents(http) + assertReplayDebugKeysKept(events[0].properties!!) + assertReplayOffShape(events[1].properties!!) + + sut.close() + } + @Test fun `remote config without a sessionRecording key sends only recording status`() { val http = replayRemoteConfigServer("""{"hasFeatureFlags": false}""")