feat: Make the flag tracker available before start()

Build the flag tracker in __init__ instead of start(), matching every other
LaunchDarkly SDK, so flag_tracker no longer raises before start(). The client
owns the flag-change Listeners and injects it into the data system, so
listeners registered before start() fire once data flows. The callback
scheduler is created lazily on the first add_flag_value_change_listener call,
which always runs on the loop thread.

Author: jsonbailey

ldclient/async_client.py

@@ -37,6 +37,7 @@
     create_diagnostic_id
 )
 from ldclient.impl.events.types import EventFactory
+from ldclient.impl.listeners import Listeners
 from ldclient.impl.model.feature_flag import FeatureFlag
 from ldclient.impl.stubs import AsyncNullEventProcessor
 from ldclient.impl.util import log
@@ -105,6 +106,16 @@ def __init__(self, config: AsyncConfig):
         self._event_factory_default = EventFactory(False)
         self._event_factory_with_reasons = EventFactory(True)
 
+        self._flag_change_listeners = Listeners()
+
+        async def variation_eval_fn(key, context):
+            return await self.variation(key, context, None)
+
+        self.__flag_tracker = AsyncFlagTrackerImpl(
+            self._flag_change_listeners,
+            variation_eval_fn
+        )
+
     async def start(self, start_wait: float = 5.0) -> None:
         """Start the client: create the HTTP session, data system, and event processor.
 
@@ -200,13 +211,6 @@ async def __start_up(self, start_wait: float):
         self._session = await self._create_http_session()
         self._data_system = self._make_data_system()
 
-        async def variation_eval_fn(key, context):
-            return await self.variation(key, context, None)
-
-        self.__flag_tracker = AsyncFlagTrackerImpl(
-            self._data_system.flag_change_listeners,
-            variation_eval_fn
-        )
         # Expose providers and store from data system
         self.__data_store_status_provider = self._data_system.data_store_status_provider
         self.__data_source_status_provider = (
@@ -289,7 +293,7 @@ def _make_data_system(self) -> AsyncDataSystem:
         if datasystem_config is None:
             from ldclient.impl.datasystem.async_fdv1 import AsyncFDv1
 
-            return AsyncFDv1(self._config, self._select_feature_store(), self._session, self._proxy)
+            return AsyncFDv1(self._config, self._select_feature_store(), self._flag_change_listeners, self._session, self._proxy)
 
         raise NotImplementedError("FDv2 is not yet supported in the async client")
 
@@ -747,9 +751,10 @@ def flag_tracker(self) -> AsyncFlagTracker:
         The :class:`ldclient.interfaces.AsyncFlagTracker` contains methods for
         requesting notifications about feature flag changes using an event
         listener model.
+
+        Listeners registered before ``start()`` receive change events once the
+        data system starts.
         """
-        if not self._started:
-            raise RuntimeError("AsyncLDClient.flag_tracker is not available until after start()")
         return self.__flag_tracker
 
     async def __aenter__(self):

ldclient/impl/async_flag_tracker.py

@@ -1,4 +1,4 @@
-from typing import Any, Callable
+from typing import Any, Callable, Optional
 
 from ldclient.context import Context
 from ldclient.impl.aio.concurrency import AsyncCallbackScheduler, AsyncLock
@@ -45,7 +45,14 @@ class AsyncFlagTrackerImpl(AsyncFlagTracker):
     def __init__(self, listeners: Listeners, eval_fn: Callable):
         self.__listeners = listeners
         self.__eval_fn = eval_fn
-        self.__scheduler = AsyncCallbackScheduler()
+        self.__scheduler: Optional[AsyncCallbackScheduler] = None
+
+    def _get_scheduler(self) -> AsyncCallbackScheduler:
+        """Creates the callback scheduler on first use. Called only from async
+        methods, so a running loop always exists for it to capture."""
+        if self.__scheduler is None:
+            self.__scheduler = AsyncCallbackScheduler()
+        return self.__scheduler
 
     def add_listener(self, listener: Callable[[FlagChange], None]):
         self.__listeners.add(listener)
@@ -54,7 +61,7 @@ def remove_listener(self, listener: Callable[[FlagChange], None]):
         self.__listeners.remove(listener)
 
     async def add_flag_value_change_listener(self, key: str, context: Context, fn: Callable[[FlagValueChange], None]) -> Callable[[FlagChange], None]:
-        listener = await AsyncFlagValueChangeListener.create(key, context, fn, self.__eval_fn, self.__scheduler)
+        listener = await AsyncFlagValueChangeListener.create(key, context, fn, self.__eval_fn, self._get_scheduler())
         self.add_listener(listener)
 
         return listener

ldclient/impl/datasystem/async_fdv1.py

@@ -42,7 +42,7 @@ class AsyncFDv1(AsyncDataSystem):
     monitoring.
     """
 
-    def __init__(self, config: AsyncConfig, store: AsyncFeatureStore, session: Optional[Any] = None, proxy: Optional[str] = None):
+    def __init__(self, config: AsyncConfig, store: AsyncFeatureStore, flag_change_listeners: Listeners, session: Optional[Any] = None, proxy: Optional[str] = None):
         self._config = config
         self._store = store
         self._session = session
@@ -59,9 +59,11 @@ def __init__(self, config: AsyncConfig, store: AsyncFeatureStore, session: Optio
             self._store, self._data_store_update_sink  # type: ignore[arg-type]
         )
 
-        # Set up the data source status tracking and listeners
+        # Set up the data source status tracking and listeners. The flag-change
+        # Listeners is provided by the client so its flag tracker (built before
+        # start()) shares the same collection.
         self._data_source_listeners = Listeners()
-        self._flag_change_listeners = Listeners()
+        self._flag_change_listeners = flag_change_listeners
         self._data_source_update_sink = AsyncDataSourceUpdateSinkImpl(
             self._store,
             self._data_source_listeners,

ldclient/testing/test_async_client.py

@@ -222,11 +222,18 @@ def after_evaluation(self, series_context, data, detail):
 
 
 @pytest.mark.asyncio
-async def test_flag_tracker_before_start_raises():
-    """Accessing flag_tracker before start() raises RuntimeError."""
+async def test_flag_tracker_available_before_start():
+    """flag_tracker is available before start(); the client's flag-change
+    Listeners is the same collection the data system uses after start()."""
     client = AsyncLDClient(_offline_config())
-    with pytest.raises(RuntimeError):
-        _ = client.flag_tracker
+
+    tracker = client.flag_tracker
+    assert tracker is not None
+    tracker.add_listener(lambda change: None)
+
+    await client.start()
+    assert client._data_system.flag_change_listeners is client._flag_change_listeners
+    await client.close()
 
 
 @pytest.mark.asyncio