Skip to content

Same agent Smaller bill. The tools and infrastructure to get more work from your AI. Fewer tokens. Less compute. Lower cost.

8.3 KB
Raw Blame
"""Tests that an early-exited OpenAI stream still ends and exports its span."""

import pytest
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter

from openlit.instrumentation.openai.async_openai import async_chat_completions
from openlit.instrumentation.openai.openai import chat_completions
from openlit._config import OpenlitConfig


def _tracer_and_exporter():
    OpenlitConfig.reset_to_defaults()
    exporter = InMemorySpanExporter()
    tracer_provider = TracerProvider()
    tracer_provider.add_span_processor(SimpleSpanProcessor(exporter))
    return tracer_provider.get_tracer("test-openai-stream-lifecycle"), exporter


def _chat_kwargs():
    return {
        "model": "gpt-4o",
        "messages": [{"role": "user", "content": "ping"}],
        "stream": True,
    }


_CHUNK = {
    "id": "chatcmpl-test",
    "model": "gpt-4o",
    "choices": [{"index": 0, "delta": {"content": "hi"}, "finish_reason": None}],
}


class FakeRawSyncStream:
    """Minimal stand-in for openai._streaming.Stream: supports the context
    manager + iterator protocol and an explicit close(), never driven to
    exhaustion by this test. raise_on_close reproduces a client disconnect
    or network error surfacing through the wrapped stream's own close(),
    which must not prevent span finalization (review on #1455)."""

    def __init__(self, chunks, raise_on_close=False):
        self._chunks = list(chunks)
        self.closed = False
        self._raise_on_close = raise_on_close

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        self.close()

    def __iter__(self):
        return self

    def __next__(self):
        if not self._chunks:
            raise StopIteration
        return self._chunks.pop(0)

    def close(self):
        """Mark closed, matching openai._streaming.Stream.close()."""
        self.closed = True
        if self._raise_on_close:
            raise RuntimeError("wrapped close failed")


class FakeRawAsyncStream:
    """Async twin of FakeRawSyncStream."""

    def __init__(self, chunks, raise_on_close=False):
        self._chunks = list(chunks)
        self.closed = False
        self._raise_on_close = raise_on_close

    async def __aenter__(self):
        return self

    async def __aexit__(self, exc_type, exc_value, traceback):
        await self.close()

    def __aiter__(self):
        return self

    async def __anext__(self):
        if not self._chunks:
            raise StopAsyncIteration
        return self._chunks.pop(0)

    async def close(self):
        """Mark closed, matching openai._streaming.AsyncStream.close()."""
        self.closed = True
        if self._raise_on_close:
            raise RuntimeError("wrapped close failed")


def test_sync_stream_closed_via_context_manager_break_still_exports_span():
    """An early `break` inside a `with ... as stream:` block must still end
    and export the span, with whatever content had already streamed in."""

    tracer, exporter = _tracer_and_exporter()
    wrapper = chat_completions(
        version="test-version",
        environment="test-env",
        application_name="test-app",
        tracer=tracer,
        pricing_info={},
        capture_message_content=False,
        metrics=None,
        disable_metrics=True,
    )

    raw_stream = FakeRawSyncStream([_CHUNK, _CHUNK])

    def fake_create(*_args, **_kwargs):
        return raw_stream

    traced_stream = wrapper(fake_create, object(), [], _chat_kwargs())

    with traced_stream as stream:
        for _chunk in stream:
            break

    assert raw_stream.closed
    spans = exporter.get_finished_spans()
    assert len(spans) == 1
    assert spans[0].name == "chat gpt-4o"


def test_sync_stream_explicit_close_still_exports_span():
    """Calling .close() directly (no context manager) must also finalize."""

    tracer, exporter = _tracer_and_exporter()
    wrapper = chat_completions(
        version="test-version",
        environment="test-env",
        application_name="test-app",
        tracer=tracer,
        pricing_info={},
        capture_message_content=False,
        metrics=None,
        disable_metrics=True,
    )

    raw_stream = FakeRawSyncStream([_CHUNK])

    def fake_create(*_args, **_kwargs):
        return raw_stream

    traced_stream = wrapper(fake_create, object(), [], _chat_kwargs())
    next(traced_stream)
    traced_stream.close()

    assert raw_stream.closed
    spans = exporter.get_finished_spans()
    assert len(spans) == 1


def test_sync_stream_full_consumption_exports_exactly_one_span():
    """Full StopIteration consumption inside a `with` block must not
    double-finalize (both __next__ and __exit__ fire)."""

    tracer, exporter = _tracer_and_exporter()
    wrapper = chat_completions(
        version="test-version",
        environment="test-env",
        application_name="test-app",
        tracer=tracer,
        pricing_info={},
        capture_message_content=False,
        metrics=None,
        disable_metrics=True,
    )

    raw_stream = FakeRawSyncStream([_CHUNK])

    def fake_create(*_args, **_kwargs):
        return raw_stream

    traced_stream = wrapper(fake_create, object(), [], _chat_kwargs())

    with traced_stream as stream:
        for _chunk in stream:
            pass

    spans = exporter.get_finished_spans()
    assert len(spans) == 1


def test_sync_stream_close_still_exports_span_when_wrapped_close_raises():
    """If the wrapped stream's own close() raises (e.g. a network error on
    disconnect), the span must still be finalized and exported rather than
    silently dropped (Sourcery review on #1455: close() called the wrapped
    close() before _finalize_streaming_span(), so a raise there skipped
    finalization entirely)."""

    tracer, exporter = _tracer_and_exporter()
    wrapper = chat_completions(
        version="test-version",
        environment="test-env",
        application_name="test-app",
        tracer=tracer,
        pricing_info={},
        capture_message_content=False,
        metrics=None,
        disable_metrics=True,
    )

    raw_stream = FakeRawSyncStream([_CHUNK], raise_on_close=True)

    def fake_create(*_args, **_kwargs):
        return raw_stream

    traced_stream = wrapper(fake_create, object(), [], _chat_kwargs())
    next(traced_stream)

    with pytest.raises(RuntimeError):
        traced_stream.close()

    assert raw_stream.closed
    spans = exporter.get_finished_spans()
    assert len(spans) == 1


@pytest.mark.asyncio
async def test_async_stream_closed_via_context_manager_break_still_exports_span():
    """Async twin of the sync early-break test."""

    tracer, exporter = _tracer_and_exporter()
    wrapper = async_chat_completions(
        version="test-version",
        environment="test-env",
        application_name="test-app",
        tracer=tracer,
        pricing_info={},
        capture_message_content=False,
        metrics=None,
        disable_metrics=True,
    )

    raw_stream = FakeRawAsyncStream([_CHUNK, _CHUNK])

    async def fake_create(*_args, **_kwargs):
        return raw_stream

    traced_stream = await wrapper(fake_create, object(), [], _chat_kwargs())

    async with traced_stream as stream:
        async for _chunk in stream:
            break

    assert raw_stream.closed
    spans = exporter.get_finished_spans()
    assert len(spans) == 1


@pytest.mark.asyncio
async def test_async_stream_close_still_exports_span_when_wrapped_close_raises():
    """Async twin of test_sync_stream_close_still_exports_span_when_wrapped_close_raises."""

    tracer, exporter = _tracer_and_exporter()
    wrapper = async_chat_completions(
        version="test-version",
        environment="test-env",
        application_name="test-app",
        tracer=tracer,
        pricing_info={},
        capture_message_content=False,
        metrics=None,
        disable_metrics=True,
    )

    raw_stream = FakeRawAsyncStream([_CHUNK], raise_on_close=True)

    async def fake_create(*_args, **_kwargs):
        return raw_stream

    traced_stream = await wrapper(fake_create, object(), [], _chat_kwargs())
    await anext(traced_stream)

    with pytest.raises(RuntimeError):
        await traced_stream.close()

    assert raw_stream.closed
    spans = exporter.get_finished_spans()
    assert len(spans) == 1