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

opentelemetry/instrumentation/openai/shared/completion_wrappers.py

@@ -1,37 +1,42 @@
 import logging
 
 from opentelemetry import context as context_api
-
-from opentelemetry.semconv_ai import (
-    SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY,
-    SpanAttributes,
-    LLMRequestTypeValues,
-)
-
-from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
-from opentelemetry.instrumentation.openai.utils import _with_tracer_wrapper, dont_throw
 from opentelemetry.instrumentation.openai.shared import (
     _set_client_attributes,
-    _set_request_attributes,
-    _set_span_attribute,
     _set_functions_attributes,
+    _set_request_attributes,
     _set_response_attributes,
+    _set_span_attribute,
+    _set_span_stream_usage,
+    get_token_count_from_string,
     is_streaming_response,
-    should_send_prompts,
     model_as_dict,
-    should_record_stream_token_usage,
-    get_token_count_from_string,
-    _set_span_stream_usage,
     propagate_trace_context,
+    should_record_stream_token_usage,
+)
+from opentelemetry.instrumentation.openai.shared.config import Config
+from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
+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,
+    is_openai_v1,
+    should_emit_events,
+    should_send_prompts,
+)
+from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
+from opentelemetry.semconv_ai import (
+    SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY,
+    LLMRequestTypeValues,
+    SpanAttributes,
 )
-
-from opentelemetry.instrumentation.openai.utils import is_openai_v1
-
 from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
 
-from opentelemetry.instrumentation.openai.shared.config import Config
-
 SPAN_NAME = "openai.completion"
 LLM_REQUEST_TYPE = LLMRequestTypeValues.COMPLETION
 
@@ -53,18 +58,21 @@ def completion_wrapper(tracer, wrapped, instance, args, kwargs):
     )
 
     _handle_request(span, kwargs, instance)
+
     try:
         response = wrapped(*args, **kwargs)
     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 e
+        raise
 
     if is_streaming_response(response):
         # span will be closed after the generator is done
         return _build_from_streaming_response(span, kwargs, response)
     else:
-        _handle_response(response, span)
+        _handle_response(response, span, instance)
 
     span.end()
     return response
@@ -84,18 +92,21 @@ async def acompletion_wrapper(tracer, wrapped, instance, args, kwargs):
     )
 
     _handle_request(span, kwargs, instance)
+
     try:
         response = await wrapped(*args, **kwargs)
     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 e
+        raise
 
     if is_streaming_response(response):
         # span will be closed after the generator is done
         return _abuild_from_streaming_response(span, kwargs, response)
     else:
-        _handle_response(response, span)
+        _handle_response(response, span, instance)
 
     span.end()
     return response
@@ -103,26 +114,41 @@ async def acompletion_wrapper(tracer, wrapped, instance, args, kwargs):
 
 @dont_throw
 def _handle_request(span, kwargs, instance):
-    _set_request_attributes(span, kwargs)
-    if should_send_prompts():
-        _set_prompts(span, kwargs.get("prompt"))
-        _set_functions_attributes(span, kwargs.get("functions"))
+    _set_request_attributes(span, kwargs, instance)
+    if should_emit_events():
+        _emit_prompts_events(kwargs)
+    else:
+        if should_send_prompts():
+            _set_prompts(span, kwargs.get("prompt"))
+            _set_functions_attributes(span, kwargs.get("functions"))
     _set_client_attributes(span, instance)
     if Config.enable_trace_context_propagation:
         propagate_trace_context(span, kwargs)
 
 
+def _emit_prompts_events(kwargs):
+    prompt = kwargs.get("prompt")
+    if isinstance(prompt, list):
+        for p in prompt:
+            emit_event(MessageEvent(content=p))
+    elif isinstance(prompt, str):
+        emit_event(MessageEvent(content=prompt))
+
+
 @dont_throw
-def _handle_response(response, span):
+def _handle_response(response, span, instance=None):
     if is_openai_v1():
         response_dict = model_as_dict(response)
     else:
         response_dict = response
 
     _set_response_attributes(span, response_dict)
-
-    if should_send_prompts():
-        _set_completions(span, response_dict.get("choices"))
+    if should_emit_events():
+        for choice in response.choices:
+            emit_event(_parse_choice_event(choice))
+    else:
+        if should_send_prompts():
+            _set_completions(span, response_dict.get("choices"))
 
 
 def _set_prompts(span, prompt):
@@ -161,8 +187,11 @@ def _build_from_streaming_response(span, request_kwargs, response):
 
     _set_token_usage(span, request_kwargs, complete_response)
 
-    if should_send_prompts():
-        _set_completions(span, complete_response.get("choices"))
+    if should_emit_events():
+        _emit_streaming_response_events(complete_response)
+    else:
+        if should_send_prompts():
+            _set_completions(span, complete_response.get("choices"))
 
     span.set_status(Status(StatusCode.OK))
     span.end()
@@ -179,13 +208,27 @@ async def _abuild_from_streaming_response(span, request_kwargs, response):
 
     _set_token_usage(span, request_kwargs, complete_response)
 
-    if should_send_prompts():
-        _set_completions(span, complete_response.get("choices"))
+    if should_emit_events():
+        _emit_streaming_response_events(complete_response)
+    else:
+        if should_send_prompts():
+            _set_completions(span, complete_response.get("choices"))
 
     span.set_status(Status(StatusCode.OK))
     span.end()
 
 
+def _emit_streaming_response_events(complete_response):
+    for i, choice in enumerate(complete_response["choices"]):
+        emit_event(
+            ChoiceEvent(
+                index=choice.get("index", i),
+                message={"content": choice.get("text"), "role": "assistant"},
+                finish_reason=choice.get("finish_reason", "unknown"),
+            )
+        )
+
+
 @dont_throw
 def _set_token_usage(span, request_kwargs, complete_response):
     # use tiktoken calculate token usage
@@ -238,3 +281,17 @@ def _accumulate_streaming_response(complete_response, item):
             complete_choice["text"] += choice.get("text")
 
     return complete_response
+
+
+def _parse_choice_event(choice) -> ChoiceEvent:
+    has_message = choice.text is not None
+    has_finish_reason = choice.finish_reason is not None
+
+    content = choice.text if has_message else None
+    finish_reason = choice.finish_reason if has_finish_reason else "unknown"
+
+    return ChoiceEvent(
+        index=choice.index,
+        message={"content": content, "role": "assistant"},
+        finish_reason=finish_reason,
+    )

opentelemetry/instrumentation/openai/shared/config.py

@@ -1,4 +1,6 @@
-from typing import Callable
+from typing import Callable, Optional
+
+from opentelemetry._events import EventLogger
 
 
 class Config:
@@ -6,5 +8,9 @@ class Config:
     enrich_assistant = False
     exception_logger = None
     get_common_metrics_attributes: Callable[[], dict] = lambda: {}
-    upload_base64_image: Callable[[str, str, str], str] = lambda trace_id, span_id, base64_image_url: str
+    upload_base64_image: Callable[[str, str, str], str] = (
+        lambda trace_id, span_id, base64_image_url: str
+    )
     enable_trace_context_propagation: bool = True
+    use_legacy_attributes = True
+    event_logger: Optional[EventLogger] = None

opentelemetry/instrumentation/openai/shared/embeddings_wrappers.py

@@ -1,40 +1,46 @@
 import logging
 import time
+from collections.abc import Iterable
 
 from opentelemetry import context as context_api
-from opentelemetry.metrics import Counter, Histogram
-from opentelemetry.semconv_ai import (
-    SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY,
-    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,
-)
 from opentelemetry.instrumentation.openai.shared import (
-    metric_shared_attributes,
+    OPENAI_LLM_USAGE_TOKEN_TYPES,
+    _get_openai_base_url,
     _set_client_attributes,
     _set_request_attributes,
-    _set_span_attribute,
     _set_response_attributes,
+    _set_span_attribute,
     _token_type,
-    should_send_prompts,
+    metric_shared_attributes,
     model_as_dict,
-    _get_openai_base_url,
-    OPENAI_LLM_USAGE_TOKEN_TYPES,
     propagate_trace_context,
 )
-
 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_embeddings_telemetry_wrapper,
+    dont_throw,
+    is_openai_v1,
+    should_emit_events,
+    should_send_prompts,
+    start_as_current_span_async,
+)
+from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
+from opentelemetry.metrics import Counter, Histogram
+from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
+from opentelemetry.semconv_ai import (
+    SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY,
+    LLMRequestTypeValues,
+    SpanAttributes,
+)
+from opentelemetry.trace import SpanKind, Status, StatusCode
 
-from opentelemetry.instrumentation.openai.utils import is_openai_v1
-
-from opentelemetry.trace import SpanKind
-from opentelemetry.trace import Status, StatusCode
+from openai._legacy_response import LegacyAPIResponse
+from openai.types.create_embedding_response import CreateEmbeddingResponse
 
 SPAN_NAME = "openai.embeddings"
 LLM_REQUEST_TYPE = LLMRequestTypeValues.EMBEDDING
@@ -84,10 +90,12 @@ def embeddings_wrapper(
             if exception_counter:
                 exception_counter.add(1, attributes=attributes)
 
+            span.set_attribute(ERROR_TYPE, e.__class__.__name__)
+            span.record_exception(e)
             span.set_status(Status(StatusCode.ERROR, str(e)))
             span.end()
 
-            raise e
+            raise
 
         duration = end_time - start_time
 
@@ -128,6 +136,7 @@ async def aembeddings_wrapper(
         attributes={SpanAttributes.LLM_REQUEST_TYPE: LLM_REQUEST_TYPE.value},
     ) as span:
         _handle_request(span, kwargs, instance)
+
         try:
             # record time for duration
             start_time = time.time()
@@ -146,12 +155,15 @@ async def aembeddings_wrapper(
             if exception_counter:
                 exception_counter.add(1, attributes=attributes)
 
+            span.set_attribute(ERROR_TYPE, e.__class__.__name__)
+            span.record_exception(e)
             span.set_status(Status(StatusCode.ERROR, str(e)))
             span.end()
 
-            raise e
+            raise
 
         duration = end_time - start_time
+
         _handle_response(
             response,
             span,
@@ -167,10 +179,16 @@ async def aembeddings_wrapper(
 
 @dont_throw
 def _handle_request(span, kwargs, instance):
-    _set_request_attributes(span, kwargs)
-    if should_send_prompts():
-        _set_prompts(span, kwargs.get("input"))
+    _set_request_attributes(span, kwargs, instance)
+
+    if should_emit_events():
+        _emit_embeddings_message_event(kwargs.get("input"))
+    else:
+        if should_send_prompts():
+            _set_prompts(span, kwargs.get("input"))
+
     _set_client_attributes(span, instance)
+
     if Config.enable_trace_context_propagation:
         propagate_trace_context(span, kwargs)
 
@@ -201,6 +219,10 @@ def _handle_response(
     # span attributes
     _set_response_attributes(span, response_dict)
 
+    # emit events
+    if should_emit_events():
+        _emit_embeddings_choice_event(response)
+
 
 def _set_embeddings_metrics(
     instance,
@@ -255,3 +277,32 @@ def _set_prompts(span, prompt):
             f"{SpanAttributes.LLM_PROMPTS}.0.content",
             prompt,
         )
+
+
+def _emit_embeddings_message_event(embeddings) -> None:
+    if isinstance(embeddings, str):
+        emit_event(MessageEvent(content=embeddings))
+    elif isinstance(embeddings, Iterable):
+        for i in embeddings:
+            emit_event(MessageEvent(content=i))
+
+
+def _emit_embeddings_choice_event(response) -> None:
+    if isinstance(response, CreateEmbeddingResponse):
+        for embedding in response.data:
+            emit_event(
+                ChoiceEvent(
+                    index=embedding.index,
+                    message={"content": embedding.embedding, "role": "assistant"},
+                )
+            )
+
+    elif isinstance(response, LegacyAPIResponse):
+        parsed_response = response.parse()
+        for embedding in parsed_response.data:
+            emit_event(
+                ChoiceEvent(
+                    index=embedding.index,
+                    message={"content": embedding.embedding, "role": "assistant"},
+                )
+            )

opentelemetry/instrumentation/openai/shared/event_emitter.py

@@ -0,0 +1,100 @@
+from dataclasses import asdict
+from enum import Enum
+from typing import Union
+
+from opentelemetry._events import Event
+from opentelemetry.instrumentation.openai.shared.event_models import (
+    ChoiceEvent,
+    MessageEvent,
+)
+from opentelemetry.instrumentation.openai.utils import (
+    should_emit_events,
+    should_send_prompts,
+)
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAIAttributes,
+)
+
+from .config import Config
+
+
+class Roles(Enum):
+    USER = "user"
+    ASSISTANT = "assistant"
+    SYSTEM = "system"
+    TOOL = "tool"
+
+
+VALID_MESSAGE_ROLES = {role.value for role in Roles}
+"""The valid roles for naming the message event."""
+
+EVENT_ATTRIBUTES = {
+    GenAIAttributes.GEN_AI_SYSTEM: GenAIAttributes.GenAiSystemValues.OPENAI.value
+}
+"""The attributes to be used for the event."""
+
+
+def emit_event(event: Union[MessageEvent, ChoiceEvent]) -> None:
+    """
+    Emit an event to the OpenTelemetry SDK.
+
+    Args:
+        event: The event to emit.
+    """
+    if not should_emit_events():
+        return
+
+    if isinstance(event, MessageEvent):
+        _emit_message_event(event)
+    elif isinstance(event, ChoiceEvent):
+        _emit_choice_event(event)
+    else:
+        raise TypeError("Unsupported event type")
+
+
+def _emit_message_event(event: MessageEvent) -> None:
+    body = asdict(event)
+
+    if event.role in VALID_MESSAGE_ROLES:
+        name = "gen_ai.{}.message".format(event.role)
+        # According to the semantic conventions, the role is conditionally required if available
+        # and not equal to the "role" in the message name. So, remove the role from the body if
+        # it is the same as the in the event name.
+        body.pop("role", None)
+    else:
+        name = "gen_ai.user.message"
+
+    # According to the semantic conventions, only the assistant role has tool call
+    if event.role != Roles.ASSISTANT.value and event.tool_calls is not None:
+        del body["tool_calls"]
+    elif event.tool_calls is None:
+        del body["tool_calls"]
+
+    if not should_send_prompts():
+        del body["content"]
+        if body.get("tool_calls") is not None:
+            for tool_call in body["tool_calls"]:
+                tool_call["function"].pop("arguments", None)
+
+    Config.event_logger.emit(Event(name=name, body=body, attributes=EVENT_ATTRIBUTES))
+
+
+def _emit_choice_event(event: ChoiceEvent) -> None:
+    body = asdict(event)
+    if event.message["role"] == Roles.ASSISTANT.value:
+        # According to the semantic conventions, the role is conditionally required if available
+        # and not equal to "assistant", so remove the role from the body if it is "assistant".
+        body["message"].pop("role", None)
+
+    if event.tool_calls is None:
+        del body["tool_calls"]
+
+    if not should_send_prompts():
+        body["message"].pop("content", None)
+        if body.get("tool_calls") is not None:
+            for tool_call in body["tool_calls"]:
+                tool_call["function"].pop("arguments", None)
+
+    Config.event_logger.emit(
+        Event(name="gen_ai.choice", body=body, attributes=EVENT_ATTRIBUTES)
+    )

opentelemetry/instrumentation/openai/shared/event_models.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass
+from typing import Any, List, Literal, Optional, TypedDict
+
+
+class _FunctionToolCall(TypedDict):
+    function_name: str
+    arguments: Optional[dict[str, Any]]
+
+
+class ToolCall(TypedDict):
+    """Represents a tool call in the AI model."""
+
+    id: str
+    function: _FunctionToolCall
+    type: Literal["function"]
+
+
+class CompletionMessage(TypedDict):
+    """Represents a message in the AI model."""
+
+    content: Any
+    role: str = "assistant"
+
+
+@dataclass
+class MessageEvent:
+    """Represents an input event for the AI model."""
+
+    content: Any
+    role: str = "user"
+    tool_calls: Optional[List[ToolCall]] = None
+
+
+@dataclass
+class ChoiceEvent:
+    """Represents a completion event for the AI model."""
+
+    index: int
+    message: CompletionMessage
+    finish_reason: str = "unknown"
+    tool_calls: Optional[List[ToolCall]] = None

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,16 +1,21 @@
 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
 
-import openai
+from opentelemetry import context as context_api
+from opentelemetry._events import EventLogger
 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 _OPENAI_VERSION >= "1.0.0"
@@ -34,7 +39,12 @@ 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
@@ -157,3 +167,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, EventLogger
+    )