fix: Delay the first big segment status poll by one interval

The status polling task ran its first query as soon as it started, while
get_status() also queries the store whenever no status is cached yet. A
status request that arrived while that first query was still in flight
found no cached status and sent a second query, so startup could produce
two metadata queries instead of one.

The polling task now waits one interval before its first query. The
inline query in get_status() still keeps the first status accurate, so
this matches the ticker semantics the Go SDK uses.

Author: jsonbailey

ldclient/impl/async_big_segments.py

@@ -65,7 +65,7 @@ def __init__(self, config: AsyncBigSegmentsConfig):
 
         if self.__store:
             self.__cache = ExpiringDict(max_len=config.context_cache_size, max_age_seconds=config.context_cache_time)
-            self.__poll_task = AsyncRepeatingTask.at_interval("ldclient.bigsegment.status-poll", config.status_poll_interval, 0, self.poll_store_and_update_status)
+            self.__poll_task = AsyncRepeatingTask.at_interval("ldclient.bigsegment.status-poll", config.status_poll_interval, config.status_poll_interval, self.poll_store_and_update_status)
 
     def start(self):
         """Starts the status polling task. Separated from __init__ so the manager

ldclient/impl/big_segments.py

@@ -67,7 +67,7 @@ def __init__(self, config: BigSegmentsConfig):
 
         if self.__store:
             self.__cache = ExpiringDict(max_len=config.context_cache_size, max_age_seconds=config.context_cache_time)
-            self.__poll_task = RepeatingTask.at_interval("ldclient.bigsegment.status-poll", config.status_poll_interval, 0, self.poll_store_and_update_status)
+            self.__poll_task = RepeatingTask.at_interval("ldclient.bigsegment.status-poll", config.status_poll_interval, config.status_poll_interval, self.poll_store_and_update_status)
             self.__poll_task.start()
 
     def stop(self):

ldclient/testing/impl/test_async_big_segments.py

@@ -26,10 +26,17 @@ class MockAsyncBigSegmentStore(AsyncBigSegmentStore):
 
     def __init__(self):
         self._membership_queries = []
+        self._metadata_queries = []
         self._memberships = {}
         self._metadata_fn = lambda: BigSegmentStoreMetadata(int(time.time() * 1000))
+        self._metadata_delay = 0.0
         self._stopped = False
 
+    def setup_metadata_delay(self, delay: float):
+        """Makes get_metadata await for the given number of seconds, so a test can
+        keep a metadata query in flight."""
+        self._metadata_delay = delay
+
     def setup_membership(self, user_hash: str, membership):
         self._memberships[user_hash] = membership
 
@@ -48,6 +55,9 @@ def _raise():
         self._metadata_fn = _raise
 
     async def get_metadata(self) -> BigSegmentStoreMetadata:
+        self._metadata_queries.append(True)
+        if self._metadata_delay:
+            await asyncio.sleep(self._metadata_delay)
         return self._metadata_fn()
 
     async def get_membership(self, context_hash: str):
@@ -61,6 +71,10 @@ async def stop(self):
     def membership_queries(self):
         return list(self._membership_queries)
 
+    @property
+    def metadata_queries(self):
+        return list(self._metadata_queries)
+
 
 async def make_started_manager(store, **kwargs):
     config = AsyncBigSegmentsConfig(store=store, **kwargs)
@@ -348,3 +362,25 @@ async def test_get_status_with_no_store_configured():
         assert status.available is False
     finally:
         await manager.stop()
+
+
+@pytest.mark.asyncio
+async def test_status_query_at_startup_polls_store_only_once():
+    """
+    The polling task waits one interval before its first query, so a status request at
+    startup is served by a single inline query. If the task queried the store as soon as
+    it started, a status request arriving while that query was still in flight would find
+    no cached status and query a second time.
+    """
+    store = MockAsyncBigSegmentStore()
+    store.setup_metadata_always_up_to_date()
+    store.setup_metadata_delay(0.25)
+
+    manager = await make_started_manager(store, status_poll_interval=10)
+    try:
+        status = await manager.get_status()
+        assert status.available is True
+    finally:
+        await manager.stop()
+
+    assert len(store.metadata_queries) == 1

ldclient/testing/impl/test_big_segments.py

@@ -185,3 +185,27 @@ def test_status_polling_detects_stale_status():
         assert status3.stale is False
     finally:
         manager.stop()
+
+
+def test_status_query_at_startup_polls_store_only_once():
+    # The polling task waits one interval before its first query, so a status
+    # request at startup is served by a single inline query. If the task queried
+    # the store as soon as it started, a status request arriving while that query
+    # was still in flight would find no cached status and query a second time.
+    metadata_queries = []
+
+    def slow_metadata():
+        metadata_queries.append(True)
+        time.sleep(0.25)
+        return BigSegmentStoreMetadata(time.time() * 1000)
+
+    store = MockBigSegmentStore()
+    store.setup_metadata(slow_metadata)
+
+    manager = BigSegmentStoreManager(BigSegmentsConfig(store=store, status_poll_interval=10))
+    try:
+        assert manager.status_provider.status.available is True
+    finally:
+        manager.stop()
+
+    assert len(metadata_queries) == 1