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

opentelemetry/instrumentation/openai/__init__.py

@@ -1,12 +1,9 @@
 from typing import Callable, Collection, Optional
-from typing_extensions import Coroutine
 
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
-
 from opentelemetry.instrumentation.openai.shared.config import Config
 from opentelemetry.instrumentation.openai.utils import is_openai_v1
-from opentelemetry.instrumentation.openai.v0 import OpenAIV0Instrumentor
-from opentelemetry.instrumentation.openai.v1 import OpenAIV1Instrumentor
+from typing_extensions import Coroutine
 
 _instruments = ("openai >= 0.27.0",)
 
@@ -17,33 +14,41 @@ class OpenAIInstrumentor(BaseInstrumentor):
     def __init__(
         self,
         enrich_assistant: bool = False,
-        enrich_token_usage: bool = False,
         exception_logger=None,
         get_common_metrics_attributes: Callable[[], dict] = lambda: {},
         upload_base64_image: Optional[
             Callable[[str, str, str, str], Coroutine[None, None, str]]
         ] = lambda *args: "",
         enable_trace_context_propagation: bool = True,
+        use_legacy_attributes: bool = True,
     ):
         super().__init__()
         Config.enrich_assistant = enrich_assistant
-        Config.enrich_token_usage = enrich_token_usage
         Config.exception_logger = exception_logger
         Config.get_common_metrics_attributes = get_common_metrics_attributes
         Config.upload_base64_image = upload_base64_image
         Config.enable_trace_context_propagation = enable_trace_context_propagation
+        Config.use_legacy_attributes = use_legacy_attributes
 
     def instrumentation_dependencies(self) -> Collection[str]:
         return _instruments
 
     def _instrument(self, **kwargs):
         if is_openai_v1():
+            from opentelemetry.instrumentation.openai.v1 import OpenAIV1Instrumentor
+
             OpenAIV1Instrumentor().instrument(**kwargs)
         else:
+            from opentelemetry.instrumentation.openai.v0 import OpenAIV0Instrumentor
+
             OpenAIV0Instrumentor().instrument(**kwargs)
 
     def _uninstrument(self, **kwargs):
         if is_openai_v1():
+            from opentelemetry.instrumentation.openai.v1 import OpenAIV1Instrumentor
+
             OpenAIV1Instrumentor().uninstrument(**kwargs)
         else:
+            from opentelemetry.instrumentation.openai.v0 import OpenAIV0Instrumentor
+
             OpenAIV0Instrumentor().uninstrument(**kwargs)

opentelemetry/instrumentation/openai/shared/__init__.py

@@ -1,42 +1,41 @@
-import os
-import openai
 import json
-import types
 import logging
-
+import types
+import openai
+import pydantic
 from importlib.metadata import version
 
-from opentelemetry import context as context_api
-from opentelemetry.trace.propagation import set_span_in_context
-from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
-
 from opentelemetry.instrumentation.openai.shared.config import Config
-from opentelemetry.semconv_ai import SpanAttributes
 from opentelemetry.instrumentation.openai.utils import (
     dont_throw,
     is_openai_v1,
-    should_record_stream_token_usage,
 )
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAIAttributes,
+    openai_attributes as OpenAIAttributes,
+)
+from opentelemetry.semconv_ai import SpanAttributes
+from opentelemetry.trace.propagation import set_span_in_context
+from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
 
 OPENAI_LLM_USAGE_TOKEN_TYPES = ["prompt_tokens", "completion_tokens"]
 PROMPT_FILTER_KEY = "prompt_filter_results"
 PROMPT_ERROR = "prompt_error"
 
-# tiktoken encodings map for different model, key is model_name, value is tiktoken encoding
-tiktoken_encodings = {}
+_PYDANTIC_VERSION = version("pydantic")
+
 
 logger = logging.getLogger(__name__)
 
 
-def should_send_prompts():
-    return (
-        os.getenv("TRACELOOP_TRACE_CONTENT") or "true"
-    ).lower() == "true" or context_api.get_value("override_enable_content_tracing")
+def _set_span_attribute(span, name, value):
+    if value is None or value == "":
+        return
 
+    if hasattr(openai, "NOT_GIVEN") and value == openai.NOT_GIVEN:
+        return
 
-def _set_span_attribute(span, name, value):
-    if value is not None and value != "" and value != openai.NOT_GIVEN:
-        span.set_attribute(name, value)
+    span.set_attribute(name, value)
 
 
 def _set_client_attributes(span, instance):
@@ -103,20 +102,30 @@ def set_tools_attributes(span, tools):
         )
 
 
-def _set_request_attributes(span, kwargs):
+def _set_request_attributes(span, kwargs, instance=None):
     if not span.is_recording():
         return
 
     _set_api_attributes(span)
-    _set_span_attribute(span, SpanAttributes.LLM_SYSTEM, "OpenAI")
-    _set_span_attribute(span, SpanAttributes.LLM_REQUEST_MODEL, kwargs.get("model"))
+
+    base_url = _get_openai_base_url(instance) if instance else ""
+    vendor = _get_vendor_from_url(base_url)
+    _set_span_attribute(span, GenAIAttributes.GEN_AI_SYSTEM, vendor)
+
+    model = kwargs.get("model")
+    if vendor == "AWS" and model and "." in model:
+        model = _cross_region_check(model)
+    elif vendor == "OpenRouter":
+        model = _extract_model_name_from_provider_format(model)
+
+    _set_span_attribute(span, GenAIAttributes.GEN_AI_REQUEST_MODEL, model)
     _set_span_attribute(
-        span, SpanAttributes.LLM_REQUEST_MAX_TOKENS, kwargs.get("max_tokens")
+        span, GenAIAttributes.GEN_AI_REQUEST_MAX_TOKENS, kwargs.get("max_tokens")
     )
     _set_span_attribute(
-        span, SpanAttributes.LLM_REQUEST_TEMPERATURE, kwargs.get("temperature")
+        span, GenAIAttributes.GEN_AI_REQUEST_TEMPERATURE, kwargs.get("temperature")
     )
-    _set_span_attribute(span, SpanAttributes.LLM_REQUEST_TOP_P, kwargs.get("top_p"))
+    _set_span_attribute(span, GenAIAttributes.GEN_AI_REQUEST_TOP_P, kwargs.get("top_p"))
     _set_span_attribute(
         span, SpanAttributes.LLM_FREQUENCY_PENALTY, kwargs.get("frequency_penalty")
     )
@@ -133,6 +142,52 @@ def _set_request_attributes(span, kwargs):
     _set_span_attribute(
         span, SpanAttributes.LLM_IS_STREAMING, kwargs.get("stream") or False
     )
+    _set_span_attribute(
+        span, OpenAIAttributes.OPENAI_REQUEST_SERVICE_TIER, kwargs.get("service_tier")
+    )
+    if response_format := kwargs.get("response_format"):
+        # backward-compatible check for
+        # openai.types.shared_params.response_format_json_schema.ResponseFormatJSONSchema
+        if (
+            isinstance(response_format, dict)
+            and response_format.get("type") == "json_schema"
+            and response_format.get("json_schema")
+        ):
+            schema = dict(response_format.get("json_schema")).get("schema")
+            if schema:
+                _set_span_attribute(
+                    span,
+                    SpanAttributes.LLM_REQUEST_STRUCTURED_OUTPUT_SCHEMA,
+                    json.dumps(schema),
+                )
+        elif (
+            isinstance(response_format, pydantic.BaseModel)
+            or (
+                hasattr(response_format, "model_json_schema")
+                and callable(response_format.model_json_schema)
+            )
+        ):
+            _set_span_attribute(
+                span,
+                SpanAttributes.LLM_REQUEST_STRUCTURED_OUTPUT_SCHEMA,
+                json.dumps(response_format.model_json_schema()),
+            )
+        else:
+            schema = None
+            try:
+                schema = json.dumps(pydantic.TypeAdapter(response_format).json_schema())
+            except Exception:
+                try:
+                    schema = json.dumps(response_format)
+                except Exception:
+                    pass
+
+            if schema:
+                _set_span_attribute(
+                    span,
+                    SpanAttributes.LLM_REQUEST_STRUCTURED_OUTPUT_SCHEMA,
+                    schema,
+                )
 
 
 @dont_throw
@@ -143,20 +198,28 @@ def _set_response_attributes(span, response):
     if "error" in response:
         _set_span_attribute(
             span,
-            f"{SpanAttributes.LLM_PROMPTS}.{PROMPT_ERROR}",
+            f"{GenAIAttributes.GEN_AI_PROMPT}.{PROMPT_ERROR}",
             json.dumps(response.get("error")),
         )
         return
 
-    _set_span_attribute(span, SpanAttributes.LLM_RESPONSE_MODEL, response.get("model"))
+    response_model = response.get("model")
+    if response_model:
+        response_model = _extract_model_name_from_provider_format(response_model)
+    _set_span_attribute(span, GenAIAttributes.GEN_AI_RESPONSE_MODEL, response_model)
+    _set_span_attribute(span, GenAIAttributes.GEN_AI_RESPONSE_ID, response.get("id"))
 
     _set_span_attribute(
         span,
         SpanAttributes.LLM_OPENAI_RESPONSE_SYSTEM_FINGERPRINT,
         response.get("system_fingerprint"),
     )
+    _set_span_attribute(
+        span,
+        OpenAIAttributes.OPENAI_RESPONSE_SERVICE_TIER,
+        response.get("service_tier"),
+    )
     _log_prompt_filter(span, response)
-
     usage = response.get("usage")
     if not usage:
         return
@@ -169,11 +232,17 @@ def _set_response_attributes(span, response):
     )
     _set_span_attribute(
         span,
-        SpanAttributes.LLM_USAGE_COMPLETION_TOKENS,
+        GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS,
         usage.get("completion_tokens"),
     )
     _set_span_attribute(
-        span, SpanAttributes.LLM_USAGE_PROMPT_TOKENS, usage.get("prompt_tokens")
+        span, GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS, usage.get("prompt_tokens")
+    )
+    prompt_tokens_details = dict(usage.get("prompt_tokens_details", {}))
+    _set_span_attribute(
+        span,
+        SpanAttributes.LLM_USAGE_CACHE_READ_INPUT_TOKENS,
+        prompt_tokens_details.get("cached_tokens", 0),
     )
     return
 
@@ -182,7 +251,7 @@ def _log_prompt_filter(span, response_dict):
     if response_dict.get("prompt_filter_results"):
         _set_span_attribute(
             span,
-            f"{SpanAttributes.LLM_PROMPTS}.{PROMPT_FILTER_KEY}",
+            f"{GenAIAttributes.GEN_AI_PROMPT}.{PROMPT_FILTER_KEY}",
             json.dumps(response_dict.get("prompt_filter_results")),
         )
 
@@ -192,17 +261,17 @@ def _set_span_stream_usage(span, prompt_tokens, completion_tokens):
     if not span.is_recording():
         return
 
-    if type(completion_tokens) is int and completion_tokens >= 0:
+    if isinstance(completion_tokens, int) and completion_tokens >= 0:
         _set_span_attribute(
-            span, SpanAttributes.LLM_USAGE_COMPLETION_TOKENS, completion_tokens
+            span, GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS, completion_tokens
         )
 
-    if type(prompt_tokens) is int and prompt_tokens >= 0:
-        _set_span_attribute(span, SpanAttributes.LLM_USAGE_PROMPT_TOKENS, prompt_tokens)
+    if isinstance(prompt_tokens, int) and prompt_tokens >= 0:
+        _set_span_attribute(span, GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS, prompt_tokens)
 
     if (
-        type(prompt_tokens) is int
-        and type(completion_tokens) is int
+        isinstance(prompt_tokens, int)
+        and isinstance(completion_tokens, int)
         and completion_tokens + prompt_tokens >= 0
     ):
         _set_span_attribute(
@@ -221,6 +290,53 @@ def _get_openai_base_url(instance):
     return ""
 
 
+def _get_vendor_from_url(base_url):
+    if not base_url:
+        return "openai"
+
+    if "openai.azure.com" in base_url:
+        return "Azure"
+    elif "amazonaws.com" in base_url or "bedrock" in base_url:
+        return "AWS"
+    elif "googleapis.com" in base_url or "vertex" in base_url:
+        return "Google"
+    elif "openrouter.ai" in base_url:
+        return "OpenRouter"
+
+    return "openai"
+
+
+def _cross_region_check(value):
+    if not value or "." not in value:
+        return value
+
+    prefixes = ["us", "us-gov", "eu", "apac"]
+    if any(value.startswith(prefix + ".") for prefix in prefixes):
+        parts = value.split(".")
+        if len(parts) > 2:
+            return parts[2]
+        else:
+            return value
+    else:
+        vendor, model = value.split(".", 1)
+        return model
+
+
+def _extract_model_name_from_provider_format(model_name):
+    """
+    Extract model name from provider/model format.
+    E.g., 'openai/gpt-4o' -> 'gpt-4o', 'anthropic/claude-3-sonnet' -> 'claude-3-sonnet'
+    """
+    if not model_name:
+        return model_name
+
+    if "/" in model_name:
+        parts = model_name.split("/")
+        return parts[-1]  # Return the last part (actual model name)
+
+    return model_name
+
+
 def is_streaming_response(response):
     if is_openai_v1():
         return isinstance(response, openai.Stream) or isinstance(
@@ -235,7 +351,7 @@ def is_streaming_response(response):
 def model_as_dict(model):
     if isinstance(model, dict):
         return model
-    if version("pydantic") < "2.0.0":
+    if _PYDANTIC_VERSION < "2.0.0":
         return model.dict()
     if hasattr(model, "model_dump"):
         return model.model_dump()
@@ -245,30 +361,6 @@ def model_as_dict(model):
         return model
 
 
-def get_token_count_from_string(string: str, model_name: str):
-    if not should_record_stream_token_usage():
-        return None
-
-    import tiktoken
-
-    if tiktoken_encodings.get(model_name) is None:
-        try:
-            encoding = tiktoken.encoding_for_model(model_name)
-        except KeyError as ex:
-            # no such model_name in tiktoken
-            logger.warning(
-                f"Failed to get tiktoken encoding for model_name {model_name}, error: {str(ex)}"
-            )
-            return None
-
-        tiktoken_encodings[model_name] = encoding
-    else:
-        encoding = tiktoken_encodings.get(model_name)
-
-    token_count = len(encoding.encode(string))
-    return token_count
-
-
 def _token_type(token_type: str):
     if token_type == "prompt_tokens":
         return "input"
@@ -282,11 +374,12 @@ def metric_shared_attributes(
     response_model: str, operation: str, server_address: str, is_streaming: bool = False
 ):
     attributes = Config.get_common_metrics_attributes()
+    vendor = _get_vendor_from_url(server_address)
 
     return {
         **attributes,
-        SpanAttributes.LLM_SYSTEM: "openai",
-        SpanAttributes.LLM_RESPONSE_MODEL: response_model,
+        GenAIAttributes.GEN_AI_SYSTEM: vendor,
+        GenAIAttributes.GEN_AI_RESPONSE_MODEL: response_model,
         "gen_ai.operation.name": operation,
         "server.address": server_address,
         "stream": is_streaming,
@@ -294,7 +387,13 @@ def metric_shared_attributes(
 
 
 def propagate_trace_context(span, kwargs):
-    extra_headers = kwargs.get("extra_headers", {})
-    ctx = set_span_in_context(span)
-    TraceContextTextMapPropagator().inject(extra_headers, context=ctx)
-    kwargs["extra_headers"] = extra_headers
+    if is_openai_v1():
+        extra_headers = kwargs.get("extra_headers", {})
+        ctx = set_span_in_context(span)
+        TraceContextTextMapPropagator().inject(extra_headers, context=ctx)
+        kwargs["extra_headers"] = extra_headers
+    else:
+        headers = kwargs.get("headers", {})
+        ctx = set_span_in_context(span)
+        TraceContextTextMapPropagator().inject(headers, context=ctx)
+        kwargs["headers"] = headers