paid-python 0.6.0__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

opentelemetry/instrumentation/openai/shared/__init__.py

@@ -1,399 +0,0 @@
-import json
-import logging
-import types
-import openai
-import pydantic
-from importlib.metadata import version
-
-from opentelemetry.instrumentation.openai.shared.config import Config
-from opentelemetry.instrumentation.openai.utils import (
-    dont_throw,
-    is_openai_v1,
-)
-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"
-
-_PYDANTIC_VERSION = version("pydantic")
-
-
-logger = logging.getLogger(__name__)
-
-
-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
-
-    span.set_attribute(name, value)
-
-
-def _set_client_attributes(span, instance):
-    if not span.is_recording():
-        return
-
-    if not is_openai_v1():
-        return
-
-    client = instance._client  # pylint: disable=protected-access
-    if isinstance(client, (openai.AsyncOpenAI, openai.OpenAI)):
-        _set_span_attribute(
-            span, SpanAttributes.LLM_OPENAI_API_BASE, str(client.base_url)
-        )
-    if isinstance(client, (openai.AsyncAzureOpenAI, openai.AzureOpenAI)):
-        _set_span_attribute(
-            span, SpanAttributes.LLM_OPENAI_API_VERSION, client._api_version
-        )  # pylint: disable=protected-access
-
-
-def _set_api_attributes(span):
-    if not span.is_recording():
-        return
-
-    if is_openai_v1():
-        return
-
-    base_url = openai.base_url if hasattr(openai, "base_url") else openai.api_base
-
-    _set_span_attribute(span, SpanAttributes.LLM_OPENAI_API_BASE, base_url)
-    _set_span_attribute(span, SpanAttributes.LLM_OPENAI_API_TYPE, openai.api_type)
-    _set_span_attribute(span, SpanAttributes.LLM_OPENAI_API_VERSION, openai.api_version)
-
-    return
-
-
-def _set_functions_attributes(span, functions):
-    if not functions:
-        return
-
-    for i, function in enumerate(functions):
-        prefix = f"{SpanAttributes.LLM_REQUEST_FUNCTIONS}.{i}"
-        _set_span_attribute(span, f"{prefix}.name", function.get("name"))
-        _set_span_attribute(span, f"{prefix}.description", function.get("description"))
-        _set_span_attribute(
-            span, f"{prefix}.parameters", json.dumps(function.get("parameters"))
-        )
-
-
-def set_tools_attributes(span, tools):
-    if not tools:
-        return
-
-    for i, tool in enumerate(tools):
-        function = tool.get("function")
-        if not function:
-            continue
-
-        prefix = f"{SpanAttributes.LLM_REQUEST_FUNCTIONS}.{i}"
-        _set_span_attribute(span, f"{prefix}.name", function.get("name"))
-        _set_span_attribute(span, f"{prefix}.description", function.get("description"))
-        _set_span_attribute(
-            span, f"{prefix}.parameters", json.dumps(function.get("parameters"))
-        )
-
-
-def _set_request_attributes(span, kwargs, instance=None):
-    if not span.is_recording():
-        return
-
-    _set_api_attributes(span)
-
-    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, GenAIAttributes.GEN_AI_REQUEST_MAX_TOKENS, kwargs.get("max_tokens")
-    )
-    _set_span_attribute(
-        span, GenAIAttributes.GEN_AI_REQUEST_TEMPERATURE, kwargs.get("temperature")
-    )
-    _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")
-    )
-    _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_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
-def _set_response_attributes(span, response):
-    if not span.is_recording():
-        return
-
-    if "error" in response:
-        _set_span_attribute(
-            span,
-            f"{GenAIAttributes.GEN_AI_PROMPT}.{PROMPT_ERROR}",
-            json.dumps(response.get("error")),
-        )
-        return
-
-    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
-
-    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,
-        GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS,
-        usage.get("completion_tokens"),
-    )
-    _set_span_attribute(
-        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
-
-
-def _log_prompt_filter(span, response_dict):
-    if response_dict.get("prompt_filter_results"):
-        _set_span_attribute(
-            span,
-            f"{GenAIAttributes.GEN_AI_PROMPT}.{PROMPT_FILTER_KEY}",
-            json.dumps(response_dict.get("prompt_filter_results")),
-        )
-
-
-@dont_throw
-def _set_span_stream_usage(span, prompt_tokens, completion_tokens):
-    if not span.is_recording():
-        return
-
-    if isinstance(completion_tokens, int) and completion_tokens >= 0:
-        _set_span_attribute(
-            span, GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS, completion_tokens
-        )
-
-    if isinstance(prompt_tokens, int) and prompt_tokens >= 0:
-        _set_span_attribute(span, GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS, prompt_tokens)
-
-    if (
-        isinstance(prompt_tokens, int)
-        and isinstance(completion_tokens, int)
-        and completion_tokens + prompt_tokens >= 0
-    ):
-        _set_span_attribute(
-            span,
-            SpanAttributes.LLM_USAGE_TOTAL_TOKENS,
-            completion_tokens + prompt_tokens,
-        )
-
-
-def _get_openai_base_url(instance):
-    if hasattr(instance, "_client"):
-        client = instance._client  # pylint: disable=protected-access
-        if isinstance(client, (openai.AsyncOpenAI, openai.OpenAI)):
-            return str(client.base_url)
-
-    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(
-            response, openai.AsyncStream
-        )
-
-    return isinstance(response, types.GeneratorType) or isinstance(
-        response, types.AsyncGeneratorType
-    )
-
-
-def model_as_dict(model):
-    if isinstance(model, dict):
-        return model
-    if _PYDANTIC_VERSION < "2.0.0":
-        return model.dict()
-    if hasattr(model, "model_dump"):
-        return model.model_dump()
-    elif hasattr(model, "parse"):  # Raw API response
-        return model_as_dict(model.parse())
-    else:
-        return model
-
-
-def _token_type(token_type: str):
-    if token_type == "prompt_tokens":
-        return "input"
-    elif token_type == "completion_tokens":
-        return "output"
-
-    return None
-
-
-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,
-        GenAIAttributes.GEN_AI_SYSTEM: vendor,
-        GenAIAttributes.GEN_AI_RESPONSE_MODEL: response_model,
-        "gen_ai.operation.name": operation,
-        "server.address": server_address,
-        "stream": is_streaming,
-    }
-
-
-def propagate_trace_context(span, kwargs):
-    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

opentelemetry/instrumentation/openai/shared/audio_wrappers.py

@@ -1,247 +0,0 @@
-import logging
-import time
-
-from opentelemetry import context as context_api
-from opentelemetry.instrumentation.openai.shared import (
-    _set_client_attributes,
-    _set_request_attributes,
-    _set_response_attributes,
-    _set_span_attribute,
-    metric_shared_attributes,
-    model_as_dict,
-)
-from opentelemetry.instrumentation.openai.utils import (
-    _with_audio_telemetry_wrapper,
-    dont_throw,
-    is_openai_v1,
-    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,
-    SpanAttributes,
-)
-from opentelemetry.trace import SpanKind, Status, StatusCode
-
-SPAN_NAME = "openai.audio.transcriptions"
-
-logger = logging.getLogger(__name__)
-
-
-def _get_audio_duration(file):
-    """
-    Extract audio duration from file object.
-    Returns duration in seconds, or None if unable to determine.
-    """
-    try:
-        # Try to get duration from common audio libraries
-        # First check if it's a file-like object with a name attribute
-        if hasattr(file, "name"):
-            file_path = file.name
-        elif isinstance(file, (str, bytes)):
-            # If it's a path string or bytes
-            return None
-        else:
-            # If it's a file-like object without name, we can't easily determine duration
-            return None
-
-        # Try mutagen (supports many formats)
-        try:
-            from mutagen import File as MutagenFile
-
-            audio = MutagenFile(file_path)
-            if audio and hasattr(audio.info, "length"):
-                return audio.info.length
-        except (ImportError, Exception):
-            pass
-
-    except Exception as e:
-        logger.debug(f"Unable to extract audio duration: {e}")
-
-    return None
-
-
-@_with_audio_telemetry_wrapper
-def transcription_wrapper(
-    tracer,
-    duration_histogram: Histogram,
-    exception_counter: Counter,
-    wrapped,
-    instance,
-    args,
-    kwargs,
-):
-    if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY) or context_api.get_value(
-        SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY
-    ):
-        return wrapped(*args, **kwargs)
-
-    with tracer.start_as_current_span(
-        name=SPAN_NAME,
-        kind=SpanKind.CLIENT,
-    ) as span:
-        _handle_request(span, kwargs, instance)
-
-        try:
-            # record time for duration
-            start_time = time.time()
-            response = wrapped(*args, **kwargs)
-            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
-            attributes = {
-                "error.type": e.__class__.__name__,
-            }
-
-            # if there are legal duration, record it
-            if duration > 0 and duration_histogram:
-                duration_histogram.record(duration, attributes=attributes)
-            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
-
-        duration = end_time - start_time
-
-        _handle_response(
-            response,
-            span,
-            instance,
-            duration_histogram,
-            duration,
-        )
-
-        return response
-
-
-@_with_audio_telemetry_wrapper
-async def atranscription_wrapper(
-    tracer,
-    duration_histogram: Histogram,
-    exception_counter: Counter,
-    wrapped,
-    instance,
-    args,
-    kwargs,
-):
-    if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY) or context_api.get_value(
-        SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY
-    ):
-        return await wrapped(*args, **kwargs)
-
-    async with start_as_current_span_async(
-        tracer=tracer,
-        name=SPAN_NAME,
-        kind=SpanKind.CLIENT,
-    ) as span:
-        _handle_request(span, kwargs, instance)
-
-        try:
-            # record time for duration
-            start_time = time.time()
-            response = await wrapped(*args, **kwargs)
-            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
-            attributes = {
-                "error.type": e.__class__.__name__,
-            }
-
-            # if there are legal duration, record it
-            if duration > 0 and duration_histogram:
-                duration_histogram.record(duration, attributes=attributes)
-            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
-
-        duration = end_time - start_time
-
-        _handle_response(
-            response,
-            span,
-            instance,
-            duration_histogram,
-            duration,
-        )
-
-        return response
-
-
-@dont_throw
-def _handle_request(span, kwargs, instance):
-    _set_request_attributes(span, kwargs, instance)
-    _set_client_attributes(span, instance)
-
-    # Extract and set audio duration
-    file_param = kwargs.get("file")
-    if file_param:
-        audio_duration = _get_audio_duration(file_param)
-        if audio_duration is not None:
-            # _set_span_attribute(
-            #     span, SpanAttributes.LLM_OPENAI_AUDIO_INPUT_DURATION_SECONDS, audio_duration
-            # )
-            # TODO(Ata): come back here later when semconv is published
-            _set_span_attribute(
-                span, 'gen_ai.openai.audio.input.duration_seconds', audio_duration
-            )
-        else:
-            print("REMOVE ME : ATA-DBG : COULD NOT READ AUDIO FILE WITH MUTAGEN")
-
-
-@dont_throw
-def _handle_response(
-    response,
-    span,
-    instance=None,
-    duration_histogram=None,
-    duration=None,
-):
-    if is_openai_v1():
-        response_dict = model_as_dict(response)
-    else:
-        response_dict = response
-
-    # metrics record
-    _set_transcription_metrics(
-        instance,
-        duration_histogram,
-        response_dict,
-        duration,
-    )
-
-    # span attributes
-    _set_response_attributes(span, response_dict)
-
-
-def _set_transcription_metrics(
-    instance,
-    duration_histogram,
-    response_dict,
-    duration,
-):
-    from opentelemetry.instrumentation.openai.shared import _get_openai_base_url
-
-    shared_attributes = metric_shared_attributes(
-        response_model=response_dict.get("model") or None,
-        operation="audio.transcriptions",
-        server_address=_get_openai_base_url(instance),
-    )
-
-    # duration metrics
-    if duration and isinstance(duration, (float, int)) and duration_histogram:
-        duration_histogram.record(duration, attributes=shared_attributes)