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

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

openlit/instrumentation/haystack/haystack.py

@@ -1,84 +1,54 @@
-# pylint: disable=duplicate-code, broad-exception-caught, too-many-statements, unused-argument
 """
-Module for monitoring Haystack applications.
+Haystack sync wrapper
 """
 
-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.haystack.utils import (
+    process_haystack_response,
+    OPERATION_MAP,
+    set_server_address_and_port,
+)
 
-# Initialize logger for logging potential issues and operations
-logger = logging.getLogger(__name__)
+def general_wrap(endpoint, version, environment, application_name,
+    tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+    """Optimized wrapper for Haystack operations"""
 
-def join_data(gen_ai_endpoint, version, environment, application_name,
-                 tracer, pricing_info, capture_message_content):
-    """
-    Creates a wrapper around a function call to trace and log its execution metrics.
+    def wrapper(wrapped, instance, args, kwargs):
+        """Fast wrapper with minimal overhead"""
 
-    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 Haystack application.
-    - environment (str): The deployment environment (e.g., 'production', 'development').
-    - application_name (str): Name of the Haystack 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.
+        # CRITICAL: Suppression check
+        if context_api.get_value(context_api._SUPPRESS_INSTRUMENTATION_KEY):
+            return wrapped(*args, **kwargs)
 
-    Returns:
-    - function: A higher-order function that takes a function 'wrapped' and returns
-                a new function that wraps 'wrapped' with additional tracing and logging.
-    """
+        # Fast operation mapping
+        operation_type = OPERATION_MAP.get(endpoint, "framework")
 
-    def wrapper(wrapped, instance, args, kwargs):
-        """
-        An inner wrapper function that executes the wrapped function, measures execution
-        time, and records trace data using OpenTelemetry.
+        # Optimized span naming
+        if endpoint == "pipeline":
+            span_name = f"{operation_type} pipeline"
+        else:
+            span_name = f"{operation_type} {endpoint}"
 
-        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.
+        # Fast server address
+        server_address, server_port = set_server_address_and_port(instance)
 
-        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:
+        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_SYSTEM,
-                                    SemanticConvention.GEN_AI_SYSTEM_HAYSTACK)
-                span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT,
-                                    gen_ai_endpoint)
-                span.set_attribute(DEPLOYMENT_ENVIRONMENT,
-                                    environment)
-                span.set_attribute(SemanticConvention.GEN_AI_OPERATION,
-                                    SemanticConvention.GEN_AI_OPERATION_TYPE_FRAMEWORK)
-                span.set_attribute(SERVICE_NAME,
-                                    application_name)
-                span.set_status(Status(StatusCode.OK))
-
-                # Return original response
-                return response
-
+                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)
-                logger.error("Error in trace creation: %s", e)
 
-                # Return original response
-                return response
+            return response
 
     return wrapper

openlit/instrumentation/haystack/utils.py

@@ -0,0 +1,377 @@
+"""
+Haystack utilities
+"""
+import time
+import json
+from typing import Dict, Any
+from opentelemetry.trace import Status, StatusCode
+from openlit.__helpers import common_framework_span_attributes, record_framework_metrics
+from openlit.semcov import SemanticConvention
+
+# Optimized operation mapping - minimal and fast
+OPERATION_MAP = {
+    "pipeline": SemanticConvention.GEN_AI_OPERATION_TYPE_FRAMEWORK,
+    "bm25_retriever": SemanticConvention.GEN_AI_OPERATION_TYPE_RETRIEVE,
+    "prompt_builder": SemanticConvention.GEN_AI_OPERATION_TYPE_FRAMEWORK,
+    "openai_generator": SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,
+    "openai_chat_generator": SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,
+    "text_embedder": SemanticConvention.GEN_AI_OPERATION_TYPE_EMBEDDING,
+    "document_embedder": SemanticConvention.GEN_AI_OPERATION_TYPE_EMBEDDING,
+}
+
+def set_server_address_and_port(instance):
+    """Fast server address extraction"""
+    return "localhost", 8080
+
+def object_count(obj):
+    """Fast object counting"""
+    try:
+        return len(obj) if hasattr(obj, "__len__") else 1
+    except:
+        return 1
+
+def extract_component_technical_details(instance, args, kwargs, endpoint) -> Dict[str, Any]:
+    """Extract comprehensive component technical details with performance optimization"""
+    details = {}
+
+    try:
+        # Component class information
+        if hasattr(instance, "__class__"):
+            details["class_name"] = instance.__class__.__name__
+            details["module_name"] = instance.__class__.__module__
+
+        # Component input type extraction (optimized)
+        if hasattr(instance, "_component_config") and hasattr(instance._component_config, "input_types"):
+            input_types = {}
+            for name, type_info in instance._component_config.input_types.items():
+                input_types[name] = str(type_info) if type_info else "Any"
+            details["input_types"] = input_types
+        elif hasattr(instance, "run") and hasattr(instance.run, "__annotations__"):
+            # Fallback: extract from method annotations
+            annotations = instance.run.__annotations__
+            input_types = {k: str(v) for k, v in annotations.items() if k != "return"}
+            details["input_types"] = input_types
+
+        # Component output type extraction (optimized)
+        if hasattr(instance, "_component_config") and hasattr(instance._component_config, "output_types"):
+            output_types = {}
+            for name, type_info in instance._component_config.output_types.items():
+                output_types[name] = str(type_info) if type_info else "Any"
+            details["output_types"] = output_types
+
+        # Enhanced input/output specifications with connections
+        if hasattr(instance, "_component_config"):
+            config = instance._component_config
+
+            # Input specifications with data flow
+            if hasattr(config, "input_sockets"):
+                input_spec = {}
+                for socket_name, socket in config.input_sockets.items():
+                    spec_info = {
+                        "type": str(getattr(socket, "type", "Any")),
+                        "default_value": str(getattr(socket, "default_value", None)),
+                        "is_optional": getattr(socket, "is_optional", False)
+                    }
+                    input_spec[socket_name] = spec_info
+                details["input_spec"] = input_spec
+
+            # Output specifications with receivers
+            if hasattr(config, "output_sockets"):
+                output_spec = {}
+                for socket_name, socket in config.output_sockets.items():
+                    spec_info = {
+                        "type": str(getattr(socket, "type", "Any")),
+                        "is_list": getattr(socket, "is_list", False)
+                    }
+                    output_spec[socket_name] = spec_info
+                details["output_spec"] = output_spec
+
+        # Runtime input data analysis (for actual values)
+        if args or kwargs:
+            runtime_inputs = {}
+            if args:
+                for i, arg in enumerate(args):
+                    runtime_inputs[f"arg_{i}"] = type(arg).__name__
+            if kwargs:
+                for key, value in kwargs.items():
+                    runtime_inputs[key] = type(value).__name__
+            details["runtime_input_types"] = runtime_inputs
+
+    except Exception:
+        # Silently continue if introspection fails - maintain performance
+        pass
+
+    return details
+
+def extract_pipeline_metadata(instance, args, kwargs) -> Dict[str, Any]:
+    """Extract pipeline-level metadata and configuration"""
+    metadata = {}
+
+    try:
+        # Pipeline configuration
+        if hasattr(instance, "graph"):
+            graph = instance.graph
+        elif hasattr(instance, "_graph"):
+            graph = instance._graph
+
+            # Component count and connections
+            if hasattr(graph, "nodes"):
+                metadata["component_count"] = len(graph.nodes())
+
+                # Extract component connections and data flow
+                connections = []
+                if hasattr(graph, "edges"):
+                    for edge in graph.edges(data=True):
+                        source, target, data = edge
+                        connection_info = {
+                            "source": source,
+                            "target": target,
+                            "data": str(data) if data else None
+                        }
+                        connections.append(connection_info)
+                metadata["connections"] = connections
+
+                # Component list with types
+                components = []
+                for node in graph.nodes():
+                    node_data = graph.nodes[node] if hasattr(graph.nodes[node], "get") else {}
+                    component_info = {
+                        "name": node,
+                        "type": str(type(node_data.get("instance", ""))) if node_data.get("instance") else "unknown"
+                    }
+                    components.append(component_info)
+                metadata["components"] = components
+
+        # Pipeline configuration parameters
+        if hasattr(instance, "max_runs_per_component"):
+            metadata["max_runs_per_component"] = instance.max_runs_per_component
+
+        # Input/output data (if provided)
+        if args and len(args) > 0:
+            # Pipeline input data
+            input_data = args[0] if args else {}
+            if isinstance(input_data, dict):
+                # Sanitize large data for telemetry
+                sanitized_input = {}
+                for key, value in input_data.items():
+                    if isinstance(value, (str, int, float, bool)):
+                        sanitized_input[key] = value
+                    elif isinstance(value, dict):
+                        sanitized_input[key] = {k: str(v)[:100] for k, v in value.items()}
+                    else:
+                        sanitized_input[key] = str(type(value)).__name__
+                metadata["input_data"] = sanitized_input
+
+    except Exception:
+        # Silently continue if metadata extraction fails
+        pass
+
+    return metadata
+
+def extract_component_connections(instance) -> Dict[str, Any]:
+    """Extract component connection and data flow information"""
+    connections = {}
+
+    try:
+        # Extract senders (components that send data to this component)
+        if hasattr(instance, "_component_config") and hasattr(instance._component_config, "input_sockets"):
+            senders = []
+            for socket_name, socket in instance._component_config.input_sockets.items():
+                if hasattr(socket, "_senders") and socket._senders:
+                    for sender in socket._senders:
+                        sender_info = {
+                            "component": str(sender),
+                            "socket": socket_name
+                        }
+                        senders.append(sender_info)
+            connections["senders"] = senders
+
+        # Extract receivers (components that receive data from this component)
+        if hasattr(instance, "_component_config") and hasattr(instance._component_config, "output_sockets"):
+            receivers = []
+            for socket_name, socket in instance._component_config.output_sockets.items():
+                if hasattr(socket, "_receivers") and socket._receivers:
+                    for receiver in socket._receivers:
+                        receiver_info = {
+                            "component": str(receiver),
+                            "socket": socket_name
+                        }
+                        receivers.append(receiver_info)
+            connections["receivers"] = receivers
+
+    except Exception:
+        # Silently continue if connection extraction fails
+        pass
+
+    return connections
+
+def process_haystack_response(response, operation_type, server_address, server_port,
+    environment, application_name, metrics, start_time, span,
+    capture_message_content, disable_metrics, version, instance=None,
+    args=None, endpoint=None, **kwargs):
+    """Enhanced response processing with comprehensive technical details and optimized performance"""
+
+    end_time = time.time()
+
+    # Essential attributes
+    common_framework_span_attributes(
+        type("Scope", (), {
+            "_span": span,
+            "_server_address": server_address,
+            "_server_port": server_port,
+            "_start_time": start_time,
+            "_end_time": end_time
+        })(),
+        SemanticConvention.GEN_AI_SYSTEM_HAYSTACK,
+        server_address, server_port, environment, application_name,
+        version, endpoint, instance
+    )
+
+    # Core operation attributes
+    span.set_attribute(SemanticConvention.GEN_AI_OPERATION, operation_type)
+
+    # Enhanced technical details collection
+    if instance:
+        # Extract comprehensive component technical details
+        tech_details = extract_component_technical_details(instance, args, kwargs, endpoint)
+
+        # Apply component technical attributes using new semantic conventions
+        if tech_details.get("class_name"):
+            span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_COMPONENT_CLASS_NAME, tech_details["class_name"])
+
+        if tech_details.get("input_types"):
+            span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_COMPONENT_INPUT_TYPES,
+                             json.dumps(tech_details["input_types"]))
+
+        if tech_details.get("output_types"):
+            span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_COMPONENT_OUTPUT_TYPES,
+                             json.dumps(tech_details["output_types"]))
+
+        if tech_details.get("input_spec"):
+            span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_COMPONENT_INPUT_SPEC,
+                             json.dumps(tech_details["input_spec"]))
+
+        if tech_details.get("output_spec"):
+            span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_COMPONENT_OUTPUT_SPEC,
+                             json.dumps(tech_details["output_spec"]))
+
+        # Component connections and data flow
+        connections = extract_component_connections(instance)
+        if connections.get("senders"):
+            span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_COMPONENT_SENDERS,
+                             json.dumps(connections["senders"]))
+
+        if connections.get("receivers"):
+            span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_COMPONENT_RECEIVERS,
+                             json.dumps(connections["receivers"]))
+
+    # Enhanced telemetry - pipeline level
+    if endpoint == "pipeline" and isinstance(response, dict):
+        span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_CONTEXT_COUNT, len(response))
+
+        # Enhanced pipeline metadata collection
+        if instance:
+            pipeline_metadata = extract_pipeline_metadata(instance, args, kwargs)
+
+            # Apply pipeline metadata using new semantic conventions
+            if pipeline_metadata.get("component_count"):
+                span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_PIPELINE_COMPONENT_COUNT,
+                                 pipeline_metadata["component_count"])
+
+            if pipeline_metadata.get("max_runs_per_component"):
+                span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_PIPELINE_MAX_RUNS,
+                                 pipeline_metadata["max_runs_per_component"])
+
+            if pipeline_metadata.get("connections"):
+                span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_COMPONENT_CONNECTIONS,
+                                 json.dumps(pipeline_metadata["connections"]))
+
+            if pipeline_metadata.get("components"):
+                span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_PIPELINE_METADATA,
+                                 json.dumps(pipeline_metadata["components"]))
+
+            if pipeline_metadata.get("input_data"):
+                span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_PIPELINE_INPUT_DATA,
+                                 json.dumps(pipeline_metadata["input_data"]))
+
+        # Pipeline output data
+        if response:
+            # Sanitize output data for telemetry
+            sanitized_output = {}
+            for key, value in response.items():
+                if isinstance(value, (str, int, float, bool)):
+                    sanitized_output[key] = value
+                elif isinstance(value, dict) and "replies" in value:
+                    sanitized_output[key] = f"{len(value['replies'])} replies"
+                else:
+                    sanitized_output[key] = str(type(value)).__name__
+            span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_PIPELINE_OUTPUT_DATA,
+                             json.dumps(sanitized_output))
+
+        # Fast LLM response extraction
+        for key, value in response.items():
+            if key in ["llm", "generator"] and isinstance(value, dict) and "replies" in value:
+                replies = value["replies"]
+                if replies and capture_message_content:
+                    span.set_attribute(SemanticConvention.GEN_AI_CONTENT_COMPLETION, str(replies[0])[:500])
+                break
+
+    # Enhanced telemetry - retriever level
+    elif "retriever" in endpoint and isinstance(response, dict) and "documents" in response:
+        docs = response["documents"]
+        span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_RETRIEVAL_COUNT, object_count(docs))
+        span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_DOCUMENTS_COUNT, object_count(docs))
+
+        # Component identification
+        if instance:
+            span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_COMPONENT_NAME, endpoint)
+            span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_COMPONENT_TYPE, "retriever")
+
+    # Enhanced telemetry - generator level
+    elif "generator" in endpoint:
+        # Component identification
+        if instance:
+            span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_COMPONENT_NAME, endpoint)
+            span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_COMPONENT_TYPE, "generator")
+
+        if args and capture_message_content:
+            span.set_attribute(SemanticConvention.GEN_AI_PROMPT, str(args[0])[:500])
+
+        if isinstance(response, dict) and "replies" in response:
+            replies = response["replies"]
+            span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_CONTEXT_COUNT, object_count(replies))
+
+    # Enhanced telemetry - prompt builder level
+    elif endpoint == "prompt_builder":
+        # Component identification
+        if instance:
+            span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_COMPONENT_NAME, endpoint)
+            span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_COMPONENT_TYPE, "prompt_builder")
+
+        if kwargs and capture_message_content:
+            for key, value in kwargs.items():
+                if key in ["documents", "question"] and value:
+                    span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_CONTEXT_COUNT, object_count([value]))
+                    break
+
+    # Component visit tracking (simulate component execution count)
+    if endpoint != "pipeline" and instance:
+        # Simple visit counter - can be enhanced with actual state tracking
+        span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_COMPONENT_VISITS, 1)
+
+    # Duration and status
+    execution_time = end_time - start_time
+    span.set_attribute(SemanticConvention.GEN_AI_CLIENT_OPERATION_DURATION, execution_time)
+
+    # Pipeline execution time tracking
+    if endpoint == "pipeline":
+        span.set_attribute(SemanticConvention.GEN_AI_FRAMEWORK_PIPELINE_EXECUTION_TIME, execution_time)
+
+    span.set_status(Status(StatusCode.OK))
+
+    # Metrics
+    if not disable_metrics:
+        record_framework_metrics(metrics, operation_type, SemanticConvention.GEN_AI_SYSTEM_HAYSTACK,
+            server_address, server_port, environment, application_name, start_time, end_time)
+
+    return response