opentelemetry-instrumentation-openai 0.34.1__py3-none-any.whl → 0.49.3__py3-none-any.whl

opentelemetry/instrumentation/openai/shared/image_gen_wrappers.py

@@ -47,7 +47,7 @@ def image_gen_metrics_wrapper(
         if exception_counter:
             exception_counter.add(1, attributes=attributes)
 
-        raise e
+        raise
 
     if is_openai_v1():
         response_dict = model_as_dict(response)

opentelemetry/instrumentation/openai/utils.py

@@ -1,17 +1,33 @@
 import asyncio
-from importlib.metadata import version
-from contextlib import asynccontextmanager
 import logging
 import os
 import threading
 import traceback
+from contextlib import asynccontextmanager
+from importlib.metadata import version
+from packaging import version as pkg_version
 
-import openai
+from opentelemetry import context as context_api
+from opentelemetry._logs import Logger
 from opentelemetry.instrumentation.openai.shared.config import Config
 
+import openai
+
+_OPENAI_VERSION = version("openai")
+
+TRACELOOP_TRACE_CONTENT = "TRACELOOP_TRACE_CONTENT"
+
 
 def is_openai_v1():
-    return version("openai") >= "1.0.0"
+    return pkg_version.parse(_OPENAI_VERSION) >= pkg_version.parse("1.0.0")
+
+
+def is_reasoning_supported():
+    # Reasoning has been introduced in OpenAI API on Dec 17, 2024
+    #     as per https://platform.openai.com/docs/changelog.
+    # The updated OpenAI library version is 1.58.0
+    #     as per https://pypi.org/project/openai/.
+    return pkg_version.parse(_OPENAI_VERSION) >= pkg_version.parse("1.58.0")
 
 
 def is_azure_openai(instance):
@@ -24,15 +40,16 @@ def is_metrics_enabled() -> bool:
     return (os.getenv("TRACELOOP_METRICS_ENABLED") or "true").lower() == "true"
 
 
-def should_record_stream_token_usage():
-    return Config.enrich_token_usage
-
-
 def _with_image_gen_metric_wrapper(func):
     def _with_metric(duration_histogram, exception_counter):
         def wrapper(wrapped, instance, args, kwargs):
             return func(
-                duration_histogram, exception_counter, wrapped, instance, args, kwargs
+                duration_histogram,
+                exception_counter,
+                wrapped,
+                instance,
+                args,
+                kwargs,
             )
 
         return wrapper
@@ -155,3 +172,19 @@ def run_async(method):
         thread.join()
     else:
         asyncio.run(method)
+
+
+def should_send_prompts():
+    return (
+        os.getenv(TRACELOOP_TRACE_CONTENT) or "true"
+    ).lower() == "true" or context_api.get_value("override_enable_content_tracing")
+
+
+def should_emit_events() -> bool:
+    """
+    Checks if the instrumentation isn't using the legacy attributes
+    and if the event logger is not None.
+    """
+    return not Config.use_legacy_attributes and isinstance(
+        Config.event_logger, Logger
+    )

opentelemetry/instrumentation/openai/v0/__init__.py

@@ -1,25 +1,28 @@
 from typing import Collection
 
+from opentelemetry._logs import get_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.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")
 
@@ -35,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:
+            logger_provider = kwargs.get("logger_provider")
+            Config.event_logger = get_logger(
+                __name__, __version__, logger_provider=logger_provider
+            )
+
         if is_metrics_enabled():
             tokens_histogram = meter.create_histogram(
                 name=Meters.LLM_TOKEN_USAGE,
@@ -61,7 +70,7 @@ class OpenAIV0Instrumentor(BaseInstrumentor):
             )
 
             streaming_time_to_first_token = meter.create_histogram(
-                name=Meters.LLM_STREAMING_TIME_TO_FIRST_TOKEN,
+                name=GenAIMetrics.GEN_AI_SERVER_TIME_TO_FIRST_TOKEN,
                 unit="s",
                 description="Time to first token in streaming chat completions",
             )
@@ -98,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",
@@ -152,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,39 +1,47 @@
 from typing import Collection
 
+from opentelemetry._logs import get_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.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",)
 
@@ -42,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)
@@ -50,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:
+            logger_provider = kwargs.get("logger_provider")
+            Config.event_logger = get_logger(
+                __name__, __version__, logger_provider=logger_provider
+            )
+
         if is_metrics_enabled():
             tokens_histogram = meter.create_histogram(
                 name=Meters.LLM_TOKEN_USAGE,
@@ -76,7 +106,7 @@ class OpenAIV1Instrumentor(BaseInstrumentor):
             )
 
             streaming_time_to_first_token = meter.create_histogram(
-                name=Meters.LLM_STREAMING_TIME_TO_FIRST_TOKEN,
+                name=GenAIMetrics.GEN_AI_SERVER_TIME_TO_FIRST_TOKEN,
                 unit="s",
                 description="Time to first token in streaming chat completions",
             )
@@ -174,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(
@@ -191,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