Skip to content

Commit 9239fab

Browse files
authored
fix(observe): defer span end when a cancellation never resumed the generator (#1792)
1 parent 38ee902 commit 9239fab

2 files changed

Lines changed: 259 additions & 22 deletions

File tree

‎langfuse/_client/observe.py‎

Lines changed: 50 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@
22
import contextvars
33
import inspect
44
import os
5+
import sys
56
from functools import wraps
67
from typing import (
78
Any,
@@ -48,6 +49,8 @@
4849
P = ParamSpec("P")
4950
R = TypeVar("R")
5051

52+
_ASYNCIO_CREATE_TASK_SUPPORTS_CONTEXT = sys.version_info >= (3, 11)
53+
5154

5255
class LangfuseDecorator:
5356
"""Implementation of the @observe decorator for seamless Langfuse tracing integration.
@@ -616,6 +619,8 @@ def _finalize_with_error(self, error: BaseException) -> None:
616619

617620
def close(self) -> None:
618621
if self._span_ended:
622+
# Still close the generator so cleanup runs in the preserved context, not at GC time.
623+
self.context.run(self.generator.close)
619624
return
620625

621626
try:
@@ -678,10 +683,23 @@ def __init__(
678683
self.capture_output = capture_output
679684
self.transform_fn = transform_fn
680685
self._span_ended = False
686+
self._pending_error: Optional[BaseException] = None
681687

682688
def __aiter__(self) -> "_ContextPreservedAsyncGeneratorWrapper":
683689
return self
684690

691+
def _generator_never_resumed(self) -> bool:
692+
try:
693+
state = inspect.getasyncgenstate(self.generator)
694+
except (AttributeError, TypeError):
695+
# getasyncgenstate is Python 3.12+; fall back to the attributes it reads.
696+
frame = getattr(self.generator, "ag_frame", None)
697+
return frame is not None and not getattr(
698+
self.generator, "ag_running", False
699+
)
700+
701+
return state in ("AGEN_CREATED", "AGEN_SUSPENDED")
702+
685703
def _finalize(self) -> None:
686704
if self._span_ended:
687705
return
@@ -711,39 +729,50 @@ def _finalize_with_error(self, error: BaseException) -> None:
711729

712730
async def aclose(self) -> None:
713731
if self._span_ended:
732+
# Still close the generator so cleanup runs in the preserved context, not at GC time.
733+
await self._close_generator()
714734
return
715735

716736
try:
717-
try:
718-
await asyncio.create_task(
719-
self.generator.aclose(),
720-
context=self.context,
721-
) # type: ignore
722-
except TypeError:
723-
await self.context.run(asyncio.create_task, self.generator.aclose())
737+
await self._close_generator()
724738
except (Exception, asyncio.CancelledError) as error:
725739
self._finalize_with_error(error)
726740
raise
727741
else:
728-
self._finalize()
742+
if self._pending_error is not None:
743+
self._finalize_with_error(self._pending_error)
744+
else:
745+
self._finalize()
746+
747+
async def _close_generator(self) -> None:
748+
if _ASYNCIO_CREATE_TASK_SUPPORTS_CONTEXT:
749+
close_task = asyncio.create_task(
750+
self.generator.aclose(),
751+
context=self.context,
752+
) # type: ignore
753+
else:
754+
close_task = self.context.run(asyncio.create_task, self.generator.aclose())
755+
756+
await close_task
729757

730758
async def close(self) -> None:
731759
await self.aclose()
732760

733761
def __del__(self) -> None:
734-
self._finalize()
762+
if self._pending_error is not None:
763+
self._finalize_with_error(self._pending_error)
764+
else:
765+
self._finalize()
735766

736767
async def __anext__(self) -> Any:
737768
try:
738769
# Run the generator's __anext__ in the preserved context
739-
try:
740-
# Python 3.11+ approach with explicit task context
770+
if _ASYNCIO_CREATE_TASK_SUPPORTS_CONTEXT:
741771
item = await asyncio.create_task(
742772
self.generator.__anext__(), # type: ignore
743773
context=self.context,
744774
) # type: ignore
745-
except TypeError:
746-
# Python 3.10 fallback - create the task inside the preserved context.
775+
else:
747776
item = await self.context.run(
748777
asyncio.create_task,
749778
self.generator.__anext__(), # type: ignore
@@ -757,6 +786,13 @@ async def __anext__(self) -> Any:
757786
except StopAsyncIteration:
758787
self._finalize()
759788
raise # Re-raise StopAsyncIteration
760-
except (Exception, asyncio.CancelledError) as e:
789+
except asyncio.CancelledError as e:
790+
if self._generator_never_resumed():
791+
# Defer span end so aclose() can run the generator's cleanup first.
792+
self._pending_error = e
793+
raise
794+
self._finalize_with_error(e)
795+
raise
796+
except Exception as e:
761797
self._finalize_with_error(e)
762798
raise

‎tests/unit/test_observe.py‎

Lines changed: 209 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,15 @@
11
import asyncio
22
import contextvars
33
import gc
4+
import inspect
45
import json
56
import sys
67
from typing import Any, AsyncGenerator, Generator, cast
78

89
import pytest
910

1011
from langfuse import observe
12+
from langfuse._client import observe as observe_module
1113
from langfuse._client.attributes import LangfuseOtelSpanAttributes
1214
from langfuse._client.observe import (
1315
_ContextPreservedAsyncGeneratorWrapper,
@@ -270,21 +272,220 @@ async def generator() -> AsyncGenerator[str, None]:
270272
assert span.ended == 1
271273

272274

275+
def test_sync_generator_wrapper_close_closes_generator_after_span_ended() -> None:
276+
marker = contextvars.ContextVar("marker", default="ambient")
277+
seen: list[str] = []
278+
279+
def generator() -> Generator[str, None, None]:
280+
try:
281+
yield "item_0"
282+
yield "item_1"
283+
finally:
284+
seen.append(marker.get())
285+
286+
span = SpanRecorder()
287+
context = contextvars.copy_context()
288+
context.run(marker.set, "preserved")
289+
wrapper = _ContextPreservedSyncGeneratorWrapper(
290+
generator(),
291+
context,
292+
cast(Any, span),
293+
False,
294+
None,
295+
)
296+
297+
assert next(wrapper) == "item_0"
298+
299+
# An error from __next__ that never resumed the generator ends the span.
300+
with pytest.raises(RuntimeError):
301+
context.run(lambda: next(wrapper))
302+
303+
assert span.ended == 1
304+
assert seen == []
305+
306+
marker.set("ambient-now")
307+
wrapper.close()
308+
309+
assert seen == ["preserved"]
310+
assert span.ended == 1
311+
312+
273313
@pytest.mark.asyncio
274-
async def test_async_generator_wrapper_fallback_preserves_context(
314+
async def test_async_generator_wrapper_aclose_closes_generator_after_span_ended() -> (
315+
None
316+
):
317+
marker = contextvars.ContextVar("marker", default="ambient")
318+
seen: list[str] = []
319+
320+
async def generator() -> AsyncGenerator[str, None]:
321+
try:
322+
yield "item_0"
323+
yield "item_1"
324+
finally:
325+
seen.append(marker.get())
326+
327+
span = SpanRecorder()
328+
context = contextvars.copy_context()
329+
context.run(marker.set, "preserved")
330+
wrapper = _ContextPreservedAsyncGeneratorWrapper(
331+
generator(),
332+
context,
333+
cast(Any, span),
334+
False,
335+
None,
336+
)
337+
338+
assert await wrapper.__anext__() == "item_0"
339+
340+
# Span ends while the generator is still suspended.
341+
wrapper._finalize_with_error(RuntimeError("ended early"))
342+
assert span.ended == 1
343+
assert seen == []
344+
345+
marker.set("ambient-now")
346+
await wrapper.aclose()
347+
348+
assert seen == ["preserved"]
349+
assert span.ended == 1
350+
351+
352+
@pytest.mark.asyncio
353+
async def test_async_generator_wrapper_defers_span_end_for_unresumed_cancel() -> None:
354+
marker = contextvars.ContextVar("marker", default="ambient")
355+
seen: list[str] = []
356+
cleanup_span_states: list[int] = []
357+
358+
async def generator() -> AsyncGenerator[str, None]:
359+
try:
360+
yield "item_0"
361+
yield "item_1"
362+
finally:
363+
seen.append(marker.get())
364+
cleanup_span_states.append(span.ended)
365+
span.update(cleanup=True)
366+
367+
span = SpanRecorder()
368+
context = contextvars.copy_context()
369+
context.run(marker.set, "preserved")
370+
raw = generator()
371+
wrapper = _ContextPreservedAsyncGeneratorWrapper(
372+
raw,
373+
context,
374+
cast(Any, span),
375+
False,
376+
None,
377+
)
378+
379+
async def consume() -> None:
380+
async for _ in wrapper:
381+
await asyncio.sleep(0)
382+
383+
consumer = asyncio.create_task(consume())
384+
for _ in range(4):
385+
await asyncio.sleep(0)
386+
# Cancel lands before the inner __anext__ task's first step.
387+
asyncio.get_running_loop().call_soon(consumer.cancel)
388+
with pytest.raises(asyncio.CancelledError):
389+
await consumer
390+
391+
assert raw.ag_frame is not None # still suspended, never resumed
392+
# Span end is deferred so the generator's cleanup can still update it.
393+
assert span.ended == 0
394+
395+
marker.set("ambient-now")
396+
await wrapper.aclose()
397+
398+
assert raw.ag_frame is None # closed
399+
assert seen == ["preserved"]
400+
assert cleanup_span_states == [0]
401+
assert span.ended == 1
402+
assert span.updates == [
403+
{"cleanup": True},
404+
{"level": "ERROR", "status_message": "CancelledError"},
405+
]
406+
407+
408+
@pytest.mark.asyncio
409+
async def test_async_generator_wrapper_defers_unresumed_cancel_without_inspect_api(
275410
monkeypatch: pytest.MonkeyPatch,
276411
) -> None:
277-
marker = contextvars.ContextVar("marker", default="ambient")
412+
# Python < 3.12 has no inspect.getasyncgenstate; the fallback must still defer.
413+
monkeypatch.delattr(inspect, "getasyncgenstate", raising=False)
414+
278415
seen: list[str] = []
279-
original_create_task = asyncio.create_task
280416

281-
def create_task_with_type_error(*args: Any, **kwargs: Any) -> asyncio.Task[Any]:
282-
if "context" in kwargs:
283-
raise TypeError("context argument unsupported")
417+
async def generator() -> AsyncGenerator[str, None]:
418+
try:
419+
yield "item_0"
420+
yield "item_1"
421+
finally:
422+
seen.append("closed")
423+
424+
span = SpanRecorder()
425+
wrapper = _ContextPreservedAsyncGeneratorWrapper(
426+
generator(),
427+
contextvars.copy_context(),
428+
cast(Any, span),
429+
False,
430+
None,
431+
)
432+
433+
async def consume() -> None:
434+
async for _ in wrapper:
435+
await asyncio.sleep(0)
436+
437+
consumer = asyncio.create_task(consume())
438+
for _ in range(4):
439+
await asyncio.sleep(0)
440+
asyncio.get_running_loop().call_soon(consumer.cancel)
441+
with pytest.raises(asyncio.CancelledError):
442+
await consumer
443+
444+
assert span.ended == 0
445+
446+
await wrapper.aclose()
447+
448+
assert seen == ["closed"]
449+
assert span.ended == 1
450+
assert span.updates[-1] == {
451+
"level": "ERROR",
452+
"status_message": "CancelledError",
453+
}
284454

285-
return original_create_task(*args, **kwargs)
286455

287-
monkeypatch.setattr(asyncio, "create_task", create_task_with_type_error)
456+
@pytest.mark.asyncio
457+
async def test_async_generator_wrapper_aclose_propagates_cleanup_type_error() -> None:
458+
async def generator() -> AsyncGenerator[str, None]:
459+
try:
460+
yield "item_0"
461+
finally:
462+
raise TypeError("cleanup failed")
463+
464+
span = SpanRecorder()
465+
wrapper = _ContextPreservedAsyncGeneratorWrapper(
466+
generator(),
467+
contextvars.copy_context(),
468+
cast(Any, span),
469+
False,
470+
None,
471+
)
472+
473+
assert await wrapper.__anext__() == "item_0"
474+
475+
with pytest.raises(TypeError, match="cleanup failed"):
476+
await wrapper.aclose()
477+
478+
assert span.ended == 1
479+
assert span.updates[-1] == {"level": "ERROR", "status_message": "cleanup failed"}
480+
481+
482+
@pytest.mark.asyncio
483+
async def test_async_generator_wrapper_fallback_preserves_context(
484+
monkeypatch: pytest.MonkeyPatch,
485+
) -> None:
486+
marker = contextvars.ContextVar("marker", default="ambient")
487+
seen: list[str] = []
488+
monkeypatch.setattr(observe_module, "_ASYNCIO_CREATE_TASK_SUPPORTS_CONTEXT", False)
288489

289490
async def generator() -> AsyncGenerator[str, None]:
290491
try:

0 commit comments

Comments
 (0)