opentelemetry-instrumentation-openai 0.44.1__tar.gz → 0.44.3__tar.gz

{opentelemetry_instrumentation_openai-0.44.1 → opentelemetry_instrumentation_openai-0.44.3}/PKG-INFO

@@ -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 → opentelemetry_instrumentation_openai-0.44.3}/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-0.44.1 → opentelemetry_instrumentation_openai-0.44.3}/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-0.44.3/opentelemetry/instrumentation/openai/v1/assistant_wrappers.py

@@ -0,0 +1,326 @@
+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,
+)
+from opentelemetry.instrumentation.openai.shared.config import Config
+from opentelemetry.instrumentation.openai.shared.event_emitter import emit_event
+from opentelemetry.instrumentation.openai.shared.event_models import (
+    ChoiceEvent,
+    MessageEvent,
+)
+from opentelemetry.instrumentation.openai.utils import (
+    _with_tracer_wrapper,
+    dont_throw,
+    should_emit_events,
+)
+from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
+from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
+from opentelemetry.semconv_ai import LLMRequestTypeValues, SpanAttributes
+from opentelemetry.trace import SpanKind, Status, StatusCode
+
+from openai._legacy_response import LegacyAPIResponse
+from openai.types.beta.threads.run import Run
+
+logger = logging.getLogger(__name__)
+
+assistants = {}
+runs = {}
+
+
+@_with_tracer_wrapper
+def assistants_create_wrapper(tracer, wrapped, instance, args, kwargs):
+    if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
+        return wrapped(*args, **kwargs)
+
+    response = wrapped(*args, **kwargs)
+
+    assistants[response.id] = {
+        "model": kwargs.get("model"),
+        "instructions": kwargs.get("instructions"),
+    }
+
+    return response
+
+
+@_with_tracer_wrapper
+def runs_create_wrapper(tracer, wrapped, instance, args, kwargs):
+    if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
+        return wrapped(*args, **kwargs)
+
+    thread_id = kwargs.get("thread_id")
+    instructions = kwargs.get("instructions")
+
+    try:
+        response = wrapped(*args, **kwargs)
+        response_dict = model_as_dict(response)
+
+        runs[thread_id] = {
+            "start_time": time.time_ns(),
+            "assistant_id": kwargs.get("assistant_id"),
+            "instructions": instructions,
+            "run_id": response_dict.get("id"),
+        }
+
+        return response
+    except Exception as e:
+        runs[thread_id] = {
+            "exception": e,
+            "end_time": time.time_ns(),
+        }
+        raise
+
+
+@_with_tracer_wrapper
+def runs_retrieve_wrapper(tracer, wrapped, instance, args, kwargs):
+    @dont_throw
+    def process_response(response):
+        if type(response) is LegacyAPIResponse:
+            parsed_response = response.parse()
+        else:
+            parsed_response = response
+        assert type(parsed_response) is Run
+
+        if parsed_response.thread_id in runs:
+            thread_id = parsed_response.thread_id
+            runs[thread_id]["end_time"] = time.time_ns()
+            if parsed_response.usage:
+                runs[thread_id]["usage"] = parsed_response.usage
+
+    if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
+        return wrapped(*args, **kwargs)
+
+    try:
+        response = wrapped(*args, **kwargs)
+        process_response(response)
+        return response
+    except Exception as e:
+        thread_id = kwargs.get("thread_id")
+        if thread_id in runs:
+            runs[thread_id]["exception"] = e
+            runs[thread_id]["end_time"] = time.time_ns()
+        raise
+
+
+@_with_tracer_wrapper
+def messages_list_wrapper(tracer, wrapped, instance, args, kwargs):
+    if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
+        return wrapped(*args, **kwargs)
+
+    id = kwargs.get("thread_id")
+
+    response = wrapped(*args, **kwargs)
+
+    response_dict = model_as_dict(response)
+    if id not in runs:
+        return response
+
+    run = runs[id]
+    messages = sorted(response_dict["data"], key=lambda x: x["created_at"])
+
+    span = tracer.start_span(
+        "openai.assistant.run",
+        kind=SpanKind.CLIENT,
+        attributes={SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.CHAT.value},
+        start_time=run.get("start_time"),
+    )
+
+    # 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,
+                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:
+                _set_span_attribute(
+                    span, f"{SpanAttributes.LLM_PROMPTS}.{prompt_index}.role", "system"
+                )
+                _set_span_attribute(
+                    span,
+                    f"{SpanAttributes.LLM_PROMPTS}.{prompt_index}.content",
+                    assistant["instructions"],
+                )
+            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"],
+        )
+        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"))
+
+    return response
+
+
+@_with_tracer_wrapper
+def runs_create_and_stream_wrapper(tracer, wrapped, instance, args, kwargs):
+    if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
+        return wrapped(*args, **kwargs)
+
+    assistant_id = kwargs.get("assistant_id")
+    instructions = kwargs.get("instructions")
+
+    span = tracer.start_span(
+        "openai.assistant.run_stream",
+        kind=SpanKind.CLIENT,
+        attributes={SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.CHAT.value},
+    )
+
+    # 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"]
+            )
+            _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"
+                    )
+                )
+            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
+            )
+
+        from opentelemetry.instrumentation.openai.v1.event_handler_wrapper import (
+            EventHandleWrapper,
+        )
+
+        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

{opentelemetry_instrumentation_openai-0.44.1 → opentelemetry_instrumentation_openai-0.44.3}/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-0.44.3/opentelemetry/instrumentation/openai/version.py

@@ -0,0 +1 @@
+__version__ = "0.44.3"

{opentelemetry_instrumentation_openai-0.44.1 → opentelemetry_instrumentation_openai-0.44.3}/pyproject.toml

@@ -8,7 +8,7 @@ show_missing = true
 
 [tool.poetry]
 name = "opentelemetry-instrumentation-openai"
-version = "0.44.1"
+version = "0.44.3"
 description = "OpenTelemetry OpenAI instrumentation"
 authors = [
   "Gal Kleinman <gal@traceloop.com>",
@@ -38,7 +38,7 @@ pytest = "^8.2.2"
 pytest-sugar = "1.0.0"
 vcrpy = "^6.0.1"
 pytest-recording = "^0.13.1"
-openai = { extras = ["datalib"], version = ">=1.66.0" }
+openai = { extras = ["datalib"], version = "1.99.7" }
 opentelemetry-sdk = "^1.27.0"
 pytest-asyncio = "^0.23.7"
 requests = "^2.31.0"

opentelemetry_instrumentation_openai-0.44.1/opentelemetry/instrumentation/openai/v1/assistant_wrappers.py

@@ -1,318 +0,0 @@
-import logging
-import time
-
-from opentelemetry import context as context_api
-from opentelemetry.instrumentation.openai.shared import (
-    _set_span_attribute,
-    model_as_dict,
-)
-from opentelemetry.instrumentation.openai.shared.config import Config
-from opentelemetry.instrumentation.openai.shared.event_emitter import emit_event
-from opentelemetry.instrumentation.openai.shared.event_models import (
-    ChoiceEvent,
-    MessageEvent,
-)
-from opentelemetry.instrumentation.openai.utils import (
-    _with_tracer_wrapper,
-    dont_throw,
-    should_emit_events,
-)
-from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
-from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
-from opentelemetry.semconv_ai import LLMRequestTypeValues, SpanAttributes
-from opentelemetry.trace import SpanKind, Status, StatusCode
-
-from openai._legacy_response import LegacyAPIResponse
-from openai.types.beta.threads.run import Run
-
-logger = logging.getLogger(__name__)
-
-assistants = {}
-runs = {}
-
-
-@_with_tracer_wrapper
-def assistants_create_wrapper(tracer, wrapped, instance, args, kwargs):
-    if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
-        return wrapped(*args, **kwargs)
-
-    response = wrapped(*args, **kwargs)
-
-    assistants[response.id] = {
-        "model": kwargs.get("model"),
-        "instructions": kwargs.get("instructions"),
-    }
-
-    return response
-
-
-@_with_tracer_wrapper
-def runs_create_wrapper(tracer, wrapped, instance, args, kwargs):
-    if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
-        return wrapped(*args, **kwargs)
-
-    thread_id = kwargs.get("thread_id")
-    instructions = kwargs.get("instructions")
-
-    try:
-        response = wrapped(*args, **kwargs)
-        response_dict = model_as_dict(response)
-
-        runs[thread_id] = {
-            "start_time": time.time_ns(),
-            "assistant_id": kwargs.get("assistant_id"),
-            "instructions": instructions,
-            "run_id": response_dict.get("id"),
-        }
-
-        return response
-    except Exception as e:
-        runs[thread_id] = {
-            "exception": e,
-            "end_time": time.time_ns(),
-        }
-        raise
-
-
-@_with_tracer_wrapper
-def runs_retrieve_wrapper(tracer, wrapped, instance, args, kwargs):
-    @dont_throw
-    def process_response(response):
-        if type(response) is LegacyAPIResponse:
-            parsed_response = response.parse()
-        else:
-            parsed_response = response
-        assert type(parsed_response) is Run
-
-        if parsed_response.thread_id in runs:
-            thread_id = parsed_response.thread_id
-            runs[thread_id]["end_time"] = time.time_ns()
-            if parsed_response.usage:
-                runs[thread_id]["usage"] = parsed_response.usage
-
-    if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
-        return wrapped(*args, **kwargs)
-
-    try:
-        response = wrapped(*args, **kwargs)
-        process_response(response)
-        return response
-    except Exception as e:
-        thread_id = kwargs.get("thread_id")
-        if thread_id in runs:
-            runs[thread_id]["exception"] = e
-            runs[thread_id]["end_time"] = time.time_ns()
-        raise
-
-
-@_with_tracer_wrapper
-def messages_list_wrapper(tracer, wrapped, instance, args, kwargs):
-    if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
-        return wrapped(*args, **kwargs)
-
-    id = kwargs.get("thread_id")
-
-    response = wrapped(*args, **kwargs)
-
-    response_dict = model_as_dict(response)
-    if id not in runs:
-        return response
-
-    run = runs[id]
-    messages = sorted(response_dict["data"], key=lambda x: x["created_at"])
-
-    span = tracer.start_span(
-        "openai.assistant.run",
-        kind=SpanKind.CLIENT,
-        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:
-            _set_span_attribute(
-                span, f"{SpanAttributes.LLM_PROMPTS}.{prompt_index}.role", "system"
-            )
-            _set_span_attribute(
-                span,
-                f"{SpanAttributes.LLM_PROMPTS}.{prompt_index}.content",
-                assistant["instructions"],
-            )
-        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))
-            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"))
-
-    return response
-
-
-@_with_tracer_wrapper
-def runs_create_and_stream_wrapper(tracer, wrapped, instance, args, kwargs):
-    if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
-        return wrapped(*args, **kwargs)
-
-    assistant_id = kwargs.get("assistant_id")
-    instructions = kwargs.get("instructions")
-
-    span = tracer.start_span(
-        "openai.assistant.run_stream",
-        kind=SpanKind.CLIENT,
-        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"
-                )
-            )
-        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
-        )
-
-    from opentelemetry.instrumentation.openai.v1.event_handler_wrapper import (
-        EventHandleWrapper,
-    )
-
-    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

opentelemetry_instrumentation_openai-0.44.1/opentelemetry/instrumentation/openai/version.py

@@ -1 +0,0 @@
-__version__ = "0.44.1"