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

openlit/instrumentation/astra/utils.py

@@ -1,102 +1,277 @@
 """
-Astra OpenTelemetry instrumentation utility functions
+Utility functions for AstraDB instrumentation.
 """
 
 import time
-import logging
+from urllib.parse import urlparse
 from opentelemetry.trace import Status, StatusCode
-from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT
-from openlit.__helpers import handle_exception
+from openlit.__helpers import (
+    common_db_span_attributes,
+    record_db_metrics,
+)
 from openlit.semcov import SemanticConvention
 
-# Initialize logger for logging potential issues and operations
-logger = logging.getLogger(__name__)
+# Operation mapping for simple span naming
+DB_OPERATION_MAP = {
+    "astra.create_collection": SemanticConvention.DB_OPERATION_CREATE_COLLECTION,
+    "astra.drop_collection": SemanticConvention.DB_OPERATION_DELETE_COLLECTION,
+    "astra.insert": SemanticConvention.DB_OPERATION_INSERT,
+    "astra.insert_one": SemanticConvention.DB_OPERATION_INSERT,
+    "astra.insert_many": SemanticConvention.DB_OPERATION_INSERT,
+    "astra.update": SemanticConvention.DB_OPERATION_UPDATE,
+    "astra.update_one": SemanticConvention.DB_OPERATION_UPDATE,
+    "astra.update_many": SemanticConvention.DB_OPERATION_UPDATE,
+    "astra.find": SemanticConvention.DB_OPERATION_SELECT,
+    "astra.find_one_and_update": SemanticConvention.DB_OPERATION_REPLACE,
+    "astra.replace_one": SemanticConvention.DB_OPERATION_REPLACE,
+    "astra.find_one_and_delete": SemanticConvention.DB_OPERATION_FIND_AND_DELETE,
+    "astra.delete": SemanticConvention.DB_OPERATION_DELETE,
+    "astra.delete_one": SemanticConvention.DB_OPERATION_DELETE,
+    "astra.delete_many": SemanticConvention.DB_OPERATION_DELETE,
+}
 
 def object_count(obj):
-    """Counts Length of object if it exists, Else returns None."""
-    return len(obj) if isinstance(obj, list) else 1
+    """
+    Counts length of object if it exists, else returns 0.
+    """
+    if isinstance(obj, list):
+        return len(obj)
+    elif obj is not None:
+        return 1
+    return 0
 
-DB_OPERATION_MAP = {
-    'astra.create_collection': SemanticConvention.DB_OPERATION_CREATE_COLLECTION,
-    'astra.drop_collection': SemanticConvention.DB_OPERATION_DELETE_COLLECTION,
-    'astra.insert': SemanticConvention.DB_OPERATION_INSERT,
-    'astra.update': SemanticConvention.DB_OPERATION_UPDATE,
-    'astra.find': SemanticConvention.DB_OPERATION_SELECT,
-    'astra.find_one_and_update': SemanticConvention.DB_OPERATION_REPLACE,
-    'astra.replace_one': SemanticConvention.DB_OPERATION_REPLACE,
-    'astra.delete': SemanticConvention.DB_OPERATION_DELETE,
-    'astra.find_one_and_delete': SemanticConvention.DB_OPERATION_FIND_AND_DELETE
-}
+def set_server_address_and_port(instance):
+    """
+    Extracts server address and port from AstraDB client instance.
+
+    Args:
+        instance: AstraDB client instance
+
+    Returns:
+        tuple: (server_address, server_port)
+    """
+    server_address = "astra.datastax.com"
+    server_port = 443
+
+    # Try getting api_endpoint from instance or its database
+    api_endpoint = getattr(instance, "api_endpoint", None)
+    if not api_endpoint:
+        # Try getting from database attribute
+        database = getattr(instance, "database", None)
+        if database:
+            api_endpoint = getattr(database, "api_endpoint", None)
+
+    if api_endpoint and isinstance(api_endpoint, str):
+        if api_endpoint.startswith(("http://", "https://")):
+            try:
+                parsed = urlparse(api_endpoint)
+                server_address = parsed.hostname or server_address
+                server_port = parsed.port or server_port
+            except Exception:
+                pass
+        else:
+            # Handle cases like "hostname:port" or just "hostname"
+            if ":" in api_endpoint:
+                parts = api_endpoint.split(":")
+                server_address = parts[0]
+                try:
+                    server_port = int(parts[1])
+                except (ValueError, IndexError):
+                    pass
+            else:
+                server_address = api_endpoint
+
+    return server_address, server_port
 
-def process_db_operations(response, span, start_time, gen_ai_endpoint,
-        version, environment, application_name,
-        capture_message_content, metrics, disable_metrics, server_address,
-        server_port, collection_name, db_operation, kwargs, args):
+def common_astra_logic(scope, environment, application_name,
+    metrics, capture_message_content, disable_metrics, version,
+    instance=None, endpoint=None):
     """
-    Process DB operation and generate Telemetry
+    Process AstraDB 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 AstraDB client
+        instance: AstraDB 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_ASTRA,
+        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)
+
+    # Get collection name from instance
+    collection_name = getattr(instance, "name", "unknown")
+    scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
+
+    if scope._db_operation == SemanticConvention.DB_OPERATION_CREATE_COLLECTION:
+        # Handle create_collection operation
+        scope._span.set_attribute(SemanticConvention.DB_COLLECTION_DIMENSION,
+            scope._kwargs.get("dimension", -1))
+        scope._span.set_attribute(SemanticConvention.DB_INDEX_METRIC,
+            str(scope._kwargs.get("metric", "")))
+
+        # Set namespace if available in response
+        if scope._response and hasattr(scope._response, "keyspace"):
+            scope._span.set_attribute(SemanticConvention.DB_NAMESPACE, scope._response.keyspace)
+
+        if scope._response and hasattr(scope._response, "name"):
+            scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, scope._response.name)
+
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
+            f"{scope._db_operation} {collection_name} "
+            f"dimension={scope._kwargs.get('dimension', 'None')} "
+            f"metric={scope._kwargs.get('metric', 'None')}")
+
+    elif scope._db_operation == SemanticConvention.DB_OPERATION_DELETE_COLLECTION:
+        # Handle drop_collection operation
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
+            f"{scope._db_operation} {collection_name}")
+
+    elif scope._db_operation == SemanticConvention.DB_OPERATION_INSERT:
+        # Handle insert operations (insert_one, insert_many, regular insert)
+        documents = scope._args[0] if scope._args else scope._kwargs.get("documents", [])
+
+        scope._span.set_attribute(SemanticConvention.DB_DOCUMENTS_COUNT, object_count(documents))
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(documents))
+
+        # Response metrics
+        if scope._response and hasattr(scope._response, "inserted_ids"):
+            scope._span.set_attribute(SemanticConvention.DB_RESPONSE_RETURNED_ROWS,
+                len(scope._response.inserted_ids))
+
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
+            f"{scope._db_operation} {collection_name} "
+            f"documents_count={object_count(documents)}")
+
+    elif scope._db_operation == SemanticConvention.DB_OPERATION_UPDATE:
+        # Handle update operations (update_one, update_many, regular update)
+        update_query = scope._args[1] if len(scope._args) > 1 else scope._kwargs.get("update", {})
+        filter_query = scope._args[0] if scope._args else scope._kwargs.get("filter", {})
+
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(update_query))
+        scope._span.set_attribute(SemanticConvention.DB_FILTER, str(filter_query))
+
+        # Response metrics
+        if scope._response and hasattr(scope._response, "update_info"):
+            scope._span.set_attribute(SemanticConvention.DB_RESPONSE_RETURNED_ROWS,
+                scope._response.update_info.get("nModified", 0))
+
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
+            f"{scope._db_operation} {collection_name} "
+            f"filter={str(filter_query)[:100]}... "
+            f"update={str(update_query)[:100]}...")
+
+    elif scope._db_operation == SemanticConvention.DB_OPERATION_REPLACE:
+        # Handle replace operations (find_one_and_update, replace_one)
+        filter_query = scope._args[0] if scope._args else scope._kwargs.get("filter", {})
+
+        # Check if it's an upsert operation
+        if scope._kwargs.get("upsert"):
+            scope._db_operation = SemanticConvention.DB_OPERATION_UPSERT
+            scope._span.set_attribute(SemanticConvention.DB_OPERATION_NAME,
+                SemanticConvention.DB_OPERATION_UPSERT)
+
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(filter_query))
+        scope._span.set_attribute(SemanticConvention.DB_FILTER, str(filter_query))
+
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
+            f"{scope._db_operation} {collection_name} "
+            f"filter={str(filter_query)[:100]}... "
+            f"upsert={scope._kwargs.get('upsert', False)}")
+
+    elif scope._db_operation == SemanticConvention.DB_OPERATION_SELECT:
+        # Handle find operations
+        filter_query = scope._args[0] if scope._args else scope._kwargs.get("filter", {})
+
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(filter_query))
+        scope._span.set_attribute(SemanticConvention.DB_FILTER, str(filter_query))
+
+        # Response metrics
+        if scope._response and hasattr(scope._response, "__len__"):
+            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"filter={str(filter_query)[:100]}...")
+
+    elif scope._db_operation in [SemanticConvention.DB_OPERATION_DELETE,
+                                 SemanticConvention.DB_OPERATION_FIND_AND_DELETE]:
+        # Handle delete operations (delete_one, delete_many, find_one_and_delete)
+        filter_query = scope._args[0] if scope._args else scope._kwargs.get("filter", {})
+
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(filter_query))
+        scope._span.set_attribute(SemanticConvention.DB_FILTER, str(filter_query))
+
+        # Response metrics
+        if scope._response and hasattr(scope._response, "deleted_count"):
+            scope._span.set_attribute(SemanticConvention.DB_RESPONSE_RETURNED_ROWS,
+                scope._response.deleted_count)
+
+        scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
+            f"{scope._db_operation} {collection_name} "
+            f"filter={str(filter_query)[:100]}...")
+
+    scope._span.set_status(Status(StatusCode.OK))
+
+    # Record metrics using helper
+    if not disable_metrics:
+        record_db_metrics(metrics, SemanticConvention.DB_SYSTEM_ASTRA,
+            scope._server_address, scope._server_port, environment, application_name,
+            scope._start_time, scope._end_time)
+
+def process_astra_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 AstraDB response and generate telemetry.
+
+    Args:
+        response: Response from AstraDB 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: AstraDB client version
+        instance: AstraDB 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
+    scope._args = args
+
+    # Process the response using common logic
+    common_astra_logic(scope, environment, application_name,
+        metrics, capture_message_content, disable_metrics, version, instance)
 
-    end_time = time.time()
-
-    try:
-        span.set_attribute(TELEMETRY_SDK_NAME, 'openlit')
-        span.set_attribute(SemanticConvention.GEN_AI_OPERATION, SemanticConvention.GEN_AI_OPERATION_TYPE_VECTORDB)
-        span.set_attribute(SemanticConvention.DB_SYSTEM_NAME, SemanticConvention.DB_SYSTEM_ASTRA)
-        span.set_attribute(SemanticConvention.DB_CLIENT_OPERATION_DURATION, end_time - start_time)
-        span.set_attribute(SemanticConvention.SERVER_ADDRESS, server_address)
-        span.set_attribute(SemanticConvention.SERVER_PORT, server_port)
-        span.set_attribute(DEPLOYMENT_ENVIRONMENT, environment)
-        span.set_attribute(SERVICE_NAME, application_name)
-        span.set_attribute(SemanticConvention.DB_OPERATION_NAME, db_operation)
-        span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
-        span.set_attribute(SemanticConvention.DB_SDK_VERSION, version)
-
-        if db_operation == SemanticConvention.DB_OPERATION_CREATE_COLLECTION:
-            span.set_attribute(SemanticConvention.DB_NAMESPACE, response.keyspace)
-            span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, response.name)
-            span.set_attribute(SemanticConvention.DB_INDEX_DIMENSION, kwargs.get('dimension', ''))
-            span.set_attribute(SemanticConvention.DB_INDEX_METRIC, str(kwargs.get('metric', '')))
-
-        if db_operation == SemanticConvention.DB_OPERATION_INSERT:
-            span.set_attribute(SemanticConvention.DB_DOCUMENTS_COUNT, object_count(args[0]))
-            span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(args[0] or kwargs.get('documents', {})))
-
-        elif db_operation == SemanticConvention.DB_OPERATION_UPDATE:
-            span.set_attribute(SemanticConvention.DB_RESPONSE_RETURNED_ROWS, response.update_info.get('nModified', 0))
-            span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(args[1] or kwargs.get('update', {})))
-
-        elif db_operation == SemanticConvention.DB_OPERATION_DELETE:
-            span.set_attribute(SemanticConvention.DB_RESPONSE_RETURNED_ROWS, response.deleted_count)
-            span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(args[0] or kwargs.get('filter', {})))
-
-        elif db_operation in [
-            SemanticConvention.DB_OPERATION_SELECT,
-            SemanticConvention.DB_OPERATION_FIND_AND_DELETE,
-            SemanticConvention.DB_OPERATION_REPLACE
-        ]:
-            span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(args or kwargs.get('filter', {})))
-
-        span.set_status(Status(StatusCode.OK))
-
-        if not disable_metrics:
-            attributes = {
-                TELEMETRY_SDK_NAME: 'openlit',
-                SERVICE_NAME: application_name,
-                SemanticConvention.DB_SYSTEM_NAME: SemanticConvention.DB_SYSTEM_ASTRA,
-                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)
-            metrics['db_client_operation_duration'].record(end_time - start_time, attributes)
-
-        # Return original response
-        return response
-
-    except Exception as e:
-        handle_exception(span, e)
-        logger.error('Error in trace creation: %s', e)
-
-        # Return original response
-        return response
+    return response

openlit/instrumentation/chroma/utils.py

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

openlit/instrumentation/controlflow/controlflow.py

@@ -19,7 +19,7 @@ def wrap_controlflow(gen_ai_endpoint, version, environment, application_name,
 
     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.
@@ -49,7 +49,7 @@ def wrap_controlflow(gen_ai_endpoint, version, environment, application_name,
 
         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.

openlit/instrumentation/embedchain/embedchain.py

@@ -19,7 +19,7 @@ def evaluate(gen_ai_endpoint, version, environment, application_name,
 
     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 EmbedChain application.
@@ -49,7 +49,7 @@ def evaluate(gen_ai_endpoint, version, environment, application_name,
 
         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.
@@ -97,7 +97,7 @@ def get_data_sources(gen_ai_endpoint, version, environment, application_name,
 
     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 EmbedChain application.
@@ -127,7 +127,7 @@ def get_data_sources(gen_ai_endpoint, version, environment, application_name,
 
         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.

openlit/instrumentation/groq/__init__.py

@@ -30,16 +30,16 @@ class GroqInstrumentor(BaseInstrumentor):
 
         # Chat completions
         wrap_function_wrapper(
-            "groq.resources.chat.completions",  
-            "Completions.create",  
+            "groq.resources.chat.completions",
+            "Completions.create",
             chat(version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         # Chat completions
         wrap_function_wrapper(
-            "groq.resources.chat.completions",  
-            "AsyncCompletions.create",  
+            "groq.resources.chat.completions",
+            "AsyncCompletions.create",
             async_chat(version, environment, application_name,
                       tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )

openlit/instrumentation/haystack/__init__.py

@@ -1,49 +1,78 @@
-# pylint: disable=useless-return, bad-staticmethod-argument, disable=duplicate-code
-"""Initializer of Auto Instrumentation of Haystack Functions"""
+"""
+OpenLIT Haystack Instrumentation
+"""
+
 from typing import Collection
 import importlib.metadata
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from wrapt import wrap_function_wrapper
 
-from openlit.instrumentation.haystack.haystack import join_data
+from openlit.instrumentation.haystack.haystack import general_wrap
+from openlit.instrumentation.haystack.async_haystack import async_general_wrap
 
 _instruments = ("haystack-ai >= 2.0.0",)
 
-WRAPPED_METHODS = [
-    {
-        "package": "haystack.components.joiners.document_joiner",
-        "object": "DocumentJoiner",
-        "endpoint": "haystack.join_data",
-        "wrapper": join_data,
-    }
-]
-
 class HaystackInstrumentor(BaseInstrumentor):
-    """An instrumentor for Cohere's client library."""
+    """Optimized instrumentor for Haystack with minimal overhead"""
 
     def instrumentation_dependencies(self) -> Collection[str]:
         return _instruments
 
     def _instrument(self, **kwargs):
-        application_name = kwargs.get("application_name")
-        environment = kwargs.get("environment")
-        tracer = kwargs.get("tracer")
-        pricing_info = kwargs.get("pricing_info")
-        capture_message_content = kwargs.get("capture_message_content")
         version = importlib.metadata.version("haystack-ai")
+        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")
+        disable_metrics = kwargs.get("disable_metrics")
+        detailed_tracing = kwargs.get("detailed_tracing", False)
 
-        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")
+        # Pipeline operations (always enabled)
+        try:
             wrap_function_wrapper(
-                wrap_package,
-                wrap_object,
-                wrapper(gen_ai_endpoint, version, environment, application_name,
-                 tracer, pricing_info, capture_message_content),
+                "haystack", "Pipeline.run",
+                general_wrap("pipeline", version, environment, application_name,
+                           tracer, pricing_info, capture_message_content,
+                           metrics, disable_metrics)
             )
+            wrap_function_wrapper(
+                "haystack", "AsyncPipeline.run_async",
+                async_general_wrap("pipeline", version, environment,
+                                 application_name, tracer, pricing_info,
+                                 capture_message_content, metrics, disable_metrics)
+            )
+        except Exception:
+            pass
+
+        # Component operations (only if detailed_tracing enabled)
+        if detailed_tracing:
+            components = [
+                ("haystack.components.retrievers.in_memory",
+                 "InMemoryBM25Retriever.run", "bm25_retriever"),
+                ("haystack.components.builders.prompt_builder",
+                 "PromptBuilder.run", "prompt_builder"),
+                ("haystack.components.generators.openai",
+                 "OpenAIGenerator.run", "openai_generator"),
+                ("haystack.components.generators.chat.openai",
+                 "OpenAIChatGenerator.run", "openai_chat_generator"),
+                ("haystack.components.embedders.openai_text_embedder",
+                 "OpenAITextEmbedder.run", "text_embedder"),
+                ("haystack.components.embedders.openai_document_embedder",
+                 "OpenAIDocumentEmbedder.run", "document_embedder"),
+            ]
+
+            for module, method, component_type in components:
+                try:
+                    wrap_function_wrapper(
+                        module, method,
+                        general_wrap(component_type, version, environment,
+                                   application_name, tracer, pricing_info,
+                                   capture_message_content, metrics, disable_metrics)
+                    )
+                except Exception:
+                    pass
 
-    @staticmethod
     def _uninstrument(self, **kwargs):
         pass

openlit/instrumentation/haystack/async_haystack.py

@@ -0,0 +1,54 @@
+"""
+Haystack async wrapper
+"""
+
+import time
+from opentelemetry.trace import SpanKind
+from opentelemetry import context as context_api
+from openlit.__helpers import handle_exception
+from openlit.instrumentation.haystack.utils import (
+    process_haystack_response,
+    OPERATION_MAP,
+    set_server_address_and_port,
+)
+
+def async_general_wrap(endpoint, version, environment, application_name,
+    tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+    """Optimized async wrapper for Haystack operations"""
+
+    async def wrapper(wrapped, instance, args, kwargs):
+        """Fast async wrapper with minimal overhead"""
+
+        # CRITICAL: Suppression check
+        if context_api.get_value(context_api._SUPPRESS_INSTRUMENTATION_KEY):
+            return await wrapped(*args, **kwargs)
+
+        # Fast operation mapping
+        operation_type = OPERATION_MAP.get(endpoint, "framework")
+
+        # Optimized span naming
+        if endpoint == "pipeline":
+            span_name = f"{operation_type} pipeline"
+        else:
+            span_name = f"{operation_type} {endpoint}"
+
+        # Fast server address
+        server_address, server_port = set_server_address_and_port(instance)
+
+        with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
+            start_time = time.time()
+            response = await wrapped(*args, **kwargs)
+
+            try:
+                response = process_haystack_response(
+                    response, operation_type, server_address, server_port,
+                    environment, application_name, metrics, start_time, span,
+                    capture_message_content, disable_metrics, version,
+                    instance, args, endpoint=endpoint, **kwargs
+                )
+            except Exception as e:
+                handle_exception(span, e)
+
+            return response
+
+    return wrapper