opentelemetry-instrumentation-openai 0.44.1__py3-none-any.whl → 0.44.3__py3-none-any.whl

opentelemetry/instrumentation/openai/shared/chat_wrappers.py

@@ -7,6 +7,7 @@ from functools import singledispatch
 from typing import List, Optional, Union
 
 from opentelemetry import context as context_api
+import pydantic
 from opentelemetry.instrumentation.openai.shared import (
     OPENAI_LLM_USAGE_TOKEN_TYPES,
     _get_openai_base_url,
@@ -47,12 +48,10 @@ from opentelemetry.semconv_ai import (
     SpanAttributes,
 )
 from opentelemetry.trace import SpanKind, Tracer
+from opentelemetry import trace
 from opentelemetry.trace.status import Status, StatusCode
 from wrapt import ObjectProxy
 
-from openai.types.chat import ChatCompletionMessageToolCall
-from openai.types.chat.chat_completion_message import FunctionCall
-
 SPAN_NAME = "openai.chat"
 PROMPT_FILTER_KEY = "prompt_filter_results"
 CONTENT_FILTER_KEY = "content_filter_results"
@@ -88,75 +87,77 @@ def chat_wrapper(
         attributes={SpanAttributes.LLM_REQUEST_TYPE: LLM_REQUEST_TYPE.value},
     )
 
-    run_async(_handle_request(span, kwargs, instance))
-    try:
-        start_time = time.time()
-        response = wrapped(*args, **kwargs)
-        end_time = time.time()
-    except Exception as e:  # pylint: disable=broad-except
-        end_time = time.time()
-        duration = end_time - start_time if "start_time" in locals() else 0
-
-        attributes = {
-            "error.type": e.__class__.__name__,
-        }
-
-        if duration > 0 and duration_histogram:
-            duration_histogram.record(duration, attributes=attributes)
-        if exception_counter:
-            exception_counter.add(1, attributes=attributes)
-
-        span.set_attribute(ERROR_TYPE, e.__class__.__name__)
-        span.record_exception(e)
-        span.set_status(Status(StatusCode.ERROR, str(e)))
-        span.end()
+    # Use the span as current context to ensure events get proper trace context
+    with trace.use_span(span, end_on_exit=False):
+        run_async(_handle_request(span, kwargs, instance))
+        try:
+            start_time = time.time()
+            response = wrapped(*args, **kwargs)
+            end_time = time.time()
+        except Exception as e:  # pylint: disable=broad-except
+            end_time = time.time()
+            duration = end_time - start_time if "start_time" in locals() else 0
+
+            attributes = {
+                "error.type": e.__class__.__name__,
+            }
 
-        raise
+            if duration > 0 and duration_histogram:
+                duration_histogram.record(duration, attributes=attributes)
+            if exception_counter:
+                exception_counter.add(1, attributes=attributes)
 
-    if is_streaming_response(response):
-        # span will be closed after the generator is done
-        if is_openai_v1():
-            return ChatStream(
-                span,
-                response,
-                instance,
-                token_counter,
-                choice_counter,
-                duration_histogram,
-                streaming_time_to_first_token,
-                streaming_time_to_generate,
-                start_time,
-                kwargs,
-            )
-        else:
-            return _build_from_streaming_response(
-                span,
-                response,
-                instance,
-                token_counter,
-                choice_counter,
-                duration_histogram,
-                streaming_time_to_first_token,
-                streaming_time_to_generate,
-                start_time,
-                kwargs,
-            )
+            span.set_attribute(ERROR_TYPE, e.__class__.__name__)
+            span.record_exception(e)
+            span.set_status(Status(StatusCode.ERROR, str(e)))
+            span.end()
 
-    duration = end_time - start_time
+            raise
 
-    _handle_response(
-        response,
-        span,
-        instance,
-        token_counter,
-        choice_counter,
-        duration_histogram,
-        duration,
-    )
+        if is_streaming_response(response):
+            # span will be closed after the generator is done
+            if is_openai_v1():
+                return ChatStream(
+                    span,
+                    response,
+                    instance,
+                    token_counter,
+                    choice_counter,
+                    duration_histogram,
+                    streaming_time_to_first_token,
+                    streaming_time_to_generate,
+                    start_time,
+                    kwargs,
+                )
+            else:
+                return _build_from_streaming_response(
+                    span,
+                    response,
+                    instance,
+                    token_counter,
+                    choice_counter,
+                    duration_histogram,
+                    streaming_time_to_first_token,
+                    streaming_time_to_generate,
+                    start_time,
+                    kwargs,
+                )
 
-    span.end()
+        duration = end_time - start_time
 
-    return response
+        _handle_response(
+            response,
+            span,
+            instance,
+            token_counter,
+            choice_counter,
+            duration_histogram,
+            duration,
+        )
+
+        span.end()
+
+        return response
 
 
 @_with_chat_telemetry_wrapper
@@ -184,78 +185,80 @@ async def achat_wrapper(
         attributes={SpanAttributes.LLM_REQUEST_TYPE: LLM_REQUEST_TYPE.value},
     )
 
-    await _handle_request(span, kwargs, instance)
+    # Use the span as current context to ensure events get proper trace context
+    with trace.use_span(span, end_on_exit=False):
+        await _handle_request(span, kwargs, instance)
 
-    try:
-        start_time = time.time()
-        response = await wrapped(*args, **kwargs)
-        end_time = time.time()
-    except Exception as e:  # pylint: disable=broad-except
-        end_time = time.time()
-        duration = end_time - start_time if "start_time" in locals() else 0
-
-        common_attributes = Config.get_common_metrics_attributes()
-        attributes = {
-            **common_attributes,
-            "error.type": e.__class__.__name__,
-        }
-
-        if duration > 0 and duration_histogram:
-            duration_histogram.record(duration, attributes=attributes)
-        if exception_counter:
-            exception_counter.add(1, attributes=attributes)
-
-        span.set_attribute(ERROR_TYPE, e.__class__.__name__)
-        span.record_exception(e)
-        span.set_status(Status(StatusCode.ERROR, str(e)))
-        span.end()
+        try:
+            start_time = time.time()
+            response = await wrapped(*args, **kwargs)
+            end_time = time.time()
+        except Exception as e:  # pylint: disable=broad-except
+            end_time = time.time()
+            duration = end_time - start_time if "start_time" in locals() else 0
+
+            common_attributes = Config.get_common_metrics_attributes()
+            attributes = {
+                **common_attributes,
+                "error.type": e.__class__.__name__,
+            }
 
-        raise
+            if duration > 0 and duration_histogram:
+                duration_histogram.record(duration, attributes=attributes)
+            if exception_counter:
+                exception_counter.add(1, attributes=attributes)
 
-    if is_streaming_response(response):
-        # span will be closed after the generator is done
-        if is_openai_v1():
-            return ChatStream(
-                span,
-                response,
-                instance,
-                token_counter,
-                choice_counter,
-                duration_histogram,
-                streaming_time_to_first_token,
-                streaming_time_to_generate,
-                start_time,
-                kwargs,
-            )
-        else:
-            return _abuild_from_streaming_response(
-                span,
-                response,
-                instance,
-                token_counter,
-                choice_counter,
-                duration_histogram,
-                streaming_time_to_first_token,
-                streaming_time_to_generate,
-                start_time,
-                kwargs,
-            )
+            span.set_attribute(ERROR_TYPE, e.__class__.__name__)
+            span.record_exception(e)
+            span.set_status(Status(StatusCode.ERROR, str(e)))
+            span.end()
 
-    duration = end_time - start_time
+            raise
 
-    _handle_response(
-        response,
-        span,
-        instance,
-        token_counter,
-        choice_counter,
-        duration_histogram,
-        duration,
-    )
+        if is_streaming_response(response):
+            # span will be closed after the generator is done
+            if is_openai_v1():
+                return ChatStream(
+                    span,
+                    response,
+                    instance,
+                    token_counter,
+                    choice_counter,
+                    duration_histogram,
+                    streaming_time_to_first_token,
+                    streaming_time_to_generate,
+                    start_time,
+                    kwargs,
+                )
+            else:
+                return _abuild_from_streaming_response(
+                    span,
+                    response,
+                    instance,
+                    token_counter,
+                    choice_counter,
+                    duration_histogram,
+                    streaming_time_to_first_token,
+                    streaming_time_to_generate,
+                    start_time,
+                    kwargs,
+                )
 
-    span.end()
+        duration = end_time - start_time
 
-    return response
+        _handle_response(
+            response,
+            span,
+            instance,
+            token_counter,
+            choice_counter,
+            duration_histogram,
+            duration,
+        )
+
+        span.end()
+
+        return response
 
 
 @dont_throw
@@ -961,8 +964,10 @@ async def _abuild_from_streaming_response(
     span.end()
 
 
+# pydantic.BaseModel here is ChatCompletionMessageFunctionToolCall (as of openai 1.99.7)
+# but we keep to a parent type to support older versions
 def _parse_tool_calls(
-    tool_calls: Optional[List[Union[dict, ChatCompletionMessageToolCall]]],
+    tool_calls: Optional[List[Union[dict, pydantic.BaseModel]]],
 ) -> Union[List[ToolCall], None]:
     """
     Util to correctly parse the tool calls data from the OpenAI API to this module's
@@ -976,12 +981,11 @@ def _parse_tool_calls(
     for tool_call in tool_calls:
         tool_call_data = None
 
-        # Handle dict or ChatCompletionMessageToolCall
         if isinstance(tool_call, dict):
             tool_call_data = copy.deepcopy(tool_call)
-        elif isinstance(tool_call, ChatCompletionMessageToolCall):
+        elif _is_chat_message_function_tool_call(tool_call):
             tool_call_data = tool_call.model_dump()
-        elif isinstance(tool_call, FunctionCall):
+        elif _is_function_call(tool_call):
             function_call = tool_call.model_dump()
             tool_call_data = ToolCall(
                 id="",
@@ -996,6 +1000,34 @@ def _parse_tool_calls(
     return result
 
 
+def _is_chat_message_function_tool_call(model: Union[dict, pydantic.BaseModel]) -> bool:
+    try:
+        from openai.types.chat.chat_completion_message_function_tool_call import (
+            ChatCompletionMessageFunctionToolCall,
+        )
+
+        return isinstance(model, ChatCompletionMessageFunctionToolCall)
+    except Exception:
+        try:
+            # Since OpenAI 1.99.3, ChatCompletionMessageToolCall is a Union,
+            # and the isinstance check will fail. This is fine, because in all
+            # those versions, the check above will succeed.
+            from openai.types.chat.chat_completion_message_tool_call import (
+                ChatCompletionMessageToolCall,
+            )
+            return isinstance(model, ChatCompletionMessageToolCall)
+        except Exception:
+            return False
+
+
+def _is_function_call(model: Union[dict, pydantic.BaseModel]) -> bool:
+    try:
+        from openai.types.chat.chat_completion_message import FunctionCall
+        return isinstance(model, FunctionCall)
+    except Exception:
+        return False
+
+
 @singledispatch
 def _parse_choice_event(choice) -> ChoiceEvent:
     has_message = choice.message is not None

opentelemetry/instrumentation/openai/shared/completion_wrappers.py

@@ -1,6 +1,7 @@
 import logging
 
 from opentelemetry import context as context_api
+from opentelemetry import trace
 from opentelemetry.instrumentation.openai.shared import (
     _set_client_attributes,
     _set_functions_attributes,
@@ -55,25 +56,27 @@ def completion_wrapper(tracer, wrapped, instance, args, kwargs):
         attributes={SpanAttributes.LLM_REQUEST_TYPE: LLM_REQUEST_TYPE.value},
     )
 
-    _handle_request(span, kwargs, instance)
+    # Use the span as current context to ensure events get proper trace context
+    with trace.use_span(span, end_on_exit=False):
+        _handle_request(span, kwargs, instance)
+
+        try:
+            response = wrapped(*args, **kwargs)
+        except Exception as e:
+            span.set_attribute(ERROR_TYPE, e.__class__.__name__)
+            span.record_exception(e)
+            span.set_status(Status(StatusCode.ERROR, str(e)))
+            span.end()
+            raise
+
+        if is_streaming_response(response):
+            # span will be closed after the generator is done
+            return _build_from_streaming_response(span, kwargs, response)
+        else:
+            _handle_response(response, span, instance)
 
-    try:
-        response = wrapped(*args, **kwargs)
-    except Exception as e:
-        span.set_attribute(ERROR_TYPE, e.__class__.__name__)
-        span.record_exception(e)
-        span.set_status(Status(StatusCode.ERROR, str(e)))
         span.end()
-        raise
-
-    if is_streaming_response(response):
-        # span will be closed after the generator is done
-        return _build_from_streaming_response(span, kwargs, response)
-    else:
-        _handle_response(response, span, instance)
-
-    span.end()
-    return response
+        return response
 
 
 @_with_tracer_wrapper
@@ -89,25 +92,27 @@ async def acompletion_wrapper(tracer, wrapped, instance, args, kwargs):
         attributes={SpanAttributes.LLM_REQUEST_TYPE: LLM_REQUEST_TYPE.value},
     )
 
-    _handle_request(span, kwargs, instance)
+    # Use the span as current context to ensure events get proper trace context
+    with trace.use_span(span, end_on_exit=False):
+        _handle_request(span, kwargs, instance)
+
+        try:
+            response = await wrapped(*args, **kwargs)
+        except Exception as e:
+            span.set_attribute(ERROR_TYPE, e.__class__.__name__)
+            span.record_exception(e)
+            span.set_status(Status(StatusCode.ERROR, str(e)))
+            span.end()
+            raise
+
+        if is_streaming_response(response):
+            # span will be closed after the generator is done
+            return _abuild_from_streaming_response(span, kwargs, response)
+        else:
+            _handle_response(response, span, instance)
 
-    try:
-        response = await wrapped(*args, **kwargs)
-    except Exception as e:
-        span.set_attribute(ERROR_TYPE, e.__class__.__name__)
-        span.record_exception(e)
-        span.set_status(Status(StatusCode.ERROR, str(e)))
         span.end()
-        raise
-
-    if is_streaming_response(response):
-        # span will be closed after the generator is done
-        return _abuild_from_streaming_response(span, kwargs, response)
-    else:
-        _handle_response(response, span, instance)
-
-    span.end()
-    return response
+        return response
 
 
 @dont_throw

opentelemetry/instrumentation/openai/v1/assistant_wrappers.py

@@ -2,6 +2,7 @@ import logging
 import time
 
 from opentelemetry import context as context_api
+from opentelemetry import trace
 from opentelemetry.instrumentation.openai.shared import (
     _set_span_attribute,
     model_as_dict,
@@ -127,110 +128,115 @@ def messages_list_wrapper(tracer, wrapped, instance, args, kwargs):
         attributes={SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.CHAT.value},
         start_time=run.get("start_time"),
     )
-    if exception := run.get("exception"):
-        span.set_attribute(ERROR_TYPE, exception.__class__.__name__)
-        span.record_exception(exception)
-        span.set_status(Status(StatusCode.ERROR, str(exception)))
-        span.end(run.get("end_time"))
-
-    prompt_index = 0
-    if assistants.get(run["assistant_id"]) is not None or Config.enrich_assistant:
-        if Config.enrich_assistant:
-            assistant = model_as_dict(
-                instance._client.beta.assistants.retrieve(run["assistant_id"])
-            )
-            assistants[run["assistant_id"]] = assistant
-        else:
-            assistant = assistants[run["assistant_id"]]
 
-        _set_span_attribute(
-            span,
-            SpanAttributes.LLM_SYSTEM,
-            "openai",
-        )
-        _set_span_attribute(
-            span,
-            SpanAttributes.LLM_REQUEST_MODEL,
-            assistant["model"],
-        )
-        _set_span_attribute(
-            span,
-            SpanAttributes.LLM_RESPONSE_MODEL,
-            assistant["model"],
-        )
-        if should_emit_events():
-            emit_event(MessageEvent(content=assistant["instructions"], role="system"))
-        else:
+    # Use the span as current context to ensure events get proper trace context
+    with trace.use_span(span, end_on_exit=False):
+        if exception := run.get("exception"):
+            span.set_attribute(ERROR_TYPE, exception.__class__.__name__)
+            span.record_exception(exception)
+            span.set_status(Status(StatusCode.ERROR, str(exception)))
+            span.end()
+            return response
+
+        prompt_index = 0
+        if assistants.get(run["assistant_id"]) is not None or Config.enrich_assistant:
+            if Config.enrich_assistant:
+                assistant = model_as_dict(
+                    instance._client.beta.assistants.retrieve(run["assistant_id"])
+                )
+                assistants[run["assistant_id"]] = assistant
+            else:
+                assistant = assistants[run["assistant_id"]]
+
             _set_span_attribute(
-                span, f"{SpanAttributes.LLM_PROMPTS}.{prompt_index}.role", "system"
+                span,
+                SpanAttributes.LLM_SYSTEM,
+                "openai",
             )
             _set_span_attribute(
                 span,
-                f"{SpanAttributes.LLM_PROMPTS}.{prompt_index}.content",
-                assistant["instructions"],
+                SpanAttributes.LLM_REQUEST_MODEL,
+                assistant["model"],
+            )
+            _set_span_attribute(
+                span,
+                SpanAttributes.LLM_RESPONSE_MODEL,
+                assistant["model"],
             )
-        prompt_index += 1
-    _set_span_attribute(
-        span, f"{SpanAttributes.LLM_PROMPTS}.{prompt_index}.role", "system"
-    )
-    _set_span_attribute(
-        span,
-        f"{SpanAttributes.LLM_PROMPTS}.{prompt_index}.content",
-        run["instructions"],
-    )
-    emit_event(MessageEvent(content=run["instructions"], role="system"))
-    prompt_index += 1
-
-    completion_index = 0
-    for msg in messages:
-        prefix = f"{SpanAttributes.LLM_COMPLETIONS}.{completion_index}"
-        content = msg.get("content")
-
-        message_content = content[0].get("text").get("value")
-        message_role = msg.get("role")
-        if message_role in ["user", "system"]:
             if should_emit_events():
-                emit_event(MessageEvent(content=message_content, role=message_role))
+                emit_event(MessageEvent(content=assistant["instructions"], role="system"))
             else:
                 _set_span_attribute(
-                    span,
-                    f"{SpanAttributes.LLM_PROMPTS}.{prompt_index}.role",
-                    message_role,
+                    span, f"{SpanAttributes.LLM_PROMPTS}.{prompt_index}.role", "system"
                 )
                 _set_span_attribute(
                     span,
                     f"{SpanAttributes.LLM_PROMPTS}.{prompt_index}.content",
-                    message_content,
+                    assistant["instructions"],
                 )
             prompt_index += 1
-        else:
-            if should_emit_events():
-                emit_event(
-                    ChoiceEvent(
-                        index=completion_index,
-                        message={"content": message_content, "role": message_role},
-                    )
-                )
-            else:
-                _set_span_attribute(span, f"{prefix}.role", msg.get("role"))
-                _set_span_attribute(span, f"{prefix}.content", message_content)
-                _set_span_attribute(
-                    span, f"gen_ai.response.{completion_index}.id", msg.get("id")
-                )
-            completion_index += 1
-
-    if run.get("usage"):
-        usage_dict = model_as_dict(run.get("usage"))
         _set_span_attribute(
-            span,
-            SpanAttributes.LLM_USAGE_COMPLETION_TOKENS,
-            usage_dict.get("completion_tokens"),
+            span, f"{SpanAttributes.LLM_PROMPTS}.{prompt_index}.role", "system"
         )
         _set_span_attribute(
             span,
-            SpanAttributes.LLM_USAGE_PROMPT_TOKENS,
-            usage_dict.get("prompt_tokens"),
+            f"{SpanAttributes.LLM_PROMPTS}.{prompt_index}.content",
+            run["instructions"],
         )
+        if should_emit_events():
+            emit_event(MessageEvent(content=run["instructions"], role="system"))
+        prompt_index += 1
+
+        completion_index = 0
+        for msg in messages:
+            prefix = f"{SpanAttributes.LLM_COMPLETIONS}.{completion_index}"
+            content = msg.get("content")
+
+            message_content = content[0].get("text").get("value")
+            message_role = msg.get("role")
+            if message_role in ["user", "system"]:
+                if should_emit_events():
+                    emit_event(MessageEvent(content=message_content, role=message_role))
+                else:
+                    _set_span_attribute(
+                        span,
+                        f"{SpanAttributes.LLM_PROMPTS}.{prompt_index}.role",
+                        message_role,
+                    )
+                    _set_span_attribute(
+                        span,
+                        f"{SpanAttributes.LLM_PROMPTS}.{prompt_index}.content",
+                        message_content,
+                    )
+                prompt_index += 1
+            else:
+                if should_emit_events():
+                    emit_event(
+                        ChoiceEvent(
+                            index=completion_index,
+                            message={"content": message_content, "role": message_role},
+                        )
+                    )
+                else:
+                    _set_span_attribute(span, f"{prefix}.role", msg.get("role"))
+                    _set_span_attribute(span, f"{prefix}.content", message_content)
+                    _set_span_attribute(
+                        span, f"gen_ai.response.{completion_index}.id", msg.get("id")
+                    )
+                completion_index += 1
+
+        if run.get("usage"):
+            usage_dict = model_as_dict(run.get("usage"))
+            _set_span_attribute(
+                span,
+                SpanAttributes.LLM_USAGE_COMPLETION_TOKENS,
+                usage_dict.get("completion_tokens"),
+            )
+            _set_span_attribute(
+                span,
+                SpanAttributes.LLM_USAGE_PROMPT_TOKENS,
+                usage_dict.get("prompt_tokens"),
+            )
 
     span.end(run.get("end_time"))
 
@@ -251,68 +257,70 @@ def runs_create_and_stream_wrapper(tracer, wrapped, instance, args, kwargs):
         attributes={SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.CHAT.value},
     )
 
-    i = 0
-    if assistants.get(assistant_id) is not None or Config.enrich_assistant:
-        if Config.enrich_assistant:
-            assistant = model_as_dict(
-                instance._client.beta.assistants.retrieve(assistant_id)
-            )
-            assistants[assistant_id] = assistant
-        else:
-            assistant = assistants[assistant_id]
-
-        _set_span_attribute(
-            span, SpanAttributes.LLM_REQUEST_MODEL, assistants[assistant_id]["model"]
-        )
-        _set_span_attribute(
-            span,
-            SpanAttributes.LLM_SYSTEM,
-            "openai",
-        )
-        _set_span_attribute(
-            span,
-            SpanAttributes.LLM_RESPONSE_MODEL,
-            assistants[assistant_id]["model"],
-        )
-        if should_emit_events():
-            emit_event(
-                MessageEvent(
-                    content=assistants[assistant_id]["instructions"], role="system"
+    # Use the span as current context to ensure events get proper trace context
+    with trace.use_span(span, end_on_exit=False):
+        i = 0
+        if assistants.get(assistant_id) is not None or Config.enrich_assistant:
+            if Config.enrich_assistant:
+                assistant = model_as_dict(
+                    instance._client.beta.assistants.retrieve(assistant_id)
                 )
+                assistants[assistant_id] = assistant
+            else:
+                assistant = assistants[assistant_id]
+
+            _set_span_attribute(
+                span, SpanAttributes.LLM_REQUEST_MODEL, assistants[assistant_id]["model"]
             )
-        else:
             _set_span_attribute(
-                span, f"{SpanAttributes.LLM_PROMPTS}.{i}.role", "system"
+                span,
+                SpanAttributes.LLM_SYSTEM,
+                "openai",
             )
             _set_span_attribute(
                 span,
-                f"{SpanAttributes.LLM_PROMPTS}.{i}.content",
-                assistants[assistant_id]["instructions"],
+                SpanAttributes.LLM_RESPONSE_MODEL,
+                assistants[assistant_id]["model"],
+            )
+            if should_emit_events():
+                emit_event(
+                    MessageEvent(
+                        content=assistants[assistant_id]["instructions"], role="system"
+                    )
+                )
+            else:
+                _set_span_attribute(
+                    span, f"{SpanAttributes.LLM_PROMPTS}.{i}.role", "system"
+                )
+                _set_span_attribute(
+                    span,
+                    f"{SpanAttributes.LLM_PROMPTS}.{i}.content",
+                    assistants[assistant_id]["instructions"],
+                )
+            i += 1
+        if should_emit_events():
+            emit_event(MessageEvent(content=instructions, role="system"))
+        else:
+            _set_span_attribute(span, f"{SpanAttributes.LLM_PROMPTS}.{i}.role", "system")
+            _set_span_attribute(
+                span, f"{SpanAttributes.LLM_PROMPTS}.{i}.content", instructions
             )
-        i += 1
-    if should_emit_events():
-        emit_event(MessageEvent(content=instructions, role="system"))
-    else:
-        _set_span_attribute(span, f"{SpanAttributes.LLM_PROMPTS}.{i}.role", "system")
-        _set_span_attribute(
-            span, f"{SpanAttributes.LLM_PROMPTS}.{i}.content", instructions
-        )
 
-    from opentelemetry.instrumentation.openai.v1.event_handler_wrapper import (
-        EventHandleWrapper,
-    )
+        from opentelemetry.instrumentation.openai.v1.event_handler_wrapper import (
+            EventHandleWrapper,
+        )
 
-    kwargs["event_handler"] = EventHandleWrapper(
-        original_handler=kwargs["event_handler"],
-        span=span,
-    )
+        kwargs["event_handler"] = EventHandleWrapper(
+            original_handler=kwargs["event_handler"],
+            span=span,
+        )
 
-    try:
-        response = wrapped(*args, **kwargs)
-        return response
-    except Exception as e:
-        span.set_attribute(ERROR_TYPE, e.__class__.__name__)
-        span.record_exception(e)
-        span.set_status(Status(StatusCode.ERROR, str(e)))
-        span.end()
-        raise
+        try:
+            response = wrapped(*args, **kwargs)
+            return response
+        except Exception as e:
+            span.set_attribute(ERROR_TYPE, e.__class__.__name__)
+            span.record_exception(e)
+            span.set_status(Status(StatusCode.ERROR, str(e)))
+            span.end()
+            raise

opentelemetry/instrumentation/openai/v1/responses_wrappers.py

@@ -447,6 +447,14 @@ def responses_get_or_create_wrapper(tracer: Tracer, wrapped, instance, args, kwa
     merged_tools = existing_data.get("tools", []) + request_tools
 
     try:
+        parsed_response_output_text = None
+        if hasattr(parsed_response, "output_text"):
+            parsed_response_output_text = parsed_response.output_text
+        else:
+            try:
+                parsed_response_output_text = parsed_response.output[0].content[0].text
+            except Exception:
+                pass
         traced_data = TracedData(
             start_time=existing_data.get("start_time", start_time),
             response_id=parsed_response.id,
@@ -456,7 +464,7 @@ def responses_get_or_create_wrapper(tracer: Tracer, wrapped, instance, args, kwa
             output_blocks={block.id: block for block in parsed_response.output}
             | existing_data.get("output_blocks", {}),
             usage=existing_data.get("usage", parsed_response.usage),
-            output_text=existing_data.get("output_text", parsed_response.output_text),
+            output_text=existing_data.get("output_text", parsed_response_output_text),
             request_model=existing_data.get("request_model", kwargs.get("model")),
             response_model=existing_data.get("response_model", parsed_response.model),
         )
@@ -541,6 +549,15 @@ async def async_responses_get_or_create_wrapper(
     merged_tools = existing_data.get("tools", []) + request_tools
 
     try:
+        parsed_response_output_text = None
+        if hasattr(parsed_response, "output_text"):
+            parsed_response_output_text = parsed_response.output_text
+        else:
+            try:
+                parsed_response_output_text = parsed_response.output[0].content[0].text
+            except Exception:
+                pass
+
         traced_data = TracedData(
             start_time=existing_data.get("start_time", start_time),
             response_id=parsed_response.id,
@@ -550,7 +567,7 @@ async def async_responses_get_or_create_wrapper(
             output_blocks={block.id: block for block in parsed_response.output}
             | existing_data.get("output_blocks", {}),
             usage=existing_data.get("usage", parsed_response.usage),
-            output_text=existing_data.get("output_text", parsed_response.output_text),
+            output_text=existing_data.get("output_text", parsed_response_output_text),
             request_model=existing_data.get("request_model", kwargs.get("model")),
             response_model=existing_data.get("response_model", parsed_response.model),
         )

opentelemetry/instrumentation/openai/version.py

@@ -1 +1 @@
-__version__ = "0.44.1"
+__version__ = "0.44.3"

{opentelemetry_instrumentation_openai-0.44.1.dist-info → opentelemetry_instrumentation_openai-0.44.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: opentelemetry-instrumentation-openai
-Version: 0.44.1
+Version: 0.44.3
 Summary: OpenTelemetry OpenAI instrumentation
 License: Apache-2.0
 Author: Gal Kleinman

{opentelemetry_instrumentation_openai-0.44.1.dist-info → opentelemetry_instrumentation_openai-0.44.3.dist-info}/RECORD

@@ -1,7 +1,7 @@
 opentelemetry/instrumentation/openai/__init__.py,sha256=Mx_nwMl0TlhUjrQOR4qdx6MEhBUKp5cuUIIXFzi3mXo,2093
 opentelemetry/instrumentation/openai/shared/__init__.py,sha256=Ba429tv5NPuQN7RoLzaj00K9oj88BaUBdPmUUsZ-7ic,12346
-opentelemetry/instrumentation/openai/shared/chat_wrappers.py,sha256=SH_IJMOIE1uqpn5f2-mlqdBBH_YvJqLG9p5amJSWTm0,37517
-opentelemetry/instrumentation/openai/shared/completion_wrappers.py,sha256=LH90ZPytXD4_yXAfRkw7N7BimkVCvMzcuMCYu0RdNVo,8824
+opentelemetry/instrumentation/openai/shared/chat_wrappers.py,sha256=whdVqpTBFyWXITuY2pJYzVx1PF7kt5pQXvG7Z0nZV8Y,39325
+opentelemetry/instrumentation/openai/shared/completion_wrappers.py,sha256=600McQXNCPFaifeD4yFq00beZ9XjGEbYT_3XVojHQT4,9244
 opentelemetry/instrumentation/openai/shared/config.py,sha256=nQfVXiznVUIv2_BHSUQpaoCnxysG3XpaYpIZdxi0mxM,477
 opentelemetry/instrumentation/openai/shared/embeddings_wrappers.py,sha256=oRHghd4vSDJ6fNHjL9G8QfKnPnp_NkZfVmTDSgZScVU,9251
 opentelemetry/instrumentation/openai/shared/event_emitter.py,sha256=iXUoyEHbC9DqwjnudkPOZlDBC4qLdEBmfsxB_q0nzbQ,3113
@@ -11,11 +11,11 @@ opentelemetry/instrumentation/openai/shared/span_utils.py,sha256=47DEQpj8HBSa-_T
 opentelemetry/instrumentation/openai/utils.py,sha256=-0ugLRCR50v25KncuOq4tXHHPzdsH5PjS4Qd_8PP0TQ,4684
 opentelemetry/instrumentation/openai/v0/__init__.py,sha256=FhpVbP8NqjN2We_srppZ_U-0-Vbk-A15VSQp3zUnW3k,6353
 opentelemetry/instrumentation/openai/v1/__init__.py,sha256=oLst4xav77tTteZKXo59uyb-2IWqw_xOafaSMzTxq9g,13255
-opentelemetry/instrumentation/openai/v1/assistant_wrappers.py,sha256=ZBbJHgsY3_OuTb9n-WN-XGK4xsH4b2zy6fO6IkElxhk,10318
+opentelemetry/instrumentation/openai/v1/assistant_wrappers.py,sha256=oa5xYEDELFN9luvSn3y1xhSs37yRYY_Pwh6htqOs8gc,11297
 opentelemetry/instrumentation/openai/v1/event_handler_wrapper.py,sha256=AT-eDZOFP-K_mm-ecdgQaILoIsEiItZmtwzwAuse86Q,4350
-opentelemetry/instrumentation/openai/v1/responses_wrappers.py,sha256=YQt2fdsdyJXczfQ5rqkOJ6CJtvF_Q4be0yX6hYpfdno,23800
-opentelemetry/instrumentation/openai/version.py,sha256=ZDD-b1AJzaso91jggbcesxnf2F7iAueyqfbMaJ4TrtA,23
-opentelemetry_instrumentation_openai-0.44.1.dist-info/METADATA,sha256=EGPJJxdzR5cjMZ4_V4ittCWDEi1WrPajSkxS4-gpSko,2150
-opentelemetry_instrumentation_openai-0.44.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-opentelemetry_instrumentation_openai-0.44.1.dist-info/entry_points.txt,sha256=vTBfiX5yXji5YHikuJHEOoBZ1TFdPQ1EI4ctd2pZSeE,93
-opentelemetry_instrumentation_openai-0.44.1.dist-info/RECORD,,
+opentelemetry/instrumentation/openai/v1/responses_wrappers.py,sha256=NSty_lrL5HJVt88d_keV-wQ17-4XGVzc9ukMLaITAug,24471
+opentelemetry/instrumentation/openai/version.py,sha256=Fgvc0TeIXcwh7WOr-X3Z00Z33fH6ATWZZONRmU5RM7c,23
+opentelemetry_instrumentation_openai-0.44.3.dist-info/METADATA,sha256=y4pHNuysf2K7XMuErYnP_aDV67b9fMptG-qq5Un6yf4,2150
+opentelemetry_instrumentation_openai-0.44.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+opentelemetry_instrumentation_openai-0.44.3.dist-info/entry_points.txt,sha256=vTBfiX5yXji5YHikuJHEOoBZ1TFdPQ1EI4ctd2pZSeE,93
+opentelemetry_instrumentation_openai-0.44.3.dist-info/RECORD,,