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

openlit/instrumentation/qdrant/__init__.py

@@ -1,5 +1,7 @@
-# pylint: disable=useless-return, bad-staticmethod-argument, disable=duplicate-code
-"""Initializer of Auto Instrumentation of Qdrant Functions"""
+"""
+OpenLIT Qdrant Instrumentation
+"""
+
 from typing import Collection
 import importlib.metadata
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
@@ -10,286 +12,69 @@ from openlit.instrumentation.qdrant.async_qdrant import async_general_wrap
 
 _instruments = ("qdrant-client >= 1.9.0",)
 
-WRAPPED_METHODS = [
-    {
-        "package": "qdrant_client",
-        "object": "QdrantClient.create_collection",
-        "endpoint": "qdrant.create_collection",
-        "wrapper": general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "QdrantClient.delete_collection",
-        "endpoint": "qdrant.delete_collection",
-        "wrapper": general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "QdrantClient.update_collection",
-        "endpoint": "qdrant.update_collection",
-        "wrapper": general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "QdrantClient.upload_collection",
-        "endpoint": "qdrant.upload_collection",
-        "wrapper": general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "QdrantClient.upsert",
-        "endpoint": "qdrant.upsert",
-        "wrapper": general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "QdrantClient.set_payload",
-        "endpoint": "qdrant.set_payload",
-        "wrapper": general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "QdrantClient.overwrite_payload",
-        "endpoint": "qdrant.overwrite_payload",
-        "wrapper": general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "QdrantClient.clear_payload",
-        "endpoint": "qdrant.clear_payload",
-        "wrapper": general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "QdrantClient.delete_payload",
-        "endpoint": "qdrant.delete_payload",
-        "wrapper": general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "QdrantClient.upload_points",
-        "endpoint": "qdrant.upload_points",
-        "wrapper": general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "QdrantClient.update_vectors",
-        "endpoint": "qdrant.update_vectors",
-        "wrapper": general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "QdrantClient.delete_vectors",
-        "endpoint": "qdrant.delete_vectors",
-        "wrapper": general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "QdrantClient.delete",
-        "endpoint": "qdrant.delete",
-        "wrapper": general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "QdrantClient.retrieve",
-        "endpoint": "qdrant.retrieve",
-        "wrapper": general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "QdrantClient.scroll",
-        "endpoint": "qdrant.scroll",
-        "wrapper": general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "QdrantClient.search",
-        "endpoint": "qdrant.search",
-        "wrapper": general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "QdrantClient.search_groups",
-        "endpoint": "qdrant.search_groups",
-        "wrapper": general_wrap,
-    },
-    {
-
-        "package": "qdrant_client",
-        "object": "QdrantClient.recommend",
-        "endpoint": "qdrant.recommend",
-        "wrapper": general_wrap,
-    },
-    {
-
-        "package": "qdrant_client",
-        "object": "QdrantClient.create_payload_index",
-        "endpoint": "qdrant.create_payload_index",
-        "wrapper": general_wrap,
-    },
-    {
-
-        "package": "qdrant_client",
-        "object": "QdrantClient.query_points",
-        "endpoint": "qdrant.query_points",
-        "wrapper": general_wrap,
-    },
-
-    # Async Client
-    {
-        "package": "qdrant_client",
-        "object": "AsyncQdrantClient.create_collection",
-        "endpoint": "qdrant.create_collection",
-        "wrapper": async_general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "AsyncQdrantClient.delete_collection",
-        "endpoint": "qdrant.delete_collection",
-        "wrapper": async_general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "AsyncQdrantClient.update_collection",
-        "endpoint": "qdrant.update_collection",
-        "wrapper": async_general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "AsyncQdrantClient.upload_collection",
-        "endpoint": "qdrant.upload_collection",
-        "wrapper": async_general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "AsyncQdrantClient.upsert",
-        "endpoint": "qdrant.upsert",
-        "wrapper": async_general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "AsyncQdrantClient.set_payload",
-        "endpoint": "qdrant.set_payload",
-        "wrapper": async_general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "AsyncQdrantClient.overwrite_payload",
-        "endpoint": "qdrant.overwrite_payload",
-        "wrapper": async_general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "AsyncQdrantClient.clear_payload",
-        "endpoint": "qdrant.clear_payload",
-        "wrapper": async_general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "AsyncQdrantClient.delete_payload",
-        "endpoint": "qdrant.delete_payload",
-        "wrapper": async_general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "AsyncQdrantClient.upload_points",
-        "endpoint": "qdrant.upload_points",
-        "wrapper": async_general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "AsyncQdrantClient.update_vectors",
-        "endpoint": "qdrant.update_vectors",
-        "wrapper": async_general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "AsyncQdrantClient.delete_vectors",
-        "endpoint": "qdrant.delete_vectors",
-        "wrapper": async_general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "AsyncQdrantClient.delete",
-        "endpoint": "qdrant.delete",
-        "wrapper": async_general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "AsyncQdrantClient.retrieve",
-        "endpoint": "qdrant.retrieve",
-        "wrapper": async_general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "AsyncQdrantClient.scroll",
-        "endpoint": "qdrant.scroll",
-        "wrapper": async_general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "AsyncQdrantClient.search",
-        "endpoint": "qdrant.search",
-        "wrapper": async_general_wrap,
-    },
-    {
-        "package": "qdrant_client",
-        "object": "AsyncQdrantClient.search_groups",
-        "endpoint": "qdrant.search_groups",
-        "wrapper": async_general_wrap,
-    },
-    {
-
-        "package": "qdrant_client",
-        "object": "AsyncQdrantClient.recommend",
-        "endpoint": "qdrant.recommend",
-        "wrapper": async_general_wrap,
-    },
-    {
-
-        "package": "qdrant_client",
-        "object": "AsyncQdrantClient.create_payload_index",
-        "endpoint": "qdrant.create_payload_index",
-        "wrapper": async_general_wrap,
-    },
-    {
-
-        "package": "qdrant_client",
-        "object": "AsyncQdrantClient.query_points",
-        "endpoint": "qdrant.query_points",
-        "wrapper": async_general_wrap,
-    },
+# Operations to wrap for both sync and async clients
+QDRANT_OPERATIONS = [
+    ("create_collection", "qdrant.create_collection"),
+    ("delete_collection", "qdrant.delete_collection"),
+    ("update_collection", "qdrant.update_collection"),
+    ("upload_collection", "qdrant.upload_collection"),
+    ("upsert", "qdrant.upsert"),
+    ("set_payload", "qdrant.set_payload"),
+    ("overwrite_payload", "qdrant.overwrite_payload"),
+    ("clear_payload", "qdrant.clear_payload"),
+    ("delete_payload", "qdrant.delete_payload"),
+    ("upload_points", "qdrant.upload_points"),
+    ("update_vectors", "qdrant.update_vectors"),
+    ("delete_vectors", "qdrant.delete_vectors"),
+    ("delete", "qdrant.delete"),
+    ("retrieve", "qdrant.retrieve"),
+    ("scroll", "qdrant.scroll"),
+    ("search", "qdrant.search"),
+    ("search_groups", "qdrant.search_groups"),
+    ("recommend", "qdrant.recommend"),
+    ("create_payload_index", "qdrant.create_payload_index"),
+    ("query_points", "qdrant.query_points"),
 ]
 
 class QdrantInstrumentor(BaseInstrumentor):
-    """An instrumentor for Qdrant's client library."""
+    """
+    An instrumentor for Qdrant client library.
+    """
 
     def instrumentation_dependencies(self) -> Collection[str]:
         return _instruments
 
     def _instrument(self, **kwargs):
-        application_name = kwargs.get("application_name")
-        environment = kwargs.get("environment")
+        version = importlib.metadata.version("qdrant-client")
+        environment = kwargs.get("environment", "default")
+        application_name = kwargs.get("application_name", "default")
         tracer = kwargs.get("tracer")
+        pricing_info = kwargs.get("pricing_info", {})
+        capture_message_content = kwargs.get("capture_message_content", False)
         metrics = kwargs.get("metrics_dict")
-        pricing_info = kwargs.get("pricing_info")
-        capture_message_content = kwargs.get("capture_message_content")
         disable_metrics = kwargs.get("disable_metrics")
-        version = importlib.metadata.version("qdrant-client")
 
-        for wrapped_method in WRAPPED_METHODS:
-            wrap_package = wrapped_method.get("package")
-            wrap_object = wrapped_method.get("object")
-            gen_ai_endpoint = wrapped_method.get("endpoint")
-            wrapper = wrapped_method.get("wrapper")
+        # Wrap sync operations
+        for method_name, endpoint in QDRANT_OPERATIONS:
             wrap_function_wrapper(
-                wrap_package,
-                wrap_object,
-                wrapper(gen_ai_endpoint, version, environment, application_name,
-                 tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+                "qdrant_client",
+                f"QdrantClient.{method_name}",
+                general_wrap(
+                    endpoint, version, environment, application_name, tracer,
+                    pricing_info, capture_message_content, metrics, disable_metrics
+                ),
             )
 
+        # Wrap async operations
+        for method_name, endpoint in QDRANT_OPERATIONS:
+            wrap_function_wrapper(
+                "qdrant_client",
+                f"AsyncQdrantClient.{method_name}",
+                async_general_wrap(
+                    endpoint, version, environment, application_name, tracer,
+                    pricing_info, capture_message_content, metrics, disable_metrics
+                ),
+            )
 
-    @staticmethod
     def _uninstrument(self, **kwargs):
         pass

openlit/instrumentation/qdrant/async_qdrant.py

@@ -1,267 +1,55 @@
 # pylint: disable=duplicate-code, broad-exception-caught, too-many-statements, unused-argument, possibly-used-before-assignment, too-many-branches
 """
-Module for monitoring Qdrant.
+Module for monitoring Qdrant async operations.
 """
 
-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
+from openlit.instrumentation.qdrant.utils import DB_OPERATION_MAP, process_qdrant_response, set_server_address_and_port
 
-# 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
-
-def async_general_wrap(gen_ai_endpoint, version, environment, application_name,
-                 tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+def async_general_wrap(gen_ai_endpoint, version, environment, application_name, 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 Pinecone function calls.
     """
 
     async 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.
+        Wraps the Qdrant async operation with tracing and logging.
         """
-        with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
-            response = await 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_QDRANT)
-
-                if gen_ai_endpoint == "qdrant.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", ""))
-
-                elif gen_ai_endpoint == "qdrant.upload_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", ""))
-
-                elif gen_ai_endpoint == "qdrant.delete_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", ""))
+        # CRITICAL: Suppression check
+        if context_api.get_value(context_api._SUPPRESS_INSTRUMENTATION_KEY):
+            return await wrapped(*args, **kwargs)
 
-                elif gen_ai_endpoint == "qdrant.update_collection":
-                    db_operation = SemanticConvention.DB_OPERATION_UPDATE_COLLECTION
-                    span.set_attribute(SemanticConvention.DB_OPERATION_NAME,
-                                       SemanticConvention.DB_OPERATION_UPDATE_COLLECTION)
-                    span.set_attribute(SemanticConvention.DB_COLLECTION_NAME,
-                                       kwargs.get("collection_name", ""))
+        # Extract operation from endpoint
+        db_operation = DB_OPERATION_MAP.get(gen_ai_endpoint, "unknown")
 
-                elif gen_ai_endpoint == "qdrant.set_payload":
-                    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_OPERATION_STATUS,
-                                       response.status)
-                    span.set_attribute(SemanticConvention.DB_VECTOR_COUNT,
-                                       object_count(kwargs.get("points", [])))
-                    span.set_attribute(SemanticConvention.DB_PAYLOAD_COUNT,
-                                       object_count(kwargs.get("payload", [])))
+        # Server address calculation
+        server_address, server_port = set_server_address_and_port(instance)
 
-                elif gen_ai_endpoint == "qdrant.retrieve":
-                    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("ids", "")))
+        # Span naming: use operation + collection
+        collection_name = kwargs.get("collection_name", "unknown")
+        span_name = f"{db_operation} {collection_name}"
 
-                elif gen_ai_endpoint == "qdrant.scroll":
-                    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("scroll_filter", "")))
-
-                elif gen_ai_endpoint in ["qdrant.search", "qdrant.search_groups"]:
-                    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("query_vector", "")))
-
-                elif gen_ai_endpoint == "qdrant.recommend":
-                    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,
-                                       "positive:" + str(kwargs.get("positive", "")) + 
-                                       " negative:" + str(kwargs.get("negative", "")))
-
-                elif gen_ai_endpoint == "qdrant.upload_points":
-                    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("points")))
-
-                elif gen_ai_endpoint == "qdrant.update_vectors":
-                    db_operation = SemanticConvention.DB_OPERATION_UPDATE
-                    span.set_attribute(SemanticConvention.DB_OPERATION_NAME,
-                                       SemanticConvention.DB_OPERATION_UPDATE)
-                    span.set_attribute(SemanticConvention.DB_COLLECTION_NAME,
-                                       kwargs.get("collection_name", ""))
-                    span.set_attribute(SemanticConvention.DB_OPERATION_STATUS,
-                                       response.status)
-                    span.set_attribute(SemanticConvention.DB_VECTOR_COUNT,
-                                       object_count(kwargs.get("points")))
-
-                elif gen_ai_endpoint == "qdrant.overwrite_payload":
-                    db_operation = SemanticConvention.DB_OPERATION_UPDATE
-                    span.set_attribute(SemanticConvention.DB_OPERATION_NAME,
-                                       SemanticConvention.DB_OPERATION_UPDATE)
-                    span.set_attribute(SemanticConvention.DB_COLLECTION_NAME,
-                                       kwargs.get("collection_name", ""))
-                    span.set_attribute(SemanticConvention.DB_OPERATION_STATUS,
-                                       response.status)
-                    span.set_attribute(SemanticConvention.DB_VECTOR_COUNT,
-                                       object_count(kwargs.get("points")))
-                    span.set_attribute(SemanticConvention.DB_PAYLOAD_COUNT,
-                                       object_count(kwargs.get("payload")))
-
-                elif gen_ai_endpoint == "qdrant.upsert":
-                    db_operation = SemanticConvention.DB_OPERATION_UPSERT
-                    span.set_attribute(SemanticConvention.DB_COLLECTION_NAME,
-                                       kwargs.get("collection_name", ""))
-                    span.set_attribute(SemanticConvention.DB_OPERATION_NAME,
-                                       SemanticConvention.DB_OPERATION_UPSERT)
-                    span.set_attribute(SemanticConvention.DB_OPERATION_STATUS,
-                                       response.status)
-                    span.set_attribute(SemanticConvention.DB_VECTOR_COUNT,
-                                       object_count(kwargs.get("points")))
-
-                elif gen_ai_endpoint in ["qdrant.delete_payload", "qdrant.delete_vectors"]:
-                    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_OPERATION_STATUS,
-                                       response.status)
-                    span.set_attribute(SemanticConvention.DB_VECTOR_COUNT,
-                                       object_count(kwargs.get("points")))
-
-                elif gen_ai_endpoint in ["qdrant.clear_payload", "qdrant.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_OPERATION_STATUS,
-                                       response.status)
-                    span.set_attribute(SemanticConvention.DB_VECTOR_COUNT,
-                                       object_count(kwargs.get("points_selector")))
-
-                elif gen_ai_endpoint == "qdrant.create_payload_index":
-                    db_operation = SemanticConvention.DB_OPERATION_CREATE_INDEX
-                    span.set_attribute(SemanticConvention.DB_OPERATION_NAME,
-                                       SemanticConvention.DB_OPERATION_CREATE_INDEX)
-                    span.set_attribute(SemanticConvention.DB_COLLECTION_NAME,
-                                       kwargs.get("collection_name", ""))
-                    span.set_attribute(SemanticConvention.DB_STATEMENT,
-                                       str(kwargs.get("query", "")))
-
-                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_QDRANT,
-                        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)
+        # CRITICAL: Use tracer.start_as_current_span() for proper context
+        with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
+            start_time = time.time()
+            response = await wrapped(*args, **kwargs)
 
-                return response
+            try:
+                # Process response with endpoint information
+                response = process_qdrant_response(
+                    response, db_operation, server_address, server_port,
+                    environment, application_name, metrics, start_time, span,
+                    capture_message_content, disable_metrics, version,
+                    instance=instance, args=args, endpoint=gen_ai_endpoint, **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