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 f7fd87b2c..ff258036f 100644 --- a/posthog-android/src/test/resources/json/snapshots/batch-request.json +++ b/posthog-android/src/test/resources/json/snapshots/batch-request.json @@ -42,9 +42,6 @@ "$lib": "posthog-android", "$lib_version": "", "$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, "$sdk_debug_pending_queue_size": "", "$set": { "plan": "pro" @@ -94,11 +91,6 @@ "$lib": "posthog-android", "$lib_version": "", "$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": "screenshot", - "$sdk_debug_replay_internal_buffer_length": 0, - "$sdk_debug_session_start": 1700000000123, "$sdk_debug_pending_queue_size": "", "$set": { "email": "person@example.com" @@ -141,9 +133,6 @@ "$lib": "posthog-android", "$lib_version": "", "$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, "$sdk_debug_pending_queue_size": "", "$group_type": "company", "$group_key": "posthog", @@ -186,9 +175,6 @@ "$lib": "posthog-android", "$lib_version": "", "$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, "$sdk_debug_pending_queue_size": "", "$groups": { "company": "posthog" @@ -234,9 +220,6 @@ "$lib": "posthog-android", "$lib_version": "", "$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, "$sdk_debug_pending_queue_size": "", "$groups": { "company": "posthog" diff --git a/posthog/src/main/java/com/posthog/PostHog.kt b/posthog/src/main/java/com/posthog/PostHog.kt index 7790c7697..6c99fce17 100644 --- a/posthog/src/main/java/com/posthog/PostHog.kt +++ b/posthog/src/main/java/com/posthog/PostHog.kt @@ -1042,11 +1042,12 @@ public class PostHog private constructor( if (timestamp != null && managerStart > 0 && timestamp.time < managerStart) { 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 = readReplayDebugProperties() + val replayProps = if (replayOff) mapOf("\$recording_status" to "disabled") else readReplayDebugProperties() if (claimed) { props.putAll(replayProps) } else { @@ -3310,6 +3311,15 @@ 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. 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 !handler.isActive() && + (!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 4b5604899..d3f04b547 100644 --- a/posthog/src/main/java/com/posthog/internal/PostHogRemoteConfig.kt +++ b/posthog/src/main/java/com/posthog/internal/PostHogRemoteConfig.kt @@ -190,6 +190,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() @@ -355,8 +360,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) @@ -1472,6 +1479,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 694b08bcb..1924ac7aa 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 @@ -4106,7 +4107,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) @@ -4143,7 +4145,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")) @@ -4198,7 +4201,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) @@ -4223,7 +4227,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.register("\$sdk_debug_replay_event_trigger_status", "registered") @@ -4281,7 +4286,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) @@ -4336,8 +4342,437 @@ 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("/i/v1/analytics/events")) { + return serializer.deserialize(request.body.unGzip().reader())!!.batch + } + } + } + + private fun replayRemoteConfigSut(http: MockWebServer): PostHogInterface = + getSut( + http.url("/").toString(), + preloadFeatureFlags = false, + integration = replayHandlerWithFullBundle(), + reloadFeatureFlags = 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 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, + reloadFeatureFlags = 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}""") + val sut = replayRemoteConfigSut(http) + sut.startSession() + + sut.capture(SDK_EVENT) + + assertReplayOffShape(capturedBatchEvents(http).first().properties!!) + + 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(), + reloadFeatureFlags = 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() + 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(), + reloadFeatureFlags = 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 `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, + reloadFeatureFlags = 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() + 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() @@ -4634,6 +5069,7 @@ internal class PostHogTest { PostHogConfig(PROJECT_TOKEN, http.url("/").toString()).apply { storagePrefix = tmpDir.newFolder().absolutePath preloadFeatureFlags = false + sessionReplay = true addIntegration(replayHandlerWithFullBundle()) dateProvider = clock addBeforeSend { @@ -7338,7 +7774,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) @@ -7410,7 +7853,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()