|
1 | 1 | import asyncio |
2 | 2 | import contextvars |
3 | 3 | import gc |
| 4 | +import inspect |
4 | 5 | import json |
5 | 6 | import sys |
6 | 7 | from typing import Any, AsyncGenerator, Generator, cast |
7 | 8 |
|
8 | 9 | import pytest |
9 | 10 |
|
10 | 11 | from langfuse import observe |
| 12 | +from langfuse._client import observe as observe_module |
11 | 13 | from langfuse._client.attributes import LangfuseOtelSpanAttributes |
12 | 14 | from langfuse._client.observe import ( |
13 | 15 | _ContextPreservedAsyncGeneratorWrapper, |
@@ -270,21 +272,220 @@ async def generator() -> AsyncGenerator[str, None]: |
270 | 272 | assert span.ended == 1 |
271 | 273 |
|
272 | 274 |
|
| 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 | + |
273 | 313 | @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( |
275 | 410 | monkeypatch: pytest.MonkeyPatch, |
276 | 411 | ) -> 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 | + |
278 | 415 | seen: list[str] = [] |
279 | | - original_create_task = asyncio.create_task |
280 | 416 |
|
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 | + } |
284 | 454 |
|
285 | | - return original_create_task(*args, **kwargs) |
286 | 455 |
|
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) |
288 | 489 |
|
289 | 490 | async def generator() -> AsyncGenerator[str, None]: |
290 | 491 | try: |
|
0 commit comments