opentelemetry-instrumentation-openai 0.38.6__tar.gz → 0.49.6__tar.gz

{opentelemetry_instrumentation_openai-0.38.6 → opentelemetry_instrumentation_openai-0.49.6}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: opentelemetry-instrumentation-openai
-Version: 0.38.6
+Version: 0.49.6
 Summary: OpenTelemetry OpenAI instrumentation
 License: Apache-2.0
 Author: Gal Kleinman
@@ -13,12 +13,12 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Provides-Extra: instruments
-Requires-Dist: opentelemetry-api (>=1.28.0,<2.0.0)
-Requires-Dist: opentelemetry-instrumentation (>=0.50b0)
-Requires-Dist: opentelemetry-semantic-conventions (>=0.50b0)
-Requires-Dist: opentelemetry-semantic-conventions-ai (==0.4.2)
-Requires-Dist: tiktoken (>=0.6.0,<1)
+Requires-Dist: opentelemetry-api (>=1.38.0,<2.0.0)
+Requires-Dist: opentelemetry-instrumentation (>=0.59b0)
+Requires-Dist: opentelemetry-semantic-conventions (>=0.59b0)
+Requires-Dist: opentelemetry-semantic-conventions-ai (>=0.4.13,<0.5.0)
 Project-URL: Repository, https://github.com/traceloop/openllmetry/tree/main/packages/opentelemetry-instrumentation-openai
 Description-Content-Type: text/markdown
 

{opentelemetry_instrumentation_openai-0.38.6 → opentelemetry_instrumentation_openai-0.49.6}/opentelemetry/instrumentation/openai/__init__.py

@@ -1,10 +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 typing_extensions import Coroutine
 
 _instruments = ("openai >= 0.27.0",)
 
@@ -15,21 +14,21 @@ 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

{opentelemetry_instrumentation_openai-0.38.6 → opentelemetry_instrumentation_openai-0.49.6}/opentelemetry/instrumentation/openai/shared/__init__.py

@@ -1,25 +1,22 @@
-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._incubating.attributes.gen_ai_attributes import (
-    GEN_AI_RESPONSE_ID,
-)
-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"
@@ -27,18 +24,10 @@ PROMPT_ERROR = "prompt_error"
 
 _PYDANTIC_VERSION = version("pydantic")
 
-# tiktoken encodings map for different model, key is model_name, value is tiktoken encoding
-tiktoken_encodings = {}
 
 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
@@ -113,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")
     )
@@ -143,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
@@ -153,19 +198,27 @@ 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"))
-    _set_span_attribute(span, GEN_AI_RESPONSE_ID, response.get("id"))
+    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:
@@ -179,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
 
@@ -192,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")),
         )
 
@@ -202,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(
@@ -231,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(
@@ -255,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"
@@ -292,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,