Update demo/mock_arf.py

demo/mock_arf.py

@@ -1,223 +1,370 @@
+# demo/mock_arf.py
 """
-Configuration management for ARF Demo
-Updated for better Pydantic compatibility and fallback handling
+Enhanced Mock ARF with scenario-aware metrics
+Generates different values based on scenario characteristics
 """
-from typing import Optional, Dict, Any, List
-from enum import Enum
-import os
-import logging
+import random
+import time
+from typing import Dict, Any, List
+import json
 
-logger = logging.getLogger(__name__)
+# Scenario-specific configurations
+SCENARIO_CONFIGS = {
+    "Cache Miss Storm": {
+        "detection_confidence_range": (0.97, 0.995),  # 97-99.5%
+        "detection_time_range": (35, 55),  # 35-55 seconds
+        "accuracy_range": (0.97, 0.995),  # 97-99.5%
+        "similar_incidents_range": (2, 5),  # 2-5 similar incidents
+        "similarity_score_range": (0.88, 0.96),  # 88-96% similarity
+        "pattern_confidence_range": (0.91, 0.97),  # 91-97% confidence
+        "success_rate_range": (0.82, 0.93),  # 82-93% success rate
+        "cost_savings_range": (5000, 9000),  # $5K-$9K savings
+        "resolution_time_range": (10, 18),  # 10-18 minutes
+        "affected_users_range": (30000, 60000),  # 30K-60K users
+        "tags": ["cache", "redis", "latency", "memory"]
+    },
+    "Database Connection Pool Exhaustion": {
+        "detection_confidence_range": (0.92, 0.98),
+        "detection_time_range": (40, 65),
+        "accuracy_range": (0.95, 0.985),
+        "similar_incidents_range": (1, 4),
+        "similarity_score_range": (0.85, 0.94),
+        "pattern_confidence_range": (0.88, 0.95),
+        "success_rate_range": (0.78, 0.88),
+        "cost_savings_range": (3500, 5500),
+        "resolution_time_range": (15, 25),
+        "affected_users_range": (15000, 30000),
+        "tags": ["database", "postgres", "connections", "pool"]
+    },
+    "Kubernetes Memory Leak": {
+        "detection_confidence_range": (0.94, 0.99),
+        "detection_time_range": (30, 50),
+        "accuracy_range": (0.96, 0.99),
+        "similar_incidents_range": (3, 6),
+        "similarity_score_range": (0.89, 0.95),
+        "pattern_confidence_range": (0.90, 0.96),
+        "success_rate_range": (0.85, 0.92),
+        "cost_savings_range": (4500, 7500),
+        "resolution_time_range": (12, 22),
+        "affected_users_range": (20000, 40000),
+        "tags": ["kubernetes", "memory", "container", "leak"]
+    },
+    "API Rate Limit Storm": {
+        "detection_confidence_range": (0.96, 0.99),
+        "detection_time_range": (25, 45),
+        "accuracy_range": (0.97, 0.99),
+        "similar_incidents_range": (2, 4),
+        "similarity_score_range": (0.87, 0.93),
+        "pattern_confidence_range": (0.89, 0.94),
+        "success_rate_range": (0.80, 0.90),
+        "cost_savings_range": (3000, 5000),
+        "resolution_time_range": (8, 15),
+        "affected_users_range": (10000, 25000),
+        "tags": ["api", "rate_limit", "throttling", "ddos"]
+    },
+    "Network Partition": {
+        "detection_confidence_range": (0.98, 0.999),
+        "detection_time_range": (20, 40),
+        "accuracy_range": (0.98, 0.995),
+        "similar_incidents_range": (1, 3),
+        "similarity_score_range": (0.90, 0.97),
+        "pattern_confidence_range": (0.93, 0.98),
+        "success_rate_range": (0.75, 0.85),
+        "cost_savings_range": (8000, 15000),
+        "resolution_time_range": (20, 35),
+        "affected_users_range": (50000, 100000),
+        "tags": ["network", "partition", "connectivity", "failure"]
+    },
+    "Storage I/O Saturation": {
+        "detection_confidence_range": (0.93, 0.98),
+        "detection_time_range": (45, 70),
+        "accuracy_range": (0.94, 0.98),
+        "similar_incidents_range": (2, 5),
+        "similarity_score_range": (0.86, 0.92),
+        "pattern_confidence_range": (0.87, 0.93),
+        "success_rate_range": (0.79, 0.87),
+        "cost_savings_range": (5500, 8500),
+        "resolution_time_range": (18, 28),
+        "affected_users_range": (25000, 45000),
+        "tags": ["storage", "disk", "io", "saturation"]
+    }
+}
+
+def get_scenario_config(scenario_name: str) -> Dict[str, Any]:
+    """Get configuration for a specific scenario with defaults"""
+    return SCENARIO_CONFIGS.get(scenario_name, {
+        "detection_confidence_range": (0.90, 0.98),
+        "detection_time_range": (30, 60),
+        "accuracy_range": (0.92, 0.98),
+        "similar_incidents_range": (1, 3),
+        "similarity_score_range": (0.85, 0.95),
+        "pattern_confidence_range": (0.85, 0.95),
+        "success_rate_range": (0.75, 0.90),
+        "cost_savings_range": (4000, 8000),
+        "resolution_time_range": (15, 30),
+        "affected_users_range": (20000, 50000),
+        "tags": ["unknown", "incident"]
+    })
 
-# Try to import from pydantic-settings, fallback to pydantic
-try:
-    from pydantic_settings import BaseSettings
-    from pydantic import Field, field_validator, ConfigDict
-    PYDANTIC_V2 = True
-    logger.info("Using pydantic-settings for BaseSettings")
-except ImportError:
-    try:
-        from pydantic import BaseSettings, Field, validator
-        PYDANTIC_V2 = False
-        logger.info("Using pydantic.BaseSettings (older version)")
-    except ImportError as e:
-        logger.warning(f"Failed to import pydantic: {e}. Using fallback settings.")
-        # Create minimal fallback
-        class BaseSettings:
-            model_config = {}
-            def __init__(self, **kwargs):
-                for k, v in kwargs.items():
-                    setattr(self, k, v)
+def simulate_arf_analysis(scenario_data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Simulate ARF analysis with scenario-specific metrics
+    
+    Args:
+        scenario_data: Dictionary containing scenario information
         
-        class Field:
-            @staticmethod
-            def default(value):
-                return value
+    Returns:
+        Dictionary with analysis results
+    """
+    scenario_name = scenario_data.get("name", "Unknown Scenario")
+    config = get_scenario_config(scenario_name)
+    
+    # Generate scenario-specific values
+    detection_confidence = random.uniform(*config["detection_confidence_range"])
+    detection_time = random.randint(*config["detection_time_range"])
+    accuracy = random.uniform(*config["accuracy_range"])
+    
+    return {
+        "analysis_complete": True,
+        "anomaly_detected": True,
+        "severity": scenario_data.get("severity", "HIGH"),
+        "confidence": round(detection_confidence, 3),  # Round to 3 decimals
+        "detection_time_ms": detection_time * 1000,  # Convert to ms for display
+        "detection_time_seconds": detection_time,
+        "accuracy": round(accuracy, 3),
+        "component": scenario_data.get("component", "unknown"),
+        "scenario_specific": True,
+        "scenario_name": scenario_name,
+        "tags": config["tags"]
+    }
+
+def run_rag_similarity_search(scenario_data: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """
+    Simulate RAG similarity search with scenario-specific results
+    
+    Args:
+        scenario_data: Dictionary containing scenario information
         
-        def validator(*args, **kwargs):
-            def decorator(func):
-                return func
-            return decorator
+    Returns:
+        List of similar incidents
+    """
+    scenario_name = scenario_data.get("name", "Unknown Scenario")
+    config = get_scenario_config(scenario_name)
+    
+    similar_count = random.randint(*config["similar_incidents_range"])
+    similar_incidents = []
+    
+    # Generate similar incidents based on scenario
+    base_time = int(time.time())
+    
+    for i in range(similar_count):
+        similarity_score = random.uniform(*config["similarity_score_range"])
+        cost_savings = random.randint(*config["cost_savings_range"])
+        resolution_time = random.randint(*config["resolution_time_range"])
+        affected_users = random.randint(*config["affected_users_range"])
         
-        def field_validator(*args, **kwargs):
-            def decorator(func):
-                return func
-            return decorator
+        # Different resolutions based on scenario type
+        if "cache" in scenario_name.lower() or "redis" in scenario_name.lower():
+            resolution = random.choice(["scale_out", "warm_cache", "memory_increase", "add_replicas"])
+        elif "database" in scenario_name.lower():
+            resolution = random.choice(["restart", "connection_pool_resize", "index_optimization", "vacuum"])
+        elif "kubernetes" in scenario_name.lower():
+            resolution = random.choice(["restart_pod", "memory_limit_increase", "node_drain", "resource_quota"])
+        elif "api" in scenario_name.lower():
+            resolution = random.choice(["circuit_breaker", "rate_limit_increase", "caching", "load_balancer"])
+        elif "network" in scenario_name.lower():
+            resolution = random.choice(["route_update", "failover", "bandwidth_increase", "redundancy"])
+        elif "storage" in scenario_name.lower():
+            resolution = random.choice(["io_optimization", "disk_upgrade", "cache_addition", "load_distribution"])
+        else:
+            resolution = random.choice(["investigate", "scale", "restart", "optimize"])
         
-        PYDANTIC_V2 = False
-
-
-class ARFMode(str, Enum):
-    """ARF operation modes"""
-    DEMO = "demo"
-    OSS = "oss"
-    ENTERPRISE = "enterprise"
-
-
-class SafetyMode(str, Enum):
-    """Safety modes for execution"""
-    ADVISORY = "advisory"
-    APPROVAL = "approval"
-    AUTONOMOUS = "autonomous"
-
+        similar_incidents.append({
+            "incident_id": f"inc_{base_time - random.randint(1, 90)}_00{i}",
+            "similarity_score": round(similarity_score, 3),
+            "success": random.random() > 0.15,  # 85% success rate
+            "resolution": resolution,
+            "cost_savings": cost_savings,
+            "detection_time": f"{random.randint(30, 60)}s",
+            "resolution_time": f"{resolution_time}m",
+            "pattern": f"{scenario_name.lower().replace(' ', '_')}_v{random.randint(1, 3)}",
+            "affected_users": affected_users,
+            "component_match": scenario_data.get("component", "unknown"),
+            "rag_source": "production_memory_v3",
+            "timestamp": f"2024-{random.randint(1, 12):02d}-{random.randint(1, 28):02d}"
+        })
+    
+    return similar_incidents
 
-class Settings(BaseSettings):
+def calculate_pattern_confidence(scenario_data: Dict[str, Any], similar_incidents: List[Dict[str, Any]]) -> float:
     """
-    Application settings with environment variable support
+    Calculate pattern confidence based on similar incidents
+    
+    Args:
+        scenario_data: Dictionary containing scenario information
+        similar_incidents: List of similar incidents from RAG search
+        
+    Returns:
+        Pattern confidence score (0-1)
     """
+    scenario_name = scenario_data.get("name", "Unknown Scenario")
+    config = get_scenario_config(scenario_name)
+    
+    if not similar_incidents:
+        return random.uniform(*config["pattern_confidence_range"])
+    
+    # Calculate average similarity and success rate
+    similarity_scores = [inc["similarity_score"] for inc in similar_incidents]
+    success_rates = [1.0 if inc["success"] else 0.0 for inc in similar_incidents]
+    
+    avg_similarity = sum(similarity_scores) / len(similarity_scores)
+    avg_success = sum(success_rates) / len(success_rates)
     
-    # ===== System Mode =====
-    arf_mode: ARFMode = Field(
-        default=ARFMode.DEMO,
-        description="ARF operation mode"
-    )
-    
-    use_mock_arf: bool = Field(
-        default=True,
-        description="Use mock ARF implementation (for demo mode)"
-    )
-    
-    # ===== ARF Configuration =====
-    arf_api_key: Optional[str] = Field(
-        default=None,
-        description="ARF API key for real integration"
-    )
-    
-    arf_base_url: str = Field(
-        default="https://api.arf.dev",
-        description="ARF API base URL"
-    )
-    
-    # ===== Business Configuration =====
-    engineer_hourly_rate: float = Field(
-        default=150.0,
-        description="Engineer hourly rate in USD"
-    )
-    
-    engineer_annual_cost: float = Field(
-        default=125000.0,
-        description="Engineer annual cost in USD"
-    )
-    
-    default_savings_rate: float = Field(
-        default=0.82,
-        description="Default savings rate with ARF"
-    )
-    
-    # ===== UI Configuration =====
-    auto_refresh_seconds: int = Field(
-        default=30,
-        description="Auto-refresh interval in seconds"
-    )
-    
-    max_history_items: int = Field(
-        default=100,
-        description="Maximum history items to display"
-    )
-    
-    # ===== Demo Configuration =====
-    default_scenario: str = Field(
-        default="Cache Miss Storm",
-        description="Default incident scenario"
-    )
-    
-    scenario_config_path: str = Field(
-        default="config/scenarios",
-        description="Path to scenario configuration files"
-    )
-    
-    # ===== Safety Configuration =====
-    default_safety_mode: SafetyMode = Field(
-        default=SafetyMode.ADVISORY,
-        description="Default safety mode"
-    )
-    
-    require_approval: bool = Field(
-        default=True,
-        description="Require human approval for execution"
-    )
-    
-    # ===== Validation =====
-    if PYDANTIC_V2:
-        @field_validator("arf_api_key")
-        @classmethod
-        def validate_api_key(cls, v: Optional[str], info) -> Optional[str]:
-            if info.data.get("arf_mode") == ARFMode.ENTERPRISE and not v:
-                raise ValueError("ARF API key required for Enterprise mode")
-            return v
+    # Weighted average: 60% similarity, 40% success rate
+    confidence = (avg_similarity * 0.6) + (avg_success * 0.4)
+    
+    # Add some randomness but keep within scenario range
+    min_conf, max_conf = config["pattern_confidence_range"]
+    confidence = max(min_conf, min(max_conf, confidence))
+    
+    return round(confidence, 3)
+
+def create_mock_healing_intent(scenario_data: Dict[str, Any], similar_incidents: List[Dict[str, Any]], confidence: float) -> Dict[str, Any]:
+    """
+    Create mock healing intent based on scenario and similar incidents
+    
+    Args:
+        scenario_data: Dictionary containing scenario information
+        similar_incidents: List of similar incidents from RAG search
+        confidence: Pattern confidence score
         
-        @field_validator("use_mock_arf")
-        @classmethod
-        def validate_mock_mode(cls, v: bool, info) -> bool:
-            if info.data.get("arf_mode") == ARFMode.DEMO:
-                return True
-            return v
+    Returns:
+        Healing intent dictionary
+    """
+    scenario_name = scenario_data.get("name", "Unknown Scenario")
+    config = get_scenario_config(scenario_name)
+    
+    component = scenario_data.get("component", "unknown")
+    
+    # Determine action based on component and scenario
+    if "cache" in component.lower() or "redis" in component.lower():
+        action = "scale_out"
+        parameters = {
+            "nodes": f"{random.randint(2, 4)}→{random.randint(5, 8)}",
+            "memory": f"{random.randint(8, 16)}GB→{random.randint(24, 64)}GB",
+            "strategy": "gradual_scale",
+            "region": "auto-select"
+        }
+    elif "database" in component.lower():
+        action = "restart"
+        parameters = {
+            "connections": f"{random.randint(50, 100)}→{random.randint(150, 300)}",
+            "timeout": f"{random.randint(30, 60)}s",
+            "strategy": "rolling_restart",
+            "maintenance_window": "immediate"
+        }
+    elif "kubernetes" in component.lower():
+        action = "memory_limit_increase"
+        parameters = {
+            "memory": f"{random.randint(512, 1024)}Mi→{random.randint(2048, 4096)}Mi",
+            "strategy": "pod_restart",
+            "drain_timeout": f"{random.randint(5, 15)}m"
+        }
+    elif "api" in component.lower():
+        action = "circuit_breaker"
+        parameters = {
+            "threshold": f"{random.randint(70, 85)}%",
+            "window": f"{random.randint(3, 10)}m",
+            "fallback": "cached_response",
+            "retry_after": f"{random.randint(30, 120)}s"
+        }
+    elif "network" in component.lower():
+        action = "failover"
+        parameters = {
+            "primary": "us-east-1",
+            "secondary": "us-west-2",
+            "timeout": f"{random.randint(10, 30)}s",
+            "health_check": "enhanced"
+        }
+    elif "storage" in component.lower():
+        action = "io_optimization"
+        parameters = {
+            "iops": f"{random.randint(1000, 3000)}→{random.randint(5000, 10000)}",
+            "throughput": f"{random.randint(100, 250)}MB/s→{random.randint(500, 1000)}MB/s",
+            "cache_size": f"{random.randint(8, 16)}GB→{random.randint(32, 64)}GB"
+        }
     else:
-        @validator("arf_api_key")
-        def validate_api_key(cls, v: Optional[str], values: Dict[str, Any]) -> Optional[str]:
-            if values.get("arf_mode") == ARFMode.ENTERPRISE and not v:
-                raise ValueError("ARF API key required for Enterprise mode")
-            return v
-        
-        @validator("use_mock_arf")
-        def validate_mock_mode(cls, v: bool, values: Dict[str, Any]) -> bool:
-            if values.get("arf_mode") == ARFMode.DEMO:
-                return True
-            return v
-    
-    # Pydantic v2 config
-    if PYDANTIC_V2:
-        model_config = ConfigDict(
-            env_file=".env",
-            env_file_encoding="utf-8",
-            case_sensitive=False,
-            use_enum_values=True,
-            extra="ignore"
-        )
+        action = "investigate"
+        parameters = {
+            "priority": "high",
+            "escalation": "tier2",
+            "timeout": "30m"
+        }
+    
+    # Calculate success rate from similar incidents
+    if similar_incidents:
+        success_count = sum(1 for inc in similar_incidents if inc["success"])
+        success_rate = success_count / len(similar_incidents)
     else:
-        class Config:
-            env_file = ".env"
-            env_file_encoding = "utf-8"
-            case_sensitive = False
-            use_enum_values = True
-
-
-# Global settings instance with robust fallback
-try:
-    settings = Settings()
-    logger.info("Settings loaded successfully")
-except Exception as e:
-    logger.warning(f"Failed to load settings from .env: {e}, using defaults")
-    # Provide comprehensive defaults
-    settings = Settings(
-        arf_mode=ARFMode.DEMO,
-        use_mock_arf=True,
-        arf_api_key=None,
-        arf_base_url="https://api.arf.dev",
-        engineer_hourly_rate=150.0,
-        engineer_annual_cost=125000.0,
-        default_savings_rate=0.82,
-        auto_refresh_seconds=30,
-        max_history_items=100,
-        default_scenario="Cache Miss Storm",
-        scenario_config_path="config/scenarios",
-        default_safety_mode=SafetyMode.ADVISORY,
-        require_approval=True
-    )
-
-
-def get_settings() -> Settings:
-    """Get settings instance (singleton pattern)"""
-    return settings
-
-
-def print_settings_summary() -> None:
-    """Print a summary of current settings (for debugging)"""
-    summary = {
-        "mode": settings.arf_mode.value,
-        "mock_mode": settings.use_mock_arf,
-        "default_scenario": settings.default_scenario,
-        "safety_mode": settings.default_safety_mode.value,
-        "requires_approval": settings.require_approval
+        success_rate = random.uniform(*config["success_rate_range"])
+    
+    # Calculate estimated impact
+    if similar_incidents:
+        avg_cost_savings = sum(inc["cost_savings"] for inc in similar_incidents) / len(similar_incidents)
+        avg_resolution_time = sum(int(inc["resolution_time"].replace('m', '')) for inc in similar_incidents) / len(similar_incidents)
+    else:
+        avg_cost_savings = sum(config["cost_savings_range"]) / 2
+        avg_resolution_time = sum(config["resolution_time_range"]) / 2
+    
+    return {
+        "action": action,
+        "component": component,
+        "confidence": round(confidence, 3),
+        "parameters": parameters,
+        "source": "mock_analysis",
+        "requires_enterprise": True,
+        "advisory_only": True,
+        "success_rate": round(success_rate, 3),
+        "estimated_impact": {
+            "cost_savings": int(avg_cost_savings),
+            "resolution_time_minutes": int(avg_resolution_time),
+            "users_protected": random.randint(*config["affected_users_range"]),
+            "mttr_reduction": f"{random.randint(60, 80)}%"
+        },
+        "safety_checks": {
+            "blast_radius": f"{random.randint(1, 3)} services",
+            "business_hours": "compliant",
+            "rollback_plan": "available",
+            "approval_required": True,
+            "risk_level": "medium" if confidence < 0.9 else "low"
+        },
+        "scenario_specific": True,
+        "scenario_name": scenario_name
     }
-    logger.info(f"Settings summary: {summary}")
+
+def get_scenario_metrics(scenario_name: str) -> Dict[str, Any]:
+    """
+    Get dynamic metrics for a specific scenario
+    
+    Args:
+        scenario_name: Name of the scenario
+        
+    Returns:
+        Dictionary with scenario-specific metrics
+    """
+    config = get_scenario_config(scenario_name)
+    
+    # Generate dynamic values within ranges
+    return {
+        "detection_confidence": round(random.uniform(*config["detection_confidence_range"]), 3),
+        "detection_time_seconds": random.randint(*config["detection_time_range"]),
+        "accuracy": round(random.uniform(*config["accuracy_range"]), 3),
+        "expected_similar_incidents": random.randint(*config["similar_incidents_range"]),
+        "avg_similarity_score": round(random.uniform(*config["similarity_score_range"]), 3),
+        "pattern_confidence": round(random.uniform(*config["pattern_confidence_range"]), 3),
+        "success_rate": round(random.uniform(*config["success_rate_range"]), 3),
+        "cost_savings_range": config["cost_savings_range"],
+        "resolution_time_range": config["resolution_time_range"],
+        "affected_users_range": config["affected_users_range"],
+        "tags": config["tags"]
+    }