From 79565eb145619696afd24c5001e2ccb97f27d0a1 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Fri, 13 Nov 2026 18:33:29 +0000 Subject: [PATCH] fix: Signal readiness when selectorless initializers are exhausted Co-Authored-By: Ryan Lamb <4955475+kinyoklion@users.noreply.github.com> --- ldclient/impl/datasystem/async_fdv2.py | 2 + ldclient/impl/datasystem/fdv2.py | 2 + ldclient/impl/datasystem/store.py | 4 ++ .../impl/datasystem/test_async_fdv2.py | 55 +++++++++++++++- .../impl/datasystem/test_fdv2_datasystem.py | 62 +++++++++++++++++++ 5 files changed, 124 insertions(+), 1 deletion(-) diff --git a/ldclient/impl/datasystem/async_fdv2.py b/ldclient/impl/datasystem/async_fdv2.py index f190a67e..326a594d 100644 --- a/ldclient/impl/datasystem/async_fdv2.py +++ b/ldclient/impl/datasystem/async_fdv2.py @@ -514,6 +514,8 @@ async def _run_initializers(self, set_on_ready: AsyncEvent) -> bool: return False except Exception as e: log.error("Initializer failed with exception: %s", e) + if self._store.is_memory_initialized(): + set_on_ready.set() return False async def _run_synchronizers(self, set_on_ready: AsyncEvent): diff --git a/ldclient/impl/datasystem/fdv2.py b/ldclient/impl/datasystem/fdv2.py index ae8281f2..e9f3fac9 100644 --- a/ldclient/impl/datasystem/fdv2.py +++ b/ldclient/impl/datasystem/fdv2.py @@ -485,6 +485,8 @@ def _run_initializers(self, set_on_ready: Event) -> bool: return False except Exception as e: log.error("Initializer failed with exception: %s", e) + if self._store.is_memory_initialized(): + set_on_ready.set() return False def _run_synchronizers(self, set_on_ready: Event): diff --git a/ldclient/impl/datasystem/store.py b/ldclient/impl/datasystem/store.py index 3904312b..e9b110b0 100644 --- a/ldclient/impl/datasystem/store.py +++ b/ldclient/impl/datasystem/store.py @@ -414,6 +414,10 @@ def is_initialized(self) -> bool: """Check if the active store is initialized.""" return self.get_active_store().initialized + def is_memory_initialized(self) -> bool: + """Check if data has been applied to the in-memory store.""" + return self._memory_store.initialized + class Store(_StoreBase): """ diff --git a/ldclient/testing/impl/datasystem/test_async_fdv2.py b/ldclient/testing/impl/datasystem/test_async_fdv2.py index 1a0a2d88..a6580d12 100644 --- a/ldclient/testing/impl/datasystem/test_async_fdv2.py +++ b/ldclient/testing/impl/datasystem/test_async_fdv2.py @@ -6,7 +6,8 @@ import pytest -from ldclient.async_config import AsyncConfig +from ldclient.async_config import AsyncConfig, AsyncDataSystemConfig +from ldclient.async_feature_store import AsyncInMemoryFeatureStore from ldclient.config import ( DataSourceBuilder, DataSourceBuilderConfig, @@ -97,6 +98,58 @@ def build(self, config: DataSourceBuilderConfig): return self._init +@pytest.mark.asyncio +@pytest.mark.parametrize("with_flag", [False, True]) +async def test_selectorless_initializer_signals_ready_after_exhaustion(with_flag): + ready = asyncio.Event() + failed_poll_called = asyncio.Event() + builder = ChangeSetBuilder() + builder.start(IntentCode.TRANSFER_FULL) + if with_flag: + builder.add_put(ObjectKind.FLAG, "flag", 1, {"key": "flag", "version": 1}) + basis = Basis(builder.finish(Selector.no_selector()), False, None) + poll = MockAsyncInitializer(_Success(value=basis)) + + class FailingPoll(MockAsyncInitializer): + async def fetch(self, ss): + assert not ready.is_set() + failed_poll_called.set() + return await super().fetch(ss) + + failed_poll = FailingPoll(_Fail(error="poll failed", exception=None)) + synchronizer = MockAsyncSynchronizer() + data_system = AsyncFDv2(AsyncConfig(sdk_key="dummy"), DataSystemConfig( + initializers=[MockAsyncInitializerBuilder(poll), MockAsyncInitializerBuilder(failed_poll)], + synchronizers=[MockAsyncSynchronizerBuilder(synchronizer)], + )) + data_system.start(ready) + try: + await asyncio.wait_for(ready.wait(), timeout=1) + assert failed_poll_called.is_set() + assert await data_system._store.is_ready() + finally: + await data_system.stop() + + +@pytest.mark.asyncio +async def test_initializer_exhaustion_does_not_signal_ready_from_persistent_data(): + persistent_store = AsyncInMemoryFeatureStore() + await persistent_store.init({FEATURES: {}}) + failed_poll = MockAsyncInitializer(_Fail(error="poll failed", exception=None)) + data_system = AsyncFDv2(AsyncConfig(sdk_key="dummy"), AsyncDataSystemConfig( + initializers=[MockAsyncInitializerBuilder(failed_poll)], + data_store=persistent_store, + )) + ready = asyncio.Event() + try: + await data_system._run_initializers(ready) + assert await data_system._store.is_ready() + assert not data_system._store.is_memory_initialized() + assert not ready.is_set() + finally: + await data_system.stop() + + def _make_valid_basis() -> Basis: builder = ChangeSetBuilder() builder.start(IntentCode.TRANSFER_FULL) diff --git a/ldclient/testing/impl/datasystem/test_fdv2_datasystem.py b/ldclient/testing/impl/datasystem/test_fdv2_datasystem.py index 6cc98a85..05edcd74 100644 --- a/ldclient/testing/impl/datasystem/test_fdv2_datasystem.py +++ b/ldclient/testing/impl/datasystem/test_fdv2_datasystem.py @@ -6,6 +6,7 @@ from threading import Event from typing import List +import pytest from mock import Mock from ldclient.config import ( @@ -15,6 +16,7 @@ DataSystemConfig ) from ldclient.datasystem import file_ds_builder +from ldclient.feature_store import InMemoryFeatureStore from ldclient.impl.datasystem import DataAvailability from ldclient.impl.datasystem.fdv2 import FDv2 from ldclient.impl.util import ( @@ -77,6 +79,66 @@ def build(self, config: DataSourceBuilderConfig) -> Initializer: # pylint: disa return self._initializer +@pytest.mark.parametrize("with_flag", [False, True]) +def test_selectorless_initializer_signals_ready_after_exhaustion(with_flag): + ready = Event() + failed_poll_called = Event() + stopped = Event() + builder = ChangeSetBuilder() + builder.start(IntentCode.TRANSFER_FULL) + if with_flag: + builder.add_put(ObjectKind.FLAG, "flag", 1, {"key": "flag", "version": 1}) + basis = Basis(builder.finish(Selector.no_selector()), False, None) + poll = _StaticInitializer("selectorless-poll", _Success(value=basis)) + + class FailingPoll(_StaticInitializer): + def fetch(self, ss): + assert not ready.is_set() + failed_poll_called.set() + return super().fetch(ss) + + failed_poll = FailingPoll("failing-poll", _Fail(error="poll failed", exception=None)) + + def never_responds(ss): + stopped.wait() + yield from () + + synchronizer = Mock(spec=Synchronizer) + synchronizer.name = "pending-synchronizer" + synchronizer.sync.side_effect = never_responds + synchronizer.stop.side_effect = stopped.set + data_system = FDv2(Config(sdk_key="dummy"), DataSystemConfig( + initializers=[_InitializerBuilder(poll), _InitializerBuilder(failed_poll)], + synchronizers=[MockDataSourceBuilder(synchronizer)], + )) + data_system.start(ready) + try: + assert ready.wait(1), "Selectorless initializer data did not signal readiness at exhaustion" + assert failed_poll_called.is_set() + assert data_system._store.is_initialized() + finally: + data_system.stop() + + +def test_initializer_exhaustion_does_not_signal_ready_from_persistent_data(): + persistent_store = InMemoryFeatureStore() + persistent_store.init({FEATURES: {}}) + failed_poll = _StaticInitializer("failing-poll", _Fail(error="poll failed", exception=None)) + data_system = FDv2(Config(sdk_key="dummy"), DataSystemConfig( + initializers=[_InitializerBuilder(failed_poll)], + synchronizers=[], + data_store=persistent_store, + )) + ready = Event() + try: + data_system._run_initializers(ready) + assert data_system._store.is_initialized() + assert not data_system._store.is_memory_initialized() + assert not ready.is_set() + finally: + data_system.stop() + + def test_two_phase_init(): td_initializer = TestDataV2.data_source() td_initializer.update(td_initializer.flag("feature-flag").on(True))