golf-mcp 0.1.19__py3-none-any.whl → 0.2.0__py3-none-any.whl

golf/telemetry/instrumentation.py

@@ -5,12 +5,22 @@ import functools
 import os
 import sys
 import time
+import json
 from collections.abc import Callable
 from contextlib import asynccontextmanager
-from typing import TypeVar
+from typing import Any, TypeVar
+from collections.abc import AsyncGenerator
 from collections import OrderedDict
 
 from opentelemetry import baggage, trace
+
+# Import endpoints with fallback for dev mode
+try:
+    # In built wheels, this exists (generated from _endpoints.py.in)
+    from golf import _endpoints  # type: ignore
+except ImportError:
+    # In editable/dev installs, fall back to env-based values
+    from golf import _endpoints_fallback as _endpoints  # type: ignore
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider
@@ -18,13 +28,38 @@ from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExport
 from opentelemetry.trace import Status, StatusCode
 
 from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request
 
 T = TypeVar("T")
 
 # Global tracer instance
 _tracer: trace.Tracer | None = None
 _provider: TracerProvider | None = None
+_detailed_tracing_enabled: bool = False
+
+
+def _safe_serialize(data: Any, max_length: int = 1000) -> str | None:
+    """Safely serialize data to string with length limit."""
+    try:
+        if isinstance(data, str):
+            serialized = data
+        else:
+            serialized = json.dumps(data, default=str, ensure_ascii=False)
+
+        if len(serialized) > max_length:
+            return serialized[:max_length] + "..." + f" (truncated from {len(serialized)} chars)"
+        return serialized
+    except (TypeError, ValueError):
+        # Fallback for non-serializable objects
+        try:
+            return str(data)[:max_length] + "..." if len(str(data)) > max_length else str(data)
+        except Exception:
+            return None
+
+
+def set_detailed_tracing(enabled: bool) -> None:
+    """Enable or disable detailed tracing with input/output capture."""
+    global _detailed_tracing_enabled
+    _detailed_tracing_enabled = enabled
 
 
 def init_telemetry(service_name: str = "golf-mcp-server") -> TracerProvider | None:
@@ -36,12 +71,25 @@ def init_telemetry(service_name: str = "golf-mcp-server") -> TracerProvider | No
 
     # Check for Golf platform integration first
     golf_api_key = os.environ.get("GOLF_API_KEY")
-    if golf_api_key and not os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT"):
-        # Auto-configure for Golf platform
+    if golf_api_key:
+        # Auto-configure for Golf platform - always use OTLP when Golf API
+        # key is present
         os.environ["OTEL_TRACES_EXPORTER"] = "otlp_http"
-        os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = "http://localhost:8000/api/v1/otel"
-        os.environ["OTEL_EXPORTER_OTLP_HEADERS"] = f"X-Golf-Key={golf_api_key}"
-        print("[INFO] Auto-configured OpenTelemetry for Golf platform ingestion")
+
+        # Only set endpoint if not already configured (allow user override)
+        if not os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT"):
+            os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = _endpoints.OTEL_ENDPOINT
+
+        # Set Golf platform headers (append to existing if present)
+        existing_headers = os.environ.get("OTEL_EXPORTER_OTLP_HEADERS", "")
+        golf_header = f"X-Golf-Key={golf_api_key}"
+
+        if existing_headers:
+            # Check if Golf key is already in headers
+            if "X-Golf-Key=" not in existing_headers:
+                os.environ["OTEL_EXPORTER_OTLP_HEADERS"] = f"{existing_headers},{golf_header}"
+        else:
+            os.environ["OTEL_EXPORTER_OTLP_HEADERS"] = golf_header
 
     # Check for required environment variables based on exporter type
     exporter_type = os.environ.get("OTEL_TRACES_EXPORTER", "console").lower()
@@ -78,9 +126,7 @@ def init_telemetry(service_name: str = "golf-mcp-server") -> TracerProvider | No
     # Configure exporter based on type
     try:
         if exporter_type == "otlp_http":
-            endpoint = os.environ.get(
-                "OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:4318/v1/traces"
-            )
+            endpoint = os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:4318/v1/traces")
             headers = os.environ.get("OTEL_EXPORTER_OTLP_HEADERS", "")
 
             # Parse headers if provided
@@ -91,13 +137,8 @@ def init_telemetry(service_name: str = "golf-mcp-server") -> TracerProvider | No
                         key, value = header.split("=", 1)
                         header_dict[key.strip()] = value.strip()
 
-            exporter = OTLPSpanExporter(
-                endpoint=endpoint, headers=header_dict if header_dict else None
-            )
+            exporter = OTLPSpanExporter(endpoint=endpoint, headers=header_dict if header_dict else None)
 
-            # Log successful configuration for Golf platform
-            if golf_api_key:
-                print(f"[INFO] OpenTelemetry configured for Golf platform: {endpoint}")
         else:
             # Default to console exporter
             exporter = ConsoleSpanExporter(out=sys.stderr)
@@ -112,7 +153,8 @@ def init_telemetry(service_name: str = "golf-mcp-server") -> TracerProvider | No
         processor = BatchSpanProcessor(
             exporter,
             max_queue_size=2048,
-            schedule_delay_millis=1000,  # Export every 1 second instead of default 5 seconds
+            schedule_delay_millis=1000,  # Export every 1 second instead of
+            # default 5 seconds
             max_export_batch_size=512,
             export_timeout_millis=5000,
         )
@@ -127,10 +169,7 @@ def init_telemetry(service_name: str = "golf-mcp-server") -> TracerProvider | No
     try:
         # Check if a provider is already set to avoid the warning
         existing_provider = trace.get_tracer_provider()
-        if (
-            existing_provider is None
-            or str(type(existing_provider).__name__) == "ProxyTracerProvider"
-        ):
+        if existing_provider is None or str(type(existing_provider).__name__) == "ProxyTracerProvider":
             # Only set if no provider exists or it's the default proxy provider
             trace.set_tracer_provider(provider)
         _provider = provider
@@ -167,7 +206,7 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
     tracer = get_tracer()
 
     @functools.wraps(func)
-    async def async_wrapper(*args, **kwargs):
+    async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
         # Record metrics timing
         import time
 
@@ -178,20 +217,25 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
 
         # start_as_current_span automatically uses the current context and manages it
         with tracer.start_as_current_span(span_name) as span:
-            # Add comprehensive attributes
+            # Add essential attributes only
             span.set_attribute("mcp.component.type", "tool")
-            span.set_attribute("mcp.component.name", tool_name)
             span.set_attribute("mcp.tool.name", tool_name)
-            span.set_attribute("mcp.tool.function", func.__name__)
             span.set_attribute(
                 "mcp.tool.module",
                 func.__module__ if hasattr(func, "__module__") else "unknown",
             )
 
-            # Add execution context
-            span.set_attribute("mcp.execution.args_count", len(args))
-            span.set_attribute("mcp.execution.kwargs_count", len(kwargs))
-            span.set_attribute("mcp.execution.async", True)
+            # Add minimal execution context
+            if args or kwargs:
+                span.set_attribute("mcp.execution.has_params", True)
+
+            # Capture inputs if detailed tracing is enabled
+            if _detailed_tracing_enabled and (args or kwargs):
+                input_data = {"args": args, "kwargs": kwargs} if args or kwargs else None
+                if input_data:
+                    input_str = _safe_serialize(input_data)
+                    if input_str:
+                        span.set_attribute("mcp.tool.input", input_str)
 
             # Extract Context parameter if present
             ctx = kwargs.get("ctx")
@@ -231,42 +275,25 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
 
                     metrics_collector = get_metrics_collector()
                     metrics_collector.increment_tool_execution(tool_name, "success")
-                    metrics_collector.record_tool_duration(
-                        tool_name, time.time() - start_time
-                    )
+                    metrics_collector.record_tool_duration(tool_name, time.time() - start_time)
                 except ImportError:
                     # Metrics not available, continue without metrics
                     pass
 
-                # Capture result metadata with better structure
+                # Capture result metadata
                 if result is not None:
-                    if isinstance(result, str | int | float | bool):
-                        span.set_attribute("mcp.tool.result.value", str(result))
-                        span.set_attribute(
-                            "mcp.tool.result.type", type(result).__name__
-                        )
-                    elif isinstance(result, list):
-                        span.set_attribute("mcp.tool.result.count", len(result))
-                        span.set_attribute("mcp.tool.result.type", "array")
-                    elif isinstance(result, dict):
-                        span.set_attribute("mcp.tool.result.count", len(result))
-                        span.set_attribute("mcp.tool.result.type", "object")
-                        # Only show first few keys to avoid exceeding attribute limits
-                        if len(result) > 0 and len(result) <= 5:
-                            keys_list = list(result.keys())[:5]
-                            # Limit key length and join
-                            truncated_keys = [
-                                str(k)[:20] + "..." if len(str(k)) > 20 else str(k)
-                                for k in keys_list
-                            ]
-                            span.set_attribute(
-                                "mcp.tool.result.sample_keys", ",".join(truncated_keys)
-                            )
-                    elif hasattr(result, "__len__"):
+                    span.set_attribute("mcp.tool.result.type", type(result).__name__)
+
+                    if isinstance(result, list | dict) and hasattr(result, "__len__"):
+                        span.set_attribute("mcp.tool.result.size", len(result))
+                    elif isinstance(result, str):
                         span.set_attribute("mcp.tool.result.length", len(result))
 
-                    # For any result, record its type
-                    span.set_attribute("mcp.tool.result.class", type(result).__name__)
+                    # Capture full output if detailed tracing is enabled
+                    if _detailed_tracing_enabled:
+                        output_str = _safe_serialize(result)
+                        if output_str:
+                            span.set_attribute("mcp.tool.output", output_str)
 
                 return result
             except Exception as e:
@@ -297,7 +324,7 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
                 raise
 
     @functools.wraps(func)
-    def sync_wrapper(*args, **kwargs):
+    def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
         # Record metrics timing
         import time
 
@@ -308,11 +335,9 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
 
         # start_as_current_span automatically uses the current context and manages it
         with tracer.start_as_current_span(span_name) as span:
-            # Add comprehensive attributes
+            # Add essential attributes only
             span.set_attribute("mcp.component.type", "tool")
-            span.set_attribute("mcp.component.name", tool_name)
             span.set_attribute("mcp.tool.name", tool_name)
-            span.set_attribute("mcp.tool.function", func.__name__)
             span.set_attribute(
                 "mcp.tool.module",
                 func.__module__ if hasattr(func, "__module__") else "unknown",
@@ -321,7 +346,6 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
             # Add execution context
             span.set_attribute("mcp.execution.args_count", len(args))
             span.set_attribute("mcp.execution.kwargs_count", len(kwargs))
-            span.set_attribute("mcp.execution.async", False)
 
             # Extract Context parameter if present
             ctx = kwargs.get("ctx")
@@ -361,42 +385,25 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
 
                     metrics_collector = get_metrics_collector()
                     metrics_collector.increment_tool_execution(tool_name, "success")
-                    metrics_collector.record_tool_duration(
-                        tool_name, time.time() - start_time
-                    )
+                    metrics_collector.record_tool_duration(tool_name, time.time() - start_time)
                 except ImportError:
                     # Metrics not available, continue without metrics
                     pass
 
-                # Capture result metadata with better structure
+                # Capture result metadata
                 if result is not None:
-                    if isinstance(result, str | int | float | bool):
-                        span.set_attribute("mcp.tool.result.value", str(result))
-                        span.set_attribute(
-                            "mcp.tool.result.type", type(result).__name__
-                        )
-                    elif isinstance(result, list):
-                        span.set_attribute("mcp.tool.result.count", len(result))
-                        span.set_attribute("mcp.tool.result.type", "array")
-                    elif isinstance(result, dict):
-                        span.set_attribute("mcp.tool.result.count", len(result))
-                        span.set_attribute("mcp.tool.result.type", "object")
-                        # Only show first few keys to avoid exceeding attribute limits
-                        if len(result) > 0 and len(result) <= 5:
-                            keys_list = list(result.keys())[:5]
-                            # Limit key length and join
-                            truncated_keys = [
-                                str(k)[:20] + "..." if len(str(k)) > 20 else str(k)
-                                for k in keys_list
-                            ]
-                            span.set_attribute(
-                                "mcp.tool.result.sample_keys", ",".join(truncated_keys)
-                            )
-                    elif hasattr(result, "__len__"):
+                    span.set_attribute("mcp.tool.result.type", type(result).__name__)
+
+                    if isinstance(result, list | dict) and hasattr(result, "__len__"):
+                        span.set_attribute("mcp.tool.result.size", len(result))
+                    elif isinstance(result, str):
                         span.set_attribute("mcp.tool.result.length", len(result))
 
-                    # For any result, record its type
-                    span.set_attribute("mcp.tool.result.class", type(result).__name__)
+                    # Capture full output if detailed tracing is enabled
+                    if _detailed_tracing_enabled:
+                        output_str = _safe_serialize(result)
+                        if output_str:
+                            span.set_attribute("mcp.tool.output", output_str)
 
                 return result
             except Exception as e:
@@ -447,21 +454,18 @@ def instrument_resource(func: Callable[..., T], resource_uri: str) -> Callable[.
     is_template = "{" in resource_uri
 
     @functools.wraps(func)
-    async def async_wrapper(*args, **kwargs):
+    async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
         # Create a more descriptive span name
         span_name = f"mcp.resource.{'template' if is_template else 'static'}.read"
         with tracer.start_as_current_span(span_name) as span:
-            # Add comprehensive attributes
+            # Add essential attributes only
             span.set_attribute("mcp.component.type", "resource")
-            span.set_attribute("mcp.component.name", resource_uri)
             span.set_attribute("mcp.resource.uri", resource_uri)
             span.set_attribute("mcp.resource.is_template", is_template)
-            span.set_attribute("mcp.resource.function", func.__name__)
             span.set_attribute(
                 "mcp.resource.module",
                 func.__module__ if hasattr(func, "__module__") else "unknown",
             )
-            span.set_attribute("mcp.execution.async", True)
 
             # Extract Context parameter if present
             ctx = kwargs.get("ctx")
@@ -493,9 +497,7 @@ def instrument_resource(func: Callable[..., T], resource_uri: str) -> Callable[.
                 span.set_status(Status(StatusCode.OK))
 
                 # Add event for successful read
-                span.add_event(
-                    "resource.read.completed", {"resource.uri": resource_uri}
-                )
+                span.add_event("resource.read.completed", {"resource.uri": resource_uri})
 
                 # Add result metadata
                 if hasattr(result, "__len__"):
@@ -532,21 +534,18 @@ def instrument_resource(func: Callable[..., T], resource_uri: str) -> Callable[.
                 raise
 
     @functools.wraps(func)
-    def sync_wrapper(*args, **kwargs):
+    def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
         # Create a more descriptive span name
         span_name = f"mcp.resource.{'template' if is_template else 'static'}.read"
         with tracer.start_as_current_span(span_name) as span:
-            # Add comprehensive attributes
+            # Add essential attributes only
             span.set_attribute("mcp.component.type", "resource")
-            span.set_attribute("mcp.component.name", resource_uri)
             span.set_attribute("mcp.resource.uri", resource_uri)
             span.set_attribute("mcp.resource.is_template", is_template)
-            span.set_attribute("mcp.resource.function", func.__name__)
             span.set_attribute(
                 "mcp.resource.module",
                 func.__module__ if hasattr(func, "__module__") else "unknown",
             )
-            span.set_attribute("mcp.execution.async", False)
 
             # Extract Context parameter if present
             ctx = kwargs.get("ctx")
@@ -578,9 +577,7 @@ def instrument_resource(func: Callable[..., T], resource_uri: str) -> Callable[.
                 span.set_status(Status(StatusCode.OK))
 
                 # Add event for successful read
-                span.add_event(
-                    "resource.read.completed", {"resource.uri": resource_uri}
-                )
+                span.add_event("resource.read.completed", {"resource.uri": resource_uri})
 
                 # Add result metadata
                 if hasattr(result, "__len__"):
@@ -622,6 +619,370 @@ def instrument_resource(func: Callable[..., T], resource_uri: str) -> Callable[.
         return sync_wrapper
 
 
+def instrument_elicitation(func: Callable[..., T], elicitation_type: str = "elicit") -> Callable[..., T]:
+    """Instrument an elicitation function with OpenTelemetry tracing."""
+    global _provider
+
+    # If telemetry is disabled, return the original function
+    if _provider is None:
+        return func
+
+    tracer = get_tracer()
+
+    @functools.wraps(func)
+    async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+        # If telemetry is disabled at runtime, call original function
+        global _provider
+        if _provider is None:
+            return await func(*args, **kwargs)
+
+        # Record metrics timing
+        start_time = time.time()
+
+        # Create a more descriptive span name
+        span_name = f"mcp.elicitation.{elicitation_type}.request"
+        with tracer.start_as_current_span(span_name) as span:
+            # Add essential attributes
+            span.set_attribute("mcp.component.type", "elicitation")
+            span.set_attribute("mcp.elicitation.type", elicitation_type)
+
+            # Capture elicitation parameters if detailed tracing is enabled
+            if _detailed_tracing_enabled:
+                # Extract message from first argument (common pattern)
+                if args:
+                    message = args[0] if isinstance(args[0], str) else None
+                    if message:
+                        span.set_attribute("mcp.elicitation.message", _safe_serialize(message, 500))
+
+                # Extract response_type from kwargs/args
+                response_type = kwargs.get("response_type") or (args[1] if len(args) > 1 else None)
+                if response_type is not None:
+                    if isinstance(response_type, list):
+                        span.set_attribute("mcp.elicitation.response_type", "choice")
+                        span.set_attribute("mcp.elicitation.choices", str(response_type))
+                    elif hasattr(response_type, "__name__"):
+                        span.set_attribute("mcp.elicitation.response_type", response_type.__name__)
+                    else:
+                        span.set_attribute("mcp.elicitation.response_type", str(type(response_type).__name__))
+
+            # Extract Context parameter if present
+            ctx = kwargs.get("ctx")
+            if ctx:
+                ctx_attrs = ["request_id", "session_id", "client_id", "user_id", "tenant_id"]
+                for attr in ctx_attrs:
+                    if hasattr(ctx, attr):
+                        value = getattr(ctx, attr)
+                        if value is not None:
+                            span.set_attribute(f"mcp.context.{attr}", str(value))
+
+            # Add event for elicitation start
+            span.add_event("elicitation.request.started")
+
+            try:
+                result = await func(*args, **kwargs)
+                span.set_status(Status(StatusCode.OK))
+
+                # Add event for successful completion
+                span.add_event("elicitation.request.completed")
+
+                # Capture result metadata
+                if result is not None and _detailed_tracing_enabled:
+                    if isinstance(result, str):
+                        span.set_attribute("mcp.elicitation.result.content", _safe_serialize(result, 500))
+                    elif isinstance(result, (list, dict)) and hasattr(result, "__len__"):
+                        span.set_attribute("mcp.elicitation.result.size", len(result))
+                        span.set_attribute("mcp.elicitation.result.content", _safe_serialize(result, 1000))
+
+                # Record metrics for successful elicitation
+                try:
+                    from golf.metrics import get_metrics_collector
+
+                    metrics_collector = get_metrics_collector()
+                    metrics_collector.increment_elicitation(elicitation_type, "success")
+                    metrics_collector.record_elicitation_duration(elicitation_type, time.time() - start_time)
+                except ImportError:
+                    pass
+
+                return result
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+
+                # Add event for error
+                span.add_event(
+                    "elicitation.request.error",
+                    {
+                        "error.type": type(e).__name__,
+                        "error.message": str(e),
+                    },
+                )
+
+                # Record metrics for failed elicitation
+                try:
+                    from golf.metrics import get_metrics_collector
+
+                    metrics_collector = get_metrics_collector()
+                    metrics_collector.increment_elicitation(elicitation_type, "error")
+                    metrics_collector.increment_error("elicitation", type(e).__name__)
+                except ImportError:
+                    pass
+
+                raise
+
+    @functools.wraps(func)
+    def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
+        # If telemetry is disabled at runtime, call original function
+        global _provider
+        if _provider is None:
+            return func(*args, **kwargs)
+
+        # Record metrics timing
+        start_time = time.time()
+
+        # Create a more descriptive span name
+        span_name = f"mcp.elicitation.{elicitation_type}.request"
+        with tracer.start_as_current_span(span_name) as span:
+            # Add essential attributes
+            span.set_attribute("mcp.component.type", "elicitation")
+            span.set_attribute("mcp.elicitation.type", elicitation_type)
+
+            # Capture elicitation parameters if detailed tracing is enabled
+            if _detailed_tracing_enabled:
+                if args:
+                    message = args[0] if isinstance(args[0], str) else None
+                    if message:
+                        span.set_attribute("mcp.elicitation.message", _safe_serialize(message, 500))
+
+            # Add event for elicitation start
+            span.add_event("elicitation.request.started")
+
+            try:
+                result = func(*args, **kwargs)
+                span.set_status(Status(StatusCode.OK))
+
+                # Add event for successful completion
+                span.add_event("elicitation.request.completed")
+
+                # Record metrics for successful elicitation
+                try:
+                    from golf.metrics import get_metrics_collector
+
+                    metrics_collector = get_metrics_collector()
+                    metrics_collector.increment_elicitation(elicitation_type, "success")
+                    metrics_collector.record_elicitation_duration(elicitation_type, time.time() - start_time)
+                except ImportError:
+                    pass
+
+                return result
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+
+                # Add event for error
+                span.add_event(
+                    "elicitation.request.error",
+                    {
+                        "error.type": type(e).__name__,
+                        "error.message": str(e),
+                    },
+                )
+
+                # Record metrics for failed elicitation
+                try:
+                    from golf.metrics import get_metrics_collector
+
+                    metrics_collector = get_metrics_collector()
+                    metrics_collector.increment_elicitation(elicitation_type, "error")
+                    metrics_collector.increment_error("elicitation", type(e).__name__)
+                except ImportError:
+                    pass
+
+                raise
+
+    if asyncio.iscoroutinefunction(func):
+        return async_wrapper
+    else:
+        return sync_wrapper
+
+
+def instrument_sampling(func: Callable[..., T], sampling_type: str = "sample") -> Callable[..., T]:
+    """Instrument a sampling function with OpenTelemetry tracing."""
+    global _provider
+
+    # If telemetry is disabled, return the original function
+    if _provider is None:
+        return func
+
+    tracer = get_tracer()
+
+    @functools.wraps(func)
+    async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+        # If telemetry is disabled at runtime, call original function
+        global _provider
+        if _provider is None:
+            return await func(*args, **kwargs)
+
+        # Record metrics timing
+        start_time = time.time()
+
+        # Create a more descriptive span name
+        span_name = f"mcp.sampling.{sampling_type}.request"
+        with tracer.start_as_current_span(span_name) as span:
+            # Add essential attributes
+            span.set_attribute("mcp.component.type", "sampling")
+            span.set_attribute("mcp.sampling.type", sampling_type)
+
+            # Capture sampling parameters
+            messages = kwargs.get("messages") or (args[0] if args else None)
+            if messages and _detailed_tracing_enabled:
+                if isinstance(messages, str):
+                    span.set_attribute("mcp.sampling.messages.content", _safe_serialize(messages, 1000))
+                elif isinstance(messages, list):
+                    span.set_attribute("mcp.sampling.messages.type", "list")
+                    span.set_attribute("mcp.sampling.messages.count", len(messages))
+                    span.set_attribute("mcp.sampling.messages.content", _safe_serialize(messages, 1000))
+
+            # Capture other sampling parameters
+            system_prompt = kwargs.get("system_prompt")
+            if system_prompt and _detailed_tracing_enabled:
+                span.set_attribute("mcp.sampling.system_prompt.length", len(str(system_prompt)))
+                span.set_attribute("mcp.sampling.system_prompt.content", _safe_serialize(system_prompt, 500))
+
+            temperature = kwargs.get("temperature")
+            if temperature is not None:
+                span.set_attribute("mcp.sampling.temperature", temperature)
+
+            max_tokens = kwargs.get("max_tokens")
+            if max_tokens is not None:
+                span.set_attribute("mcp.sampling.max_tokens", max_tokens)
+
+            model_preferences = kwargs.get("model_preferences")
+            if model_preferences:
+                if isinstance(model_preferences, str):
+                    span.set_attribute("mcp.sampling.model_preferences", model_preferences)
+                elif isinstance(model_preferences, list):
+                    span.set_attribute("mcp.sampling.model_preferences", ",".join(model_preferences))
+
+            # Extract Context parameter if present
+            ctx = kwargs.get("ctx")
+            if ctx:
+                ctx_attrs = ["request_id", "session_id", "client_id", "user_id", "tenant_id"]
+                for attr in ctx_attrs:
+                    if hasattr(ctx, attr):
+                        value = getattr(ctx, attr)
+                        if value is not None:
+                            span.set_attribute(f"mcp.context.{attr}", str(value))
+
+            # Add event for sampling start
+            span.add_event("sampling.request.started")
+
+            try:
+                result = await func(*args, **kwargs)
+                span.set_status(Status(StatusCode.OK))
+
+                # Add event for successful completion
+                span.add_event("sampling.request.completed")
+
+                # Capture result metadata
+                if result is not None and _detailed_tracing_enabled and isinstance(result, str):
+                    span.set_attribute("mcp.sampling.result.content", _safe_serialize(result, 1000))
+
+                # Record metrics for successful sampling
+                try:
+                    from golf.metrics import get_metrics_collector
+
+                    metrics_collector = get_metrics_collector()
+                    metrics_collector.increment_sampling(sampling_type, "success")
+                    metrics_collector.record_sampling_duration(sampling_type, time.time() - start_time)
+                    if isinstance(result, str):
+                        metrics_collector.record_sampling_tokens(sampling_type, len(result.split()))
+                except ImportError:
+                    pass
+
+                return result
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+
+                # Add event for error
+                span.add_event(
+                    "sampling.request.error",
+                    {
+                        "error.type": type(e).__name__,
+                        "error.message": str(e),
+                    },
+                )
+
+                # Record metrics for failed sampling
+                try:
+                    from golf.metrics import get_metrics_collector
+
+                    metrics_collector = get_metrics_collector()
+                    metrics_collector.increment_sampling(sampling_type, "error")
+                    metrics_collector.increment_error("sampling", type(e).__name__)
+                except ImportError:
+                    pass
+
+                raise
+
+    @functools.wraps(func)
+    def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
+        # If telemetry is disabled at runtime, call original function
+        global _provider
+        if _provider is None:
+            return func(*args, **kwargs)
+
+        # Record metrics timing
+        start_time = time.time()
+
+        # Create a more descriptive span name
+        span_name = f"mcp.sampling.{sampling_type}.request"
+        with tracer.start_as_current_span(span_name) as span:
+            # Add essential attributes
+            span.set_attribute("mcp.component.type", "sampling")
+            span.set_attribute("mcp.sampling.type", sampling_type)
+
+            # Add event for sampling start
+            span.add_event("sampling.request.started")
+
+            try:
+                result = func(*args, **kwargs)
+                span.set_status(Status(StatusCode.OK))
+
+                # Add event for successful completion
+                span.add_event("sampling.request.completed")
+
+                # Record metrics for successful sampling
+                try:
+                    from golf.metrics import get_metrics_collector
+
+                    metrics_collector = get_metrics_collector()
+                    metrics_collector.increment_sampling(sampling_type, "success")
+                    metrics_collector.record_sampling_duration(sampling_type, time.time() - start_time)
+                except ImportError:
+                    pass
+
+                return result
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+
+                # Add event for error
+                span.add_event(
+                    "sampling.request.error",
+                    {
+                        "error.type": type(e).__name__,
+                        "error.message": str(e),
+                    },
+                )
+                raise
+
+    if asyncio.iscoroutinefunction(func):
+        return async_wrapper
+    else:
+        return sync_wrapper
+
+
 def instrument_prompt(func: Callable[..., T], prompt_name: str) -> Callable[..., T]:
     """Instrument a prompt function with OpenTelemetry tracing."""
     global _provider
@@ -633,20 +994,17 @@ def instrument_prompt(func: Callable[..., T], prompt_name: str) -> Callable[...,
     tracer = get_tracer()
 
     @functools.wraps(func)
-    async def async_wrapper(*args, **kwargs):
+    async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
         # Create a more descriptive span name
         span_name = f"mcp.prompt.{prompt_name}.generate"
         with tracer.start_as_current_span(span_name) as span:
-            # Add comprehensive attributes
+            # Add essential attributes only
             span.set_attribute("mcp.component.type", "prompt")
-            span.set_attribute("mcp.component.name", prompt_name)
             span.set_attribute("mcp.prompt.name", prompt_name)
-            span.set_attribute("mcp.prompt.function", func.__name__)
             span.set_attribute(
                 "mcp.prompt.module",
                 func.__module__ if hasattr(func, "__module__") else "unknown",
             )
-            span.set_attribute("mcp.execution.async", True)
 
             # Extract Context parameter if present
             ctx = kwargs.get("ctx")
@@ -678,9 +1036,7 @@ def instrument_prompt(func: Callable[..., T], prompt_name: str) -> Callable[...,
                 span.set_status(Status(StatusCode.OK))
 
                 # Add event for successful generation
-                span.add_event(
-                    "prompt.generation.completed", {"prompt.name": prompt_name}
-                )
+                span.add_event("prompt.generation.completed", {"prompt.name": prompt_name})
 
                 # Add message count and type information
                 if isinstance(result, list):
@@ -697,9 +1053,7 @@ def instrument_prompt(func: Callable[..., T], prompt_name: str) -> Callable[...,
 
                     if roles:
                         unique_roles = list(set(roles))
-                        span.set_attribute(
-                            "mcp.prompt.result.roles", ",".join(unique_roles)
-                        )
+                        span.set_attribute("mcp.prompt.result.roles", ",".join(unique_roles))
                         span.set_attribute(
                             "mcp.prompt.result.role_counts",
                             str({role: roles.count(role) for role in unique_roles}),
@@ -727,20 +1081,17 @@ def instrument_prompt(func: Callable[..., T], prompt_name: str) -> Callable[...,
                 raise
 
     @functools.wraps(func)
-    def sync_wrapper(*args, **kwargs):
+    def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
         # Create a more descriptive span name
         span_name = f"mcp.prompt.{prompt_name}.generate"
         with tracer.start_as_current_span(span_name) as span:
-            # Add comprehensive attributes
+            # Add essential attributes only
             span.set_attribute("mcp.component.type", "prompt")
-            span.set_attribute("mcp.component.name", prompt_name)
             span.set_attribute("mcp.prompt.name", prompt_name)
-            span.set_attribute("mcp.prompt.function", func.__name__)
             span.set_attribute(
                 "mcp.prompt.module",
                 func.__module__ if hasattr(func, "__module__") else "unknown",
             )
-            span.set_attribute("mcp.execution.async", False)
 
             # Extract Context parameter if present
             ctx = kwargs.get("ctx")
@@ -772,9 +1123,7 @@ def instrument_prompt(func: Callable[..., T], prompt_name: str) -> Callable[...,
                 span.set_status(Status(StatusCode.OK))
 
                 # Add event for successful generation
-                span.add_event(
-                    "prompt.generation.completed", {"prompt.name": prompt_name}
-                )
+                span.add_event("prompt.generation.completed", {"prompt.name": prompt_name})
 
                 # Add message count and type information
                 if isinstance(result, list):
@@ -791,9 +1140,7 @@ def instrument_prompt(func: Callable[..., T], prompt_name: str) -> Callable[...,
 
                     if roles:
                         unique_roles = list(set(roles))
-                        span.set_attribute(
-                            "mcp.prompt.result.roles", ",".join(unique_roles)
-                        )
+                        span.set_attribute("mcp.prompt.result.roles", ",".join(unique_roles))
                         span.set_attribute(
                             "mcp.prompt.result.role_counts",
                             str({role: roles.count(role) for role in unique_roles}),
@@ -830,7 +1177,7 @@ def instrument_prompt(func: Callable[..., T], prompt_name: str) -> Callable[...,
 class BoundedSessionTracker:
     """Memory-safe session tracker with automatic expiration."""
 
-    def __init__(self, max_sessions: int = 1000, session_ttl: int = 3600):
+    def __init__(self, max_sessions: int = 1000, session_ttl: int = 3600) -> None:
         self.max_sessions = max_sessions
         self.session_ttl = session_ttl
         self.sessions: OrderedDict[str, float] = OrderedDict()
@@ -860,13 +1207,9 @@ class BoundedSessionTracker:
 
         return True
 
-    def _cleanup_expired(self, current_time: float):
+    def _cleanup_expired(self, current_time: float) -> None:
         """Remove expired sessions."""
-        expired = [
-            sid
-            for sid, timestamp in self.sessions.items()
-            if current_time - timestamp > self.session_ttl
-        ]
+        expired = [sid for sid, timestamp in self.sessions.items() if current_time - timestamp > self.session_ttl]
         for sid in expired:
             del self.sessions[sid]
 
@@ -875,14 +1218,12 @@ class BoundedSessionTracker:
 
 
 class SessionTracingMiddleware(BaseHTTPMiddleware):
-    def __init__(self, app):
+    def __init__(self, app: Any) -> None:
         super().__init__(app)
         # Use memory-safe session tracker instead of unbounded collections
-        self.session_tracker = BoundedSessionTracker(
-            max_sessions=1000, session_ttl=3600
-        )
+        self.session_tracker = BoundedSessionTracker(max_sessions=1000, session_ttl=3600)
 
-    async def dispatch(self, request: Request, call_next):
+    async def dispatch(self, request: Any, call_next: Callable[..., Any]) -> Any:
         # Record HTTP request timing
         import time
 
@@ -912,7 +1253,8 @@ class SessionTracingMiddleware(BaseHTTPMiddleware):
                     from golf.metrics import get_metrics_collector
 
                     metrics_collector = get_metrics_collector()
-                    # Use a default duration since we don't track exact start times anymore
+                    # Use a default duration since we don't track exact start
+                    # times anymore
                     # This is less precise but memory-safe
                     metrics_collector.record_session_duration(300.0)  # 5 min default
                 except ImportError:
@@ -935,15 +1277,10 @@ class SessionTracingMiddleware(BaseHTTPMiddleware):
 
         tracer = get_tracer()
         with tracer.start_as_current_span(span_name) as span:
-            # Add comprehensive HTTP attributes
+            # Add essential HTTP attributes
             span.set_attribute("http.method", method)
-            span.set_attribute("http.url", str(request.url))
-            span.set_attribute("http.scheme", request.url.scheme)
-            span.set_attribute("http.host", request.url.hostname or "unknown")
             span.set_attribute("http.target", path)
-            span.set_attribute(
-                "http.user_agent", request.headers.get("user-agent", "unknown")
-            )
+            span.set_attribute("http.host", request.url.hostname or "unknown")
 
             # Add session tracking
             if session_id:
@@ -973,15 +1310,10 @@ class SessionTracingMiddleware(BaseHTTPMiddleware):
 
                 # Add response attributes
                 span.set_attribute("http.status_code", response.status_code)
-                span.set_attribute(
-                    "http.status_class", f"{response.status_code // 100}xx"
-                )
 
                 # Set span status based on HTTP status
                 if response.status_code >= 400:
-                    span.set_status(
-                        Status(StatusCode.ERROR, f"HTTP {response.status_code}")
-                    )
+                    span.set_status(Status(StatusCode.ERROR, f"HTTP {response.status_code}"))
                 else:
                     span.set_status(Status(StatusCode.OK))
 
@@ -1004,16 +1336,10 @@ class SessionTracingMiddleware(BaseHTTPMiddleware):
                     # Clean up path for metrics (remove query params, normalize)
                     clean_path = path.split("?")[0]  # Remove query parameters
                     if clean_path.startswith("/"):
-                        clean_path = (
-                            clean_path[1:] or "root"
-                        )  # Remove leading slash, handle root
-
-                    metrics_collector.increment_http_request(
-                        method, response.status_code, clean_path
-                    )
-                    metrics_collector.record_http_duration(
-                        method, clean_path, time.time() - start_time
-                    )
+                        clean_path = clean_path[1:] or "root"  # Remove leading slash, handle root
+
+                    metrics_collector.increment_http_request(method, response.status_code, clean_path)
+                    metrics_collector.record_http_duration(method, clean_path, time.time() - start_time)
                 except ImportError:
                     # Metrics not available, continue without metrics
                     pass
@@ -1045,9 +1371,7 @@ class SessionTracingMiddleware(BaseHTTPMiddleware):
                     if clean_path.startswith("/"):
                         clean_path = clean_path[1:] or "root"
 
-                    metrics_collector.increment_http_request(
-                        method, 500, clean_path
-                    )  # Assume 500 for exceptions
+                    metrics_collector.increment_http_request(method, 500, clean_path)  # Assume 500 for exceptions
                     metrics_collector.increment_error("http", type(e).__name__)
                 except ImportError:
                     pass
@@ -1059,7 +1383,7 @@ class SessionTracingMiddleware(BaseHTTPMiddleware):
 
 
 @asynccontextmanager
-async def telemetry_lifespan(mcp_instance):
+async def telemetry_lifespan(mcp_instance: Any) -> AsyncGenerator[None, None]:
     """Simplified lifespan for telemetry initialization and cleanup."""
     global _provider
 
@@ -1081,9 +1405,7 @@ async def telemetry_lifespan(mcp_instance):
                 app.add_middleware(SessionTracingMiddleware)
 
         # Also try to instrument FastMCP's internal handlers
-        if hasattr(mcp_instance, "_tool_manager") and hasattr(
-            mcp_instance._tool_manager, "tools"
-        ):
+        if hasattr(mcp_instance, "_tool_manager") and hasattr(mcp_instance._tool_manager, "tools"):
             # The tools should already be instrumented when they were registered
             pass
 
@@ -1091,7 +1413,7 @@ async def telemetry_lifespan(mcp_instance):
         if hasattr(mcp_instance, "handle_request"):
             original_handle_request = mcp_instance.handle_request
 
-            async def traced_handle_request(*args, **kwargs):
+            async def traced_handle_request(*args: Any, **kwargs: Any) -> Any:
                 tracer = get_tracer()
                 with tracer.start_as_current_span("mcp.handle_request") as span:
                     span.set_attribute("mcp.request.handler", "handle_request")