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

golf/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.17"
+__version__ = "0.1.19"

golf/core/builder.py

@@ -562,6 +562,18 @@ class CodeGenerator:
         if self.settings.opentelemetry_enabled:
             imports.extend(generate_telemetry_imports())
 
+        # Add metrics imports if enabled
+        if self.settings.metrics_enabled:
+            from golf.core.builder_metrics import (
+                generate_metrics_imports,
+                generate_metrics_instrumentation,
+                generate_session_tracking,
+            )
+
+            imports.extend(generate_metrics_imports())
+            imports.extend(generate_metrics_instrumentation())
+            imports.extend(generate_session_tracking())
+
         # Add health check imports if enabled
         if self.settings.health_check_enabled:
             imports.extend(
@@ -672,6 +684,44 @@ class CodeGenerator:
                         f"{full_module_path}.{entry_func}, '{component.name}')"
                     )
 
+                    if component_type == ComponentType.TOOL:
+                        registration += (
+                            f'\nmcp.add_tool(_wrapped_func, name="{component.name}", '
+                            f'description="{component.docstring or ""}"'
+                        )
+                        # Add annotations if present
+                        if hasattr(component, "annotations") and component.annotations:
+                            registration += f", annotations={component.annotations}"
+                        registration += ")"
+                    elif component_type == ComponentType.RESOURCE:
+                        registration += (
+                            f"\nmcp.add_resource_fn(_wrapped_func, "
+                            f'uri="{component.uri_template}", name="{component.name}", '
+                            f'description="{component.docstring or ""}")'
+                        )
+                    else:  # PROMPT
+                        registration += (
+                            f'\nmcp.add_prompt(_wrapped_func, name="{component.name}", '
+                            f'description="{component.docstring or ""}")'
+                        )
+                elif self.settings.metrics_enabled:
+                    # Use metrics instrumentation
+                    registration = (
+                        f"# Register the {component_type.value} "
+                        f"'{component.name}' with metrics"
+                    )
+                    entry_func = (
+                        component.entry_function
+                        if hasattr(component, "entry_function")
+                        and component.entry_function
+                        else "export"
+                    )
+
+                    registration += (
+                        f"\n_wrapped_func = instrument_{component_type.value}("
+                        f"{full_module_path}.{entry_func}, '{component.name}')"
+                    )
+
                     if component_type == ComponentType.TOOL:
                         registration += (
                             f'\nmcp.add_tool(_wrapped_func, name="{component.name}", '
@@ -826,6 +876,15 @@ class CodeGenerator:
                 ]
             )
 
+        # Add metrics initialization if enabled
+        early_metrics_init = []
+        if self.settings.metrics_enabled:
+            from golf.core.builder_metrics import generate_metrics_initialization
+
+            early_metrics_init.extend(
+                generate_metrics_initialization(self.settings.name)
+            )
+
         # Main entry point with transport-specific app initialization
         main_code = [
             'if __name__ == "__main__":',
@@ -864,6 +923,13 @@ class CodeGenerator:
                 )
                 middleware_list.append("Middleware(ApiKeyMiddleware)")
 
+            # Add metrics middleware if enabled
+            if self.settings.metrics_enabled:
+                middleware_setup.append(
+                    "    from starlette.middleware import Middleware"
+                )
+                middleware_list.append("Middleware(MetricsMiddleware)")
+
             # Add OpenTelemetry middleware if enabled
             if self.settings.opentelemetry_enabled:
                 middleware_setup.append(
@@ -904,6 +970,13 @@ class CodeGenerator:
                 )
                 middleware_list.append("Middleware(ApiKeyMiddleware)")
 
+            # Add metrics middleware if enabled
+            if self.settings.metrics_enabled:
+                middleware_setup.append(
+                    "    from starlette.middleware import Middleware"
+                )
+                middleware_list.append("Middleware(MetricsMiddleware)")
+
             # Add OpenTelemetry middleware if enabled
             if self.settings.opentelemetry_enabled:
                 middleware_setup.append(
@@ -937,6 +1010,13 @@ class CodeGenerator:
                 ["    # Run with stdio transport", '    mcp.run(transport="stdio")']
             )
 
+        # Add metrics route if enabled
+        metrics_route_code = []
+        if self.settings.metrics_enabled:
+            from golf.core.builder_metrics import generate_metrics_route
+
+            metrics_route_code = generate_metrics_route(self.settings.metrics_path)
+
         # Add health check route if enabled
         health_check_code = []
         if self.settings.health_check_enabled:
@@ -953,14 +1033,16 @@ class CodeGenerator:
 
         # Combine all sections
         # Order: imports, env_section, auth_setup, server_code (mcp init),
-        # early_telemetry_init, component_registrations, health_check_code, main_code (run block)
+        # early_telemetry_init, early_metrics_init, component_registrations, metrics_route_code, health_check_code, main_code (run block)
         code = "\n".join(
             imports
             + env_section
             + auth_setup_code
             + server_code_lines
             + early_telemetry_init
+            + early_metrics_init
             + component_registrations
+            + metrics_route_code
             + health_check_code
             + main_code
         )

golf/core/builder_auth.py

@@ -187,6 +187,11 @@ def generate_api_key_auth_components(
         "        # Debug mode from environment",
         "        debug = os.environ.get('GOLF_API_KEY_DEBUG', '').lower() == 'true'",
         "        ",
+        "        # Skip auth for monitoring endpoints",
+        "        path = request.url.path",
+        "        if path in ['/metrics', '/health']:",
+        "            return await call_next(request)",
+        "        ",
         "        api_key_config = get_api_key_config()",
         "        ",
         "        if api_key_config:",

golf/core/builder_metrics.py

@@ -0,0 +1,232 @@
+"""Metrics integration for the GolfMCP build process.
+
+This module provides functions for generating Prometheus metrics initialization
+and collection code for FastMCP servers built with GolfMCP.
+"""
+
+
+def generate_metrics_imports() -> list[str]:
+    """Generate import statements for metrics collection.
+
+    Returns:
+        List of import statements for metrics
+    """
+    return [
+        "# Prometheus metrics imports",
+        "from golf.metrics import init_metrics, get_metrics_collector",
+        "from prometheus_client import generate_latest, CONTENT_TYPE_LATEST",
+        "from starlette.responses import Response",
+        "from starlette.middleware.base import BaseHTTPMiddleware",
+        "from starlette.requests import Request",
+        "import time",
+    ]
+
+
+def generate_metrics_initialization(server_name: str) -> list[str]:
+    """Generate metrics initialization code.
+
+    Args:
+        server_name: Name of the MCP server
+
+    Returns:
+        List of code lines for metrics initialization
+    """
+    return [
+        "# Initialize metrics collection",
+        "init_metrics(enabled=True)",
+        "",
+    ]
+
+
+def generate_metrics_route(metrics_path: str) -> list[str]:
+    """Generate the metrics endpoint route code.
+
+    Args:
+        metrics_path: Path for the metrics endpoint (e.g., "/metrics")
+
+    Returns:
+        List of code lines for the metrics route
+    """
+    return [
+        "# Add metrics endpoint",
+        f'@mcp.custom_route("{metrics_path}", methods=["GET"])',
+        "async def metrics_endpoint(request):",
+        '    """Prometheus metrics endpoint for monitoring."""',
+        "    # Update uptime before returning metrics",
+        "    update_uptime()",
+        "    return Response(generate_latest(), media_type=CONTENT_TYPE_LATEST)",
+        "",
+    ]
+
+
+def get_metrics_dependencies() -> list[str]:
+    """Get list of metrics dependencies to add to pyproject.toml.
+
+    Returns:
+        List of package requirements strings
+    """
+    return [
+        "prometheus-client>=0.19.0",
+    ]
+
+
+def generate_metrics_instrumentation() -> list[str]:
+    """Generate metrics instrumentation wrapper functions.
+
+    Returns:
+        List of code lines for metrics instrumentation
+    """
+    return [
+        "# Metrics instrumentation wrapper functions",
+        "import time",
+        "import functools",
+        "from typing import Any, Callable",
+        "",
+        "def instrument_tool(func: Callable, tool_name: str) -> Callable:",
+        '    """Wrap a tool function with metrics collection."""',
+        "    @functools.wraps(func)",
+        "    async def wrapper(*args, **kwargs) -> Any:",
+        "        collector = get_metrics_collector()",
+        "        start_time = time.time()",
+        "        status = 'success'",
+        "        try:",
+        "            result = await func(*args, **kwargs)",
+        "            return result",
+        "        except Exception as e:",
+        "            status = 'error'",
+        "            collector.increment_error('tool', type(e).__name__)",
+        "            raise",
+        "        finally:",
+        "            duration = time.time() - start_time",
+        "            collector.increment_tool_execution(tool_name, status)",
+        "            collector.record_tool_duration(tool_name, duration)",
+        "    return wrapper",
+        "",
+        "def instrument_resource(func: Callable, resource_name: str) -> Callable:",
+        '    """Wrap a resource function with metrics collection."""',
+        "    @functools.wraps(func)",
+        "    async def wrapper(*args, **kwargs) -> Any:",
+        "        collector = get_metrics_collector()",
+        "        try:",
+        "            result = await func(*args, **kwargs)",
+        "            # Extract URI from args if available for resource_reads metric",
+        "            if args and len(args) > 0:",
+        "                uri = str(args[0]) if args[0] else resource_name",
+        "            else:",
+        "                uri = resource_name",
+        "            collector.increment_resource_read(uri)",
+        "            return result",
+        "        except Exception as e:",
+        "            collector.increment_error('resource', type(e).__name__)",
+        "            raise",
+        "    return wrapper",
+        "",
+        "def instrument_prompt(func: Callable, prompt_name: str) -> Callable:",
+        '    """Wrap a prompt function with metrics collection."""',
+        "    @functools.wraps(func)",
+        "    async def wrapper(*args, **kwargs) -> Any:",
+        "        collector = get_metrics_collector()",
+        "        try:",
+        "            result = await func(*args, **kwargs)",
+        "            collector.increment_prompt_generation(prompt_name)",
+        "            return result",
+        "        except Exception as e:",
+        "            collector.increment_error('prompt', type(e).__name__)",
+        "            raise",
+        "    return wrapper",
+        "",
+        "# HTTP Request Metrics Middleware",
+        "class MetricsMiddleware(BaseHTTPMiddleware):",
+        '    """Middleware to collect HTTP request metrics."""',
+        "",
+        "    async def dispatch(self, request: Request, call_next):",
+        "        collector = get_metrics_collector()",
+        "        start_time = time.time()",
+        "        ",
+        "        # Extract path and method",
+        "        method = request.method",
+        "        path = request.url.path",
+        "        ",
+        "        try:",
+        "            response = await call_next(request)",
+        "            status_code = response.status_code",
+        "        except Exception as e:",
+        "            status_code = 500",
+        "            collector.increment_error('http', type(e).__name__)",
+        "            raise",
+        "        finally:",
+        "            duration = time.time() - start_time",
+        "            collector.increment_http_request(method, status_code, path)",
+        "            collector.record_http_duration(method, path, duration)",
+        "        ",
+        "        return response",
+        "",
+        "# Session tracking helpers",
+        "import atexit",
+        "from contextlib import asynccontextmanager",
+        "",
+        "# Global server start time for uptime tracking",
+        "_server_start_time = time.time()",
+        "",
+        "def track_session_start():",
+        '    """Track when a new session starts."""',
+        "    collector = get_metrics_collector()",
+        "    collector.increment_session()",
+        "",
+        "def track_session_end(start_time: float):",
+        '    """Track when a session ends."""',
+        "    collector = get_metrics_collector()",
+        "    duration = time.time() - start_time",
+        "    collector.record_session_duration(duration)",
+        "",
+        "def update_uptime():",
+        '    """Update the uptime metric."""',
+        "    collector = get_metrics_collector()",
+        "    uptime = time.time() - _server_start_time",
+        "    collector.set_uptime(uptime)",
+        "",
+        "# Initialize uptime tracking",
+        "update_uptime()",
+        "",
+    ]
+
+
+def generate_session_tracking() -> list[str]:
+    """Generate session tracking integration code.
+
+    Returns:
+        List of code lines for session tracking
+    """
+    return [
+        "# Session tracking integration",
+        "import asyncio",
+        "from typing import Dict",
+        "",
+        "# Track active sessions",
+        "_active_sessions: Dict[str, float] = {}",
+        "",
+        "# Hook into FastMCP's session lifecycle if available",
+        "try:",
+        "    from fastmcp.server import SessionManager",
+        "    ",
+        "    # Monkey patch session creation if possible",
+        "    _original_create_session = getattr(mcp, '_create_session', None)",
+        "    if _original_create_session:",
+        "        async def _patched_create_session(*args, **kwargs):",
+        "            session_id = str(id(args)) if args else 'unknown'",
+        "            _active_sessions[session_id] = time.time()",
+        "            track_session_start()",
+        "            try:",
+        "                return await _original_create_session(*args, **kwargs)",
+        "            except Exception:",
+        "                # If session creation fails, clean up",
+        "                if session_id in _active_sessions:",
+        "                    del _active_sessions[session_id]",
+        "                raise",
+        "        ",
+        "        mcp._create_session = _patched_create_session",
+        "except (ImportError, AttributeError):",
+        "    # Fallback: track sessions via request patterns",
+        "    pass",
+        "",
+    ]

golf/core/config.py

@@ -115,6 +115,12 @@ class Settings(BaseSettings):
         description="Make Streamable-HTTP transport stateless (new session per request)",
     )
 
+    # Metrics configuration
+    metrics_enabled: bool = Field(
+        False, description="Enable Prometheus metrics endpoint"
+    )
+    metrics_path: str = Field("/metrics", description="Metrics endpoint path")
+
 
 def find_config_path(start_path: Path | None = None) -> Path | None:
     """Find the golf config file by searching upwards from the given path.

golf/metrics/__init__.py

@@ -0,0 +1,10 @@
+"""Golf metrics module for Prometheus-compatible metrics collection."""
+
+from golf.metrics.collector import MetricsCollector, get_metrics_collector
+from golf.metrics.registry import init_metrics
+
+__all__ = [
+    "MetricsCollector",
+    "get_metrics_collector",
+    "init_metrics",
+]

golf/metrics/collector.py

@@ -0,0 +1,239 @@
+"""Metrics collector for Golf MCP servers."""
+
+from typing import Optional
+
+# Global metrics collector instance
+_metrics_collector: Optional["MetricsCollector"] = None
+
+
+class MetricsCollector:
+    """Collects metrics for Golf MCP servers using Prometheus client."""
+
+    def __init__(self, enabled: bool = False) -> None:
+        """Initialize the metrics collector.
+
+        Args:
+            enabled: Whether metrics collection is enabled
+        """
+        self.enabled = enabled
+        self._metrics = {}
+
+        if self.enabled:
+            self._init_prometheus_metrics()
+
+    def _init_prometheus_metrics(self) -> None:
+        """Initialize Prometheus metrics if enabled."""
+        try:
+            from prometheus_client import Counter, Histogram, Gauge
+
+            # Tool execution metrics
+            self._metrics["tool_executions"] = Counter(
+                "golf_tool_executions_total",
+                "Total number of tool executions",
+                ["tool_name", "status"],
+            )
+
+            self._metrics["tool_duration"] = Histogram(
+                "golf_tool_duration_seconds",
+                "Tool execution duration in seconds",
+                ["tool_name"],
+            )
+
+            # HTTP request metrics
+            self._metrics["http_requests"] = Counter(
+                "golf_http_requests_total",
+                "Total number of HTTP requests",
+                ["method", "status_code", "path"],
+            )
+
+            self._metrics["http_duration"] = Histogram(
+                "golf_http_request_duration_seconds",
+                "HTTP request duration in seconds",
+                ["method", "path"],
+            )
+
+            # Resource access metrics
+            self._metrics["resource_reads"] = Counter(
+                "golf_resource_reads_total",
+                "Total number of resource reads",
+                ["resource_uri"],
+            )
+
+            # Prompt generation metrics
+            self._metrics["prompt_generations"] = Counter(
+                "golf_prompt_generations_total",
+                "Total number of prompt generations",
+                ["prompt_name"],
+            )
+
+            # Error metrics
+            self._metrics["errors"] = Counter(
+                "golf_errors_total",
+                "Total number of errors",
+                ["component_type", "error_type"],
+            )
+
+            # Session metrics
+            self._metrics["sessions_total"] = Counter(
+                "golf_sessions_total", "Total number of sessions created"
+            )
+
+            self._metrics["session_duration"] = Histogram(
+                "golf_session_duration_seconds", "Session duration in seconds"
+            )
+
+            # System metrics
+            self._metrics["uptime"] = Gauge(
+                "golf_uptime_seconds", "Server uptime in seconds"
+            )
+
+        except ImportError:
+            # Prometheus client not available, disable metrics
+            self.enabled = False
+
+    def increment_tool_execution(self, tool_name: str, status: str) -> None:
+        """Record a tool execution.
+
+        Args:
+            tool_name: Name of the tool that was executed
+            status: Execution status ('success' or 'error')
+        """
+        if not self.enabled or "tool_executions" not in self._metrics:
+            return
+
+        self._metrics["tool_executions"].labels(
+            tool_name=tool_name, status=status
+        ).inc()
+
+    def record_tool_duration(self, tool_name: str, duration: float) -> None:
+        """Record tool execution duration.
+
+        Args:
+            tool_name: Name of the tool
+            duration: Execution duration in seconds
+        """
+        if not self.enabled or "tool_duration" not in self._metrics:
+            return
+
+        self._metrics["tool_duration"].labels(tool_name=tool_name).observe(duration)
+
+    def increment_http_request(self, method: str, status_code: int, path: str) -> None:
+        """Record an HTTP request.
+
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            status_code: HTTP status code
+            path: Request path
+        """
+        if not self.enabled or "http_requests" not in self._metrics:
+            return
+
+        self._metrics["http_requests"].labels(
+            method=method, status_code=str(status_code), path=path
+        ).inc()
+
+    def record_http_duration(self, method: str, path: str, duration: float) -> None:
+        """Record HTTP request duration.
+
+        Args:
+            method: HTTP method
+            path: Request path
+            duration: Request duration in seconds
+        """
+        if not self.enabled or "http_duration" not in self._metrics:
+            return
+
+        self._metrics["http_duration"].labels(method=method, path=path).observe(
+            duration
+        )
+
+    def increment_resource_read(self, resource_uri: str) -> None:
+        """Record a resource read.
+
+        Args:
+            resource_uri: URI of the resource that was read
+        """
+        if not self.enabled or "resource_reads" not in self._metrics:
+            return
+
+        self._metrics["resource_reads"].labels(resource_uri=resource_uri).inc()
+
+    def increment_prompt_generation(self, prompt_name: str) -> None:
+        """Record a prompt generation.
+
+        Args:
+            prompt_name: Name of the prompt that was generated
+        """
+        if not self.enabled or "prompt_generations" not in self._metrics:
+            return
+
+        self._metrics["prompt_generations"].labels(prompt_name=prompt_name).inc()
+
+    def increment_error(self, component_type: str, error_type: str) -> None:
+        """Record an error.
+
+        Args:
+            component_type: Type of component ('tool', 'resource', 'prompt', 'http')
+            error_type: Type of error ('timeout', 'auth_error', 'validation_error', etc.)
+        """
+        if not self.enabled or "errors" not in self._metrics:
+            return
+
+        self._metrics["errors"].labels(
+            component_type=component_type, error_type=error_type
+        ).inc()
+
+    def increment_session(self) -> None:
+        """Record a new session."""
+        if not self.enabled or "sessions_total" not in self._metrics:
+            return
+
+        self._metrics["sessions_total"].inc()
+
+    def record_session_duration(self, duration: float) -> None:
+        """Record session duration.
+
+        Args:
+            duration: Session duration in seconds
+        """
+        if not self.enabled or "session_duration" not in self._metrics:
+            return
+
+        self._metrics["session_duration"].observe(duration)
+
+    def set_uptime(self, seconds: float) -> None:
+        """Set the server uptime.
+
+        Args:
+            seconds: Server uptime in seconds
+        """
+        if not self.enabled or "uptime" not in self._metrics:
+            return
+
+        self._metrics["uptime"].set(seconds)
+
+
+def init_metrics_collector(enabled: bool = False) -> MetricsCollector:
+    """Initialize the global metrics collector.
+
+    Args:
+        enabled: Whether to enable metrics collection
+
+    Returns:
+        The initialized metrics collector
+    """
+    global _metrics_collector
+    _metrics_collector = MetricsCollector(enabled=enabled)
+    return _metrics_collector
+
+
+def get_metrics_collector() -> MetricsCollector:
+    """Get the global metrics collector instance.
+
+    Returns:
+        The metrics collector, or a disabled one if not initialized
+    """
+    global _metrics_collector
+    if _metrics_collector is None:
+        _metrics_collector = MetricsCollector(enabled=False)
+    return _metrics_collector

golf/metrics/registry.py

@@ -0,0 +1,12 @@
+"""Metrics registry for Golf MCP servers."""
+
+from golf.metrics.collector import init_metrics_collector
+
+
+def init_metrics(enabled: bool = False) -> None:
+    """Initialize the metrics system.
+
+    Args:
+        enabled: Whether to enable metrics collection
+    """
+    init_metrics_collector(enabled=enabled)

golf/telemetry/instrumentation.py

@@ -4,9 +4,11 @@ import asyncio
 import functools
 import os
 import sys
+import time
 from collections.abc import Callable
 from contextlib import asynccontextmanager
 from typing import TypeVar
+from collections import OrderedDict
 
 from opentelemetry import baggage, trace
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
@@ -15,6 +17,9 @@ from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
 from opentelemetry.trace import Status, StatusCode
 
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+
 T = TypeVar("T")
 
 # Global tracer instance
@@ -163,6 +168,11 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
 
     @functools.wraps(func)
     async def async_wrapper(*args, **kwargs):
+        # Record metrics timing
+        import time
+
+        start_time = time.time()
+
         # Create a more descriptive span name
         span_name = f"mcp.tool.{tool_name}.execute"
 
@@ -205,45 +215,6 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
             if session_id_from_baggage:
                 span.set_attribute("mcp.session.id", session_id_from_baggage)
 
-            # Add tool arguments as span attributes (be careful with sensitive data)
-            for i, arg in enumerate(args):
-                if isinstance(arg, str | int | float | bool) or arg is None:
-                    span.set_attribute(f"mcp.tool.arg.{i}", str(arg))
-                elif hasattr(arg, "__dict__"):
-                    # For objects, just record the type
-                    span.set_attribute(f"mcp.tool.arg.{i}.type", type(arg).__name__)
-
-            # Add named arguments with better naming
-            for key, value in kwargs.items():
-                if key != "ctx":
-                    if value is None:
-                        span.set_attribute(f"mcp.tool.input.{key}", "null")
-                    elif isinstance(value, str | int | float | bool):
-                        span.set_attribute(f"mcp.tool.input.{key}", str(value))
-                    elif isinstance(value, list | tuple):
-                        span.set_attribute(f"mcp.tool.input.{key}.count", len(value))
-                        span.set_attribute(f"mcp.tool.input.{key}.type", "array")
-                    elif isinstance(value, dict):
-                        span.set_attribute(f"mcp.tool.input.{key}.count", len(value))
-                        span.set_attribute(f"mcp.tool.input.{key}.type", "object")
-                        # Only show first few keys to avoid exceeding attribute limits
-                        if len(value) > 0 and len(value) <= 5:
-                            keys_list = list(value.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(
-                                f"mcp.tool.input.{key}.sample_keys",
-                                ",".join(truncated_keys),
-                            )
-                    else:
-                        # For other types, at least record the type
-                        span.set_attribute(
-                            f"mcp.tool.input.{key}.type", type(value).__name__
-                        )
-
             # Add event for tool execution start
             span.add_event("tool.execution.started", {"tool.name": tool_name})
 
@@ -254,6 +225,19 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
                 # Add event for successful completion
                 span.add_event("tool.execution.completed", {"tool.name": tool_name})
 
+                # Record metrics for successful execution
+                try:
+                    from golf.metrics import get_metrics_collector
+
+                    metrics_collector = get_metrics_collector()
+                    metrics_collector.increment_tool_execution(tool_name, "success")
+                    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
                 if result is not None:
                     if isinstance(result, str | int | float | bool):
@@ -298,10 +282,27 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
                         "error.message": str(e),
                     },
                 )
+
+                # Record metrics for failed execution
+                try:
+                    from golf.metrics import get_metrics_collector
+
+                    metrics_collector = get_metrics_collector()
+                    metrics_collector.increment_tool_execution(tool_name, "error")
+                    metrics_collector.increment_error("tool", type(e).__name__)
+                except ImportError:
+                    # Metrics not available, continue without metrics
+                    pass
+
                 raise
 
     @functools.wraps(func)
     def sync_wrapper(*args, **kwargs):
+        # Record metrics timing
+        import time
+
+        start_time = time.time()
+
         # Create a more descriptive span name
         span_name = f"mcp.tool.{tool_name}.execute"
 
@@ -344,45 +345,6 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
             if session_id_from_baggage:
                 span.set_attribute("mcp.session.id", session_id_from_baggage)
 
-            # Add tool arguments as span attributes (be careful with sensitive data)
-            for i, arg in enumerate(args):
-                if isinstance(arg, str | int | float | bool) or arg is None:
-                    span.set_attribute(f"mcp.tool.arg.{i}", str(arg))
-                elif hasattr(arg, "__dict__"):
-                    # For objects, just record the type
-                    span.set_attribute(f"mcp.tool.arg.{i}.type", type(arg).__name__)
-
-            # Add named arguments with better naming
-            for key, value in kwargs.items():
-                if key != "ctx":
-                    if value is None:
-                        span.set_attribute(f"mcp.tool.input.{key}", "null")
-                    elif isinstance(value, str | int | float | bool):
-                        span.set_attribute(f"mcp.tool.input.{key}", str(value))
-                    elif isinstance(value, list | tuple):
-                        span.set_attribute(f"mcp.tool.input.{key}.count", len(value))
-                        span.set_attribute(f"mcp.tool.input.{key}.type", "array")
-                    elif isinstance(value, dict):
-                        span.set_attribute(f"mcp.tool.input.{key}.count", len(value))
-                        span.set_attribute(f"mcp.tool.input.{key}.type", "object")
-                        # Only show first few keys to avoid exceeding attribute limits
-                        if len(value) > 0 and len(value) <= 5:
-                            keys_list = list(value.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(
-                                f"mcp.tool.input.{key}.sample_keys",
-                                ",".join(truncated_keys),
-                            )
-                    else:
-                        # For other types, at least record the type
-                        span.set_attribute(
-                            f"mcp.tool.input.{key}.type", type(value).__name__
-                        )
-
             # Add event for tool execution start
             span.add_event("tool.execution.started", {"tool.name": tool_name})
 
@@ -393,6 +355,19 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
                 # Add event for successful completion
                 span.add_event("tool.execution.completed", {"tool.name": tool_name})
 
+                # Record metrics for successful execution
+                try:
+                    from golf.metrics import get_metrics_collector
+
+                    metrics_collector = get_metrics_collector()
+                    metrics_collector.increment_tool_execution(tool_name, "success")
+                    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
                 if result is not None:
                     if isinstance(result, str | int | float | bool):
@@ -437,6 +412,18 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
                         "error.message": str(e),
                     },
                 )
+
+                # Record metrics for failed execution
+                try:
+                    from golf.metrics import get_metrics_collector
+
+                    metrics_collector = get_metrics_collector()
+                    metrics_collector.increment_tool_execution(tool_name, "error")
+                    metrics_collector.increment_error("tool", type(e).__name__)
+                except ImportError:
+                    # Metrics not available, continue without metrics
+                    pass
+
                 raise
 
     # Return appropriate wrapper based on function type
@@ -683,16 +670,6 @@ def instrument_prompt(func: Callable[..., T], prompt_name: str) -> Callable[...,
             if session_id_from_baggage:
                 span.set_attribute("mcp.session.id", session_id_from_baggage)
 
-            # Add prompt arguments
-            for key, value in kwargs.items():
-                if key != "ctx":
-                    if isinstance(value, str | int | float | bool) or value is None:
-                        span.set_attribute(f"mcp.prompt.arg.{key}", str(value))
-                    else:
-                        span.set_attribute(
-                            f"mcp.prompt.arg.{key}.type", type(value).__name__
-                        )
-
             # Add event for prompt generation start
             span.add_event("prompt.generation.started", {"prompt.name": prompt_name})
 
@@ -787,16 +764,6 @@ def instrument_prompt(func: Callable[..., T], prompt_name: str) -> Callable[...,
             if session_id_from_baggage:
                 span.set_attribute("mcp.session.id", session_id_from_baggage)
 
-            # Add prompt arguments
-            for key, value in kwargs.items():
-                if key != "ctx":
-                    if isinstance(value, str | int | float | bool) or value is None:
-                        span.set_attribute(f"mcp.prompt.arg.{key}", str(value))
-                    else:
-                        span.set_attribute(
-                            f"mcp.prompt.arg.{key}.type", type(value).__name__
-                        )
-
             # Add event for prompt generation start
             span.add_event("prompt.generation.started", {"prompt.name": prompt_name})
 
@@ -859,6 +826,238 @@ def instrument_prompt(func: Callable[..., T], prompt_name: str) -> Callable[...,
         return sync_wrapper
 
 
+# Add the BoundedSessionTracker class before SessionTracingMiddleware
+class BoundedSessionTracker:
+    """Memory-safe session tracker with automatic expiration."""
+
+    def __init__(self, max_sessions: int = 1000, session_ttl: int = 3600):
+        self.max_sessions = max_sessions
+        self.session_ttl = session_ttl
+        self.sessions: OrderedDict[str, float] = OrderedDict()
+        self.last_cleanup = time.time()
+
+    def track_session(self, session_id: str) -> bool:
+        """Track a session, returns True if it's new."""
+        current_time = time.time()
+
+        # Periodic cleanup (every 5 minutes)
+        if current_time - self.last_cleanup > 300:
+            self._cleanup_expired(current_time)
+            self.last_cleanup = current_time
+
+        # Check if session exists and is still valid
+        if session_id in self.sessions:
+            # Move to end (mark as recently used)
+            self.sessions.move_to_end(session_id)
+            return False
+
+        # New session
+        self.sessions[session_id] = current_time
+
+        # Enforce max size
+        while len(self.sessions) > self.max_sessions:
+            self.sessions.popitem(last=False)  # Remove oldest
+
+        return True
+
+    def _cleanup_expired(self, current_time: float):
+        """Remove expired sessions."""
+        expired = [
+            sid
+            for sid, timestamp in self.sessions.items()
+            if current_time - timestamp > self.session_ttl
+        ]
+        for sid in expired:
+            del self.sessions[sid]
+
+    def get_active_session_count(self) -> int:
+        return len(self.sessions)
+
+
+class SessionTracingMiddleware(BaseHTTPMiddleware):
+    def __init__(self, app):
+        super().__init__(app)
+        # Use memory-safe session tracker instead of unbounded collections
+        self.session_tracker = BoundedSessionTracker(
+            max_sessions=1000, session_ttl=3600
+        )
+
+    async def dispatch(self, request: Request, call_next):
+        # Record HTTP request timing
+        import time
+
+        start_time = time.time()
+
+        # Extract session ID from query params or headers
+        session_id = request.query_params.get("session_id")
+        if not session_id:
+            # Check headers as fallback
+            session_id = request.headers.get("x-session-id")
+
+        # Track session metrics using memory-safe tracker
+        if session_id:
+            is_new_session = self.session_tracker.track_session(session_id)
+
+            if is_new_session:
+                try:
+                    from golf.metrics import get_metrics_collector
+
+                    metrics_collector = get_metrics_collector()
+                    metrics_collector.increment_session()
+                except ImportError:
+                    pass
+            else:
+                # Record session duration for existing sessions
+                try:
+                    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
+                    # This is less precise but memory-safe
+                    metrics_collector.record_session_duration(300.0)  # 5 min default
+                except ImportError:
+                    pass
+
+        # Create a descriptive span name based on the request
+        method = request.method
+        path = request.url.path
+
+        # Determine the operation type from the path
+        operation_type = "unknown"
+        if "/mcp" in path:
+            operation_type = "mcp.request"
+        elif "/sse" in path:
+            operation_type = "sse.stream"
+        elif "/auth" in path:
+            operation_type = "auth"
+
+        span_name = f"{operation_type}.{method.lower()}"
+
+        tracer = get_tracer()
+        with tracer.start_as_current_span(span_name) as span:
+            # Add comprehensive 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")
+            )
+
+            # Add session tracking
+            if session_id:
+                span.set_attribute("mcp.session.id", session_id)
+                span.set_attribute(
+                    "mcp.session.active_count",
+                    self.session_tracker.get_active_session_count(),
+                )
+                # Add to baggage for propagation
+                ctx = baggage.set_baggage("mcp.session.id", session_id)
+                from opentelemetry import context
+
+                token = context.attach(ctx)
+            else:
+                token = None
+
+            # Add request size if available
+            content_length = request.headers.get("content-length")
+            if content_length:
+                span.set_attribute("http.request.size", int(content_length))
+
+            # Add event for request start
+            span.add_event("http.request.started", {"method": method, "path": path})
+
+            try:
+                response = await call_next(request)
+
+                # 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}")
+                    )
+                else:
+                    span.set_status(Status(StatusCode.OK))
+
+                # Add event for request completion
+                span.add_event(
+                    "http.request.completed",
+                    {
+                        "method": method,
+                        "path": path,
+                        "status_code": response.status_code,
+                    },
+                )
+
+                # Record HTTP request metrics
+                try:
+                    from golf.metrics import get_metrics_collector
+
+                    metrics_collector = get_metrics_collector()
+
+                    # 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
+                    )
+                except ImportError:
+                    # Metrics not available, continue without metrics
+                    pass
+
+                return response
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+
+                # Add event for error
+                span.add_event(
+                    "http.request.error",
+                    {
+                        "method": method,
+                        "path": path,
+                        "error.type": type(e).__name__,
+                        "error.message": str(e),
+                    },
+                )
+
+                # Record HTTP error metrics
+                try:
+                    from golf.metrics import get_metrics_collector
+
+                    metrics_collector = get_metrics_collector()
+
+                    # Clean up path for metrics
+                    clean_path = path.split("?")[0]
+                    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_error("http", type(e).__name__)
+                except ImportError:
+                    pass
+
+                raise
+            finally:
+                if token:
+                    context.detach(token)
+
+
 @asynccontextmanager
 async def telemetry_lifespan(mcp_instance):
     """Simplified lifespan for telemetry initialization and cleanup."""
@@ -875,112 +1074,6 @@ async def telemetry_lifespan(mcp_instance):
 
     # Try to add session tracking middleware if possible
     try:
-        from starlette.middleware.base import BaseHTTPMiddleware
-        from starlette.requests import Request
-
-        class SessionTracingMiddleware(BaseHTTPMiddleware):
-            async def dispatch(self, request: Request, call_next):
-                # Extract session ID from query params or headers
-                session_id = request.query_params.get("session_id")
-                if not session_id:
-                    # Check headers as fallback
-                    session_id = request.headers.get("x-session-id")
-
-                # Create a descriptive span name based on the request
-                method = request.method
-                path = request.url.path
-
-                # Determine the operation type from the path
-                operation_type = "unknown"
-                if "/mcp" in path:
-                    operation_type = "mcp.request"
-                elif "/sse" in path:
-                    operation_type = "sse.stream"
-                elif "/auth" in path:
-                    operation_type = "auth"
-
-                span_name = f"{operation_type}.{method.lower()}"
-
-                tracer = get_tracer()
-                with tracer.start_as_current_span(span_name) as span:
-                    # Add comprehensive 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")
-                    )
-
-                    # Add session tracking
-                    if session_id:
-                        span.set_attribute("mcp.session.id", session_id)
-                        # Add to baggage for propagation
-                        ctx = baggage.set_baggage("mcp.session.id", session_id)
-                        from opentelemetry import context
-
-                        token = context.attach(ctx)
-                    else:
-                        token = None
-
-                    # Add request size if available
-                    content_length = request.headers.get("content-length")
-                    if content_length:
-                        span.set_attribute("http.request.size", int(content_length))
-
-                    # Add event for request start
-                    span.add_event(
-                        "http.request.started", {"method": method, "path": path}
-                    )
-
-                    try:
-                        response = await call_next(request)
-
-                        # 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}")
-                            )
-                        else:
-                            span.set_status(Status(StatusCode.OK))
-
-                        # Add event for request completion
-                        span.add_event(
-                            "http.request.completed",
-                            {
-                                "method": method,
-                                "path": path,
-                                "status_code": response.status_code,
-                            },
-                        )
-
-                        return response
-                    except Exception as e:
-                        span.record_exception(e)
-                        span.set_status(Status(StatusCode.ERROR, str(e)))
-
-                        # Add event for error
-                        span.add_event(
-                            "http.request.error",
-                            {
-                                "method": method,
-                                "path": path,
-                                "error.type": type(e).__name__,
-                                "error.message": str(e),
-                            },
-                        )
-                        raise
-                    finally:
-                        if token:
-                            context.detach(token)
-
         # Try to add middleware to FastMCP app if it has Starlette app
         if hasattr(mcp_instance, "app") or hasattr(mcp_instance, "_app"):
             app = getattr(mcp_instance, "app", getattr(mcp_instance, "_app", None))

{golf_mcp-0.1.17.dist-info → golf_mcp-0.1.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: golf-mcp
-Version: 0.1.17
+Version: 0.1.19
 Summary: Framework for building MCP servers
 Author-email: Antoni Gmitruk <antoni@golf.dev>
 License-Expression: Apache-2.0
@@ -34,6 +34,8 @@ Requires-Dist: opentelemetry-sdk>=1.33.1; extra == "telemetry"
 Requires-Dist: opentelemetry-instrumentation-asgi>=0.40b0; extra == "telemetry"
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=0.40b0; extra == "telemetry"
 Requires-Dist: wrapt>=1.17.0; extra == "telemetry"
+Provides-Extra: metrics
+Requires-Dist: prometheus-client>=0.22.1; extra == "metrics"
 Dynamic: license-file
 
 <div align="center">

{golf_mcp-0.1.17.dist-info → golf_mcp-0.1.19.dist-info}/RECORD

@@ -1,4 +1,4 @@
-golf/__init__.py,sha256=BzIjnki8Bz3evNWo6bjGxxpLhy_tN9MRYhtM0MnDiWs,23
+golf/__init__.py,sha256=cAJAbAh288a9AL-3yxwFzEM1L26izSJ6wma5aiml_9Y,23
 golf/auth/__init__.py,sha256=Rj4yUngJklk6xrDCrxqLTtoDAMzF1HcTvy_l8wREeao,4103
 golf/auth/api_key.py,sha256=LiIraLiH2v7s3yavidaI6BDlAEfK8XnWF15QmaJn9G4,2378
 golf/auth/helpers.py,sha256=ZogdcHM7J2PN6cL6F6OLZ3gyoUR3dwAFDxOJQ2DW_bc,6526
@@ -11,10 +11,11 @@ golf/commands/build.py,sha256=jhdxB5EwwCC_8PgqdXLUKuBpnycjh0gft3_7EuTo6ro,2319
 golf/commands/init.py,sha256=DUAvGqOUapWdF2cgWPscqHRvyOZDiajR0F0Wkn_jm-k,10355
 golf/commands/run.py,sha256=xsiG5LZw4qVt3cRTTfIoWP4Bf4AxNBBJKx0NNfoua40,2884
 golf/core/__init__.py,sha256=4bKeskJ2fPaZqkz2xQScSa3phRLLrmrczwSL632jv-o,52
-golf/core/builder.py,sha256=9TCtZIUaywxMsC3FIj3VFFgEA7sfrER5WaM4BfYAUS8,55807
-golf/core/builder_auth.py,sha256=6oGw1HsHdtAjfbJKoyakBrFp2v6FgrO1hFuLR9thiY4,13821
+golf/core/builder.py,sha256=flsXnlwOTUhXFMpmZwoxWgnK_oLj4zpSyqcKuDnXezw,59526
+golf/core/builder_auth.py,sha256=nGgyMTiRAqaNfh1FSvoFe6oTVq9RgfMf9JoFGAv2_do,14050
+golf/core/builder_metrics.py,sha256=j6Gtgd867o46JbDfSNGNsHt1QtV1XHKUJs1z8r4siQM,8830
 golf/core/builder_telemetry.py,sha256=jobFgRSspLQLuitL4ytk6asSUdTqYcDxGY3sTjkrZd4,2654
-golf/core/config.py,sha256=B_GcPDjf2PuOemZNaFMOEuzqtnCchQaJCQkYAuULUgQ,7184
+golf/core/config.py,sha256=6yPtwzVTJauufEnrfUbxsz69H8jC0Ra427oDaRM0-xE,7397
 golf/core/parser.py,sha256=BQRus1O9zmzSmyavwLVfN8BpYFkbrWUDrgQ7yrYfAKw,42457
 golf/core/platform.py,sha256=Z2yEi6ilmQCLC_uAD_oZdVO0WvkL4tsyw7sx0vHhysI,6440
 golf/core/telemetry.py,sha256=CjZ7urbizaRjyFiVBjfGW8V4PmNCG1_quk3FvbVTcjw,15772
@@ -46,11 +47,14 @@ golf/examples/basic/tools/hello.py,sha256=s7Soiq9Wn7oKIvA6Hid8UKB14iyR7HZppIbIT4
 golf/examples/basic/tools/payments/charge.py,sha256=PIYdFV90hu35H1veLI8ueuYwebzrr5SCTX-x6lxRmU4,1800
 golf/examples/basic/tools/payments/common.py,sha256=hfyuQRIjrQfSqGjyY55W6pZSD5jL6O0geCE0DGx0v10,1302
 golf/examples/basic/tools/payments/refund.py,sha256=Qpl4GWvUw-L06oGQMbBzG8pikfCWfBCFcpkRiDOzmyQ,1607
+golf/metrics/__init__.py,sha256=O91y-hj_E9R06gqV8pDZrzHxOIl-1T415Hj9RvFAp3o,283
+golf/metrics/collector.py,sha256=iyRszP8TAAigyOsUFTGdKN8Xeob36LhUvXW9tntJrbA,7617
+golf/metrics/registry.py,sha256=mXQE4Pwf3PopGYjcUu4eGgPDAe085YWcsvcvWk0ny8Q,310
 golf/telemetry/__init__.py,sha256=ESGCg5HKwTCIfID1e_K7EE0bOWkSzMidlLtdqQgBd0w,396
-golf/telemetry/instrumentation.py,sha256=2B0R918-OLpRdyXMTpHuerfc_4osuSi7Lrh9Y2luXfs,43575
-golf_mcp-0.1.17.dist-info/licenses/LICENSE,sha256=5_j2f6fTJmvfmUewzElhkpAaXg2grVoxKouOA8ihV6E,11348
-golf_mcp-0.1.17.dist-info/METADATA,sha256=-OBF6l8aFo-QYVpnf2c2Uas-8obFK5KYp0EaRvlr_7E,12871
-golf_mcp-0.1.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-golf_mcp-0.1.17.dist-info/entry_points.txt,sha256=5y7rHYM8jGpU-nfwdknCm5XsApLulqsnA37MO6BUTYg,43
-golf_mcp-0.1.17.dist-info/top_level.txt,sha256=BQToHcBUufdyhp9ONGMIvPE40jMEtmI20lYaKb4hxOg,5
-golf_mcp-0.1.17.dist-info/RECORD,,
+golf/telemetry/instrumentation.py,sha256=8n69nYUzsLCvItyYVe7TbxiyfYjgJHqC4sV7GgwL7QI,44652
+golf_mcp-0.1.19.dist-info/licenses/LICENSE,sha256=5_j2f6fTJmvfmUewzElhkpAaXg2grVoxKouOA8ihV6E,11348
+golf_mcp-0.1.19.dist-info/METADATA,sha256=VWwqQwy6gSijjJcjA2A2euWf53gHpZ3KhFRwK8yrE4U,12956
+golf_mcp-0.1.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+golf_mcp-0.1.19.dist-info/entry_points.txt,sha256=5y7rHYM8jGpU-nfwdknCm5XsApLulqsnA37MO6BUTYg,43
+golf_mcp-0.1.19.dist-info/top_level.txt,sha256=BQToHcBUufdyhp9ONGMIvPE40jMEtmI20lYaKb4hxOg,5
+golf_mcp-0.1.19.dist-info/RECORD,,