openlit 1.34.26__py3-none-any.whl → 1.34.28__py3-none-any.whl

openlit/instrumentation/milvus/milvus.py

@@ -1,179 +1,52 @@
-# pylint: disable=duplicate-code, broad-exception-caught, too-many-statements, unused-argument, possibly-used-before-assignment, too-many-branches
 """
-Module for monitoring Milvus.
+Module for monitoring Milvus API calls.
 """
 
-import logging
-from opentelemetry.trace import SpanKind, Status, StatusCode
-from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT
+import time
+from opentelemetry.trace import SpanKind
+from opentelemetry import context as context_api
 from openlit.__helpers import handle_exception
-from openlit.semcov import SemanticConvention
-
-# Initialize logger for logging potential issues and operations
-logger = logging.getLogger(__name__)
-
-def object_count(obj):
-    """
-    Counts Length of object if it exists, Else returns None
-    """
-    try:
-        cnt = len(obj)
-    # pylint: disable=bare-except
-    except:
-        cnt = 0
-
-    return cnt
+from openlit.instrumentation.milvus.utils import (
+    process_milvus_response,
+    DB_OPERATION_MAP,
+    set_server_address_and_port,
+)
 
 def general_wrap(gen_ai_endpoint, version, environment, application_name,
-                 tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+    tracer, pricing_info, capture_message_content, metrics, disable_metrics):
     """
-    Creates a wrapper around a function call to trace and log its execution metrics.
-
-    This function wraps any given function to measure its execution time,
-    log its operation, and trace its execution using OpenTelemetry.
-    
-    Parameters:
-    - gen_ai_endpoint (str): A descriptor or name for the endpoint being traced.
-    - version (str): The version of the Langchain application.
-    - environment (str): The deployment environment (e.g., 'production', 'development').
-    - application_name (str): Name of the Langchain application.
-    - tracer (opentelemetry.trace.Tracer): The tracer object used for OpenTelemetry tracing.
-    - pricing_info (dict): Information about the pricing for internal metrics (currently not used).
-    - capture_message_content (bool): Flag indicating whether to trace the content of the response.
-
-    Returns:
-    - function: A higher-order function that takes a function 'wrapped' and returns
-                a new function that wraps 'wrapped' with additional tracing and logging.
+    Generates a telemetry wrapper for Milvus function calls.
     """
-
     def wrapper(wrapped, instance, args, kwargs):
-        """
-        An inner wrapper function that executes the wrapped function, measures execution
-        time, and records trace data using OpenTelemetry.
-
-        Parameters:
-        - wrapped (Callable): The original function that this wrapper will execute.
-        - instance (object): The instance to which the wrapped function belongs. This
-                             is used for instance methods. For static and classmethods,
-                             this may be None.
-        - args (tuple): Positional arguments passed to the wrapped function.
-        - kwargs (dict): Keyword arguments passed to the wrapped function.
-
-        Returns:
-        - The result of the wrapped function call.
-        
-        The wrapper initiates a span with the provided tracer, sets various attributes
-        on the span based on the function's execution and response, and ensures
-        errors are handled and logged appropriately.
-        """
-        with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
+        # CRITICAL: Suppression check
+        if context_api.get_value(context_api._SUPPRESS_INSTRUMENTATION_KEY):
+            return wrapped(*args, **kwargs)
+
+        # Get server address and port using the standard helper
+        server_address, server_port = set_server_address_and_port(instance)
+
+        db_operation = DB_OPERATION_MAP.get(gen_ai_endpoint, "unknown")
+        if db_operation == "create_collection":
+            collection_name = kwargs.get("collection_name") or (args[0] if args else "unknown")
+        else:
+            collection_name = kwargs.get("collection_name", "unknown")
+        span_name = f"{db_operation} {collection_name}"
+
+        with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
+            start_time = time.time()
             response = wrapped(*args, **kwargs)
 
             try:
-                span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
-                span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT,
-                                   gen_ai_endpoint)
-                span.set_attribute(DEPLOYMENT_ENVIRONMENT,
-                                   environment)
-                span.set_attribute(SERVICE_NAME,
-                                   application_name)
-                span.set_attribute(SemanticConvention.GEN_AI_OPERATION,
-                                   SemanticConvention.GEN_AI_OPERATION_TYPE_VECTORDB)
-                span.set_attribute(SemanticConvention.DB_SYSTEM_NAME,
-                                   SemanticConvention.DB_SYSTEM_MILVUS)
-
-                if gen_ai_endpoint == "milvus.create_collection":
-                    db_operation = SemanticConvention.DB_OPERATION_CREATE_COLLECTION
-                    span.set_attribute(SemanticConvention.DB_OPERATION_NAME,
-                                       SemanticConvention.DB_OPERATION_CREATE_COLLECTION)
-                    span.set_attribute(SemanticConvention.DB_COLLECTION_NAME,
-                                       kwargs.get("collection_name", ""))
-                    span.set_attribute(SemanticConvention.DB_COLLECTION_DIMENSION,
-                                       kwargs.get("dimension", ""))
-
-                elif gen_ai_endpoint == "milvus.drop_collection":
-                    db_operation = SemanticConvention.DB_OPERATION_DELETE_COLLECTION
-                    span.set_attribute(SemanticConvention.DB_OPERATION_NAME,
-                                       SemanticConvention.DB_OPERATION_DELETE_COLLECTION)
-                    span.set_attribute(SemanticConvention.DB_COLLECTION_NAME,
-                                       kwargs.get("collection_name", ""))
-
-                elif gen_ai_endpoint == "milvus.insert":
-                    db_operation = SemanticConvention.DB_OPERATION_ADD
-                    span.set_attribute(SemanticConvention.DB_OPERATION_NAME,
-                                       SemanticConvention.DB_OPERATION_ADD)
-                    span.set_attribute(SemanticConvention.DB_COLLECTION_NAME,
-                                       kwargs.get("collection_name", ""))
-                    span.set_attribute(SemanticConvention.DB_VECTOR_COUNT,
-                                       object_count(kwargs.get("data")))
-                    span.set_attribute(SemanticConvention.DB_OPERATION_COST,
-                                       response["cost"])
-
-                elif gen_ai_endpoint == "milvus.search":
-                    db_operation = SemanticConvention.DB_OPERATION_QUERY
-                    span.set_attribute(SemanticConvention.DB_OPERATION_NAME,
-                                       SemanticConvention.DB_OPERATION_QUERY)
-                    span.set_attribute(SemanticConvention.DB_COLLECTION_NAME,
-                                       kwargs.get("collection_name", ""))
-                    span.set_attribute(SemanticConvention.DB_STATEMENT,
-                                       str(kwargs.get("data")))
-
-                elif gen_ai_endpoint in ["milvus.query", "milvus.get"]:
-                    db_operation = SemanticConvention.DB_OPERATION_QUERY
-                    span.set_attribute(SemanticConvention.DB_OPERATION_NAME,
-                                       SemanticConvention.DB_OPERATION_QUERY)
-                    span.set_attribute(SemanticConvention.DB_COLLECTION_NAME,
-                                       kwargs.get("collection_name", ""))
-                    span.set_attribute(SemanticConvention.DB_STATEMENT,
-                                       str(kwargs.get("output_fields")))
-
-                elif gen_ai_endpoint == "milvus.upsert":
-                    db_operation = SemanticConvention.DB_OPERATION_ADD
-                    span.set_attribute(SemanticConvention.DB_OPERATION_NAME,
-                                       SemanticConvention.DB_OPERATION_UPSERT)
-                    span.set_attribute(SemanticConvention.DB_COLLECTION_NAME,
-                                       kwargs.get("collection_name", ""))
-                    span.set_attribute(SemanticConvention.DB_VECTOR_COUNT,
-                                       object_count(kwargs.get("data")))
-                    span.set_attribute(SemanticConvention.DB_OPERATION_COST,
-                                       response["cost"])
-
-                elif gen_ai_endpoint == "milvus.delete":
-                    db_operation = SemanticConvention.DB_OPERATION_DELETE
-                    span.set_attribute(SemanticConvention.DB_OPERATION_NAME,
-                                       SemanticConvention.DB_OPERATION_DELETE)
-                    span.set_attribute(SemanticConvention.DB_COLLECTION_NAME,
-                                       kwargs.get("collection_name", ""))
-                    span.set_attribute(SemanticConvention.DB_FILTER,
-                                       str(kwargs.get("filter", "")))
-
-                span.set_status(Status(StatusCode.OK))
-
-                if disable_metrics is False:
-                    attributes = {
-                        TELEMETRY_SDK_NAME:
-                            "openlit",
-                        SERVICE_NAME:
-                            application_name,
-                        SemanticConvention.DB_SYSTEM_NAME:
-                            SemanticConvention.DB_SYSTEM_MILVUS,
-                        DEPLOYMENT_ENVIRONMENT:
-                            environment,
-                        SemanticConvention.GEN_AI_OPERATION:
-                            SemanticConvention.GEN_AI_OPERATION_TYPE_VECTORDB,
-                        SemanticConvention.DB_OPERATION_NAME:
-                            db_operation
-                    }
-
-                    metrics["db_requests"].add(1, attributes)
-
-                return response
+                # Process response and generate telemetry
+                response = process_milvus_response(
+                    response, db_operation, server_address, server_port,
+                    environment, application_name, metrics, start_time, span,
+                    capture_message_content, disable_metrics, version, instance, args, **kwargs
+                )
 
             except Exception as e:
                 handle_exception(span, e)
-                logger.error("Error in trace creation: %s", e)
 
-                # Return original response
-                return response
+            return response
 
     return wrapper

openlit/instrumentation/milvus/utils.py

@@ -0,0 +1,276 @@
+"""
+Utility functions for Milvus instrumentation.
+"""
+
+import time
+from urllib.parse import urlparse
+from opentelemetry.trace import Status, StatusCode
+from openlit.__helpers import (
+    common_db_span_attributes,
+    record_db_metrics,
+)
+from openlit.semcov import SemanticConvention
+
+# Operation mapping for simple span naming
+DB_OPERATION_MAP = {
+    "milvus.create_collection": SemanticConvention.DB_OPERATION_CREATE_COLLECTION,
+    "milvus.drop_collection": SemanticConvention.DB_OPERATION_DELETE_COLLECTION,
+    "milvus.insert": SemanticConvention.DB_OPERATION_INSERT,
+    "milvus.upsert": SemanticConvention.DB_OPERATION_UPSERT,
+    "milvus.search": SemanticConvention.DB_OPERATION_SEARCH,
+    "milvus.query": SemanticConvention.DB_OPERATION_QUERY,
+    "milvus.get": SemanticConvention.DB_OPERATION_GET,
+    "milvus.delete": SemanticConvention.DB_OPERATION_DELETE,
+}
+
+def object_count(obj):
+    """
+    Counts length of object if it exists, else returns 0.
+    """
+    return len(obj) if obj else 0
+
+def set_server_address_and_port(instance):
+    """
+    Extracts server address and port from Milvus client instance.
+
+    Args:
+        instance: Milvus client instance
+
+    Returns:
+        tuple: (server_address, server_port)
+    """
+    server_address = "localhost"
+    server_port = 19530  # Default Milvus port
+
+    # Try getting uri from multiple potential attributes
+    client_config = getattr(instance, "_client_config", None)
+    if client_config:
+        uri = getattr(client_config, "uri", None)
+        if uri and isinstance(uri, str):
+            if uri.startswith(("http://", "https://")):
+                try:
+                    parsed = urlparse(uri)
+                    server_address = parsed.hostname or server_address
+                    server_port = parsed.port or server_port
+                except Exception:
+                    pass
+            else:
+                # Handle cases like "localhost:19530" or just "localhost"
+                if ":" in uri:
+                    parts = uri.split(":")
+                    server_address = parts[0]
+                    try:
+                        server_port = int(parts[1])
+                    except (ValueError, IndexError):
+                        pass
+                else:
+                    server_address = uri
+
+    return server_address, server_port
+
+def common_milvus_logic(scope, environment, application_name,
+    metrics, capture_message_content, disable_metrics, version,
+    instance=None, endpoint=None):
+    """
+    Process Milvus database request and generate telemetry.
+
+    Args:
+        scope: Scope object containing span, response, and operation details
+        environment: Deployment environment
+        application_name: Name of the application
+        metrics: Metrics dictionary for recording telemetry
+        capture_message_content: Flag to capture message content
+        disable_metrics: Flag to disable metrics collection
+        version: Version of the Milvus client
+        instance: Milvus client instance
+        endpoint: Operation endpoint for differentiation
+    """
+    scope._end_time = time.time()
+
+    # Set common database span attributes using helper
+    common_db_span_attributes(scope, SemanticConvention.DB_SYSTEM_MILVUS,
+        scope._server_address, scope._server_port, environment, application_name, version)
+
+    # Set DB operation specific attributes
+    scope._span.set_attribute(SemanticConvention.DB_OPERATION_NAME, scope._db_operation)
+    scope._span.set_attribute(SemanticConvention.DB_CLIENT_OPERATION_DURATION,
+        scope._end_time - scope._start_time)
+
+    if scope._db_operation == SemanticConvention.DB_OPERATION_CREATE_COLLECTION:
+        collection_name = scope._kwargs.get("collection_name", "unknown")
+
+        # Standard database attributes
+        scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
+        scope._span.set_attribute(SemanticConvention.DB_COLLECTION_DIMENSION,
+            scope._kwargs.get("dimension", -1))
+
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
+            f"{scope._db_operation} {collection_name} "
+            f"dimension={scope._kwargs.get('dimension', 'None')}")
+
+    elif scope._db_operation == SemanticConvention.DB_OPERATION_DELETE_COLLECTION:
+        collection_name = scope._kwargs.get("collection_name", "unknown")
+
+        # Standard database attributes
+        scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
+
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
+            f"{scope._db_operation} {collection_name}")
+
+    elif scope._db_operation == SemanticConvention.DB_OPERATION_INSERT:
+        collection_name = scope._kwargs.get("collection_name", "unknown")
+        data = scope._kwargs.get("data", [])
+
+        # Standard database attributes
+        scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
+        scope._span.set_attribute(SemanticConvention.DB_VECTOR_COUNT, object_count(data))
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(data))
+
+        # Response metrics
+        if scope._response and scope._response.get("insert_count"):
+            scope._span.set_attribute(SemanticConvention.DB_RESPONSE_RETURNED_ROWS,
+                scope._response["insert_count"])
+
+        if scope._response and scope._response.get("cost"):
+            scope._span.set_attribute(SemanticConvention.DB_OPERATION_COST,
+                scope._response["cost"])
+
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
+            f"{scope._db_operation} {collection_name} "
+            f"data_count={object_count(data)}")
+
+    elif scope._db_operation == SemanticConvention.DB_OPERATION_UPSERT:
+        collection_name = scope._kwargs.get("collection_name", "unknown")
+        data = scope._kwargs.get("data", [])
+
+        # Standard database attributes
+        scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
+        scope._span.set_attribute(SemanticConvention.DB_VECTOR_COUNT, object_count(data))
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(data))
+
+        # Response metrics
+        if scope._response and scope._response.get("upsert_count"):
+            scope._span.set_attribute(SemanticConvention.DB_RESPONSE_RETURNED_ROWS,
+                scope._response["upsert_count"])
+
+        if scope._response and scope._response.get("cost"):
+            scope._span.set_attribute(SemanticConvention.DB_OPERATION_COST,
+                scope._response["cost"])
+
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
+            f"{scope._db_operation} {collection_name} "
+            f"data_count={object_count(data)}")
+
+    elif scope._db_operation == SemanticConvention.DB_OPERATION_SEARCH:
+        collection_name = scope._kwargs.get("collection_name", "unknown")
+        data = scope._kwargs.get("data", [])
+
+        # Standard database attributes
+        scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(data))
+        scope._span.set_attribute(SemanticConvention.DB_VECTOR_QUERY_TOP_K,
+            scope._kwargs.get("limit", -1))
+
+        # Search specific attributes
+        scope._span.set_attribute(SemanticConvention.DB_FILTER,
+            str(scope._kwargs.get("filter", "")))
+
+        # Response metrics
+        if scope._response and isinstance(scope._response, list):
+            scope._span.set_attribute(SemanticConvention.DB_RESPONSE_RETURNED_ROWS,
+                len(scope._response))
+
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
+            f"{scope._db_operation} {collection_name} "
+            f"data={str(data)[:100]}... "
+            f"limit={scope._kwargs.get('limit', 'None')}")
+
+    elif scope._db_operation in [SemanticConvention.DB_OPERATION_QUERY, SemanticConvention.DB_OPERATION_GET]:
+        collection_name = scope._kwargs.get("collection_name", "unknown")
+        output_fields = scope._kwargs.get("output_fields", [])
+
+        # Standard database attributes
+        scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(output_fields))
+
+        # Query specific attributes
+        scope._span.set_attribute(SemanticConvention.DB_FILTER,
+            str(scope._kwargs.get("filter", "")))
+
+        # Response metrics
+        if scope._response and isinstance(scope._response, list):
+            scope._span.set_attribute(SemanticConvention.DB_RESPONSE_RETURNED_ROWS,
+                len(scope._response))
+
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
+            f"{scope._db_operation} {collection_name} "
+            f"output_fields={output_fields} "
+            f"filter={scope._kwargs.get('filter', 'None')}")
+
+    elif scope._db_operation == SemanticConvention.DB_OPERATION_DELETE:
+        collection_name = scope._kwargs.get("collection_name", "unknown")
+
+        # Standard database attributes
+        scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
+        scope._span.set_attribute(SemanticConvention.DB_FILTER,
+            str(scope._kwargs.get("filter", "")))
+
+        # Response metrics
+        if scope._response and scope._response.get("delete_count"):
+            scope._span.set_attribute(SemanticConvention.DB_RESPONSE_RETURNED_ROWS,
+                scope._response["delete_count"])
+
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
+            f"{scope._db_operation} {collection_name} "
+            f"filter={scope._kwargs.get('filter', 'None')}")
+
+    scope._span.set_status(Status(StatusCode.OK))
+
+    # Record metrics using helper
+    if not disable_metrics:
+        record_db_metrics(metrics, SemanticConvention.DB_SYSTEM_MILVUS,
+            scope._server_address, scope._server_port, environment, application_name,
+            scope._start_time, scope._end_time)
+
+def process_milvus_response(response, db_operation, server_address, server_port,
+    environment, application_name, metrics, start_time, span,
+    capture_message_content, disable_metrics, version, instance, args, **kwargs):
+    """
+    Process Milvus response and generate telemetry.
+
+    Args:
+        response: Response from Milvus operation
+        db_operation: Database operation type
+        server_address: Server address
+        server_port: Server port
+        environment: Deployment environment
+        application_name: Application name
+        metrics: Metrics dictionary
+        start_time: Start time of the operation
+        span: OpenTelemetry span
+        capture_message_content: Flag to capture message content
+        disable_metrics: Flag to disable metrics
+        version: Milvus client version
+        instance: Milvus client instance
+        args: Positional arguments
+        **kwargs: Keyword arguments
+
+    Returns:
+        Original response
+    """
+
+    # Create a scope object to hold all the context
+    scope = type("GenericScope", (), {})()
+    scope._response = response
+    scope._db_operation = db_operation
+    scope._server_address = server_address
+    scope._server_port = server_port
+    scope._start_time = start_time
+    scope._span = span
+    scope._kwargs = kwargs
+
+    # Process the response using common logic
+    common_milvus_logic(scope, environment, application_name,
+        metrics, capture_message_content, disable_metrics, version, instance)
+
+    return response

openlit/instrumentation/openai/__init__.py

@@ -35,15 +35,15 @@ class OpenAIInstrumentor(BaseInstrumentor):
 
         # chat completions
         wrap_function_wrapper(
-            "openai.resources.chat.completions",  
-            "Completions.create",  
+            "openai.resources.chat.completions",
+            "Completions.create",
             chat_completions(version, environment, application_name,
                 tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         wrap_function_wrapper(
-            "openai.resources.chat.completions",  
-            "AsyncCompletions.create",  
+            "openai.resources.chat.completions",
+            "AsyncCompletions.create",
             async_chat_completions(version, environment, application_name,
                 tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
@@ -65,75 +65,75 @@ class OpenAIInstrumentor(BaseInstrumentor):
 
         # responses
         wrap_function_wrapper(
-            "openai.resources.responses.responses",  
-            "Responses.create",  
+            "openai.resources.responses.responses",
+            "Responses.create",
             responses(version, environment, application_name,
                 tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         wrap_function_wrapper(
-            "openai.resources.responses.responses",  
-            "AsyncResponses.create",  
+            "openai.resources.responses.responses",
+            "AsyncResponses.create",
             async_responses(version, environment, application_name,
                 tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         # embeddings
         wrap_function_wrapper(
-            "openai.resources.embeddings",  
-            "Embeddings.create",  
+            "openai.resources.embeddings",
+            "Embeddings.create",
             embedding(version, environment, application_name,
                 tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         wrap_function_wrapper(
-            "openai.resources.embeddings",  
-            "AsyncEmbeddings.create",  
+            "openai.resources.embeddings",
+            "AsyncEmbeddings.create",
             async_embedding(version, environment, application_name,
                 tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         # image generation
         wrap_function_wrapper(
-            "openai.resources.images",  
-            "Images.generate",  
+            "openai.resources.images",
+            "Images.generate",
             image_generate(version, environment, application_name,
                 tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         wrap_function_wrapper(
-            "openai.resources.images",  
-            "AsyncImages.generate",  
+            "openai.resources.images",
+            "AsyncImages.generate",
             async_image_generate(version, environment, application_name,
                 tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         # image variations
         wrap_function_wrapper(
-            "openai.resources.images",  
-            "Images.create_variation",  
+            "openai.resources.images",
+            "Images.create_variation",
             image_variatons(version, environment, application_name,
                 tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         wrap_function_wrapper(
-            "openai.resources.images",  
-            "AsyncImages.create_variation",  
+            "openai.resources.images",
+            "AsyncImages.create_variation",
             async_image_variations(version, environment, application_name,
                 tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         # audio generation
         wrap_function_wrapper(
-            "openai.resources.audio.speech",  
-            "Speech.create",  
+            "openai.resources.audio.speech",
+            "Speech.create",
             audio_create(version, environment, application_name,
                 tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         wrap_function_wrapper(
-            "openai.resources.audio.speech",  
-            "AsyncSpeech.create",  
+            "openai.resources.audio.speech",
+            "AsyncSpeech.create",
             async_audio_create(version, environment, application_name,
                 tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )

openlit/instrumentation/openai/utils.py

@@ -37,9 +37,15 @@ def format_content(messages):
 
     # Handle list of messages
     formatted_messages = []
+
     for message in messages:
-        role = message.get("role", "user")
-        content = message.get("content", "")
+        try:
+            role = message.get("role", "user") or message.role
+            content = message.get("content", "") or message.content
+
+        except:
+            role = "user"
+            content = str(messages)
 
         if isinstance(content, list):
             content_str_list = []
@@ -442,9 +448,9 @@ def common_chat_logic(scope, pricing_info, environment, application_name, metric
     scope._span.set_attribute(SemanticConvention.GEN_AI_OUTPUT_TYPE, "text" if isinstance(scope._llmresponse, str) else "json")
 
     # OpenAI-specific attributes
-    if hasattr(scope, "_system_fingerprint"):
+    if hasattr(scope, "_system_fingerprint") and scope._system_fingerprint:
         scope._span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_SYSTEM_FINGERPRINT, scope._system_fingerprint)
-    if hasattr(scope, "_service_tier"):
+    if hasattr(scope, "_service_tier") and scope._service_tier:
         scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_SERVICE_TIER, scope._service_tier)
 
     # Span Attributes for Tools - optimized

openlit/instrumentation/pinecone/utils.py

@@ -33,10 +33,10 @@ def object_count(obj):
 def set_server_address_and_port(instance):
     """
     Extracts server address and port from Pinecone client instance.
-    
+
     Args:
         instance: Pinecone client instance
-        
+
     Returns:
         tuple: (server_address, server_port)
     """

openlit/instrumentation/qdrant/utils.py

@@ -47,10 +47,10 @@ def object_count(obj):
 def set_server_address_and_port(instance):
     """
     Extracts server address and port from Qdrant client instance.
-    
+
     Args:
         instance: Qdrant client instance
-        
+
     Returns:
         tuple: (server_address, server_port)
     """