opentelemetry-instrumentation-openai 0.16.5__tar.gz → 0.16.6__tar.gz

{opentelemetry_instrumentation_openai-0.16.5 → opentelemetry_instrumentation_openai-0.16.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: opentelemetry-instrumentation-openai
-Version: 0.16.5
+Version: 0.16.6
 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.5 → opentelemetry_instrumentation_openai-0.16.6}/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-0.16.5 → opentelemetry_instrumentation_openai-0.16.6}/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-0.16.5 → opentelemetry_instrumentation_openai-0.16.6}/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,
@@ -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):
@@ -361,7 +361,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 +390,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,
@@ -456,6 +457,7 @@ def _build_from_streaming_response(
     span.end()
 
 
+@dont_throw
 async def _abuild_from_streaming_response(
     span,
     response,
@@ -540,7 +542,10 @@ 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")
+
+        if choice.get("content_filter_results"):
+            complete_choice["message"]["content"] = "FILTERED"

{opentelemetry_instrumentation_openai-0.16.5 → opentelemetry_instrumentation_openai-0.16.6}/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-0.16.5 → opentelemetry_instrumentation_openai-0.16.6}/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-0.16.5 → opentelemetry_instrumentation_openai-0.16.6}/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-0.16.5 → opentelemetry_instrumentation_openai-0.16.6}/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-0.16.5 → opentelemetry_instrumentation_openai-0.16.6}/opentelemetry/instrumentation/openai/utils.py

@@ -1,5 +1,6 @@
 from importlib.metadata import version
 from contextlib import asynccontextmanager
+import logging
 import os
 
 from opentelemetry.instrumentation.openai.shared.config import Config
@@ -99,3 +100,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-0.16.6/opentelemetry/instrumentation/openai/version.py

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

{opentelemetry_instrumentation_openai-0.16.5 → opentelemetry_instrumentation_openai-0.16.6}/pyproject.toml

@@ -8,7 +8,7 @@ show_missing = true
 
 [tool.poetry]
 name = "opentelemetry-instrumentation-openai"
-version = "0.16.5"
+version = "0.16.6"
 description = "OpenTelemetry OpenAI instrumentation"
 authors = [
   "Gal Kleinman <gal@traceloop.com>",

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

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