Skip to content

The agent engineering platform.

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.py
index 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, _MemoryStream
from langchain_core.utils.aiter import aclosing
from 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.py
index 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, GenerationChunk
from langchain_core.runnables import RunnableConfig, ensure_config
from langchain_core.tracers._streaming import _StreamingCallbackHandler
from 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, _MemoryStream
if TYPE_CHECKING:
from collections.abc import AsyncIterator, Iterator, Sequence
@@ -287,11 +287,7 @@ class LogStreamCallbackHandler(BaseTracer, _StreamingCallbackHandler[Any]):
self.exclude_types = exclude_types
self.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.py
index 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 weakref
from asyncio import AbstractEventLoop, Queue
from collections.abc import AsyncIterator
from typing import Any, Generic, TypeVar
@@ -16,6 +18,56 @@ from typing import Any, Generic, TypeVar
T = 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: object
diff --git a/libs/core/tests/unit_tests/tracers/test_memory_stream.py b/libs/core/tests/unit_tests/tracers/test_memory_stream.py
index 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 gc
import math
+import threading
import 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()