golf-mcp 0.1.10__py3-none-any.whl → 0.1.11__py3-none-any.whl

golf/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.10"
+__version__ = "0.1.11"

golf/cli/main.py

@@ -106,7 +106,7 @@ def build_dev(
     if not project_root:
         console.print("[bold red]Error: No GolfMCP project found in the current directory or any parent directory.[/bold red]")
         console.print("Run 'golf init <project_name>' to create a new project.")
-        track_event("cli_build_failed", {"success": False, "environment": "dev"})
+        track_event("cli_build_failed", {"success": False, "environment": "dev", "error_type": "NoProjectFound", "error_message": "No GolfMCP project found"})
         raise typer.Exit(code=1)
     
     # Load settings from the found project
@@ -124,8 +124,10 @@ def build_dev(
         build_project(project_root, settings, output_dir, build_env="dev", copy_env=True)
         # Track successful build with environment
         track_event("cli_build_success", {"success": True, "environment": "dev"})
-    except Exception:
-        track_event("cli_build_failed", {"success": False, "environment": "dev"})
+    except Exception as e:
+        error_type = type(e).__name__
+        error_message = str(e)
+        track_event("cli_build_failed", {"success": False, "environment": "dev", "error_type": error_type, "error_message": error_message})
         raise
 
 
@@ -142,7 +144,7 @@ def build_prod(
     if not project_root:
         console.print("[bold red]Error: No GolfMCP project found in the current directory or any parent directory.[/bold red]")
         console.print("Run 'golf init <project_name>' to create a new project.")
-        track_event("cli_build_failed", {"success": False, "environment": "prod"})
+        track_event("cli_build_failed", {"success": False, "environment": "prod", "error_type": "NoProjectFound", "error_message": "No GolfMCP project found"})
         raise typer.Exit(code=1)
     
     # Load settings from the found project
@@ -160,8 +162,10 @@ def build_prod(
         build_project(project_root, settings, output_dir, build_env="prod", copy_env=False)
         # Track successful build with environment
         track_event("cli_build_success", {"success": True, "environment": "prod"})
-    except Exception:
-        track_event("cli_build_failed", {"success": False, "environment": "prod"})
+    except Exception as e:
+        error_type = type(e).__name__
+        error_message = str(e)
+        track_event("cli_build_failed", {"success": False, "environment": "prod", "error_type": error_type, "error_message": error_message})
         raise
 
 
@@ -191,7 +195,7 @@ def run(
     if not project_root:
         console.print("[bold red]Error: No GolfMCP project found in the current directory or any parent directory.[/bold red]")
         console.print("Run 'golf init <project_name>' to create a new project.")
-        track_event("cli_run_failed", {"success": False})
+        track_event("cli_run_failed", {"success": False, "error_type": "NoProjectFound", "error_message": "No GolfMCP project found"})
         raise typer.Exit(code=1)
     
     # Load settings from the found project
@@ -207,13 +211,20 @@ def run(
     if not dist_dir.exists():
         if build_first:
             console.print(f"[yellow]Dist directory {dist_dir} not found. Building first...[/yellow]")
-            # Build the project
-            from golf.commands.build import build_project
-            build_project(project_root, settings, dist_dir)
+            try:
+                # Build the project
+                from golf.commands.build import build_project
+                build_project(project_root, settings, dist_dir)
+            except Exception as e:
+                error_type = type(e).__name__
+                error_message = str(e)
+                console.print(f"[bold red]Error building project:[/bold red] {error_message}")
+                track_event("cli_run_failed", {"success": False, "error_type": f"BuildError.{error_type}", "error_message": error_message})
+                raise
         else:
             console.print(f"[bold red]Error: Dist directory {dist_dir} not found.[/bold red]")
             console.print("Run 'golf build' first or use --build to build automatically.")
-            track_event("cli_run_failed", {"success": False})
+            track_event("cli_run_failed", {"success": False, "error_type": "DistNotFound", "error_message": "Dist directory not found"})
             raise typer.Exit(code=1)
     
     try:
@@ -231,13 +242,15 @@ def run(
         if return_code == 0:
             track_event("cli_run_success", {"success": True})
         else:
-            track_event("cli_run_failed", {"success": False})
+            track_event("cli_run_failed", {"success": False, "error_type": "NonZeroExit", "error_message": f"Server exited with code {return_code}"})
         
         # Exit with the same code as the server
         if return_code != 0:
             raise typer.Exit(code=return_code)
-    except Exception:
-        track_event("cli_run_failed", {"success": False})
+    except Exception as e:
+        error_type = type(e).__name__
+        error_message = str(e)
+        track_event("cli_run_failed", {"success": False, "error_type": error_type, "error_message": error_message})
         raise
 
 

golf/commands/init.py

@@ -9,7 +9,7 @@ from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.prompt import Confirm
 
-from golf.core.telemetry import track_event
+from golf.core.telemetry import track_event, track_command
 
 console = Console()
 
@@ -26,72 +26,83 @@ def initialize_project(
         output_dir: Directory where the project will be created
         template: Template to use (basic or api_key)
     """
-    # Validate template
-    valid_templates = ("basic", "api_key")
-    if template not in valid_templates:
-        console.print(f"[bold red]Error:[/bold red] Unknown template '{template}'")
-        console.print(f"Available templates: {', '.join(valid_templates)}")
-        track_event("cli_init_failed", {"success": False})
-        return
-    
-    # Check if directory exists
-    if output_dir.exists():
-        if not output_dir.is_dir():
+    try:
+        # Validate template
+        valid_templates = ("basic", "api_key")
+        if template not in valid_templates:
+            console.print(f"[bold red]Error:[/bold red] Unknown template '{template}'")
+            console.print(f"Available templates: {', '.join(valid_templates)}")
+            track_command("init", success=False, error_type="InvalidTemplate", error_message=f"Unknown template: {template}")
+            return
+        
+        # Check if directory exists
+        if output_dir.exists():
+            if not output_dir.is_dir():
+                console.print(
+                    f"[bold red]Error:[/bold red] '{output_dir}' exists but is not a directory."
+                )
+                track_command("init", success=False, error_type="NotADirectory", error_message="Target exists but is not a directory")
+                return
+            
+            # Check if directory is empty
+            if any(output_dir.iterdir()):
+                if not Confirm.ask(
+                    f"Directory '{output_dir}' is not empty. Continue anyway?",
+                    default=False,
+                ):
+                    console.print("Initialization cancelled.")
+                    track_event("cli_init_cancelled", {"success": False})
+                    return
+        else:
+            # Create the directory
+            output_dir.mkdir(parents=True)
+        
+        # Find template directory within the installed package
+        import golf
+        package_init_file = Path(golf.__file__)
+        # The 'examples' directory is now inside the 'golf' package directory
+        # e.g. golf/examples/basic, so go up one from __init__.py to get to 'golf'
+        template_dir = package_init_file.parent / "examples" / template
+        
+        if not template_dir.exists():
             console.print(
-                f"[bold red]Error:[/bold red] '{output_dir}' exists but is not a directory."
+                f"[bold red]Error:[/bold red] Could not find template '{template}'"
             )
-            track_event("cli_init_failed", {"success": False})
+            track_command("init", success=False, error_type="TemplateNotFound", error_message=f"Template directory not found: {template}")
             return
         
-        # Check if directory is empty
-        if any(output_dir.iterdir()):
-            if not Confirm.ask(
-                f"Directory '{output_dir}' is not empty. Continue anyway?",
-                default=False,
-            ):
-                console.print("Initialization cancelled.")
-                track_event("cli_init_cancelled", {"success": False})
-                return
-    else:
-        # Create the directory
-        output_dir.mkdir(parents=True)
-    
-    # Find template directory within the installed package
-    import golf
-    package_init_file = Path(golf.__file__)
-    # The 'examples' directory is now inside the 'golf' package directory
-    # e.g. golf/examples/basic, so go up one from __init__.py to get to 'golf'
-    template_dir = package_init_file.parent / "examples" / template
-    
-    if not template_dir.exists():
-        console.print(
-            f"[bold red]Error:[/bold red] Could not find template '{template}'"
-        )
-        track_event("cli_init_failed", {"success": False})
-        return
-    
-    # Copy template files
-    with Progress(
-        SpinnerColumn(),
-        TextColumn("[bold green]Creating project structure...[/bold green]"),
-        transient=True,
-    ) as progress:
-        progress.add_task("copying", total=None)
+        # Copy template files
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[bold green]Creating project structure...[/bold green]"),
+            transient=True,
+        ) as progress:
+            progress.add_task("copying", total=None)
+            
+            # Copy directory structure
+            _copy_template(template_dir, output_dir, project_name)
         
-        # Copy directory structure
-        _copy_template(template_dir, output_dir, project_name)
-    
-    # Create virtual environment
-    console.print("[bold green]Project initialized successfully![/bold green]")
-    console.print(f"\nTo get started, run:")
-    console.print(f"  cd {output_dir.name}")
-    console.print(f"  golf build dev")
-    
-    # Track successful initialization
-    track_event("cli_init_success", {
-        "success": True,
-        "template": template
-    })
+        # Create virtual environment
+        console.print("[bold green]Project initialized successfully![/bold green]")
+        console.print(f"\nTo get started, run:")
+        console.print(f"  cd {output_dir.name}")
+        console.print(f"  golf build dev")
+        
+        # Track successful initialization
+        track_event("cli_init_success", {
+            "success": True,
+            "template": template
+        })
+    except Exception as e:
+        # Capture error details for telemetry
+        error_type = type(e).__name__
+        error_message = str(e)
+        
+        console.print(f"[bold red]Error during initialization:[/bold red] {error_message}")
+        track_command("init", success=False, error_type=error_type, error_message=error_message)
+        
+        # Re-raise to maintain existing behavior
+        raise
 
 
 def _copy_template(source_dir: Path, target_dir: Path, project_name: str) -> None:

golf/core/builder.py

@@ -765,14 +765,25 @@ class CodeGenerator:
                     "    # For SSE with API key auth, we need to get the app and add middleware",
                     "    app = mcp.http_app(transport=\"sse\")",
                     "    app.add_middleware(ApiKeyMiddleware)",
-                    "    # Run with the configured app",
-                    "    uvicorn.run(app, host=host, port=port, log_level=\"info\")"
                 ])
             else:
                 main_code.extend([
-                    "    # For SSE, FastMCP's run method handles auth integration better",
-                    "    mcp.run(transport=\"sse\", host=host, port=port, log_level=\"info\")"
+                    "    # For SSE, get the app to add middleware",
+                    "    app = mcp.http_app(transport=\"sse\")",
                 ])
+            
+            # Add OpenTelemetry middleware to the SSE app if enabled
+            if self.settings.opentelemetry_enabled:
+                main_code.extend([
+                    "    # Apply OpenTelemetry middleware to the SSE app",
+                    "    from opentelemetry.instrumentation.asgi import OpenTelemetryMiddleware",
+                    "    app = OpenTelemetryMiddleware(app)",
+                ])
+            
+            main_code.extend([
+                "    # Run with the configured app",
+                "    uvicorn.run(app, host=host, port=port, log_level=\"info\")"
+            ])
         elif self.settings.transport in ["streamable-http", "http"]:
             main_code.extend([
                 "    # Create HTTP app and run with uvicorn",

golf/core/telemetry.py

@@ -243,7 +243,7 @@ def track_event(event_name: str, properties: Optional[Dict[str, Any]] = None) ->
         # Filter properties to only include safe ones
         if properties:
             # Only include specific safe properties
-            safe_keys = {"success", "environment", "template", "command_type"}
+            safe_keys = {"success", "environment", "template", "command_type", "error_type", "error_message"}
             for key in safe_keys:
                 if key in properties:
                     safe_properties[key] = properties[key]
@@ -260,15 +260,68 @@ def track_event(event_name: str, properties: Optional[Dict[str, Any]] = None) ->
         pass
 
 
-def track_command(command: str, success: bool = True) -> None:
+def track_command(command: str, success: bool = True, error_type: Optional[str] = None, error_message: Optional[str] = None) -> None:
     """Track a CLI command execution with minimal info.
     
     Args:
         command: The command being executed (e.g., "init", "build", "run")
         success: Whether the command was successful
+        error_type: Type of error if command failed (e.g., "ValueError", "FileNotFoundError")
+        error_message: Sanitized error message (no sensitive data)
     """
-    # Simplify the event to just command and success
-    track_event(f"cli_{command}", {"success": success})
+    properties = {"success": success}
+    
+    # Add error details if command failed
+    if not success and (error_type or error_message):
+        if error_type:
+            properties["error_type"] = error_type
+        if error_message:
+            # Sanitize error message - remove file paths and sensitive info
+            sanitized_message = _sanitize_error_message(error_message)
+            properties["error_message"] = sanitized_message
+    
+    track_event(f"cli_{command}", properties)
+
+
+def _sanitize_error_message(message: str) -> str:
+    """Sanitize error message to remove sensitive information.
+    
+    Args:
+        message: Raw error message
+        
+    Returns:
+        Sanitized error message
+    """
+    import re
+    
+    # Remove absolute file paths but keep the filename
+    # Unix-style paths
+    message = re.sub(r'/(?:Users|home|var|tmp|opt|usr|etc)/[^\s"\']+/([^/\s"\']+)', r'\1', message)
+    # Windows-style paths
+    message = re.sub(r'[A-Za-z]:\\[^\s"\']+\\([^\\s"\']+)', r'\1', message)
+    # Generic path pattern (catches remaining paths)
+    message = re.sub(r'(?:^|[\s"])(/[^\s"\']+/)+([^/\s"\']+)', r'\2', message)
+    
+    # Remove potential API keys or tokens (common patterns)
+    # Generic API keys (20+ alphanumeric with underscores/hyphens)
+    message = re.sub(r'\b[a-zA-Z0-9_-]{32,}\b', '[REDACTED]', message)
+    # Bearer tokens
+    message = re.sub(r'Bearer\s+[a-zA-Z0-9_.-]+', 'Bearer [REDACTED]', message)
+    
+    # Remove email addresses
+    message = re.sub(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', '[EMAIL]', message)
+    
+    # Remove IP addresses
+    message = re.sub(r'\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b', '[IP]', message)
+    
+    # Remove port numbers in URLs
+    message = re.sub(r':[0-9]{2,5}(?=/|$|\s)', ':[PORT]', message)
+    
+    # Truncate to reasonable length
+    if len(message) > 200:
+        message = message[:197] + "..."
+    
+    return message
 
 
 def flush() -> None: