opentelemetry-instrumentation-openai 0.16.5__py3-none-any.whl → 0.16.7__py3-none-any.whl

opentelemetry/instrumentation/openai/__init__.py

@@ -14,11 +14,15 @@ class OpenAIInstrumentor(BaseInstrumentor):
     """An instrumentor for OpenAI's client library."""
 
     def __init__(
-        self, enrich_assistant: bool = False, enrich_token_usage: bool = False
+        self,
+        enrich_assistant: bool = False,
+        enrich_token_usage: bool = False,
+        exception_logger=None,
     ):
         super().__init__()
         Config.enrich_assistant = enrich_assistant
         Config.enrich_token_usage = enrich_token_usage
+        Config.exception_logger = exception_logger
 
     def instrumentation_dependencies(self) -> Collection[str]:
         return _instruments

opentelemetry/instrumentation/openai/shared/__init__.py

@@ -10,6 +10,7 @@ from opentelemetry import context as context_api
 
 from opentelemetry.semconv.ai import SpanAttributes
 from opentelemetry.instrumentation.openai.utils import (
+    dont_throw,
     is_openai_v1,
     should_record_stream_token_usage,
 )
@@ -46,19 +47,13 @@ def _set_client_attributes(span, instance):
     if not is_openai_v1():
         return
 
-    try:
-        client = instance._client  # pylint: disable=protected-access
-        if isinstance(client, (openai.AsyncOpenAI, openai.OpenAI)):
-            _set_span_attribute(span, OPENAI_API_BASE, str(client.base_url))
-        if isinstance(client, (openai.AsyncAzureOpenAI, openai.AzureOpenAI)):
-            _set_span_attribute(
-                span, OPENAI_API_VERSION, client._api_version
-            )  # pylint: disable=protected-access
-
-    except Exception as ex:  # pylint: disable=broad-except
-        logger.warning(
-            "Failed to set api attributes for openai v1 span, error: %s", str(ex)
-        )
+    client = instance._client  # pylint: disable=protected-access
+    if isinstance(client, (openai.AsyncOpenAI, openai.OpenAI)):
+        _set_span_attribute(span, OPENAI_API_BASE, str(client.base_url))
+    if isinstance(client, (openai.AsyncAzureOpenAI, openai.AzureOpenAI)):
+        _set_span_attribute(
+            span, OPENAI_API_VERSION, client._api_version
+        )  # pylint: disable=protected-access
 
 
 def _set_api_attributes(span):
@@ -68,16 +63,11 @@ def _set_api_attributes(span):
     if is_openai_v1():
         return
 
-    try:
-        base_url = openai.base_url if hasattr(openai, "base_url") else openai.api_base
+    base_url = openai.base_url if hasattr(openai, "base_url") else openai.api_base
 
-        _set_span_attribute(span, OPENAI_API_BASE, base_url)
-        _set_span_attribute(span, OPENAI_API_TYPE, openai.api_type)
-        _set_span_attribute(span, OPENAI_API_VERSION, openai.api_version)
-    except Exception as ex:  # pylint: disable=broad-except
-        logger.warning(
-            "Failed to set api attributes for openai span, error: %s", str(ex)
-        )
+    _set_span_attribute(span, OPENAI_API_BASE, base_url)
+    _set_span_attribute(span, OPENAI_API_TYPE, openai.api_type)
+    _set_span_attribute(span, OPENAI_API_VERSION, openai.api_version)
 
     return
 
@@ -116,76 +106,62 @@ def _set_request_attributes(span, kwargs):
     if not span.is_recording():
         return
 
-    try:
-        _set_api_attributes(span)
-        _set_span_attribute(span, SpanAttributes.LLM_VENDOR, "OpenAI")
-        _set_span_attribute(span, SpanAttributes.LLM_REQUEST_MODEL, kwargs.get("model"))
-        _set_span_attribute(
-            span, SpanAttributes.LLM_REQUEST_MAX_TOKENS, kwargs.get("max_tokens")
-        )
-        _set_span_attribute(
-            span, SpanAttributes.LLM_TEMPERATURE, kwargs.get("temperature")
-        )
-        _set_span_attribute(span, SpanAttributes.LLM_TOP_P, kwargs.get("top_p"))
-        _set_span_attribute(
-            span, SpanAttributes.LLM_FREQUENCY_PENALTY, kwargs.get("frequency_penalty")
-        )
-        _set_span_attribute(
-            span, SpanAttributes.LLM_PRESENCE_PENALTY, kwargs.get("presence_penalty")
-        )
-        _set_span_attribute(span, SpanAttributes.LLM_USER, kwargs.get("user"))
-        _set_span_attribute(
-            span, SpanAttributes.LLM_HEADERS, str(kwargs.get("headers"))
-        )
-        # The new OpenAI SDK removed the `headers` and create new field called `extra_headers`
-        if kwargs.get("extra_headers") is not None:
-            _set_span_attribute(
-                span, SpanAttributes.LLM_HEADERS, str(kwargs.get("extra_headers"))
-            )
+    _set_api_attributes(span)
+    _set_span_attribute(span, SpanAttributes.LLM_VENDOR, "OpenAI")
+    _set_span_attribute(span, SpanAttributes.LLM_REQUEST_MODEL, kwargs.get("model"))
+    _set_span_attribute(
+        span, SpanAttributes.LLM_REQUEST_MAX_TOKENS, kwargs.get("max_tokens")
+    )
+    _set_span_attribute(span, SpanAttributes.LLM_TEMPERATURE, kwargs.get("temperature"))
+    _set_span_attribute(span, SpanAttributes.LLM_TOP_P, kwargs.get("top_p"))
+    _set_span_attribute(
+        span, SpanAttributes.LLM_FREQUENCY_PENALTY, kwargs.get("frequency_penalty")
+    )
+    _set_span_attribute(
+        span, SpanAttributes.LLM_PRESENCE_PENALTY, kwargs.get("presence_penalty")
+    )
+    _set_span_attribute(span, SpanAttributes.LLM_USER, kwargs.get("user"))
+    _set_span_attribute(span, SpanAttributes.LLM_HEADERS, str(kwargs.get("headers")))
+    # The new OpenAI SDK removed the `headers` and create new field called `extra_headers`
+    if kwargs.get("extra_headers") is not None:
         _set_span_attribute(
-            span, SpanAttributes.LLM_IS_STREAMING, kwargs.get("stream") or False
-        )
-    except Exception as ex:  # pylint: disable=broad-except
-        logger.warning(
-            "Failed to set input attributes for openai span, error: %s", str(ex)
+            span, SpanAttributes.LLM_HEADERS, str(kwargs.get("extra_headers"))
         )
+    _set_span_attribute(
+        span, SpanAttributes.LLM_IS_STREAMING, kwargs.get("stream") or False
+    )
 
 
+@dont_throw
 def _set_response_attributes(span, response):
     if not span.is_recording():
         return
 
-    try:
-        _set_span_attribute(
-            span, SpanAttributes.LLM_RESPONSE_MODEL, response.get("model")
-        )
+    _set_span_attribute(span, SpanAttributes.LLM_RESPONSE_MODEL, response.get("model"))
 
-        usage = response.get("usage")
-        if not usage:
-            return
+    usage = response.get("usage")
+    if not usage:
+        return
 
-        if is_openai_v1() and not isinstance(usage, dict):
-            usage = usage.__dict__
+    if is_openai_v1() and not isinstance(usage, dict):
+        usage = usage.__dict__
 
-        _set_span_attribute(
-            span, SpanAttributes.LLM_USAGE_TOTAL_TOKENS, usage.get("total_tokens")
-        )
-        _set_span_attribute(
-            span,
-            SpanAttributes.LLM_USAGE_COMPLETION_TOKENS,
-            usage.get("completion_tokens"),
-        )
-        _set_span_attribute(
-            span, SpanAttributes.LLM_USAGE_PROMPT_TOKENS, usage.get("prompt_tokens")
-        )
+    _set_span_attribute(
+        span, SpanAttributes.LLM_USAGE_TOTAL_TOKENS, usage.get("total_tokens")
+    )
+    _set_span_attribute(
+        span,
+        SpanAttributes.LLM_USAGE_COMPLETION_TOKENS,
+        usage.get("completion_tokens"),
+    )
+    _set_span_attribute(
+        span, SpanAttributes.LLM_USAGE_PROMPT_TOKENS, usage.get("prompt_tokens")
+    )
 
-        return
-    except Exception as ex:  # pylint: disable=broad-except
-        logger.warning(
-            "Failed to set response attributes for openai span, error: %s", str(ex)
-        )
+    return
 
 
+@dont_throw
 def _set_span_stream_usage(span, prompt_tokens, completion_tokens):
     if not span.is_recording():
         return

opentelemetry/instrumentation/openai/shared/chat_wrappers.py

@@ -9,6 +9,7 @@ from opentelemetry.semconv.ai import SpanAttributes, LLMRequestTypeValues
 from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
 from opentelemetry.instrumentation.openai.utils import (
     _with_chat_telemetry_wrapper,
+    dont_throw,
 )
 from opentelemetry.instrumentation.openai.shared import (
     _set_client_attributes,
@@ -29,7 +30,7 @@ from opentelemetry.instrumentation.openai.shared import (
 from opentelemetry.trace import SpanKind, Tracer
 from opentelemetry.trace.status import Status, StatusCode
 
-from opentelemetry.instrumentation.openai.utils import is_openai_v1
+from opentelemetry.instrumentation.openai.utils import is_openai_v1, is_azure_openai
 
 SPAN_NAME = "openai.chat"
 LLM_REQUEST_TYPE = LLMRequestTypeValues.CHAT
@@ -187,6 +188,7 @@ async def achat_wrapper(
     return response
 
 
+@dont_throw
 def _handle_request(span, kwargs, instance):
     _set_request_attributes(span, kwargs)
     _set_client_attributes(span, instance)
@@ -198,6 +200,7 @@ def _handle_request(span, kwargs, instance):
             set_tools_attributes(span, kwargs.get("tools"))
 
 
+@dont_throw
 def _handle_response(
     response,
     span,
@@ -278,18 +281,15 @@ def _set_prompts(span, messages):
     if not span.is_recording() or messages is None:
         return
 
-    try:
-        for i, msg in enumerate(messages):
-            prefix = f"{SpanAttributes.LLM_PROMPTS}.{i}"
-            if isinstance(msg.get("content"), str):
-                content = msg.get("content")
-            elif isinstance(msg.get("content"), list):
-                content = json.dumps(msg.get("content"))
+    for i, msg in enumerate(messages):
+        prefix = f"{SpanAttributes.LLM_PROMPTS}.{i}"
+        if isinstance(msg.get("content"), str):
+            content = msg.get("content")
+        elif isinstance(msg.get("content"), list):
+            content = json.dumps(msg.get("content"))
 
-            _set_span_attribute(span, f"{prefix}.role", msg.get("role"))
-            _set_span_attribute(span, f"{prefix}.content", content)
-    except Exception as ex:  # pylint: disable=broad-except
-        logger.warning("Failed to set prompts for openai span, error: %s", str(ex))
+        _set_span_attribute(span, f"{prefix}.role", msg.get("role"))
+        _set_span_attribute(span, f"{prefix}.content", content)
 
 
 def _set_completions(span, choices):
@@ -303,6 +303,11 @@ def _set_completions(span, choices):
             span, f"{prefix}.finish_reason", choice.get("finish_reason")
         )
 
+        if choice.get("finish_reason") == "content_filter":
+            _set_span_attribute(span, f"{prefix}.role", "assistant")
+            _set_span_attribute(span, f"{prefix}.content", "FILTERED")
+            return
+
         message = choice.get("message")
         if not message:
             return
@@ -361,7 +366,7 @@ def _set_streaming_token_metrics(
         completion_content = ""
         model_name = complete_response.get("model") or None
 
-        for choice in complete_response.get("choices"):  # type: dict
+        for choice in complete_response.get("choices"):
             if choice.get("message") and choice.get("message").get("content"):
                 completion_content += choice["message"]["content"]
 
@@ -390,6 +395,7 @@ def _set_streaming_token_metrics(
             token_counter.add(completion_usage, attributes=attributes_with_token_type)
 
 
+@dont_throw
 def _build_from_streaming_response(
     span,
     response,
@@ -427,9 +433,10 @@ def _build_from_streaming_response(
         "stream": True,
     }
 
-    _set_streaming_token_metrics(
-        request_kwargs, complete_response, span, token_counter, shared_attributes
-    )
+    if not is_azure_openai(instance):
+        _set_streaming_token_metrics(
+            request_kwargs, complete_response, span, token_counter, shared_attributes
+        )
 
     # choice metrics
     if choice_counter and complete_response.get("choices"):
@@ -456,6 +463,7 @@ def _build_from_streaming_response(
     span.end()
 
 
+@dont_throw
 async def _abuild_from_streaming_response(
     span,
     response,
@@ -493,9 +501,10 @@ async def _abuild_from_streaming_response(
         "stream": True,
     }
 
-    _set_streaming_token_metrics(
-        request_kwargs, complete_response, span, token_counter, shared_attributes
-    )
+    if not is_azure_openai(instance):
+        _set_streaming_token_metrics(
+            request_kwargs, complete_response, span, token_counter, shared_attributes
+        )
 
     # choice metrics
     if choice_counter and complete_response.get("choices"):
@@ -540,7 +549,7 @@ def _accumulate_stream_items(item, complete_response):
 
         delta = choice.get("delta")
 
-        if delta.get("content"):
+        if delta and delta.get("content"):
             complete_choice["message"]["content"] += delta.get("content")
-        if delta.get("role"):
+        if delta and delta.get("role"):
             complete_choice["message"]["role"] = delta.get("role")

opentelemetry/instrumentation/openai/shared/completion_wrappers.py

@@ -5,7 +5,7 @@ from opentelemetry import context as context_api
 from opentelemetry.semconv.ai import SpanAttributes, LLMRequestTypeValues
 
 from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
-from opentelemetry.instrumentation.openai.utils import _with_tracer_wrapper
+from opentelemetry.instrumentation.openai.utils import _with_tracer_wrapper, dont_throw
 from opentelemetry.instrumentation.openai.shared import (
     _set_client_attributes,
     _set_request_attributes,
@@ -48,7 +48,7 @@ def completion_wrapper(tracer, wrapped, instance, args, kwargs):
 
     if is_streaming_response(response):
         # span will be closed after the generator is done
-        return _build_from_streaming_response(span, response, kwargs)
+        return _build_from_streaming_response(span, kwargs, response)
     else:
         _handle_response(response, span)
 
@@ -72,7 +72,7 @@ async def acompletion_wrapper(tracer, wrapped, instance, args, kwargs):
 
     if is_streaming_response(response):
         # span will be closed after the generator is done
-        return _abuild_from_streaming_response(span, response)
+        return _abuild_from_streaming_response(span, kwargs, response)
     else:
         _handle_response(response, span)
 
@@ -80,6 +80,7 @@ async def acompletion_wrapper(tracer, wrapped, instance, args, kwargs):
     return response
 
 
+@dont_throw
 def _handle_request(span, kwargs, instance):
     _set_request_attributes(span, kwargs)
     if should_send_prompts():
@@ -88,6 +89,7 @@ def _handle_request(span, kwargs, instance):
     _set_client_attributes(span, instance)
 
 
+@dont_throw
 def _handle_response(response, span):
     if is_openai_v1():
         response_dict = model_as_dict(response)
@@ -104,56 +106,65 @@ def _set_prompts(span, prompt):
     if not span.is_recording() or not prompt:
         return
 
-    try:
-        _set_span_attribute(
-            span,
-            f"{SpanAttributes.LLM_PROMPTS}.0.user",
-            prompt[0] if isinstance(prompt, list) else prompt,
-        )
-    except Exception as ex:  # pylint: disable=broad-except
-        logger.warning("Failed to set prompts for openai span, error: %s", str(ex))
+    _set_span_attribute(
+        span,
+        f"{SpanAttributes.LLM_PROMPTS}.0.user",
+        prompt[0] if isinstance(prompt, list) else prompt,
+    )
 
 
+@dont_throw
 def _set_completions(span, choices):
     if not span.is_recording() or not choices:
         return
 
-    try:
-        for choice in choices:
-            index = choice.get("index")
-            prefix = f"{SpanAttributes.LLM_COMPLETIONS}.{index}"
-            _set_span_attribute(
-                span, f"{prefix}.finish_reason", choice.get("finish_reason")
-            )
-            _set_span_attribute(span, f"{prefix}.content", choice.get("text"))
-    except Exception as e:
-        logger.warning("Failed to set completion attributes, error: %s", str(e))
+    for choice in choices:
+        index = choice.get("index")
+        prefix = f"{SpanAttributes.LLM_COMPLETIONS}.{index}"
+        _set_span_attribute(
+            span, f"{prefix}.finish_reason", choice.get("finish_reason")
+        )
+        _set_span_attribute(span, f"{prefix}.content", choice.get("text"))
 
 
-def _build_from_streaming_response(span, response, request_kwargs=None):
+@dont_throw
+def _build_from_streaming_response(span, request_kwargs, response):
     complete_response = {"choices": [], "model": ""}
     for item in response:
-        item_to_yield = item
-        if is_openai_v1():
-            item = model_as_dict(item)
+        yield item
+        _accumulate_streaming_response(complete_response, item)
 
-        complete_response["model"] = item.get("model")
+    _set_response_attributes(span, complete_response)
 
-        for choice in item.get("choices"):
-            index = choice.get("index")
-            if len(complete_response.get("choices")) <= index:
-                complete_response["choices"].append({"index": index, "text": ""})
-            complete_choice = complete_response.get("choices")[index]
-            if choice.get("finish_reason"):
-                complete_choice["finish_reason"] = choice.get("finish_reason")
+    _set_token_usage(span, request_kwargs, complete_response)
 
-            if choice.get("text"):
-                complete_choice["text"] += choice.get("text")
+    if should_send_prompts():
+        _set_completions(span, complete_response.get("choices"))
 
-        yield item_to_yield
+    span.set_status(Status(StatusCode.OK))
+    span.end()
+
+
+@dont_throw
+async def _abuild_from_streaming_response(span, request_kwargs, response):
+    complete_response = {"choices": [], "model": ""}
+    async for item in response:
+        yield item
+        _accumulate_streaming_response(complete_response, item)
 
     _set_response_attributes(span, complete_response)
 
+    _set_token_usage(span, request_kwargs, complete_response)
+
+    if should_send_prompts():
+        _set_completions(span, complete_response.get("choices"))
+
+    span.set_status(Status(StatusCode.OK))
+    span.end()
+
+
+@dont_throw
+def _set_token_usage(span, request_kwargs, complete_response):
     # use tiktoken calculate token usage
     if should_record_stream_token_usage():
         prompt_usage = -1
@@ -172,46 +183,35 @@ def _build_from_streaming_response(span, response, request_kwargs=None):
             completion_content = ""
             model_name = complete_response.get("model") or None
 
-            for choice in complete_response.get("choices"):  # type: dict
+            for choice in complete_response.get("choices"):
                 if choice.get("text"):
                     completion_content += choice.get("text")
 
             if model_name:
-                completion_usage = get_token_count_from_string(completion_content, model_name)
+                completion_usage = get_token_count_from_string(
+                    completion_content, model_name
+                )
 
         # span record
         _set_span_stream_usage(span, prompt_usage, completion_usage)
 
-    if should_send_prompts():
-        _set_completions(span, complete_response.get("choices"))
 
-    span.set_status(Status(StatusCode.OK))
-    span.end()
+@dont_throw
+def _accumulate_streaming_response(complete_response, item):
+    if is_openai_v1():
+        item = model_as_dict(item)
 
+    complete_response["model"] = item.get("model")
 
-async def _abuild_from_streaming_response(span, response):
-    complete_response = {"choices": [], "model": ""}
-    async for item in response:
-        item_to_yield = item
-        if is_openai_v1():
-            item = model_as_dict(item)
-
-        for choice in item.get("choices"):
-            index = choice.get("index")
-            if len(complete_response.get("choices")) <= index:
-                complete_response["choices"].append({"index": index, "text": ""})
-            complete_choice = complete_response.get("choices")[index]
-            if choice.get("finish_reason"):
-                complete_choice["finish_reason"] = choice.get("finish_reason")
+    for choice in item.get("choices"):
+        index = choice.get("index")
+        if len(complete_response.get("choices")) <= index:
+            complete_response["choices"].append({"index": index, "text": ""})
+        complete_choice = complete_response.get("choices")[index]
+        if choice.get("finish_reason"):
+            complete_choice["finish_reason"] = choice.get("finish_reason")
 
+        if choice.get("text"):
             complete_choice["text"] += choice.get("text")
 
-        yield item_to_yield
-
-    _set_response_attributes(span, complete_response)
-
-    if should_send_prompts():
-        _set_completions(span, complete_response.get("choices"))
-
-    span.set_status(Status(StatusCode.OK))
-    span.end()
+    return complete_response

opentelemetry/instrumentation/openai/shared/config.py

@@ -1,3 +1,4 @@
 class Config:
     enrich_token_usage = False
     enrich_assistant = False
+    exception_logger = None

opentelemetry/instrumentation/openai/shared/embeddings_wrappers.py

@@ -7,6 +7,7 @@ from opentelemetry.semconv.ai import SpanAttributes, LLMRequestTypeValues
 
 from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
 from opentelemetry.instrumentation.openai.utils import (
+    dont_throw,
     start_as_current_span_async,
     _with_embeddings_telemetry_wrapper,
 )
@@ -144,6 +145,7 @@ async def aembeddings_wrapper(
         return response
 
 
+@dont_throw
 def _handle_request(span, kwargs, instance):
     _set_request_attributes(span, kwargs)
     if should_send_prompts():
@@ -151,6 +153,7 @@ def _handle_request(span, kwargs, instance):
     _set_client_attributes(span, instance)
 
 
+@dont_throw
 def _handle_response(
     response,
     span,
@@ -217,17 +220,12 @@ def _set_prompts(span, prompt):
     if not span.is_recording() or not prompt:
         return
 
-    try:
-        if isinstance(prompt, list):
-            for i, p in enumerate(prompt):
-                _set_span_attribute(
-                    span, f"{SpanAttributes.LLM_PROMPTS}.{i}.content", p
-                )
-        else:
-            _set_span_attribute(
-                span,
-                f"{SpanAttributes.LLM_PROMPTS}.0.content",
-                prompt,
-            )
-    except Exception as ex:  # pylint: disable=broad-except
-        logger.warning("Failed to set prompts for openai span, error: %s", str(ex))
+    if isinstance(prompt, list):
+        for i, p in enumerate(prompt):
+            _set_span_attribute(span, f"{SpanAttributes.LLM_PROMPTS}.{i}.content", p)
+    else:
+        _set_span_attribute(
+            span,
+            f"{SpanAttributes.LLM_PROMPTS}.0.content",
+            prompt,
+        )

opentelemetry/instrumentation/openai/shared/image_gen_wrappers.py

@@ -6,14 +6,24 @@ from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
 from opentelemetry.metrics import Counter, Histogram
 
 from opentelemetry.instrumentation.openai import is_openai_v1
-from opentelemetry.instrumentation.openai.shared import _get_openai_base_url, model_as_dict
-from opentelemetry.instrumentation.openai.utils import _with_image_gen_metric_wrapper
+from opentelemetry.instrumentation.openai.shared import (
+    _get_openai_base_url,
+    model_as_dict,
+)
+from opentelemetry.instrumentation.openai.utils import (
+    _with_image_gen_metric_wrapper,
+)
 
 
 @_with_image_gen_metric_wrapper
-def image_gen_metrics_wrapper(duration_histogram: Histogram,
-                              exception_counter: Counter,
-                              wrapped, instance, args, kwargs):
+def image_gen_metrics_wrapper(
+    duration_histogram: Histogram,
+    exception_counter: Counter,
+    wrapped,
+    instance,
+    args,
+    kwargs,
+):
     if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
         return wrapped(*args, **kwargs)
 
@@ -24,7 +34,7 @@ def image_gen_metrics_wrapper(duration_histogram: Histogram,
         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
+        duration = end_time - start_time if "start_time" in locals() else 0
 
         attributes = {
             "error.type": e.__class__.__name__,

opentelemetry/instrumentation/openai/utils.py

@@ -1,7 +1,9 @@
 from importlib.metadata import version
 from contextlib import asynccontextmanager
+import logging
 import os
 
+import openai
 from opentelemetry.instrumentation.openai.shared.config import Config
 
 
@@ -9,6 +11,12 @@ def is_openai_v1():
     return version("openai") >= "1.0.0"
 
 
+def is_azure_openai(instance):
+    return is_openai_v1() and isinstance(
+        instance._client, (openai.AsyncAzureOpenAI, openai.AzureOpenAI)
+    )
+
+
 def is_metrics_enabled() -> bool:
     return (os.getenv("TRACELOOP_METRICS_ENABLED") or "true").lower() == "true"
 
@@ -99,3 +107,24 @@ def _with_tracer_wrapper(func):
 async def start_as_current_span_async(tracer, *args, **kwargs):
     with tracer.start_as_current_span(*args, **kwargs) as span:
         yield span
+
+
+def dont_throw(func):
+    """
+    A decorator that wraps the passed in function and logs exceptions instead of throwing them.
+
+    @param func: The function to wrap
+    @return: The wrapper function
+    """
+    # Obtain a logger specific to the function's module
+    logger = logging.getLogger(func.__module__)
+
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            logger.warning("Failed to execute %s, error: %s", func.__name__, str(e))
+            if Config.exception_logger:
+                Config.exception_logger(e)
+
+    return wrapper

opentelemetry/instrumentation/openai/version.py

@@ -1 +1 @@
-__version__ = "0.16.5"
+__version__ = "0.16.7"

{opentelemetry_instrumentation_openai-0.16.5.dist-info → opentelemetry_instrumentation_openai-0.16.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: opentelemetry-instrumentation-openai
-Version: 0.16.5
+Version: 0.16.7
 Summary: OpenTelemetry OpenAI instrumentation
 Home-page: https://github.com/traceloop/openllmetry/tree/main/packages/opentelemetry-instrumentation-openai
 License: Apache-2.0

opentelemetry_instrumentation_openai-0.16.7.dist-info/RECORD

@@ -0,0 +1,17 @@
+opentelemetry/instrumentation/openai/__init__.py,sha256=xl3Kvqry9glVhu8VtdknfUE9FpXQ7KWAFqtVlpjE-40,1344
+opentelemetry/instrumentation/openai/shared/__init__.py,sha256=h5H3SCwmBC4WzQ4MPrf3yqMfFb0sVRvTEpyTLZAAtwA,7343
+opentelemetry/instrumentation/openai/shared/chat_wrappers.py,sha256=9u2G8gLbQpo-KZfBVguFMKEA5sJurYNjeQ1kdR17pEY,16993
+opentelemetry/instrumentation/openai/shared/completion_wrappers.py,sha256=-JHfgyxic5I3Wr3Uc_L-U7ztDVFcyovtF37tNLtaW3s,6604
+opentelemetry/instrumentation/openai/shared/config.py,sha256=5uekQEnmYo1o6tsTD2IGc-cVmHUo5KmUC4pOVdrFFNk,102
+opentelemetry/instrumentation/openai/shared/embeddings_wrappers.py,sha256=OIKWoc8Ah26E5Our0lkpGwZpIoJrWE-8WX_gvUrROio,6586
+opentelemetry/instrumentation/openai/shared/image_gen_wrappers.py,sha256=9buL2SHcu4cEWYdoavr8lCxpmWo_1dpciPXpXCofvIs,1888
+opentelemetry/instrumentation/openai/utils.py,sha256=IM5l_MjM7XnO0e7tDGsPml-juQ9SI1QK200X0atiAyE,3357
+opentelemetry/instrumentation/openai/v0/__init__.py,sha256=ngmmYyfTwRQSjTZAvNpBIOHQ1BIUXeQnOQz126Iucp0,6116
+opentelemetry/instrumentation/openai/v1/__init__.py,sha256=6XHk11JhkpZixgMDsjb0b-efd8LlBTG0jjMCyf0fOSo,8652
+opentelemetry/instrumentation/openai/v1/assistant_wrappers.py,sha256=T6Vtdp1fAZdcYjGiTMZwkn4F4DgsltD4p4xLEFW-GhI,5874
+opentelemetry/instrumentation/openai/v1/event_handler_wrapper.py,sha256=SAzYoun2yyOloofyOWtxpm8E2M9TL3Nm8TgKdNyXHuY,2779
+opentelemetry/instrumentation/openai/version.py,sha256=d1jssHDng02ej4s_3Yzl--DPqN1B-xx2byinKhvGh94,23
+opentelemetry_instrumentation_openai-0.16.7.dist-info/METADATA,sha256=ZUfCo0ht5swUkuBriVUHO_SWQdRMqt-8ITyzrpMmkHE,2218
+opentelemetry_instrumentation_openai-0.16.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+opentelemetry_instrumentation_openai-0.16.7.dist-info/entry_points.txt,sha256=vTBfiX5yXji5YHikuJHEOoBZ1TFdPQ1EI4ctd2pZSeE,93
+opentelemetry_instrumentation_openai-0.16.7.dist-info/RECORD,,

opentelemetry_instrumentation_openai-0.16.5.dist-info/RECORD

@@ -1,17 +0,0 @@
-opentelemetry/instrumentation/openai/__init__.py,sha256=VSQyN0asXvBQD4jAm46xnHRHjKU74Zqzo1UimaC0ws8,1245
-opentelemetry/instrumentation/openai/shared/__init__.py,sha256=o0QGgSMDC8aE2PmV3z6AMdH4nP-SiUQ0w3aKhXXBvzg,8320
-opentelemetry/instrumentation/openai/shared/chat_wrappers.py,sha256=4DliMcFOJCBLGh0nLtdbdG811K_1bxJWAvBJK5Rpd2A,16771
-opentelemetry/instrumentation/openai/shared/completion_wrappers.py,sha256=xg9qNqijT5ZJOk509l9Q7kVHLwo88DUH-Uv4tzSkeOQ,7045
-opentelemetry/instrumentation/openai/shared/config.py,sha256=hd2oUeASejh5bEKot76pvQNONpWKsrw2S3iH3j3XsVs,74
-opentelemetry/instrumentation/openai/shared/embeddings_wrappers.py,sha256=nIcUJonuhjaz_-HgCaX6A0R-NQ0eCvOGbXrfLSI_z10,6773
-opentelemetry/instrumentation/openai/shared/image_gen_wrappers.py,sha256=SnmhXnnO5pyc0x9wvbYb1S_OVM4TYr7qeJPZbs3YxJg,1899
-opentelemetry/instrumentation/openai/utils.py,sha256=l63pdGpBMEy8oLPlt4QrNL35qYW4nf5ItNsZYYZG7jU,2554
-opentelemetry/instrumentation/openai/v0/__init__.py,sha256=ngmmYyfTwRQSjTZAvNpBIOHQ1BIUXeQnOQz126Iucp0,6116
-opentelemetry/instrumentation/openai/v1/__init__.py,sha256=6XHk11JhkpZixgMDsjb0b-efd8LlBTG0jjMCyf0fOSo,8652
-opentelemetry/instrumentation/openai/v1/assistant_wrappers.py,sha256=T6Vtdp1fAZdcYjGiTMZwkn4F4DgsltD4p4xLEFW-GhI,5874
-opentelemetry/instrumentation/openai/v1/event_handler_wrapper.py,sha256=SAzYoun2yyOloofyOWtxpm8E2M9TL3Nm8TgKdNyXHuY,2779
-opentelemetry/instrumentation/openai/version.py,sha256=r0anPjT1FU7ZF59Wu8yrTS7JfVcf5Cbwqs29-uSLGyo,23
-opentelemetry_instrumentation_openai-0.16.5.dist-info/METADATA,sha256=-ds4WFxRIyDpiVcDNlf7Uug5lNO_-623usUUvB0JNkI,2218
-opentelemetry_instrumentation_openai-0.16.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-opentelemetry_instrumentation_openai-0.16.5.dist-info/entry_points.txt,sha256=vTBfiX5yXji5YHikuJHEOoBZ1TFdPQ1EI4ctd2pZSeE,93
-opentelemetry_instrumentation_openai-0.16.5.dist-info/RECORD,,