api-mocker 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

api_mocker/analytics.py

@@ -0,0 +1,368 @@
+"""
+Analytics and metrics tracking for api-mocker.
+"""
+
+import json
+import time
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+import sqlite3
+import threading
+from dataclasses import dataclass, asdict
+import hashlib
+import platform
+import psutil
+import requests
+from contextlib import contextmanager
+
+@dataclass
+class RequestMetrics:
+    """Metrics for a single request."""
+    request_id: str
+    timestamp: float
+    method: str
+    path: str
+    status_code: int
+    response_time_ms: float
+    request_size_bytes: int
+    response_size_bytes: int
+    user_agent: str
+    ip_address: str
+    path_params: Dict[str, str]
+    query_params: Dict[str, str]
+
+@dataclass
+class ServerMetrics:
+    """Overall server metrics."""
+    server_id: str
+    start_time: float
+    uptime_seconds: float
+    total_requests: int
+    requests_per_minute: float
+    average_response_time_ms: float
+    error_rate: float
+    memory_usage_mb: float
+    cpu_usage_percent: float
+    active_connections: int
+
+@dataclass
+class UserSession:
+    """User session tracking."""
+    session_id: str
+    start_time: float
+    last_activity: float
+    total_requests: int
+    unique_endpoints: int
+    user_agent: str
+    ip_address: str
+
+class AnalyticsManager:
+    """Manages analytics and metrics collection."""
+    
+    def __init__(self, db_path: str = "api_mocker_analytics.db"):
+        self.db_path = Path(db_path)
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._lock = threading.Lock()
+        self.server_id = str(uuid.uuid4())
+        self.start_time = time.time()
+        self._init_database()
+        
+    def _init_database(self):
+        """Initialize the analytics database."""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS request_metrics (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    request_id TEXT NOT NULL,
+                    timestamp REAL NOT NULL,
+                    method TEXT NOT NULL,
+                    path TEXT NOT NULL,
+                    status_code INTEGER NOT NULL,
+                    response_time_ms REAL NOT NULL,
+                    request_size_bytes INTEGER NOT NULL,
+                    response_size_bytes INTEGER NOT NULL,
+                    user_agent TEXT,
+                    ip_address TEXT,
+                    path_params TEXT,
+                    query_params TEXT,
+                    server_id TEXT NOT NULL
+                )
+            """)
+            
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS server_metrics (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    server_id TEXT NOT NULL,
+                    timestamp REAL NOT NULL,
+                    uptime_seconds REAL NOT NULL,
+                    total_requests INTEGER NOT NULL,
+                    requests_per_minute REAL NOT NULL,
+                    average_response_time_ms REAL NOT NULL,
+                    error_rate REAL NOT NULL,
+                    memory_usage_mb REAL NOT NULL,
+                    cpu_usage_percent REAL NOT NULL,
+                    active_connections INTEGER NOT NULL
+                )
+            """)
+            
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS user_sessions (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    session_id TEXT NOT NULL,
+                    start_time REAL NOT NULL,
+                    last_activity REAL NOT NULL,
+                    total_requests INTEGER NOT NULL,
+                    unique_endpoints INTEGER NOT NULL,
+                    user_agent TEXT,
+                    ip_address TEXT,
+                    server_id TEXT NOT NULL
+                )
+            """)
+            
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS feature_usage (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    feature_name TEXT NOT NULL,
+                    usage_count INTEGER NOT NULL,
+                    last_used REAL NOT NULL,
+                    server_id TEXT NOT NULL
+                )
+            """)
+            
+            # Create indexes for better performance
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_request_timestamp ON request_metrics(timestamp)")
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_request_path ON request_metrics(path)")
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_server_metrics_timestamp ON server_metrics(timestamp)")
+            
+    def track_request(self, metrics: RequestMetrics):
+        """Track a single request."""
+        with self._lock:
+            with sqlite3.connect(self.db_path) as conn:
+                conn.execute("""
+                    INSERT INTO request_metrics 
+                    (request_id, timestamp, method, path, status_code, response_time_ms,
+                     request_size_bytes, response_size_bytes, user_agent, ip_address,
+                     path_params, query_params, server_id)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """, (
+                    metrics.request_id, metrics.timestamp, metrics.method, metrics.path,
+                    metrics.status_code, metrics.response_time_ms, metrics.request_size_bytes,
+                    metrics.response_size_bytes, metrics.user_agent, metrics.ip_address,
+                    json.dumps(metrics.path_params), json.dumps(metrics.query_params),
+                    self.server_id
+                ))
+                
+    def get_server_metrics(self) -> ServerMetrics:
+        """Get current server metrics."""
+        with sqlite3.connect(self.db_path) as conn:
+            # Get total requests
+            total_requests = conn.execute(
+                "SELECT COUNT(*) FROM request_metrics WHERE server_id = ?", 
+                (self.server_id,)
+            ).fetchone()[0]
+            
+            # Get requests in last minute
+            one_minute_ago = time.time() - 60
+            recent_requests = conn.execute(
+                "SELECT COUNT(*) FROM request_metrics WHERE server_id = ? AND timestamp > ?",
+                (self.server_id, one_minute_ago)
+            ).fetchone()[0]
+            
+            # Get average response time
+            avg_response_time = conn.execute(
+                "SELECT AVG(response_time_ms) FROM request_metrics WHERE server_id = ?",
+                (self.server_id,)
+            ).fetchone()[0] or 0
+            
+            # Get error rate
+            total_errors = conn.execute(
+                "SELECT COUNT(*) FROM request_metrics WHERE server_id = ? AND status_code >= 400",
+                (self.server_id,)
+            ).fetchone()[0]
+            error_rate = (total_errors / total_requests * 100) if total_requests > 0 else 0
+            
+            # System metrics
+            memory_usage = psutil.virtual_memory().percent
+            cpu_usage = psutil.cpu_percent()
+            
+            return ServerMetrics(
+                server_id=self.server_id,
+                start_time=self.start_time,
+                uptime_seconds=time.time() - self.start_time,
+                total_requests=total_requests,
+                requests_per_minute=recent_requests,
+                average_response_time_ms=avg_response_time,
+                error_rate=error_rate,
+                memory_usage_mb=memory_usage,
+                cpu_usage_percent=cpu_usage,
+                active_connections=0  # TODO: Implement connection tracking
+            )
+            
+    def track_feature_usage(self, feature_name: str):
+        """Track feature usage."""
+        with self._lock:
+            with sqlite3.connect(self.db_path) as conn:
+                # Check if feature exists
+                existing = conn.execute(
+                    "SELECT usage_count FROM feature_usage WHERE feature_name = ? AND server_id = ?",
+                    (feature_name, self.server_id)
+                ).fetchone()
+                
+                if existing:
+                    conn.execute("""
+                        UPDATE feature_usage 
+                        SET usage_count = usage_count + 1, last_used = ?
+                        WHERE feature_name = ? AND server_id = ?
+                    """, (time.time(), feature_name, self.server_id))
+                else:
+                    conn.execute("""
+                        INSERT INTO feature_usage (feature_name, usage_count, last_used, server_id)
+                        VALUES (?, 1, ?, ?)
+                    """, (feature_name, time.time(), self.server_id))
+                    
+    def get_analytics_summary(self, hours: int = 24) -> Dict[str, Any]:
+        """Get analytics summary for the specified time period."""
+        since = time.time() - (hours * 3600)
+        
+        with sqlite3.connect(self.db_path) as conn:
+            # Request statistics
+            total_requests = conn.execute(
+                "SELECT COUNT(*) FROM request_metrics WHERE server_id = ? AND timestamp > ?",
+                (self.server_id, since)
+            ).fetchone()[0]
+            
+            # Method distribution
+            methods = conn.execute("""
+                SELECT method, COUNT(*) as count 
+                FROM request_metrics 
+                WHERE server_id = ? AND timestamp > ?
+                GROUP BY method
+            """, (self.server_id, since)).fetchall()
+            
+            # Status code distribution
+            status_codes = conn.execute("""
+                SELECT status_code, COUNT(*) as count 
+                FROM request_metrics 
+                WHERE server_id = ? AND timestamp > ?
+                GROUP BY status_code
+            """, (self.server_id, since)).fetchall()
+            
+            # Most popular endpoints
+            popular_endpoints = conn.execute("""
+                SELECT path, COUNT(*) as count 
+                FROM request_metrics 
+                WHERE server_id = ? AND timestamp > ?
+                GROUP BY path 
+                ORDER BY count DESC 
+                LIMIT 10
+            """, (self.server_id, since)).fetchall()
+            
+            # Average response times by endpoint
+            response_times = conn.execute("""
+                SELECT path, AVG(response_time_ms) as avg_time 
+                FROM request_metrics 
+                WHERE server_id = ? AND timestamp > ?
+                GROUP BY path 
+                ORDER BY avg_time DESC 
+                LIMIT 10
+            """, (self.server_id, since)).fetchall()
+            
+            # Feature usage
+            feature_usage = conn.execute("""
+                SELECT feature_name, usage_count 
+                FROM feature_usage 
+                WHERE server_id = ?
+                ORDER BY usage_count DESC
+            """, (self.server_id,)).fetchall()
+            
+            return {
+                "period_hours": hours,
+                "total_requests": total_requests,
+                "methods": dict(methods),
+                "status_codes": dict(status_codes),
+                "popular_endpoints": dict(popular_endpoints),
+                "slowest_endpoints": dict(response_times),
+                "feature_usage": dict(feature_usage),
+                "server_metrics": asdict(self.get_server_metrics())
+            }
+            
+    def export_analytics(self, output_path: str, format: str = "json"):
+        """Export analytics data."""
+        summary = self.get_analytics_summary()
+        
+        if format.lower() == "json":
+            with open(output_path, 'w') as f:
+                json.dump(summary, f, indent=2)
+        elif format.lower() == "csv":
+            # TODO: Implement CSV export
+            pass
+            
+    def cleanup_old_data(self, days: int = 30):
+        """Clean up old analytics data."""
+        cutoff = time.time() - (days * 24 * 3600)
+        
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute(
+                "DELETE FROM request_metrics WHERE timestamp < ?",
+                (cutoff,)
+            )
+            conn.execute(
+                "DELETE FROM server_metrics WHERE timestamp < ?",
+                (cutoff,)
+            )
+            conn.execute(
+                "DELETE FROM user_sessions WHERE last_activity < ?",
+                (cutoff,)
+            )
+
+class AnalyticsMiddleware:
+    """FastAPI middleware for automatic analytics tracking."""
+    
+    def __init__(self, analytics_manager: AnalyticsManager):
+        self.analytics = analytics_manager
+        
+    async def __call__(self, request, call_next):
+        start_time = time.time()
+        
+        # Track feature usage
+        self.analytics.track_feature_usage("http_request")
+        
+        # Process request
+        response = await call_next(request)
+        
+        # Calculate metrics
+        end_time = time.time()
+        response_time_ms = (end_time - start_time) * 1000
+        
+        # Get request size (approximate)
+        request_size = len(str(request.headers)) + len(str(request.query_params))
+        if hasattr(request, 'body'):
+            request_size += len(str(request.body))
+            
+        # Get response size (approximate)
+        response_size = len(str(response.headers))
+        if hasattr(response, 'body'):
+            response_size += len(str(response.body))
+            
+        # Create metrics
+        metrics = RequestMetrics(
+            request_id=str(uuid.uuid4()),
+            timestamp=start_time,
+            method=request.method,
+            path=request.url.path,
+            status_code=response.status_code,
+            response_time_ms=response_time_ms,
+            request_size_bytes=request_size,
+            response_size_bytes=response_size,
+            user_agent=request.headers.get("user-agent", ""),
+            ip_address=request.client.host if request.client else "",
+            path_params=dict(request.path_params),
+            query_params=dict(request.query_params)
+        )
+        
+        # Track the request
+        self.analytics.track_request(metrics)
+        
+        return response 

api_mocker/cli.py

@@ -11,6 +11,9 @@ from api_mocker import MockServer
 from api_mocker.openapi import OpenAPIParser, PostmanImporter
 from api_mocker.recorder import RequestRecorder, ProxyRecorder, ReplayEngine
 from api_mocker.plugins import PluginManager, BUILTIN_PLUGINS
+from api_mocker.analytics import AnalyticsManager
+from api_mocker.dashboard import DashboardManager
+from api_mocker.advanced import AdvancedFeatures, RateLimitConfig, CacheConfig, AuthConfig
 
 app = typer.Typer(help="api-mocker: The industry-standard, production-ready, free API mocking and development acceleration tool.")
 console = Console()
@@ -493,5 +496,169 @@ api-mocker record https://api.example.com --output recordings/recorded.json
             console.print(f"[red]✗[/red] Failed to create project: {e}")
             raise typer.Exit(1)
 
+@app.command()
+def analytics(
+    action: str = typer.Argument(..., help="Analytics action (dashboard, export, summary)"),
+    hours: int = typer.Option(24, "--hours", help="Time period for analytics (hours)"),
+    output: str = typer.Option(None, "--output", help="Output file for export"),
+    format: str = typer.Option("json", "--format", help="Export format (json, csv)"),
+):
+    """Manage analytics and metrics."""
+    try:
+        analytics_manager = AnalyticsManager()
+        
+        if action == "dashboard":
+            console.print("[blue]📊[/blue] Starting analytics dashboard...")
+            dashboard = DashboardManager(analytics_manager)
+            dashboard.start()
+            
+        elif action == "export":
+            if not output:
+                output = f"analytics-{int(time.time())}.{format}"
+                
+            console.print(f"[blue]📤[/blue] Exporting analytics to {output}...")
+            analytics_manager.export_analytics(output, format)
+            console.print(f"[green]✓[/green] Analytics exported to: {output}")
+            
+        elif action == "summary":
+            console.print(f"[blue]📈[/blue] Generating analytics summary for last {hours} hours...")
+            summary = analytics_manager.get_analytics_summary(hours)
+            
+            # Display summary
+            table = Table(title=f"Analytics Summary (Last {hours} hours)")
+            table.add_column("Metric", style="cyan")
+            table.add_column("Value", style="green")
+            
+            table.add_row("Total Requests", str(summary["total_requests"]))
+            table.add_row("Popular Endpoints", str(len(summary["popular_endpoints"])))
+            table.add_row("Average Response Time", f"{summary['server_metrics']['average_response_time_ms']:.2f}ms")
+            table.add_row("Error Rate", f"{summary['server_metrics']['error_rate']:.2f}%")
+            
+            console.print(table)
+            
+        else:
+            console.print(f"[red]✗[/red] Unknown action: {action}")
+            raise typer.Exit(1)
+            
+    except Exception as e:
+        console.print(f"[red]✗[/red] Analytics error: {e}")
+        raise typer.Exit(1)
+
+@app.command()
+def advanced(
+    feature: str = typer.Argument(..., help="Advanced feature (rate-limit, cache, auth, health)"),
+    config_file: str = typer.Option(None, "--config", help="Configuration file path"),
+    enable: bool = typer.Option(True, "--enable/--disable", help="Enable or disable feature"),
+):
+    """Configure advanced features."""
+    try:
+        if feature == "rate-limit":
+            console.print("[blue]🛡️[/blue] Configuring rate limiting...")
+            
+            config = RateLimitConfig(
+                requests_per_minute=60,
+                requests_per_hour=1000,
+                burst_size=10
+            )
+            
+            if config_file:
+                # Load from file
+                with open(config_file, 'r') as f:
+                    if config_file.endswith('.yaml') or config_file.endswith('.yml'):
+                        import yaml
+                        file_config = yaml.safe_load(f)
+                    else:
+                        file_config = json.load(f)
+                        
+                config = RateLimitConfig(**file_config.get("rate_limit", {}))
+            
+            console.print(f"[green]✓[/green] Rate limiting configured:")
+            console.print(f"  - Requests per minute: {config.requests_per_minute}")
+            console.print(f"  - Requests per hour: {config.requests_per_hour}")
+            console.print(f"  - Burst size: {config.burst_size}")
+            
+        elif feature == "cache":
+            console.print("[blue]⚡[/blue] Configuring caching...")
+            
+            config = CacheConfig(
+                enabled=True,
+                ttl_seconds=300,
+                max_size=1000,
+                strategy="lru"
+            )
+            
+            if config_file:
+                with open(config_file, 'r') as f:
+                    if config_file.endswith('.yaml') or config_file.endswith('.yml'):
+                        import yaml
+                        file_config = yaml.safe_load(f)
+                    else:
+                        file_config = json.load(f)
+                        
+                config = CacheConfig(**file_config.get("cache", {}))
+            
+            console.print(f"[green]✓[/green] Caching configured:")
+            console.print(f"  - Enabled: {config.enabled}")
+            console.print(f"  - TTL: {config.ttl_seconds} seconds")
+            console.print(f"  - Max size: {config.max_size}")
+            console.print(f"  - Strategy: {config.strategy}")
+            
+        elif feature == "auth":
+            console.print("[blue]🔐[/blue] Configuring authentication...")
+            
+            config = AuthConfig(
+                enabled=True,
+                secret_key="your-secret-key-change-this",
+                algorithm="HS256",
+                token_expiry_hours=24
+            )
+            
+            if config_file:
+                with open(config_file, 'r') as f:
+                    if config_file.endswith('.yaml') or config_file.endswith('.yml'):
+                        import yaml
+                        file_config = yaml.safe_load(f)
+                    else:
+                        file_config = json.load(f)
+                        
+                config = AuthConfig(**file_config.get("auth", {}))
+            
+            console.print(f"[green]✓[/green] Authentication configured:")
+            console.print(f"  - Enabled: {config.enabled}")
+            console.print(f"  - Algorithm: {config.algorithm}")
+            console.print(f"  - Token expiry: {config.token_expiry_hours} hours")
+            
+        elif feature == "health":
+            console.print("[blue]🏥[/blue] Running health checks...")
+            
+            from api_mocker.advanced import HealthChecker, check_database_connection, check_memory_usage, check_disk_space
+            
+            health_checker = HealthChecker()
+            health_checker.add_check("database", check_database_connection)
+            health_checker.add_check("memory", check_memory_usage)
+            health_checker.add_check("disk", check_disk_space)
+            
+            status = health_checker.get_health_status()
+            
+            table = Table(title="Health Check Results")
+            table.add_column("Check", style="cyan")
+            table.add_column("Status", style="green")
+            
+            for check_name, check_status in status["checks"].items():
+                status_icon = "✓" if check_status else "✗"
+                status_color = "green" if check_status else "red"
+                table.add_row(check_name, f"[{status_color}]{status_icon}[/{status_color}]")
+            
+            console.print(table)
+            console.print(f"Overall status: {status['status']}")
+            
+        else:
+            console.print(f"[red]✗[/red] Unknown feature: {feature}")
+            raise typer.Exit(1)
+            
+    except Exception as e:
+        console.print(f"[red]✗[/red] Advanced feature error: {e}")
+        raise typer.Exit(1)
+
 if __name__ == "__main__":
     app()