From 26a2abc8a25bee09f5196842c9aaaa61aeb5a5bb Mon Sep 17 00:00:00 2001 From: Anna Garcia Date: Fri, 6 Nov 2026 15:14:56 -0500 Subject: [PATCH] fix: replay onFeatureFlags to a late listener without waiting for the flags request The catch-up replay for a listener registered after setup() hopped onto the remote config thread first, so it queued behind an in-flight /config or /flags request. With bootstrap flags and a slow network, the listener never saw the bootstrapped values. Post the replay straight to the listener executor (the main thread on Android) instead; delivery still reads the latest value at run time and skips one already delivered, so a load landing right after is delivered once, after the replay. --- posthog/src/main/java/com/posthog/PostHog.kt | 15 ++-- .../java/com/posthog/PostHogBootstrapTest.kt | 72 +++++++++++++++++-- 2 files changed, 75 insertions(+), 12 deletions(-) diff --git a/posthog/src/main/java/com/posthog/PostHog.kt b/posthog/src/main/java/com/posthog/PostHog.kt index 77c4506d6..799c111e9 100644 --- a/posthog/src/main/java/com/posthog/PostHog.kt +++ b/posthog/src/main/java/com/posthog/PostHog.kt @@ -2592,11 +2592,16 @@ public class PostHog private constructor( val listener = FeatureFlagsListener(callback) featureFlagsListeners.add(listener) - remoteConfigExecutor.executeSafely { - runFeatureFlagsListener { - // Read at delivery time so a delivery already queued can't be followed by an older value. - lastFeatureFlagsLoaded?.let { deliverFeatureFlags(listener, it) } - } + // Read at delivery time so a delivery already queued can't be followed by an older value. + val replay = { lastFeatureFlagsLoaded?.let { deliverFeatureFlags(listener, it) } } + // Post straight to the listener executor (the main thread on Android), so the replay doesn't + // wait behind a flags request in flight on the remote config thread. Without one, listeners + // run on the remote config thread, so the replay queues there. + val executor = config?.featureFlagsListenerExecutor + if (executor != null) { + executor.executeSafely { replay() } + } else { + remoteConfigExecutor.executeSafely { runFeatureFlagsListener { replay() } } } return PostHogFeatureFlagsSubscription { diff --git a/posthog/src/test/java/com/posthog/PostHogBootstrapTest.kt b/posthog/src/test/java/com/posthog/PostHogBootstrapTest.kt index ebac2c24c..380e7e5c6 100644 --- a/posthog/src/test/java/com/posthog/PostHogBootstrapTest.kt +++ b/posthog/src/test/java/com/posthog/PostHogBootstrapTest.kt @@ -15,6 +15,7 @@ import org.junit.Rule import org.junit.rules.TemporaryFolder import java.io.File import java.util.concurrent.CountDownLatch +import java.util.concurrent.Executor import java.util.concurrent.Executors import java.util.concurrent.LinkedBlockingQueue import java.util.concurrent.TimeUnit @@ -49,6 +50,7 @@ internal class PostHogBootstrapTest { storagePrefix: String = tmpDir.newFolder().absolutePath, logger: TestLogger? = null, optOut: Boolean = false, + featureFlagsListenerExecutor: Executor? = null, ): PostHogInterface { config = PostHogConfig(PROJECT_TOKEN, host).apply { @@ -60,6 +62,7 @@ internal class PostHogBootstrapTest { this.cachePreferences = cachePreferences this.bootstrap = bootstrap this.optOut = optOut + this.featureFlagsListenerExecutor = featureFlagsListenerExecutor if (logger != null) { this.logger = logger } @@ -368,24 +371,79 @@ internal class PostHogBootstrapTest { http.shutdown() } + private fun heldFlagsServer(release: CountDownLatch): MockWebServer { + val http = MockWebServer() + http.dispatcher = + object : Dispatcher() { + override fun dispatch(request: RecordedRequest): MockResponse { + release.await(10, TimeUnit.SECONDS) + if (request.path!!.contains("/flags")) { + return MockResponse().setBody("""{"featureFlags":{"beta-ui":"test"}}""") + } + return MockResponse().setBody("""{"hasFeatureFlags":true}""") + } + } + http.start() + return http + } + @Test - fun `onFeatureFlags replays bootstrapped flags to a listener registered after setup`() { + fun `onFeatureFlags replays bootstrapped flags to a late listener while setup's load is in flight`() { + val release = CountDownLatch(1) + val http = heldFlagsServer(release) + val listenerExecutor = Executors.newSingleThreadExecutor() val sut = getSut( - host = "http://127.0.0.1:1", - // the replay comes from setup's flag loading, before /config answers - reloadFeatureFlags = true, + host = http.url("/").toString(), + preloadFeatureFlags = true, bootstrap = PostHogBootstrapConfig(featureFlags = mapOf("beta-ui" to true)), + featureFlagsListenerExecutor = listenerExecutor, ) + http.takeRequest(5, TimeUnit.SECONDS)!! val updates = LinkedBlockingQueue() sut.onFeatureFlags { updates.add(it) } - // setup's load to the unreachable host may already have failed, which keeps the bootstrapped flags - val loaded = updates.poll(5, TimeUnit.SECONDS)!! - assertEquals(mapOf("beta-ui" to true), loaded.variants) + val replayed = updates.poll(2, TimeUnit.SECONDS) + assertEquals(mapOf("beta-ui" to true), replayed?.variants) + assertFalse(replayed!!.errorsLoading) + + release.countDown() + val loaded = updates.poll(5, TimeUnit.SECONDS) + assertEquals(mapOf("beta-ui" to "test"), loaded?.variants) + assertFalse(loaded!!.errorsLoading) + assertNull(updates.poll(1, TimeUnit.SECONDS)) sut.close() + listenerExecutor.shutdownAndAwaitTermination() + http.shutdown() + } + + @Test + fun `onFeatureFlags delivers a load that lands before a late listener's replay runs once`() { + val release = CountDownLatch(1) + val http = heldFlagsServer(release) + val queued = LinkedBlockingQueue() + val sut = + getSut( + host = http.url("/").toString(), + preloadFeatureFlags = true, + bootstrap = PostHogBootstrapConfig(featureFlags = mapOf("beta-ui" to true)), + featureFlagsListenerExecutor = Executor { queued.add(it) }, + ) + http.takeRequest(5, TimeUnit.SECONDS)!! + + val updates = mutableListOf() + sut.onFeatureFlags { updates.add(it) } + release.countDown() + http.takeRequest(5, TimeUnit.SECONDS)!! + remoteConfigExecutor.submit {}.get(5, TimeUnit.SECONDS) + generateSequence { queued.poll() }.forEach { it.run() } + + assertEquals(listOf>(mapOf("beta-ui" to "test")), updates.map { it.variants }) + + sut.close() + http.shutdown() } @Test