Handle NonRecordingSpans correctly in OpenAI instrumentation (#1145)

Author: alexmojaki

logfire/_internal/integrations/llm_providers/llm_provider.py

@@ -5,7 +5,7 @@
 from typing import TYPE_CHECKING, Any, Callable, cast
 
 from ...constants import ONE_SECOND_IN_NANOSECONDS
-from ...utils import is_instrumentation_suppressed, suppress_instrumentation
+from ...utils import is_instrumentation_suppressed, log_internal_error, suppress_instrumentation
 
 if TYPE_CHECKING:
     from ...main import Logfire, LogfireSpan
@@ -80,44 +80,48 @@ def uninstrument_context():
     is_async = is_async_client_fn(client if isinstance(client, type) else type(client))
 
     def _instrumentation_setup(*args: Any, **kwargs: Any) -> Any:
-        if is_instrumentation_suppressed():
-            return None, None, kwargs
+        try:
+            if is_instrumentation_suppressed():
+                return None, None, kwargs
 
-        options = kwargs.get('options') or args[-1]
-        message_template, span_data, stream_state_cls = get_endpoint_config_fn(options)
-        if not message_template:
-            return None, None, kwargs
+            options = kwargs.get('options') or args[-1]
+            message_template, span_data, stream_state_cls = get_endpoint_config_fn(options)
+            if not message_template:
+                return None, None, kwargs
 
-        span_data['async'] = is_async
+            span_data['async'] = is_async
 
-        stream = kwargs['stream']
+            stream = kwargs['stream']
 
-        if stream and stream_state_cls:
-            stream_cls = kwargs['stream_cls']
-            assert stream_cls is not None, 'Expected `stream_cls` when streaming'
+            if stream and stream_state_cls:
+                stream_cls = kwargs['stream_cls']
+                assert stream_cls is not None, 'Expected `stream_cls` when streaming'
 
-            if is_async:
+                if is_async:
 
-                class LogfireInstrumentedAsyncStream(stream_cls):
-                    async def __stream__(self) -> AsyncIterator[Any]:
-                        with record_streaming(logfire_llm, span_data, stream_state_cls) as record_chunk:
-                            async for chunk in super().__stream__():  # type: ignore
-                                record_chunk(chunk)
-                                yield chunk
+                    class LogfireInstrumentedAsyncStream(stream_cls):
+                        async def __stream__(self) -> AsyncIterator[Any]:
+                            with record_streaming(logfire_llm, span_data, stream_state_cls) as record_chunk:
+                                async for chunk in super().__stream__():  # type: ignore
+                                    record_chunk(chunk)
+                                    yield chunk
 
-                kwargs['stream_cls'] = LogfireInstrumentedAsyncStream
-            else:
+                    kwargs['stream_cls'] = LogfireInstrumentedAsyncStream
+                else:
 
-                class LogfireInstrumentedStream(stream_cls):
-                    def __stream__(self) -> Iterator[Any]:
-                        with record_streaming(logfire_llm, span_data, stream_state_cls) as record_chunk:
-                            for chunk in super().__stream__():  # type: ignore
-                                record_chunk(chunk)
-                                yield chunk
+                    class LogfireInstrumentedStream(stream_cls):
+                        def __stream__(self) -> Iterator[Any]:
+                            with record_streaming(logfire_llm, span_data, stream_state_cls) as record_chunk:
+                                for chunk in super().__stream__():  # type: ignore
+                                    record_chunk(chunk)
+                                    yield chunk
 
-                kwargs['stream_cls'] = LogfireInstrumentedStream
+                    kwargs['stream_cls'] = LogfireInstrumentedStream
 
-        return message_template, span_data, kwargs
+            return message_template, span_data, kwargs
+        except Exception:  # pragma: no cover
+            log_internal_error()
+            return None, None, kwargs
 
     # In these methods, `*args` is only expected to be `(self,)`
     # in the case where we instrument classes rather than client instances.

logfire/_internal/integrations/llm_providers/openai.py

@@ -12,7 +12,6 @@
 from openai.types.create_embedding_response import CreateEmbeddingResponse
 from openai.types.images_response import ImagesResponse
 from openai.types.responses import Response
-from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.trace import get_current_span
 
 from logfire import LogfireSpan
@@ -94,10 +93,10 @@ def get_endpoint_config(options: FinalRequestOptions) -> EndpointConfig:
 def is_current_agent_span(*span_names: str):
     current_span = get_current_span()
     return (
-        isinstance(current_span, ReadableSpan)
-        and current_span.instrumentation_scope
-        and current_span.instrumentation_scope.name == 'logfire.openai_agents'
-        and current_span.name in span_names
+        current_span.is_recording()
+        and (instrumentation_scope := getattr(current_span, 'instrumentation_scope', None))
+        and instrumentation_scope.name == 'logfire.openai_agents'
+        and getattr(current_span, 'name', None) in span_names
     )
 
 
@@ -187,9 +186,13 @@ def on_response(response: ResponseT, span: LogfireSpan) -> ResponseT:
     elif isinstance(response, ImagesResponse):
         span.set_attribute('response_data', {'images': response.data})
     elif isinstance(response, Response):  # pragma: no branch
-        events = json.loads(span.attributes['events'])  # type: ignore
-        events += responses_output_events(response)
-        span.set_attribute('events', events)
+        try:
+            events = json.loads(span.attributes['events'])  # type: ignore
+        except Exception:
+            pass
+        else:
+            events += responses_output_events(response)
+            span.set_attribute('events', events)
 
     return response
 

tests/otel_integrations/cassettes/test_openai/test_responses_api_nonrecording.yaml

@@ -0,0 +1,104 @@
+interactions:
+- request:
+    body: '{"input":"hi","model":"gpt-4.1"}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate, zstd
+      connection:
+      - keep-alive
+      content-length:
+      - '32'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.86.0
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.86.0
+      x-stainless-read-timeout:
+      - '600'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.12.6
+    method: POST
+    uri: https://api.openai.com/v1/responses
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAA3RUwXKjMAy95yu8Pjcd00BCctlr9xvaHUaxRcLWWIwtd5vp5N93MISQbnphQE96
+        fnqS+VwIIRsjd0J6DF21LgulcGVKhXmZgYJ1saqhwD3kWwBcq40p1Lpe56YGgGwlH3oC2v9BzRcS
+        cgGHuPYIjKaCHss2hVKb9bbcJiwwcAx9jaa2s8hohqI96LeDp+h6VTXYgCmM3pOXO+GitSnQuEth
+        ZZChseEWDeyj5obcTbyFj4oid5Erpjf8ApJB20s6dLzMH7Plk3oqlipfZvnYaKqUO/GyEEKIz/Sc
+        HGzDYTIQTKl7A0vY1DVqDeUm325qvGtg4uBTh4kFQ4ADXoHvnEqgJsforpLmsm5oL03jB0/VKQGc
+        I4aLUS+/b8CUvhPyGa2lH+KZ/goNTvwSR7SdOFEUTAZOP8VrNOXKvEaDCuTEcB7fJlLpySY5EEIT
+        GBwPyX1iSpIdeLAWbcVEttJg01zZx2ENOo/vDcVQXTatSt5PI/QIgVzjDnI3+iCxrsnzLKn3NLYt
+        +NMYXAhxHpYS/XujseIG+12TBmuIdjBMBiaPcy2MbYceOKZw9qjGaLJsPLwm38L1ezaQlDc1P5w/
+        9HykRg8mRSY5AdfxSKau6uZn+uh0mmFS3QTY28t9immbJkGNu9n98uH/8Ow+Tao16COaa50alI/V
+        X29Ult0D7vFO8/qOmonBzpi3k1kx4M0PoUUGAww9/Xlx/gcAAP//AwChpk6j2wQAAA==
+    headers:
+      CF-RAY:
+      - 950a509f8f060714-CPT
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Mon, 16 Jun 2025 12:29:49 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=jeuQbol7J8yslwqEiMFKQOGwqn_sSNjE10ScC9yGaZM-1750076989-1.0.1.1-18DSSIpXUsRzxtm2_m5_5KeVD3l4lGJj77S_rsi0E3DfDhLeSOTgpu.aR6hCIJkjOzqzNeF03iPxXdTihETti4O7RuQBPChu7xmbqC2eGdM;
+        path=/; expires=Mon, 16-Jun-25 12:59:49 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=AfHPPG8IeRnW5Ieut_5AqKANl_AZEK61zM8VqZiePwg-1750076989962-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - pydantic-28gund
+      openai-processing-ms:
+      - '361'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      x-ratelimit-limit-requests:
+      - '10000'
+      x-ratelimit-limit-tokens:
+      - '2000000'
+      x-ratelimit-remaining-requests:
+      - '9999'
+      x-ratelimit-remaining-tokens:
+      - '1999972'
+      x-ratelimit-reset-requests:
+      - 6ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_6058ae08c495d2f122fcd029965b4e3a
+    status:
+      code: 200
+      message: OK
+version: 1

tests/otel_integrations/test_openai.py

@@ -2057,3 +2057,15 @@ def test_responses_api(exporter: TestExporter) -> None:
             },
         ]
     )
+
+
+@pytest.mark.vcr()
+def test_responses_api_nonrecording(exporter: TestExporter, config_kwargs: dict[str, Any]) -> None:
+    client = openai.Client()
+    logfire.instrument_openai(client)
+    logfire.configure(**config_kwargs, sampling=logfire.SamplingOptions(head=0))
+    with logfire.span('span'):
+        response = client.responses.create(model='gpt-4.1', input='hi')
+    assert response.output_text == snapshot('Hello! How can I help you today? 😊')
+
+    assert exporter.exported_spans_as_dict() == []