golf-mcp 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

golf/core/builder_auth.py

@@ -8,28 +8,34 @@ from golf.auth import get_auth_config
 from golf.auth.api_key import get_api_key_config
 
 
-def generate_auth_code(server_name: str, host: str = "127.0.0.1", port: int = 3000, https: bool = False) -> str:
-    """Generate code for setting up authentication in the FastMCP app.
-    This code string will be injected into the generated server.py and executed at its runtime.
+def generate_auth_code(server_name: str, host: str = "127.0.0.1", port: int = 3000, https: bool = False, opentelemetry_enabled: bool = False, transport: str = "streamable-http") -> dict:
+    """Generate authentication components for the FastMCP app.
+    
+    Returns a dictionary with:
+        - imports: List of import statements
+        - setup_code: Auth setup code (provider configuration, etc.)
+        - fastmcp_args: Dict of arguments to add to FastMCP constructor
+        - has_auth: Whether auth is configured
     """
     # Check for API key configuration first
     api_key_config = get_api_key_config()
     if api_key_config:
-        return generate_api_key_auth_code(server_name)
+        return generate_api_key_auth_components(server_name, opentelemetry_enabled, transport)
     
     # Otherwise check for OAuth configuration
     original_provider_config, required_scopes_from_config = get_auth_config()
     
     if not original_provider_config:
-        # If no auth config from pre_build.py, just generate basic FastMCP instantiation
-        return f"mcp = FastMCP({repr(server_name)}) # No authentication configured"
-
-    # This list will hold lines of Python code to be written into server.py
-    generated_code_lines = []
+        # If no auth config, return empty components
+        return {
+            "imports": [],
+            "setup_code": [],
+            "fastmcp_args": {},
+            "has_auth": False
+        }
 
-    # Imports needed at the top of server.py for the auth setup block
-    # Note: FastMCP itself is imported by the main server generation logic later.
-    generated_code_lines.extend([
+    # Build auth components
+    auth_imports = [
         "import os",
         "import sys  # For stderr output",
         "from mcp.server.auth.settings import AuthSettings, ClientRegistrationOptions",
@@ -37,11 +43,12 @@ def generate_auth_code(server_name: str, host: str = "127.0.0.1", port: int = 30
         "from golf.auth.oauth import GolfOAuthProvider",
         "# get_access_token and create_callback_handler are used by generated auth_routes",
         "from golf.auth import get_access_token, create_callback_handler",
-        "",
-    ])
+    ]
+
+    setup_code_lines = []
 
     # Code to determine runtime server address configuration
-    generated_code_lines.extend([
+    setup_code_lines.extend([
         "# Determine runtime server address configuration",
         f"runtime_host = os.environ.get('HOST', {repr(host)})",
         f"runtime_port = int(os.environ.get('PORT', {repr(port)}))",
@@ -57,7 +64,7 @@ def generate_auth_code(server_name: str, host: str = "127.0.0.1", port: int = 30
     ])
 
     # Code to load secrets from environment variables AT RUNTIME in server.py
-    generated_code_lines.extend([
+    setup_code_lines.extend([
         "# Load secrets from environment variables using names specified in pre_build.py ProviderConfig",
         f"runtime_client_id = os.environ.get({repr(original_provider_config.client_id_env_var)})",
         f"runtime_client_secret = os.environ.get({repr(original_provider_config.client_secret_env_var)})",
@@ -75,7 +82,7 @@ def generate_auth_code(server_name: str, host: str = "127.0.0.1", port: int = 30
     ])
 
     # Code to instantiate ProviderConfig using runtime-loaded secrets and other baked-in non-secrets
-    generated_code_lines.extend([
+    setup_code_lines.extend([
         "# Instantiate ProviderConfig with runtime-resolved secrets and other pre-configured values",
         f"provider_config_instance = GolfProviderConfigInternal(", # Use aliased import
         f"    provider={repr(original_provider_config.provider)},",
@@ -101,8 +108,8 @@ def generate_auth_code(server_name: str, host: str = "127.0.0.1", port: int = 30
         "",
     ])
 
-    # AuthSettings and FastMCP instantiation
-    generated_code_lines.extend([
+    # AuthSettings creation
+    setup_code_lines.extend([
         "# Create auth settings for FastMCP",
         "auth_settings = AuthSettings(",
         "    issuer_url=runtime_issuer_url,",
@@ -114,31 +121,52 @@ def generate_auth_code(server_name: str, host: str = "127.0.0.1", port: int = 30
         f"    required_scopes={repr(required_scopes_from_config) if required_scopes_from_config else None}",
         ")",
         "",
-        "# Create FastMCP instance with auth configuration",
-        f"mcp = FastMCP({repr(server_name)}, auth_server_provider=auth_provider, auth=auth_settings)"
     ])
-    
-    return "\n".join(generated_code_lines)
+
+    # FastMCP constructor arguments
+    fastmcp_args = {
+        "auth_server_provider": "auth_provider",
+        "auth": "auth_settings"
+    }
+
+    return {
+        "imports": auth_imports,
+        "setup_code": setup_code_lines,
+        "fastmcp_args": fastmcp_args,
+        "has_auth": True
+    }
 
 
-def generate_api_key_auth_code(server_name: str) -> str:
-    """Generate code for API key authentication middleware."""
+def generate_api_key_auth_components(server_name: str, opentelemetry_enabled: bool = False, transport: str = "streamable-http") -> dict:
+    """Generate authentication components for API key authentication.
+    
+    Returns a dictionary with:
+        - imports: List of import statements
+        - setup_code: Auth setup code (middleware setup)
+        - fastmcp_args: Dict of arguments to add to FastMCP constructor
+        - has_auth: Whether auth is configured
+        - post_init_code: Code to run after FastMCP instance is created
+    """
     api_key_config = get_api_key_config()
     if not api_key_config:
-        return f"mcp = FastMCP({repr(server_name)}) # No API key authentication configured"
+        return {
+            "imports": [],
+            "setup_code": [],
+            "fastmcp_args": {},
+            "has_auth": False,
+            "post_init_code": []
+        }
     
-    generated_code_lines = []
-    
-    # Imports
-    generated_code_lines.extend([
+    auth_imports = [
         "# API key authentication setup",
         "from golf.auth.helpers import set_api_key",
         "from golf.auth.api_key import get_api_key_config",
         "from starlette.middleware.base import BaseHTTPMiddleware",
         "from starlette.requests import Request",
-        "",
-        f"mcp = FastMCP({repr(server_name)})",
-        "",
+        "from starlette.responses import JSONResponse",
+    ]
+    
+    setup_code_lines = [
         "# Middleware to extract API key from headers",
         "class ApiKeyMiddleware(BaseHTTPMiddleware):",
         "    async def dispatch(self, request: Request, call_next):",
@@ -155,9 +183,24 @@ def generate_api_key_auth_code(server_name: str) -> str:
         "                    api_key = v",
         "                    break",
         "            ",
+        "            # Check if API key is required and missing",
+        "            if api_key_config.required and not api_key:",
+        "                return JSONResponse(",
+        "                    {'error': 'unauthorized', 'detail': f'Missing required {header_name} header'},",
+        "                    status_code=401,",
+        "                    headers={'WWW-Authenticate': f'{header_name} realm=\"MCP Server\"'}",
+        "                )",
+        "            ",
         "            # Strip prefix if configured and present",
         "            if api_key and header_prefix and api_key.startswith(header_prefix):",
         "                api_key = api_key[len(header_prefix):]",
+        "            elif api_key and header_prefix and api_key_config.required:",
+        "                # Has API key but wrong format when required",
+        "                return JSONResponse(",
+        "                    {'error': 'unauthorized', 'detail': f'Invalid {header_name} format, expected prefix: {header_prefix}'},",
+        "                    status_code=401,",
+        "                    headers={'WWW-Authenticate': f'{header_name} realm=\"MCP Server\"'}",
+        "                )",
         "            ",
         "            # Store the API key in context for tools to access",
         "            set_api_key(api_key)",
@@ -166,11 +209,84 @@ def generate_api_key_auth_code(server_name: str) -> str:
         "        response = await call_next(request)",
         "        return response",
         "",
-        "# Add the middleware to the FastMCP app",
-        "mcp.app.add_middleware(ApiKeyMiddleware)",
-    ])
+    ]
+    
+    # API key auth is handled via middleware, not FastMCP constructor args
+    fastmcp_args = {}
+    
+    # Code to run after FastMCP instance is created
+    # FastMCP doesn't expose .app directly, so we need to use custom_route
+    # to add a middleware-like functionality
+    post_init_code = [
+        "# API key authentication via custom middleware function",
+        "# Since FastMCP doesn't expose .app, we'll use a different approach",
+        "import functools",
+        "from starlette.responses import JSONResponse",
+        "",
+        "# Store original method references",
+        "_original_call_tool = mcp._mcp_call_tool if hasattr(mcp, '_mcp_call_tool') else None",
+        "_original_read_resource = mcp._mcp_read_resource if hasattr(mcp, '_mcp_read_resource') else None",
+        "_original_get_prompt = mcp._mcp_get_prompt if hasattr(mcp, '_mcp_get_prompt') else None",
+        "",
+        "# Wrapper to extract API key before processing",
+        "def with_api_key_extraction(original_method):",
+        "    @functools.wraps(original_method)",
+        "    async def wrapper(request, *args, **kwargs):",
+        "        # Extract API key from request headers",
+        "        api_key_config = get_api_key_config()",
+        "        if api_key_config and hasattr(request, 'headers'):",
+        "            header_name = api_key_config.header_name",
+        "            header_prefix = api_key_config.header_prefix",
+        "            ",
+        "            # Case-insensitive header lookup",
+        "            api_key = None",
+        "            for k, v in request.headers.items():",
+        "                if k.lower() == header_name.lower():",
+        "                    api_key = v",
+        "                    break",
+        "            ",
+        "            # Check if API key is required and missing",
+        "            if api_key_config.required and not api_key:",
+        "                return JSONResponse(",
+        "                    {'error': 'unauthorized', 'detail': f'Missing required {header_name} header'},",
+        "                    status_code=401,",
+        "                    headers={'WWW-Authenticate': f'{header_name} realm=\"MCP Server\"'}",
+        "                )",
+        "            ",
+        "            # Strip prefix if configured and present",
+        "            if api_key and header_prefix and api_key.startswith(header_prefix):",
+        "                api_key = api_key[len(header_prefix):]",
+        "            elif api_key and header_prefix and api_key_config.required:",
+        "                # Has API key but wrong format when required",
+        "                return JSONResponse(",
+        "                    {'error': 'unauthorized', 'detail': f'Invalid {header_name} format, expected prefix: {header_prefix}'},",
+        "                    status_code=401,",
+        "                    headers={'WWW-Authenticate': f'{header_name} realm=\"MCP Server\"'}",
+        "                )",
+        "            ",
+        "            # Store the API key in context for tools to access",
+        "            set_api_key(api_key)",
+        "        ",
+        "        # Call the original method",
+        "        return await original_method(request, *args, **kwargs)",
+        "    return wrapper",
+        "",
+        "# Wrap the MCP methods if they exist",
+        "if _original_call_tool:",
+        "    mcp._mcp_call_tool = with_api_key_extraction(_original_call_tool)",
+        "if _original_read_resource:",
+        "    mcp._mcp_read_resource = with_api_key_extraction(_original_read_resource)",
+        "if _original_get_prompt:",
+        "    mcp._mcp_get_prompt = with_api_key_extraction(_original_get_prompt)",
+    ]
     
-    return "\n".join(generated_code_lines)
+    return {
+        "imports": auth_imports,
+        "setup_code": setup_code_lines,
+        "fastmcp_args": fastmcp_args,
+        "has_auth": True,
+        "post_init_code": post_init_code
+    }
 
 
 def generate_auth_routes() -> str:

golf/core/builder_telemetry.py

@@ -4,194 +4,60 @@ This module provides functions for generating OpenTelemetry initialization
 and instrumentation code for FastMCP servers built with GolfMCP.
 """
 
-from golf import __version__
-
-def generate_otel_lifespan_code(default_exporter: str = "console", project_name: str = "UnknownGolfService") -> str:
-    """Generate code for the OpenTelemetry lifespan function.
+def generate_telemetry_imports() -> list[str]:
+    """Generate import statements for telemetry instrumentation.
     
-    Args:
-        default_exporter: Default exporter type to use if OTEL_TRACES_EXPORTER is not set
-        project_name: The name of the project, used as default for OTEL_SERVICE_NAME
-        
     Returns:
-        Python code string for the OpenTelemetry lifespan function
+        List of import statements for telemetry
     """
-    return f"""
-# --- OpenTelemetry Lifespan Start ---
-# These variables are global within the generated server.py module scope
-_golf_otel_provider_global = None
-_golf_otel_initialized_flag = False
-
-from contextlib import asynccontextmanager
-import os
-import sys
-import logging
-from opentelemetry import trace
-from opentelemetry.trace import NoOpTracerProvider
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
-from opentelemetry.sdk.resources import Resource as OtelResource
-from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
-
-# Optional: Configure OpenTelemetry's own logger to be less verbose
-# logging.getLogger('opentelemetry').setLevel(logging.WARNING)
-
-@asynccontextmanager
-async def otel_lifespan(app): # 'app' is the FastMCP instance passed by _lifespan_wrapper
-    global _golf_otel_provider_global, _golf_otel_initialized_flag
+    return [
+        "# OpenTelemetry instrumentation imports",
+        "from golf.telemetry import (",
+        "    instrument_tool,",
+        "    instrument_resource,",
+        "    instrument_prompt,",
+        "    telemetry_lifespan,",
+        ")",
+    ]
 
-    # These will be resolved when otel_lifespan runs in the generated server.py
-    # .format() inserts build-time fallbacks {project_name} and {default_exporter}
-    service_name_to_use = os.environ.get("OTEL_SERVICE_NAME", "{project_name}")
-    exporter_type_to_use = os.environ.get("OTEL_TRACES_EXPORTER", "{default_exporter}").lower()
+def generate_component_registration_with_telemetry(
+    component_type: str,
+    component_name: str,
+    module_path: str,
+    entry_function: str,
+    docstring: str = "",
+    uri_template: str = None
+) -> str:
+    """Generate component registration code with telemetry instrumentation.
     
-    # Local variable for the provider created in this specific call, if any.
-    local_provider_instance_for_shutdown = None
-
-    try:
-        if not _golf_otel_initialized_flag:
-            # Double check if a real provider is already globally set by another mechanism
-            # trace.get_tracer_provider() returns a NoOpTracerProvider by default.
-            current_global_otel_provider = trace.get_tracer_provider()
-            if isinstance(current_global_otel_provider, NoOpTracerProvider):
-                print(f"[OTel] Initializing OpenTelemetry Globals (service={{service_name_to_use}}, exporter={{exporter_type_to_use}})...", file=sys.stderr)
-                
-                resource = OtelResource.create({{"service.name": service_name_to_use}})
-                provider_to_set = TracerProvider(resource=resource)
-                
-                exporter = None
-                if exporter_type_to_use == "otlp_http":
-                    endpoint = os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT")
-                    exporter = OTLPSpanExporter(endpoint=endpoint) if endpoint else OTLPSpanExporter()
-                else: # Default to console
-                    exporter = ConsoleSpanExporter(out=sys.stderr) # Ensure console output goes to stderr
-                    
-                processor = BatchSpanProcessor(exporter)
-                provider_to_set.add_span_processor(processor)
-                
-                trace.set_tracer_provider(provider_to_set)
-                _golf_otel_provider_global = provider_to_set # Store it globally
-                _golf_otel_initialized_flag = True
-                local_provider_instance_for_shutdown = provider_to_set # Mark for shutdown by this invocation
-                print(f"[OTel] Global OpenTelemetry provider SET (service={{service_name_to_use}}, exporter={{exporter_type_to_use}})", file=sys.stderr)
-            else:
-                # A real provider is already set globally. Do not override.
-                # Assign it to _golf_otel_provider_global if not already assigned, for consistency,
-                # but don't mark it for shutdown by this specific lifespan invocation.
-                if _golf_otel_provider_global is None:
-                    _golf_otel_provider_global = current_global_otel_provider
-                _golf_otel_initialized_flag = True # Mark as initialized to prevent re-entry by this mechanism
-                print(f"[OTel] Global OpenTelemetry provider was ALREADY SET by another mechanism. Using existing.", file=sys.stderr)
-        else:
-            # print(f"[OTel Lifespan DEBUG] Already initialized by this mechanism. Yielding.", file=sys.stderr)
-            pass # Already initialized by this mechanism in a previous entry
-
-        yield {{}} # Application runs here
+    Args:
+        component_type: Type of component ('tool', 'resource', 'prompt')
+        component_name: Name of the component
+        module_path: Full module path to the component
+        entry_function: Entry function name
+        docstring: Component description
+        uri_template: URI template for resources (optional)
         
-    except Exception as e:
-        print("[OTel] ERROR during OpenTelemetry setup/yield: " + str(e), file=sys.stderr)
-        import traceback
-        print(traceback.format_exc(), file=sys.stderr)
-        raise 
-    finally:
-        # Only the instance of otel_lifespan that successfully initialized the provider
-        # should be responsible for its shutdown.
-        if local_provider_instance_for_shutdown:
-            # print(f"[OTel Lifespan DEBUG] Shutting down OTel Provider for service={{service_name_to_use}}.", file=sys.stderr)
-            local_provider_instance_for_shutdown.shutdown()
-            _golf_otel_initialized_flag = False # Allow re-init if server process truly restarts
-            _golf_otel_provider_global = None
-            print("[OTel] Provider shut down by this lifespan instance.", file=sys.stderr)
-# --- OpenTelemetry Lifespan End ---
-"""
-
-def generate_otel_instrumentation_code() -> str:
-    """Generate code for instrumenting the FastMCP instance.
-    
     Returns:
-        Python code string for instrumenting FastMCP methods
+        Python code string for registering the component with instrumentation
     """
-    return f"""
-# Instrument FastMCP instance
-import wrapt
-import json
-import sys # For debug prints
-from opentelemetry import trace as otel_trace
-from opentelemetry.trace import SpanKind, Status, StatusCode
-
-print("[OTel Instrumentation] Applying FastMCP method wrappers...", file=sys.stderr)
-
-# Create a tracer for the instrumentation
-otel_tracer = otel_trace.get_tracer("golfmcp.fastmcp", "{__version__}")
-print(f"[OTel Instrumentation] Acquired tracer: {{str(otel_tracer)}}", file=sys.stderr)
-
-def otel_operation_wrapper(operation_name_suffix):
-    def wrapper(wrapped, instance, args, kwargs):
-        component_name = args[0] if args else "unknown"
-        span_name = "mcp." + operation_name_suffix
-        # print(f"[OTel Instrumentation DEBUG] Wrapping: {{instance.name}}.{{operation_name_suffix}} for component: {{component_name}}", file=sys.stderr)
+    func_ref = f"{module_path}.{entry_function}"
+    escaped_docstring = docstring.replace('"', '\\"') if docstring else ""
+    
+    if component_type == "tool":
+        wrapped_func = f"instrument_tool({func_ref}, '{component_name}')"
+        return f'mcp.add_tool({wrapped_func}, name="{component_name}", description="{escaped_docstring}")'
         
-        with otel_tracer.start_as_current_span(span_name, kind=SpanKind.SERVER) as span:
-            # print(f"[OTel Instrumentation DEBUG] Started span: {{span_name}}, Trace ID: {{span.get_span_context().trace_id}}", file=sys.stderr)
-            span.set_attribute("rpc.system", "mcp")
-            span.set_attribute("rpc.method", operation_name_suffix)
-            span.set_attribute("rpc.service", instance.name)
-            
-            # Set operation-specific attributes
-            if component_name != "unknown":
-                component_type = operation_name_suffix.split("_")[1] if "_" in operation_name_suffix else "component"
-                span.set_attribute("mcp." + component_type + ".name", str(component_name))
-            
-            # For call_tool, add parameters (carefully, to avoid sensitive data)
-            if operation_name_suffix == "call_tool" and len(args) > 1 and args[1]:
-                try:
-                    params_str = json.dumps(args[1])
-                    # Truncate long parameter strings to avoid huge spans
-                    span.set_attribute("mcp.request.arguments", params_str[:1024] if len(params_str) > 1024 else params_str)
-                except Exception:
-                    span.set_attribute("mcp.request.arguments", "[serialization_error]")
-            
-            try:
-                # Call the original method
-                result = wrapped(*args, **kwargs)
-                
-                # Set success status
-                span.set_status(Status(StatusCode.OK))
-                
-                # Add result count for list operations
-                if "list" in operation_name_suffix and isinstance(result, list):
-                    span.set_attribute("mcp.response.count", len(result))
-                
-                return result
-            except Exception as e:
-                # Record the exception and set error status
-                span.record_exception(e)
-                span.set_status(Status(StatusCode.ERROR, str(e)))
-                raise
+    elif component_type == "resource":
+        wrapped_func = f"instrument_resource({func_ref}, '{uri_template}')"
+        return f'mcp.add_resource_fn({wrapped_func}, uri="{uri_template}", name="{component_name}", description="{escaped_docstring}")'
+        
+    elif component_type == "prompt":
+        wrapped_func = f"instrument_prompt({func_ref}, '{component_name}')"
+        return f'mcp.add_prompt({wrapped_func}, name="{component_name}", description="{escaped_docstring}")'
     
-    return wrapper
-
-# Define the methods to instrument
-methods_to_patch = [
-    ("_mcp_call_tool", "call_tool"),
-    ("_mcp_read_resource", "read_resource"),
-    ("_mcp_get_prompt", "get_prompt"),
-    ("_mcp_list_tools", "list_tools"),
-    ("_mcp_list_resources", "list_resources"),
-    ("_mcp_list_resource_templates", "list_resource_templates"),
-    ("_mcp_list_prompts", "list_prompts")
-]
-
-# Apply instrumentation to each method
-# This code runs in server.py *after* 'mcp' is defined.
-# The 'mcp' variable needs to be in the scope where this instrumentation code is placed.
-for method_name, operation_suffix in methods_to_patch:
-    if hasattr(mcp, method_name): # 'mcp' should be the FastMCP instance
-        # print(f"[OTel Instrumentation DEBUG] Patching {{method_name}} on {{mcp}}", file=sys.stderr)
-        wrapt.wrap_function_wrapper(mcp, method_name, otel_operation_wrapper(operation_name_suffix))
-
-print("[OTel Instrumentation] MCP method instrumentation attempted.", file=sys.stderr)
-"""
+    else:
+        raise ValueError(f"Unknown component type: {component_type}")
 
 def get_otel_dependencies() -> list[str]:
     """Get list of OpenTelemetry dependencies to add to pyproject.toml.
@@ -204,5 +70,4 @@ def get_otel_dependencies() -> list[str]:
         "opentelemetry-sdk>=1.18.0",
         "opentelemetry-instrumentation-asgi>=0.40b0",
         "opentelemetry-exporter-otlp-proto-http>=0.40b0",
-        "wrapt>=1.14.0",
     ]

golf/core/telemetry.py

@@ -6,6 +6,8 @@ import platform
 from pathlib import Path
 from typing import Optional, Dict, Any
 import json
+import uuid
+import getpass
 
 import posthog
 from rich.console import Console
@@ -115,8 +117,7 @@ def set_telemetry_enabled(enabled: bool, persist: bool = True) -> None:
 def get_anonymous_id() -> str:
     """Get or create a persistent anonymous ID for this machine.
     
-    The ID is stored in the user's home directory and is based on
-    machine characteristics to be consistent across sessions.
+    The ID is stored in the user's home directory and is unique per installation.
     """
     global _anonymous_id
     
@@ -129,16 +130,35 @@ def get_anonymous_id() -> str:
     if id_file.exists():
         try:
             _anonymous_id = id_file.read_text().strip()
-            if _anonymous_id:
+            # Check if ID is in the old format (no hyphen between hash and random component)
+            # Old format: golf-[8 chars hash][8 chars random]
+            # New format: golf-[8 chars hash]-[8 chars random]
+            if _anonymous_id and _anonymous_id.startswith("golf-") and len(_anonymous_id) == 21:
+                # This is likely the old format, regenerate
+                _anonymous_id = None
+            elif _anonymous_id:
                 return _anonymous_id
         except Exception:
             pass
     
-    # Generate new ID based on machine characteristics
-    # This ensures the same ID across sessions on the same machine
-    machine_data = f"{platform.node()}-{platform.machine()}-{platform.system()}"
-    machine_hash = hashlib.sha256(machine_data.encode()).hexdigest()[:16]
-    _anonymous_id = f"golf-{machine_hash}"
+    # Generate new ID with more unique data
+    # Include home directory path to differentiate between users on same machine
+    # Include a random component to ensure uniqueness even with identical setups
+    
+    try:
+        username = getpass.getuser()
+    except Exception:
+        username = "unknown"
+    
+    # Combine multiple factors for uniqueness
+    machine_data = f"{platform.node()}-{platform.machine()}-{platform.system()}-{username}-{str(Path.home())}"
+    machine_hash = hashlib.sha256(machine_data.encode()).hexdigest()[:8]
+    
+    # Add a random component to ensure uniqueness
+    random_component = str(uuid.uuid4()).split('-')[0]  # First 8 chars of UUID
+    
+    # Use hyphen separator for clarity and ensure PostHog treats these as different IDs
+    _anonymous_id = f"golf-{machine_hash}-{random_component}"
     
     # Try to save for next time
     try:
@@ -195,6 +215,28 @@ def track_event(event_name: str, properties: Optional[Dict[str, Any]] = None) ->
         # Get anonymous ID
         anonymous_id = get_anonymous_id()
         
+        # Set person properties to differentiate installations
+        # This helps PostHog understand these are different users
+        try:
+            hostname = platform.node()
+        except Exception:
+            hostname = "unknown"
+            
+        person_properties = {
+            "$set": {
+                "golf_version": __version__,
+                "os": platform.system(),
+                "hostname": hostname,
+                "python_version": f"{platform.python_version_tuple()[0]}.{platform.python_version_tuple()[1]}",
+            }
+        }
+        
+        # Identify the user with properties
+        posthog.identify(
+            distinct_id=anonymous_id,
+            properties=person_properties
+        )
+        
         # Only include minimal, non-identifying properties
         safe_properties = {
             "golf_version": __version__,

golf/examples/api_key/.env

@@ -0,0 +1,2 @@
+OTEL_EXPORTER_OTLP_ENDPOINT="http://localhost:4318/v1/traces"
+OTEL_SERVICE_NAME="golf-mcp"

golf/examples/api_key/.env.example

@@ -0,0 +1,5 @@
+GOLF_CLIENT_ID="default-client-id"
+GOLF_CLIENT_SECRET="default-secret"
+JWT_SECRET="example-jwt-secret-for-development-only"
+OTEL_EXPORTER_OTLP_ENDPOINT="http://localhost:4318/v1/traces"
+OTEL_SERVICE_NAME="golf-mcp"