openlit 1.33.8__py3-none-any.whl → 1.33.10__py3-none-any.whl

openlit/__helpers.py

@@ -6,9 +6,12 @@ import os
 import json
 import logging
 from urllib.parse import urlparse
+from typing import Any, Dict, List, Tuple
 import requests
 import tiktoken
+from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT
 from opentelemetry.trace import Status, StatusCode
+from openlit.semcov import SemanticConvetion
 
 # Set up logging
 logger = logging.getLogger(__name__)
@@ -197,3 +200,88 @@ def handle_exception(span,e):
     # Record the exception details within the span
     span.record_exception(e)
     span.set_status(Status(StatusCode.ERROR))
+
+def calculate_ttft(timestamps: List[float], start_time: float) -> float:
+    """
+    Calculate the time to the first tokens.
+    
+    :param timestamps: List of timestamps for received tokens
+    :param start_time: The start time of the streaming process
+    :return: Time to the first tokens
+    """
+    if timestamps:
+        return timestamps[0] - start_time
+    return 0.0
+
+def calculate_tbt(timestamps: List[float]) -> float:
+    """
+    Calculate the average time between tokens.
+    
+    :param timestamps: List of timestamps for received tokens
+    :return: Average time between tokens
+    """
+    if len(timestamps) > 1:
+        time_diffs = [timestamps[i] - timestamps[i - 1] for i in range(1, len(timestamps))]
+        return sum(time_diffs) / len(time_diffs)
+    return 0.0
+
+def create_metrics_attributes(
+    service_name: str,
+    deployment_environment: str,
+    operation: str,
+    system: str,
+    request_model: str,
+    server_address: str,
+    server_port: int,
+    response_model: str,
+) -> Dict[Any, Any]:
+    """
+    Returns OTel metrics attributes
+    """
+    return {
+        TELEMETRY_SDK_NAME: "openlit",
+        SERVICE_NAME: service_name,
+        DEPLOYMENT_ENVIRONMENT: deployment_environment,
+        SemanticConvetion.GEN_AI_OPERATION: operation,
+        SemanticConvetion.GEN_AI_SYSTEM: system,
+        SemanticConvetion.GEN_AI_REQUEST_MODEL: request_model,
+        SemanticConvetion.SERVER_ADDRESS: server_address,
+        SemanticConvetion.SERVER_PORT: server_port,
+        SemanticConvetion.GEN_AI_RESPONSE_MODEL: response_model
+    }
+
+def set_server_address_and_port(client_instance: Any,
+    default_server_address: str, default_server_port: int) -> Tuple[str, int]:
+    """
+    Determines and returns the server address and port based on the provided client's `base_url`,
+    using defaults if none found or values are None.
+    """
+
+    # Try getting base_url from multiple potential attributes
+    base_client = getattr(client_instance, "_client", None)
+    base_url = getattr(base_client, "base_url", None)
+
+    if not base_url:
+        # Attempt to get endpoint from instance._config.endpoint if base_url is not set
+        config = getattr(client_instance, "_config", None)
+        base_url = getattr(config, "endpoint", None)
+
+    if not base_url:
+        # Attempt to get server_url from instance.sdk_configuration.server_url
+        config = getattr(client_instance, "sdk_configuration", None)
+        base_url = getattr(config, "server_url", None)
+
+    if base_url:
+        if isinstance(base_url, str):
+            url = urlparse(base_url)
+            server_address = url.hostname or default_server_address
+            server_port = url.port if url.port is not None else default_server_port
+        else:  # base_url might not be a str; handle as an object.
+            server_address = getattr(base_url, "host", None) or default_server_address
+            port_attr = getattr(base_url, "port", None)
+            server_port = port_attr if port_attr is not None else default_server_port
+    else:  # no base_url or endpoint provided; use defaults.
+        server_address = default_server_address
+        server_port = default_server_port
+
+    return server_address, server_port

openlit/__init__.py

@@ -17,6 +17,7 @@ import requests
 # Import internal modules for setting up tracing and fetching pricing info.
 from opentelemetry import trace as t
 from opentelemetry.trace import SpanKind, Status, StatusCode, Span
+from opentelemetry.sdk.resources import SERVICE_NAME, DEPLOYMENT_ENVIRONMENT
 from openlit.semcov import SemanticConvetion
 from openlit.otel.tracing import setup_tracing
 from openlit.otel.metrics import setup_meter
@@ -251,7 +252,7 @@ def init(
         "gpt4all": "gpt4all",
         "elevenlabs": "elevenlabs",
         "vllm": "vllm",
-        "google-ai-studio": "google.generativeai",
+        "google-ai-studio": "google.genai",
         "azure-ai-inference": "azure.ai.inference",
         "langchain": "langchain",
         "llama_index": "llama_index",
@@ -555,11 +556,11 @@ def trace(wrapped):
                 span.set_attribute("function.args", str(args))
                 span.set_attribute("function.kwargs", str(kwargs))
                 span.set_attribute(
-                    SemanticConvetion.GEN_AI_APPLICATION_NAME,
+                    SERVICE_NAME,
                     OpenlitConfig.application_name,
                 )
                 span.set_attribute(
-                    SemanticConvetion.GEN_AI_ENVIRONMENT, OpenlitConfig.environment
+                    DEPLOYMENT_ENVIRONMENT, OpenlitConfig.environment
                 )
             except Exception as meta_exception:
                 logging.error(

openlit/instrumentation/ag2/ag2.py

@@ -5,7 +5,7 @@ Module for monitoring AG2.
 
 import logging
 from opentelemetry.trace import SpanKind, Status, StatusCode
-from opentelemetry.sdk.resources import TELEMETRY_SDK_NAME
+from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT
 from openlit.__helpers import handle_exception
 from openlit.semcov import SemanticConvetion
 
@@ -70,12 +70,12 @@ def wrap_ag2(gen_ai_endpoint, version, environment, application_name,
                                    gen_ai_endpoint)
                 span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
                                    SemanticConvetion.GEN_AI_SYSTEM_AG2)
-                span.set_attribute(SemanticConvetion.GEN_AI_ENVIRONMENT,
+                span.set_attribute(DEPLOYMENT_ENVIRONMENT,
                                    environment)
-                span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
+                span.set_attribute(SERVICE_NAME,
                                    application_name)
-                span.set_attribute(SemanticConvetion.GEN_AI_TYPE,
-                                   SemanticConvetion.GEN_AI_TYPE_AGENT)
+                span.set_attribute(SemanticConvetion.GEN_AI_OPERATION,
+                                   SemanticConvetion.GEN_AI_OPERATION_TYPE_AGENT)
                 span.set_attribute(SemanticConvetion.GEN_AI_AGENT_ROLE,
                                    instance.name)
                 if llm_model:

openlit/instrumentation/ai21/__init__.py

@@ -37,13 +37,13 @@ class AI21Instrumentor(BaseInstrumentor):
         wrap_function_wrapper(
             "ai21.clients.studio.resources.chat.chat_completions",
             "ChatCompletions.create",
-            chat("ai21.chat.completions", version, environment, application_name,
+            chat(version, environment, application_name,
                   tracer, pricing_info, trace_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
             "ai21.clients.studio.resources.studio_conversational_rag",
             "StudioConversationalRag.create",
-            chat_rag("ai21.conversational_rag", version, environment, application_name,
+            chat_rag(version, environment, application_name,
                   tracer, pricing_info, trace_content, metrics, disable_metrics),
         )
 
@@ -51,13 +51,13 @@ class AI21Instrumentor(BaseInstrumentor):
         wrap_function_wrapper(
             "ai21.clients.studio.resources.chat.async_chat_completions",
             "AsyncChatCompletions.create",
-            async_chat("ai21.chat.completions", version, environment, application_name,
+            async_chat(version, environment, application_name,
                   tracer, pricing_info, trace_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
             "ai21.clients.studio.resources.studio_conversational_rag",
             "AsyncStudioConversationalRag.create",
-            async_chat_rag("ai21.conversational_rag", version, environment, application_name,
+            async_chat_rag(version, environment, application_name,
                   tracer, pricing_info, trace_content, metrics, disable_metrics),
         )