opentelemetry-instrumentation-openai 0.40.13__py3-none-any.whl → 0.41.0__py3-none-any.whl

opentelemetry/instrumentation/openai/v0/__init__.py

@@ -1,26 +1,28 @@
 from typing import Collection
 
+from opentelemetry._events import get_event_logger
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
-from opentelemetry.trace import get_tracer
-from opentelemetry.metrics import get_meter
-from wrapt import wrap_function_wrapper
-from opentelemetry.semconv._incubating.metrics import gen_ai_metrics as GenAIMetrics
-
 from opentelemetry.instrumentation.openai.shared.chat_wrappers import (
-    chat_wrapper,
     achat_wrapper,
+    chat_wrapper,
 )
 from opentelemetry.instrumentation.openai.shared.completion_wrappers import (
-    completion_wrapper,
     acompletion_wrapper,
+    completion_wrapper,
 )
+from opentelemetry.instrumentation.openai.shared.config import Config
 from opentelemetry.instrumentation.openai.shared.embeddings_wrappers import (
-    embeddings_wrapper,
     aembeddings_wrapper,
+    embeddings_wrapper,
 )
 from opentelemetry.instrumentation.openai.utils import is_metrics_enabled
 from opentelemetry.instrumentation.openai.version import __version__
+from opentelemetry.instrumentation.utils import unwrap
+from opentelemetry.metrics import get_meter
+from opentelemetry.semconv._incubating.metrics import gen_ai_metrics as GenAIMetrics
 from opentelemetry.semconv_ai import Meters
+from opentelemetry.trace import get_tracer
+from wrapt import wrap_function_wrapper
 
 _instruments = ("openai >= 0.27.0", "openai < 1.0.0")
 
@@ -36,6 +38,12 @@ class OpenAIV0Instrumentor(BaseInstrumentor):
         meter_provider = kwargs.get("meter_provider")
         meter = get_meter(__name__, __version__, meter_provider)
 
+        if not Config.use_legacy_attributes:
+            event_logger_provider = kwargs.get("event_logger_provider")
+            Config.event_logger = get_event_logger(
+                __name__, __version__, event_logger_provider=event_logger_provider
+            )
+
         if is_metrics_enabled():
             tokens_histogram = meter.create_histogram(
                 name=Meters.LLM_TOKEN_USAGE,
@@ -99,9 +107,16 @@ class OpenAIV0Instrumentor(BaseInstrumentor):
                 embeddings_exception_counter,
             ) = (None, None, None)
 
-        wrap_function_wrapper("openai", "Completion.create", completion_wrapper(tracer))
         wrap_function_wrapper(
-            "openai", "Completion.acreate", acompletion_wrapper(tracer)
+            "openai",
+            "Completion.create",
+            completion_wrapper(tracer),
+        )
+
+        wrap_function_wrapper(
+            "openai",
+            "Completion.acreate",
+            acompletion_wrapper(tracer),
         )
         wrap_function_wrapper(
             "openai",
@@ -153,4 +168,9 @@ class OpenAIV0Instrumentor(BaseInstrumentor):
         )
 
     def _uninstrument(self, **kwargs):
-        pass
+        unwrap("openai", "Completion.create")
+        unwrap("openai", "Completion.acreate")
+        unwrap("openai", "ChatCompletion.create")
+        unwrap("openai", "ChatCompletion.acreate")
+        unwrap("openai", "Embedding.create")
+        unwrap("openai", "Embedding.acreate")

opentelemetry/instrumentation/openai/v1/__init__.py

@@ -1,40 +1,47 @@
 from typing import Collection
 
+from opentelemetry._events import get_event_logger
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
-from opentelemetry.trace import get_tracer
-
-from opentelemetry.metrics import get_meter
-from opentelemetry.semconv._incubating.metrics import gen_ai_metrics as GenAIMetrics
-
-from wrapt import wrap_function_wrapper
-
 from opentelemetry.instrumentation.openai.shared.chat_wrappers import (
-    chat_wrapper,
     achat_wrapper,
+    chat_wrapper,
 )
 from opentelemetry.instrumentation.openai.shared.completion_wrappers import (
-    completion_wrapper,
     acompletion_wrapper,
+    completion_wrapper,
 )
+from opentelemetry.instrumentation.openai.shared.config import Config
 from opentelemetry.instrumentation.openai.shared.embeddings_wrappers import (
-    embeddings_wrapper,
     aembeddings_wrapper,
+    embeddings_wrapper,
 )
 from opentelemetry.instrumentation.openai.shared.image_gen_wrappers import (
     image_gen_metrics_wrapper,
 )
+from opentelemetry.instrumentation.openai.utils import is_metrics_enabled
 from opentelemetry.instrumentation.openai.v1.assistant_wrappers import (
     assistants_create_wrapper,
+    messages_list_wrapper,
+    runs_create_and_stream_wrapper,
     runs_create_wrapper,
     runs_retrieve_wrapper,
-    runs_create_and_stream_wrapper,
-    messages_list_wrapper,
 )
 
-from opentelemetry.instrumentation.openai.utils import is_metrics_enabled
-from opentelemetry.instrumentation.openai.version import __version__
+from opentelemetry.instrumentation.openai.v1.responses_wrappers import (
+    async_responses_cancel_wrapper,
+    async_responses_get_or_create_wrapper,
+    responses_cancel_wrapper,
+    responses_get_or_create_wrapper,
+)
 
+from opentelemetry.instrumentation.openai.version import __version__
+from opentelemetry.instrumentation.utils import unwrap
+from opentelemetry.metrics import get_meter
+from opentelemetry.semconv._incubating.metrics import gen_ai_metrics as GenAIMetrics
 from opentelemetry.semconv_ai import Meters
+from opentelemetry.trace import get_tracer
+from wrapt import wrap_function_wrapper
+
 
 _instruments = ("openai >= 1.0.0",)
 
@@ -43,6 +50,22 @@ class OpenAIV1Instrumentor(BaseInstrumentor):
     def instrumentation_dependencies(self) -> Collection[str]:
         return _instruments
 
+    def _try_wrap(self, module, function, wrapper):
+        """
+        Wrap a function if it exists, otherwise do nothing.
+        This is useful for handling cases where the function is not available in
+        the older versions of the library.
+
+        Args:
+            module (str): The module to wrap, e.g. "openai.resources.chat.completions"
+            function (str): "Object.function" to wrap, e.g. "Completions.parse"
+            wrapper (callable): The wrapper to apply to the function.
+        """
+        try:
+            wrap_function_wrapper(module, function, wrapper)
+        except (AttributeError, ModuleNotFoundError):
+            pass
+
     def _instrument(self, **kwargs):
         tracer_provider = kwargs.get("tracer_provider")
         tracer = get_tracer(__name__, __version__, tracer_provider)
@@ -51,6 +74,12 @@ class OpenAIV1Instrumentor(BaseInstrumentor):
         meter_provider = kwargs.get("meter_provider")
         meter = get_meter(__name__, __version__, meter_provider)
 
+        if not Config.use_legacy_attributes:
+            event_logger_provider = kwargs.get("event_logger_provider")
+            Config.event_logger = get_event_logger(
+                __name__, __version__, event_logger_provider=event_logger_provider
+            )
+
         if is_metrics_enabled():
             tokens_histogram = meter.create_histogram(
                 name=Meters.LLM_TOKEN_USAGE,
@@ -175,6 +204,33 @@ class OpenAIV1Instrumentor(BaseInstrumentor):
                 embeddings_exception_counter,
             ),
         )
+        # in newer versions, Completions.parse are out of beta
+        self._try_wrap(
+            "openai.resources.chat.completions",
+            "Completions.parse",
+            chat_wrapper(
+                tracer,
+                tokens_histogram,
+                chat_choice_counter,
+                duration_histogram,
+                chat_exception_counter,
+                streaming_time_to_first_token,
+                streaming_time_to_generate,
+            ),
+        )
+        self._try_wrap(
+            "openai.resources.chat.completions",
+            "AsyncCompletions.parse",
+            achat_wrapper(
+                tracer,
+                tokens_histogram,
+                chat_choice_counter,
+                duration_histogram,
+                chat_exception_counter,
+                streaming_time_to_first_token,
+                streaming_time_to_generate,
+            ),
+        )
 
         if is_metrics_enabled():
             image_gen_exception_counter = meter.create_counter(
@@ -192,60 +248,111 @@ class OpenAIV1Instrumentor(BaseInstrumentor):
         )
 
         # Beta APIs may not be available consistently in all versions
-        try:
-            wrap_function_wrapper(
-                "openai.resources.beta.assistants",
-                "Assistants.create",
-                assistants_create_wrapper(tracer),
-            )
-            wrap_function_wrapper(
-                "openai.resources.beta.chat.completions",
-                "Completions.parse",
-                chat_wrapper(
-                    tracer,
-                    tokens_histogram,
-                    chat_choice_counter,
-                    duration_histogram,
-                    chat_exception_counter,
-                    streaming_time_to_first_token,
-                    streaming_time_to_generate,
-                ),
-            )
-            wrap_function_wrapper(
-                "openai.resources.beta.chat.completions",
-                "AsyncCompletions.parse",
-                achat_wrapper(
-                    tracer,
-                    tokens_histogram,
-                    chat_choice_counter,
-                    duration_histogram,
-                    chat_exception_counter,
-                    streaming_time_to_first_token,
-                    streaming_time_to_generate,
-                ),
-            )
-            wrap_function_wrapper(
-                "openai.resources.beta.threads.runs",
-                "Runs.create",
-                runs_create_wrapper(tracer),
-            )
-            wrap_function_wrapper(
-                "openai.resources.beta.threads.runs",
-                "Runs.retrieve",
-                runs_retrieve_wrapper(tracer),
-            )
-            wrap_function_wrapper(
-                "openai.resources.beta.threads.runs",
-                "Runs.create_and_stream",
-                runs_create_and_stream_wrapper(tracer),
-            )
-            wrap_function_wrapper(
-                "openai.resources.beta.threads.messages",
-                "Messages.list",
-                messages_list_wrapper(tracer),
-            )
-        except (AttributeError, ModuleNotFoundError):
-            pass
+        self._try_wrap(
+            "openai.resources.beta.assistants",
+            "Assistants.create",
+            assistants_create_wrapper(tracer),
+        )
+        self._try_wrap(
+            "openai.resources.beta.chat.completions",
+            "Completions.parse",
+            chat_wrapper(
+                tracer,
+                tokens_histogram,
+                chat_choice_counter,
+                duration_histogram,
+                chat_exception_counter,
+                streaming_time_to_first_token,
+                streaming_time_to_generate,
+            ),
+        )
+        self._try_wrap(
+            "openai.resources.beta.chat.completions",
+            "AsyncCompletions.parse",
+            achat_wrapper(
+                tracer,
+                tokens_histogram,
+                chat_choice_counter,
+                duration_histogram,
+                chat_exception_counter,
+                streaming_time_to_first_token,
+                streaming_time_to_generate,
+            ),
+        )
+        self._try_wrap(
+            "openai.resources.beta.threads.runs",
+            "Runs.create",
+            runs_create_wrapper(tracer),
+        )
+        self._try_wrap(
+            "openai.resources.beta.threads.runs",
+            "Runs.retrieve",
+            runs_retrieve_wrapper(tracer),
+        )
+        self._try_wrap(
+            "openai.resources.beta.threads.runs",
+            "Runs.create_and_stream",
+            runs_create_and_stream_wrapper(tracer),
+        )
+        self._try_wrap(
+            "openai.resources.beta.threads.messages",
+            "Messages.list",
+            messages_list_wrapper(tracer),
+        )
+        self._try_wrap(
+            "openai.resources.responses",
+            "Responses.create",
+            responses_get_or_create_wrapper(tracer),
+        )
+        self._try_wrap(
+            "openai.resources.responses",
+            "Responses.retrieve",
+            responses_get_or_create_wrapper(tracer),
+        )
+        self._try_wrap(
+            "openai.resources.responses",
+            "Responses.cancel",
+            responses_cancel_wrapper(tracer),
+        )
+        self._try_wrap(
+            "openai.resources.responses",
+            "AsyncResponses.create",
+            async_responses_get_or_create_wrapper(tracer),
+        )
+        self._try_wrap(
+            "openai.resources.responses",
+            "AsyncResponses.retrieve",
+            async_responses_get_or_create_wrapper(tracer),
+        )
+        self._try_wrap(
+            "openai.resources.responses",
+            "AsyncResponses.cancel",
+            async_responses_cancel_wrapper(tracer),
+        )
 
     def _uninstrument(self, **kwargs):
-        pass
+        unwrap("openai.resources.chat.completions", "Completions.create")
+        unwrap("openai.resources.completions", "Completions.create")
+        unwrap("openai.resources.embeddings", "Embeddings.create")
+        unwrap("openai.resources.chat.completions", "AsyncCompletions.create")
+        unwrap("openai.resources.completions", "AsyncCompletions.create")
+        unwrap("openai.resources.embeddings", "AsyncEmbeddings.create")
+        unwrap("openai.resources.images", "Images.generate")
+
+        # Beta APIs may not be available consistently in all versions
+        try:
+            unwrap("openai.resources.beta.assistants", "Assistants.create")
+            unwrap("openai.resources.beta.chat.completions", "Completions.parse")
+            unwrap("openai.resources.beta.chat.completions", "AsyncCompletions.parse")
+            unwrap("openai.resources.beta.threads.runs", "Runs.create")
+            unwrap("openai.resources.beta.threads.runs", "Runs.retrieve")
+            unwrap("openai.resources.beta.threads.runs", "Runs.create_and_stream")
+            unwrap("openai.resources.beta.threads.messages", "Messages.list")
+            unwrap("openai.resources.responses", "Responses.create")
+            unwrap("openai.resources.responses", "Responses.retrieve")
+            unwrap("openai.resources.responses", "Responses.cancel")
+            unwrap("openai.resources.responses", "AsyncResponses.create")
+            unwrap("openai.resources.responses", "AsyncResponses.retrieve")
+            unwrap("openai.resources.responses", "AsyncResponses.cancel")
+        except ImportError:
+            pass

opentelemetry/instrumentation/openai/v1/assistant_wrappers.py

@@ -1,17 +1,26 @@
 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.trace import SpanKind
-from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
-
-from opentelemetry.semconv_ai import SpanAttributes, LLMRequestTypeValues
-
-from opentelemetry.instrumentation.openai.utils import _with_tracer_wrapper, dont_throw
 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
@@ -45,17 +54,24 @@ def runs_create_wrapper(tracer, wrapped, instance, args, kwargs):
     thread_id = kwargs.get("thread_id")
     instructions = kwargs.get("instructions")
 
-    response = wrapped(*args, **kwargs)
-    response_dict = model_as_dict(response)
+    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"),
-    }
+        runs[thread_id] = {
+            "start_time": time.time_ns(),
+            "assistant_id": kwargs.get("assistant_id"),
+            "instructions": instructions,
+            "run_id": response_dict.get("id"),
+        }
 
-    return response
+        return response
+    except Exception as e:
+        runs[thread_id] = {
+            "exception": e,
+            "end_time": time.time_ns(),
+        }
+        raise
 
 
 @_with_tracer_wrapper
@@ -77,10 +93,16 @@ def runs_retrieve_wrapper(tracer, wrapped, instance, args, kwargs):
     if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
         return wrapped(*args, **kwargs)
 
-    response = wrapped(*args, **kwargs)
-    process_response(response)
-
-    return response
+    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
@@ -105,6 +127,11 @@ 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:
@@ -131,17 +158,27 @@ def messages_list_wrapper(tracer, wrapped, instance, args, kwargs):
             SpanAttributes.LLM_RESPONSE_MODEL,
             assistant["model"],
         )
-        _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"],
-        )
+        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"]
+        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
@@ -152,13 +189,34 @@ def messages_list_wrapper(tracer, wrapped, instance, args, kwargs):
         message_content = content[0].get("text").get("value")
         message_role = msg.get("role")
         if message_role in ["user", "system"]:
-            _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)
+            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:
-            _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"))
+            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"):
@@ -216,24 +274,45 @@ def runs_create_and_stream_wrapper(tracer, wrapped, instance, args, kwargs):
             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",
-            assistants[assistant_id]["instructions"],
+            span, f"{SpanAttributes.LLM_PROMPTS}.{i}.content", instructions
         )
-        i += 1
-    _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,
+        original_handler=kwargs["event_handler"],
+        span=span,
     )
 
-    response = wrapped(*args, **kwargs)
-
-    return response
+    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