golf-mcp 0.1.17__tar.gz → 0.1.18__tar.gz

{golf_mcp-0.1.17/src/golf_mcp.egg-info → golf_mcp-0.1.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: golf-mcp
-Version: 0.1.17
+Version: 0.1.18
 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 → golf_mcp-0.1.18}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "golf-mcp"
-version = "0.1.17"
+version = "0.1.18"
 description = "Framework for building MCP servers"
 authors = [
     {name = "Antoni Gmitruk", email = "antoni@golf.dev"}
@@ -45,6 +45,9 @@ telemetry = [
     "opentelemetry-exporter-otlp-proto-http>=0.40b0",
     "wrapt>=1.17.0"
 ]
+metrics = [
+    "prometheus-client>=0.22.1"
+]
 
 [project.scripts]
 golf = "golf.cli.main:app"
@@ -64,7 +67,7 @@ golf = ["examples/**/*"]
 
 [tool.poetry]
 name = "golf-mcp"
-version = "0.1.17"
+version = "0.1.18"
 description = "Framework for building MCP servers with zero boilerplate"
 authors = ["Antoni Gmitruk <antoni@golf.dev>"]
 license = "Apache-2.0"
@@ -100,9 +103,11 @@ opentelemetry-sdk = {version = ">=1.33.1", optional = true}
 opentelemetry-instrumentation-asgi = {version = ">=0.40b0", optional = true}
 opentelemetry-exporter-otlp-proto-http = {version = ">=0.40b0", optional = true}
 wrapt = {version = ">=1.17.0", optional = true}
+prometheus-client = {version = ">=0.22.1", optional = true}
 
 [tool.poetry.extras]
 telemetry = ["opentelemetry-api", "opentelemetry-sdk", "opentelemetry-instrumentation-asgi", "opentelemetry-exporter-otlp-proto-http", "wrapt"]
+metrics = ["prometheus-client"]
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.4.0"

golf_mcp-0.1.18/src/golf/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.18"

{golf_mcp-0.1.17 → golf_mcp-0.1.18}/src/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_mcp-0.1.17 → golf_mcp-0.1.18}/src/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_mcp-0.1.18/src/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_mcp-0.1.17 → golf_mcp-0.1.18}/src/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_mcp-0.1.18/src/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",
+]