opentelemetry-instrumentation-openai 0.17.0__tar.gz → 0.17.2__tar.gz

{opentelemetry_instrumentation_openai-0.17.0 → opentelemetry_instrumentation_openai-0.17.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: opentelemetry-instrumentation-openai
-Version: 0.17.0
+Version: 0.17.2
 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.17.0 → opentelemetry_instrumentation_openai-0.17.2}/opentelemetry/instrumentation/openai/shared/chat_wrappers.py

@@ -1,6 +1,8 @@
 import json
 import logging
 import time
+from wrapt import ObjectProxy
+
 
 from opentelemetry import context as context_api
 from opentelemetry.metrics import Counter, Histogram
@@ -85,7 +87,7 @@ def chat_wrapper(
 
     if is_streaming_response(response):
         # span will be closed after the generator is done
-        return _build_from_streaming_response(
+        return ChatStream(
             span,
             response,
             instance,
@@ -159,7 +161,7 @@ async def achat_wrapper(
 
     if is_streaming_response(response):
         # span will be closed after the generator is done
-        return _abuild_from_streaming_response(
+        return ChatStream(
             span,
             response,
             instance,
@@ -395,161 +397,140 @@ def _set_streaming_token_metrics(
             token_counter.add(completion_usage, attributes=attributes_with_token_type)
 
 
-@dont_throw
-def _build_from_streaming_response(
-    span,
-    response,
-    instance=None,
-    token_counter=None,
-    choice_counter=None,
-    duration_histogram=None,
-    streaming_time_to_first_token=None,
-    streaming_time_to_generate=None,
-    start_time=None,
-    request_kwargs=None,
-):
-    complete_response = {"choices": [], "model": ""}
-
-    first_token = True
-    time_of_first_token = start_time  # will be updated when first token is received
-
-    for item in response:
-        span.add_event(name="llm.content.completion.chunk")
-
-        item_to_yield = item
-
-        if first_token and streaming_time_to_first_token:
-            time_of_first_token = time.time()
-            streaming_time_to_first_token.record(time_of_first_token - start_time)
-            first_token = False
-
-        _accumulate_stream_items(item, complete_response)
-
-        yield item_to_yield
-
-    shared_attributes = {
-        "gen_ai.response.model": complete_response.get("model") or None,
-        "server.address": _get_openai_base_url(instance),
-        "stream": True,
-    }
-
-    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"):
-        _set_choice_counter_metrics(
-            choice_counter, complete_response.get("choices"), shared_attributes
-        )
-
-    # duration metrics
-    if start_time and isinstance(start_time, (float, int)):
-        duration = time.time() - start_time
-    else:
-        duration = None
-    if duration and isinstance(duration, (float, int)) and duration_histogram:
-        duration_histogram.record(duration, attributes=shared_attributes)
-    if streaming_time_to_generate and time_of_first_token:
-        streaming_time_to_generate.record(time.time() - time_of_first_token)
-
-    _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()
-
-
-@dont_throw
-async def _abuild_from_streaming_response(
-    span,
-    response,
-    instance=None,
-    token_counter=None,
-    choice_counter=None,
-    duration_histogram=None,
-    streaming_time_to_first_token=None,
-    streaming_time_to_generate=None,
-    start_time=None,
-    request_kwargs=None,
-):
-    complete_response = {"choices": [], "model": ""}
-
-    first_token = True
-    time_of_first_token = start_time  # will be updated when first token is received
-
-    async for item in response:
-        span.add_event(name="llm.content.completion.chunk")
-
-        item_to_yield = item
-
-        if first_token and streaming_time_to_first_token:
-            time_of_first_token = time.time()
-            streaming_time_to_first_token.record(time_of_first_token - start_time)
-            first_token = False
-
-        _accumulate_stream_items(item, complete_response)
-
-        yield item_to_yield
-
-    shared_attributes = {
-        "gen_ai.response.model": complete_response.get("model") or None,
-        "server.address": _get_openai_base_url(instance),
-        "stream": True,
-    }
-
-    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"):
-        _set_choice_counter_metrics(
-            choice_counter, complete_response.get("choices"), shared_attributes
-        )
-
-    # duration metrics
-    if start_time and isinstance(start_time, (float, int)):
-        duration = time.time() - start_time
-    else:
-        duration = None
-    if duration and isinstance(duration, (float, int)) and duration_histogram:
-        duration_histogram.record(duration, attributes=shared_attributes)
-    if streaming_time_to_generate and time_of_first_token:
-        streaming_time_to_generate.record(time.time() - time_of_first_token)
-
-    _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()
-
+class ChatStream(ObjectProxy):
+    def __init__(
+        self,
+        span,
+        response,
+        instance=None,
+        token_counter=None,
+        choice_counter=None,
+        duration_histogram=None,
+        streaming_time_to_first_token=None,
+        streaming_time_to_generate=None,
+        start_time=None,
+        request_kwargs=None,
+    ):
+        super().__init__(response)
+
+        self._span = span
+        self._instance = instance
+        self._token_counter = token_counter
+        self._choice_counter = choice_counter
+        self._duration_histogram = duration_histogram
+        self._streaming_time_to_first_token = streaming_time_to_first_token
+        self._streaming_time_to_generate = streaming_time_to_generate
+        self._start_time = start_time
+        self._request_kwargs = request_kwargs
+
+        self._first_token = True
+        # will be updated when first token is received
+        self._time_of_first_token = self._start_time
+        self._complete_response = {"choices": [], "model": ""}
+
+    def __enter__(self):
+        return self
+
+    def __iter__(self):
+        return self
+
+    def __aiter__(self):
+        return self
+
+    def __next__(self):
+        try:
+            chunk = self.__wrapped__.__next__()
+        except Exception as e:
+            if isinstance(e, StopIteration):
+                self._close_span()
+            raise e
+        else:
+            self._process_item(chunk)
+            return chunk
+
+    async def __anext__(self):
+        try:
+            chunk = await self.__wrapped__.__anext__()
+        except Exception as e:
+            if isinstance(e, StopAsyncIteration):
+                self._close_span()
+            raise e
+        else:
+            self._process_item(chunk)
+            return chunk
+
+    def _process_item(self, item):
+        self._span.add_event(name="llm.content.completion.chunk")
+
+        if self._first_token and self._streaming_time_to_first_token:
+            self._time_of_first_token = time.time()
+            self._streaming_time_to_first_token.record(
+                self._time_of_first_token - self._start_time
+            )
+            self._first_token = False
+
+        if is_openai_v1():
+            item = model_as_dict(item)
+
+        self._complete_response["model"] = item.get("model")
+
+        for choice in item.get("choices"):
+            index = choice.get("index")
+            if len(self._complete_response.get("choices")) <= index:
+                self._complete_response["choices"].append(
+                    {"index": index, "message": {"content": "", "role": ""}}
+                )
+            complete_choice = self._complete_response.get("choices")[index]
+            if choice.get("finish_reason"):
+                complete_choice["finish_reason"] = choice.get("finish_reason")
+
+            delta = choice.get("delta")
+
+            if delta and delta.get("content"):
+                complete_choice["message"]["content"] += delta.get("content")
+            if delta and delta.get("role"):
+                complete_choice["message"]["role"] = delta.get("role")
+
+    def _close_span(self):
+        shared_attributes = {
+            "gen_ai.response.model": self._complete_response.get("model") or None,
+            "server.address": _get_openai_base_url(self._instance),
+            "stream": True,
+        }
 
-def _accumulate_stream_items(item, complete_response):
-    if is_openai_v1():
-        item = model_as_dict(item)
+        if not is_azure_openai(self._instance):
+            _set_streaming_token_metrics(
+                self._request_kwargs,
+                self._complete_response,
+                self._span,
+                self._token_counter,
+                shared_attributes,
+            )
 
-    complete_response["model"] = item.get("model")
+        # choice metrics
+        if self._choice_counter and self._complete_response.get("choices"):
+            _set_choice_counter_metrics(
+                self._choice_counter,
+                self._complete_response.get("choices"),
+                shared_attributes,
+            )
 
-    for choice in item.get("choices"):
-        index = choice.get("index")
-        if len(complete_response.get("choices")) <= index:
-            complete_response["choices"].append(
-                {"index": index, "message": {"content": "", "role": ""}}
+        # duration metrics
+        if self._start_time and isinstance(self._start_time, (float, int)):
+            duration = time.time() - self._start_time
+        else:
+            duration = None
+        if duration and isinstance(duration, (float, int)) and self._duration_histogram:
+            self._duration_histogram.record(duration, attributes=shared_attributes)
+        if self._streaming_time_to_generate and self._time_of_first_token:
+            self._streaming_time_to_generate.record(
+                time.time() - self._time_of_first_token
             )
-        complete_choice = complete_response.get("choices")[index]
-        if choice.get("finish_reason"):
-            complete_choice["finish_reason"] = choice.get("finish_reason")
 
-        delta = choice.get("delta")
+        _set_response_attributes(self._span, self._complete_response)
+
+        if should_send_prompts():
+            _set_completions(self._span, self._complete_response.get("choices"))
 
-        if delta and delta.get("content"):
-            complete_choice["message"]["content"] += delta.get("content")
-        if delta and delta.get("role"):
-            complete_choice["message"]["role"] = delta.get("role")
+        self._span.set_status(Status(StatusCode.OK))
+        self._span.end()

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

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

{opentelemetry_instrumentation_openai-0.17.0 → opentelemetry_instrumentation_openai-0.17.2}/pyproject.toml

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

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

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