The agent engineering platform.
Python agentsaiai-agentsanthropicchatgptdeepagentsenterpriseframeworkgeminigenerative-ailangchainlanggraphllmmultiagentopen-sourceopenaipydanticpythonragtypescript
fix(core): close internally created event loops in streaming tracers (#39222)
Mason Daughertya6b904fd5b1e
diff --git a/libs/core/langchain_core/tracers/event_stream.py b/libs/core/langchain_core/tracers/event_stream.pyindex 6e406827db..764ff72f8b 100644--- a/libs/core/langchain_core/tracers/event_stream.py+++ b/libs/core/langchain_core/tracers/event_stream.py@@ -40,7 +40,7 @@ from langchain_core.tracers.log_stream import (RunLog,_astream_log_implementation,)-from langchain_core.tracers.memory_stream import _MemoryStream+from langchain_core.tracers.memory_stream import _get_or_create_loop, _MemoryStreamfrom langchain_core.utils.aiter import aclosingfrom langchain_core.utils.uuid import uuid7@@ -139,11 +139,7 @@ class _AstreamEventsCallbackHandler(exclude_tags=exclude_tags,)- try:- loop = asyncio.get_event_loop()- except RuntimeError:- loop = asyncio.new_event_loop()- memory_stream = _MemoryStream[StreamEvent](loop)+ memory_stream = _MemoryStream[StreamEvent](_get_or_create_loop(self))self.send_stream = memory_stream.get_send_stream()self.receive_stream = memory_stream.get_receive_stream()diff --git a/libs/core/langchain_core/tracers/log_stream.py b/libs/core/langchain_core/tracers/log_stream.pyindex 3bb2889b9d..92b5bd20b3 100644--- a/libs/core/langchain_core/tracers/log_stream.py+++ b/libs/core/langchain_core/tracers/log_stream.py@@ -26,7 +26,7 @@ from langchain_core.outputs import ChatGenerationChunk, GenerationChunkfrom langchain_core.runnables import RunnableConfig, ensure_configfrom langchain_core.tracers._streaming import _StreamingCallbackHandlerfrom langchain_core.tracers.base import BaseTracer-from langchain_core.tracers.memory_stream import _MemoryStream+from langchain_core.tracers.memory_stream import _get_or_create_loop, _MemoryStreamif TYPE_CHECKING:from collections.abc import AsyncIterator, Iterator, Sequence@@ -287,11 +287,7 @@ class LogStreamCallbackHandler(BaseTracer, _StreamingCallbackHandler[Any]):self.exclude_types = exclude_typesself.exclude_tags = exclude_tags- try:- loop = asyncio.get_event_loop()- except RuntimeError:- loop = asyncio.new_event_loop()- memory_stream = _MemoryStream[RunLogPatch](loop)+ memory_stream = _MemoryStream[RunLogPatch](_get_or_create_loop(self))self.lock = threading.Lock()self.send_stream = memory_stream.get_send_stream()self.receive_stream = memory_stream.get_receive_stream()diff --git a/libs/core/langchain_core/tracers/memory_stream.py b/libs/core/langchain_core/tracers/memory_stream.pyindex 9047e60105..878f1703c2 100644--- a/libs/core/langchain_core/tracers/memory_stream.py+++ b/libs/core/langchain_core/tracers/memory_stream.py@@ -9,6 +9,8 @@ code."""import asyncio+import contextlib+import weakreffrom asyncio import AbstractEventLoop, Queuefrom collections.abc import AsyncIteratorfrom typing import Any, Generic, TypeVar@@ -16,6 +18,56 @@ from typing import Any, Generic, TypeVarT = TypeVar("T")+def _close_loop_quietly(loop: AbstractEventLoop) -> None:+ """Close an event loop that was created internally, as a finalizer callback.++ Errors are suppressed rather than logged. `weakref.finalize` defaults to+ `atexit=True`, so this can run during interpreter shutdown, where `logging`+ may already be torn down. Python routes finalizer exceptions to+ `sys.unraisablehook` rather than propagating them, so suppressing here only+ avoids dumping a traceback to stderr at a nondeterministic moment, which is+ the same kind of noise this cleanup exists to remove. If `close()` does+ fail, the loop's own `__del__` still emits+ `ResourceWarning: unclosed event loop`, so the leak stays detectable.++ Args:+ loop: The event loop to close. A running loop is left alone.+ """+ if loop.is_running():+ # `close()` would raise; leave the `ResourceWarning` as the signal.+ return+ with contextlib.suppress(Exception):+ loop.close()+++def _get_or_create_loop(owner: object) -> AbstractEventLoop:+ """Get the current event loop, creating one if this thread has none.++ Args:+ owner: Object whose lifetime bounds a loop created here.++ A loop created by this function is closed once `owner` is+ garbage collected.++ Returns:+ The event loop to back a `_MemoryStream` with.+ """+ try:+ return asyncio.get_event_loop()+ except RuntimeError:+ # No loop is set on this thread. That is always the case in a sync+ # context on Python 3.14+, where `get_event_loop()` no longer creates+ # one implicitly, and on any version in a non-main thread.+ #+ # This loop is ours: unlike one returned by `get_event_loop()`, no+ # caller owns it, so close it once `owner` dies. Otherwise the loop's+ # `__del__` emits `ResourceWarning: unclosed event loop` at whatever+ # nondeterministic point GC happens to run.+ loop = asyncio.new_event_loop()+ weakref.finalize(owner, _close_loop_quietly, loop)+ return loop++class _SendStream(Generic[T]):def __init__(self, reader_loop: AbstractEventLoop, queue: Queue[Any], done: objectdiff --git a/libs/core/tests/unit_tests/tracers/test_memory_stream.py b/libs/core/tests/unit_tests/tracers/test_memory_stream.pyindex c0840a3c19..9898b76c9b 100644--- a/libs/core/tests/unit_tests/tracers/test_memory_stream.py+++ b/libs/core/tests/unit_tests/tracers/test_memory_stream.py@@ -1,9 +1,17 @@import asyncio+import gcimport math+import threadingimport time-from collections.abc import AsyncIterator+import weakref+from collections.abc import AsyncIterator, Callable+from typing import Any, TypeVar-from langchain_core.tracers.memory_stream import _MemoryStream+from langchain_core.tracers.event_stream import _AstreamEventsCallbackHandler+from langchain_core.tracers.log_stream import LogStreamCallbackHandler+from langchain_core.tracers.memory_stream import _close_loop_quietly, _MemoryStream++T = TypeVar("T")async def test_same_event_loop() -> None:@@ -138,3 +146,106 @@ async def test_closed_stream() -> None:await writer.aclose()assert [chunk async for chunk in reader] == []+++def _run_in_thread(fn: Callable[[], T]) -> T:+ """Run `fn` in a worker thread and return its result.++ Two reasons for the thread: a worker thread never has an implicit current+ event loop on any supported Python version, which is what forces the+ `asyncio.new_event_loop()` fallback in `_get_or_create_loop`; and event loop+ policy state is thread-local, so any loop set here cannot leak into the rest+ of the test session and change which branch later tests take.+ """+ result: list[T] = []+ thread = threading.Thread(target=lambda: result.append(fn()))+ thread.start()+ thread.join()+ assert len(result) == 1, "worker thread raised before returning (see stderr)"+ return result[0]+++def _make_handlers() -> list[Any]:+ """Construct one handler of each streaming type from a sync context."""+ return [_AstreamEventsCallbackHandler(), LogStreamCallbackHandler()]+++def test_internally_created_event_loop_is_closed() -> None:+ """Regression test for `ResourceWarning: unclosed event loop` at GC time.++ When a streaming callback handler is constructed from a synchronous context+ with no current event loop, it falls back to `asyncio.new_event_loop()`.+ That loop must be closed once the handler is garbage collected; otherwise+ the loop's `__del__` emits a `ResourceWarning` at whatever nondeterministic+ point GC runs. Landing inside a `warnings.catch_warnings(record=True)`+ block turns the leak into an order-dependent flaky failure.++ Asserts the loop is positively closed rather than merely that no warning+ appeared, so the test cannot pass vacuously if the handler stops being+ collectible (e.g. via a global registry or a reference cycle).+ """+ handlers = _run_in_thread(_make_handlers)+ loops = [handler.send_stream._reader_loop for handler in handlers]+ assert len(loops) == 2+ assert all(not loop.is_closed() for loop in loops)++ refs = [weakref.ref(handler) for handler in handlers]+ handlers.clear()+ gc.collect()++ assert all(ref() is None for ref in refs), (+ "handlers were not collected, so the assertion below would be vacuous"+ )+ assert all(loop.is_closed() for loop in loops), (+ "finalizer did not close the internally created event loop"+ )+++def test_caller_owned_event_loop_is_not_closed() -> None:+ """A loop we did not create must be left alone when the handler is GCed.++ The complement of `test_internally_created_event_loop_is_closed`, and the+ more dangerous half to get wrong: closing a loop the caller owns would+ break user code at an arbitrary GC point, silently, since+ `_close_loop_quietly` suppresses errors.+ """++ def construct() -> tuple[asyncio.AbstractEventLoop, list[Any]]:+ caller_loop = asyncio.new_event_loop()+ asyncio.set_event_loop(caller_loop)+ return caller_loop, _make_handlers()++ caller_loop, handlers = _run_in_thread(construct)+ try:+ assert all(+ handler.send_stream._reader_loop is caller_loop for handler in handlers+ ), "handlers did not adopt the caller's loop, so this test proves nothing"++ handlers.clear()+ gc.collect()++ assert not caller_loop.is_closed(), (+ "a caller-owned event loop must not be closed when the handler that "+ "borrowed it is garbage collected"+ )+ finally:+ caller_loop.close()+++def test_close_loop_quietly_leaves_running_loop_open() -> None:+ """A running loop cannot be closed, so the finalizer must not try."""++ async def close_self_while_running() -> bool:+ loop = asyncio.get_running_loop()+ _close_loop_quietly(loop)+ return loop.is_closed()++ loop = asyncio.new_event_loop()+ try:+ assert loop.run_until_complete(close_self_while_running()) is False+ finally:+ loop.close()++ # Idempotent on an already-closed loop.+ _close_loop_quietly(loop)+ assert loop.is_closed()