refactor: Simplify async client close() teardown

Remove the close() timeout: no other LaunchDarkly SDK bounds close, and
without a timeout the whole teardown always runs, so nothing leaks. Merge
the failed-start cleanup into _close_components so both close() and a
failed start() share one idempotent teardown, and mark a failed start
closed so a later close() is a no-op.

Author: jsonbailey

ldclient/async_client.py

@@ -148,31 +148,13 @@ async def start(self, start_wait: float = 5.0) -> None:
             try:
                 await self.__start_up(start_wait)
             except BaseException:
-                # Catch BaseException so a cancelled start (CancelledError) also
-                # releases the components __start_up began; re-raise propagates it.
-                await self._cleanup_partial_start()
+                # Catch BaseException, not Exception, so a cancelled start
+                # (CancelledError) also tears down what __start_up began.
+                self._closed = True
+                await self._close_components()
                 raise
 
-    async def _cleanup_partial_start(self):
-        """Release any resources that were partially created during a failed
-        __start_up."""
-        for name, stop in (
-            ("data system", self._data_system.stop),
-            ("big-segment store manager", self.__big_segment_store_manager.stop),
-            ("event processor", self._event_processor.stop),
-        ):
-            try:
-                await stop()
-            except Exception as e:
-                log.warning("Error stopping %s during failed start: %s", name, e)
-        if self._session is not None:
-            try:
-                await self._session.close()
-            except Exception as e:
-                log.warning("Error closing HTTP session during failed start: %s", e)
-            self._session = None
-
-    async def close(self, close_timeout: float = 2.0) -> None:
+    async def close(self) -> None:
         """Shut down the client and release all resources.
 
         Safe to call multiple times — subsequent calls are no-ops.
@@ -184,29 +166,26 @@ async def close(self, close_timeout: float = 2.0) -> None:
 
             # A client that was never started has nothing running to release.
             if self._started:
-                try:
-                    await asyncio.wait_for(self._close_components(), timeout=close_timeout)
-                except asyncio.TimeoutError:
-                    log.warning("Timed out closing AsyncLDClient components")
-                except Exception as e:
-                    log.warning("Error closing AsyncLDClient components: %s", e)
-
-            if self._session is not None:
-                try:
-                    await self._session.close()
-                except Exception as e:
-                    log.warning("Error closing HTTP session: %s", e)
+                await self._close_components()
 
     async def _close_components(self):
-        """Releases the threads and network connections used by the SDK
-        components. The public :meth:`close` wraps this with a timeout."""
+        """Stop the SDK components and release the shared HTTP session."""
         log.info("Closing LaunchDarkly client..")
+
         await self._data_system.stop()
         await self.__big_segment_store_manager.stop()
 
-        # The event processor is last because it may still be sending events that were generated by the other components.
+        # The event processor is last because it may still be sending events the
+        # other components generated.
         await self._event_processor.stop()
 
+        if self._session is not None:
+            try:
+                await self._session.close()
+            except Exception as e:
+                log.warning("Error closing HTTP session: %s", e)
+            self._session = None
+
     async def __start_up(self, start_wait: float):
         environment_metadata = get_environment_metadata(self._config, "python-server-sdk-async")
         plugin_hooks = get_plugin_hooks(self._config.plugins, environment_metadata)

ldclient/testing/test_async_client.py

@@ -127,6 +127,7 @@ async def test_flush_delegates_to_event_processor():
     # Replace the event processor with a mock that tracks flush calls
     mock_ep = MagicMock()
     mock_ep.flush = MagicMock(return_value=None)
+    mock_ep.stop = AsyncMock()
     client._event_processor = mock_ep
 
     await client.flush()
@@ -143,6 +144,7 @@ async def test_flush_is_noop_when_offline():
 
     mock_ep = MagicMock()
     mock_ep.flush = MagicMock(return_value=None)
+    mock_ep.stop = AsyncMock()
     client._event_processor = mock_ep
 
     await client.flush()
@@ -384,8 +386,9 @@ def boom(*args, **kwargs):
 
     with pytest.raises(RuntimeError):
         await client.start()
-    # A failed start marks the client started (spent); a retry is a no-op.
+    # A failed start marks the client started (spent) and closed (torn down).
     assert client._started is True
+    assert client._closed is True
 
     # Retry does not re-run start-up (it would raise again if it did).
     await client.start()
@@ -398,14 +401,14 @@ async def test_start_cleans_up_and_propagates_on_cancellation(monkeypatch):
     client = AsyncLDClient(_offline_config())
 
     cleaned = False
-    original_cleanup = client._cleanup_partial_start
+    original_cleanup = client._close_components
 
-    async def spy_cleanup():
+    async def spy_cleanup(*args, **kwargs):
         nonlocal cleaned
         cleaned = True
-        await original_cleanup()
+        await original_cleanup(*args, **kwargs)
 
-    client._cleanup_partial_start = spy_cleanup
+    client._close_components = spy_cleanup
 
     def cancel(*args, **kwargs):
         raise asyncio.CancelledError()
@@ -416,9 +419,11 @@ def cancel(*args, **kwargs):
         await client.start()
 
     # Cleanup ran (stopping the started components), the instance is spent
-    # (single-shot via _started), and the CancelledError propagated.
+    # (single-shot via _started), it is closed, and the CancelledError
+    # propagated.
     assert cleaned is True
     assert client._started is True
+    assert client._closed is True
 
 
 @pytest.mark.asyncio