debug_execution_engine.py

#!/usr/bin/env python3
"""Debug script for Milestone 2.5: Execution Engine.

This script walks through each component step-by-step.
Run with: python debug_execution_engine.py

Recommended: Set breakpoints in your IDE at the marked locations.
"""

import asyncio
import sys
from datetime import datetime, timezone
from pathlib import Path

# Add project root to path
project_root = Path(__file__).parent
sys.path.insert(0, str(project_root))

# Enable verbose logging
import logging

logging.basicConfig(
    level=logging.DEBUG, format="%(asctime)s | %(name)s | %(levelname)s | %(message)s"
)

print("=" * 80)
print("MILESTONE 2.5 DEBUG: Execution Engine Deep Dive")
print("=" * 80)


# =============================================================================
# PART 1: Understanding the Schemas (Data Models)
# =============================================================================


def debug_part1_schemas():
    """Debug Part 1: Understand ExecutionStatus and ExecutionResult."""
    print("\n" + "=" * 80)
    print("PART 1: SCHEMAS - ExecutionStatus & ExecutionResult")
    print("=" * 80)

    # BREAKPOINT 1: Set breakpoint here
    from src.agents.schemas import ExecutionResult, ExecutionStatus

    # --- ExecutionStatus Enum ---
    print("\n📦 ExecutionStatus Enum:")
    print("-" * 40)

    # This enum tracks the lifecycle of an action
    for status in ExecutionStatus:
        print(f"  {status.name} = '{status.value}'")

    # State machine visualization:
    print("\n📊 State Machine:")
    print(
        """
    PENDING → RUNNING → SUCCESS
                ↓
              FAILED → ROLLED_BACK
    """
    )

    # --- ExecutionResult Model ---
    print("\n📦 ExecutionResult Model:")
    print("-" * 40)

    # BREAKPOINT 2: Step into ExecutionResult creation
    #
    # TO DEBUG: Set breakpoint on the next line (line 70)
    # If breakpoint doesn't stop:
    #   1. Make sure you're running in DEBUG mode (F5), not just running (F9)
    #   2. Check .vscode/launch.json exists (I created it for you)
    #   3. Try the simple version: debug_execution_engine_simple.py
    #   4. Or add: import pdb; pdb.set_trace() before this line

    result = ExecutionResult(
        action_id="test-action-001",
        status=ExecutionStatus.SUCCESS,
        started_at=datetime.now(timezone.utc),
        completed_at=datetime.now(timezone.utc),
    )

    print(f"  action_id: {result.action_id}")
    print(f"  status: {result.status}")
    print(f"  started_at: {result.started_at}")
    print(f"  completed_at: {result.completed_at}")
    print(f"  error_message: {result.error_message}")
    print(f"  rollback_status: {result.rollback_status}")

    # --- Failed Result with Rollback ---
    print("\n📦 ExecutionResult with Rollback:")
    print("-" * 40)

    failed_result = ExecutionResult(
        action_id="test-action-002",
        status=ExecutionStatus.FAILED,
        started_at=datetime.now(timezone.utc),
        completed_at=datetime.now(timezone.utc),
        error_message="Connection timeout",
        rollback_status=ExecutionStatus.SUCCESS,
        rollback_completed_at=datetime.now(timezone.utc),
    )

    print(f"  status: {failed_result.status}")
    print(f"  error_message: {failed_result.error_message}")
    print(f"  rollback_status: {failed_result.rollback_status}")

    print("\n✅ Part 1 Complete: You now understand the data models")
    return result, failed_result


# =============================================================================
# PART 2: Understanding the Executors
# =============================================================================


async def debug_part2_executors():
    """Debug Part 2: Understand how Action Executors work."""
    print("\n" + "=" * 80)
    print("PART 2: EXECUTORS - How Actions Are Executed")
    print("=" * 80)

    from src.agents.executor import (
        RestartServiceExecutor,
        ScaleServiceExecutor,
        get_executor,
    )
    from src.agents.schemas import ExecutionStatus, RemediationAction

    # --- Executor Factory ---
    print("\n📦 Executor Factory (get_executor):")
    print("-" * 40)

    # BREAKPOINT 3: Step into get_executor
    restart_executor = get_executor("restart_service")
    scale_executor = get_executor("scale_service")

    print(f"  restart_service → {type(restart_executor).__name__}")
    print(f"  scale_service → {type(scale_executor).__name__}")

    # --- Create Test Action ---
    print("\n📦 Creating Test Action:")
    print("-" * 40)

    action = RemediationAction(
        action_id="debug-action-001",
        action_type="restart_service",
        target="web-server-01",
        parameters={},
        estimated_downtime_seconds=30,
        risk_level="low",
        approved=True,
    )

    print(f"  action_id: {action.action_id}")
    print(f"  action_type: {action.action_type}")
    print(f"  target: {action.target}")
    print(f"  risk_level: {action.risk_level}")

    # --- Execute Action ---
    print("\n📦 Executing Action:")
    print("-" * 40)

    # BREAKPOINT 4: Step into execute() method
    # This is where the action is "performed" (mocked)
    executor = get_executor(action.action_type)

    # Force success for predictable debugging
    import random

    original_random = random.random
    random.random = lambda: 0.5  # Always succeed (< 0.9)

    try:
        result = await executor.execute(action)

        print(f"  Execution Status: {result.status}")
        print(f"  Started At: {result.started_at}")
        print(f"  Completed At: {result.completed_at}")

        if result.status == ExecutionStatus.SUCCESS:
            print("  ✅ Action executed successfully")
        else:
            print(f"  ❌ Action failed: {result.error_message}")
    finally:
        random.random = original_random

    # --- Validate Action ---
    print("\n📦 Validating Action:")
    print("-" * 40)

    # BREAKPOINT 5: Step into validate() method
    is_valid = await executor.validate(action)
    print(f"  Action is valid: {is_valid}")

    # Invalid action type
    action.action_type = "invalid_type"
    is_valid = await executor.validate(action)
    print(f"  After changing type to 'invalid_type': {is_valid}")

    print("\n✅ Part 2 Complete: You now understand how executors work")
    return result


# =============================================================================
# PART 3: Understanding Rollback Logic
# =============================================================================


async def debug_part3_rollback():
    """Debug Part 3: Understand when and how rollback happens."""
    print("\n" + "=" * 80)
    print("PART 3: ROLLBACK - Safety Mechanism")
    print("=" * 80)

    from unittest.mock import MagicMock

    from src.agents.rollback import execute_rollback, should_rollback, validate_rollback
    from src.agents.schemas import ExecutionResult, ExecutionStatus, RemediationAction

    # --- Create Mock Config ---
    config = MagicMock()
    config.agent.enable_rollback_on_failure = True
    config.agent.rollback_on_timeout = True
    config.agent.atomic_high_risk_actions = True

    # --- should_rollback() Decision Logic ---
    print("\n📦 should_rollback() - Decision Logic:")
    print("-" * 40)

    # BREAKPOINT 6: Step into should_rollback()

    # Case 1: High-risk action failure → Always rollback
    high_risk_action = RemediationAction(
        action_id="high-risk-001",
        action_type="rollback_deployment",
        target="api-service",
        parameters={},
        estimated_downtime_seconds=300,
        risk_level="high",
    )

    failed_result = ExecutionResult(
        action_id="high-risk-001",
        status=ExecutionStatus.FAILED,
        started_at=datetime.now(timezone.utc),
        completed_at=datetime.now(timezone.utc),
        error_message="Deployment failed",
    )

    should_rb = should_rollback(high_risk_action, failed_result, config)
    print(f"  High-risk + Failed → Should rollback: {should_rb}")

    # Case 2: Success → Never rollback
    success_result = ExecutionResult(
        action_id="success-001",
        status=ExecutionStatus.SUCCESS,
        started_at=datetime.now(timezone.utc),
        completed_at=datetime.now(timezone.utc),
    )

    should_rb = should_rollback(high_risk_action, success_result, config)
    print(f"  High-risk + Success → Should rollback: {should_rb}")

    # Case 3: Low-risk + Failed → Check config
    low_risk_action = RemediationAction(
        action_id="low-risk-001",
        action_type="restart_service",
        target="web-server",
        parameters={},
        estimated_downtime_seconds=30,
        risk_level="low",
    )

    should_rb = should_rollback(low_risk_action, failed_result, config)
    print(f"  Low-risk + Failed → Should rollback: {should_rb}")

    # --- Execute Rollback ---
    print("\n📦 execute_rollback() - Undo Action:")
    print("-" * 40)

    # BREAKPOINT 7: Step into execute_rollback()
    scale_action = RemediationAction(
        action_id="scale-001",
        action_type="scale_service",
        target="cache-service",
        parameters={"instance_count": 2},
        estimated_downtime_seconds=60,
        risk_level="low",
    )

    scale_failed = ExecutionResult(
        action_id="scale-001",
        status=ExecutionStatus.FAILED,
        started_at=datetime.now(timezone.utc),
        completed_at=datetime.now(timezone.utc),
        error_message="Insufficient resources",
    )

    rolled_back = await execute_rollback(scale_action, scale_failed, config)

    print(f"  Original status: {scale_failed.status}")
    print(f"  Rollback status: {rolled_back.rollback_status}")
    print(f"  Rollback completed at: {rolled_back.rollback_completed_at}")

    # --- Validate Rollback ---
    print("\n📦 validate_rollback() - Check Success:")
    print("-" * 40)

    # BREAKPOINT 8: Step into validate_rollback()
    is_valid = validate_rollback(scale_action, rolled_back)
    print(f"  Rollback was successful: {is_valid}")

    print("\n✅ Part 3 Complete: You now understand rollback logic")


# =============================================================================
# PART 4: Understanding the Execute Node
# =============================================================================


async def debug_part4_execute_node():
    """Debug Part 4: Understand how execute_node integrates with LangGraph."""
    print("\n" + "=" * 80)
    print("PART 4: EXECUTE NODE - LangGraph Integration")
    print("=" * 80)

    from src.agents.nodes.execute import execute_node
    from src.agents.schemas import (
        AnalysisResult,
        DetectionResult,
        ExecutionStatus,
        IncidentMetrics,
        RemediationAction,
        RemediationPlan,
        create_initial_state,
    )

    # --- Create Full State ---
    print("\n📦 Creating Agent State with Approved Plan:")
    print("-" * 40)

    # BREAKPOINT 9: Understand the state structure
    metrics = [
        IncidentMetrics(
            metric_name="cpu_usage_percent",
            current_value=95.0,
            baseline_value=70.0,
            deviation_score=3.5,
            labels={"service": "web-server"},
        )
    ]

    state = create_initial_state("debug-incident-001", metrics)

    # Add detection result
    state["detection_result"] = DetectionResult(
        is_anomaly=True,
        confidence=0.90,
        detection_method="z_score",
        threshold_used=3.0,
    )

    # Add analysis result
    state["analysis_result"] = AnalysisResult(
        root_cause="High CPU usage due to memory leak in web-server",
        confidence=0.85,
        evidence=["CPU spiked from 70% to 95%"],
        affected_services=["web-server"],
        token_usage=450,
    )

    # Add approved remediation plan
    plan = RemediationPlan(
        actions=[
            RemediationAction(
                action_id="action-1",
                action_type="restart_service",
                target="web-server",
                parameters={},
                estimated_downtime_seconds=30,
                risk_level="low",
                approved=True,  # ← IMPORTANT: Must be approved
            )
        ],
        total_estimated_downtime_seconds=30,
    )
    plan.approved_at = datetime.now(timezone.utc)
    plan.approved_by = "debug-user@example.com"

    state["remediation_plan"] = plan
    state["human_approval"] = True  # ← IMPORTANT: Must be True

    print(f"  incident_id: {state['incident_id']}")
    print(f"  detection_result.is_anomaly: {state['detection_result'].is_anomaly}")
    print(
        f"  analysis_result.root_cause: {state['analysis_result'].root_cause[:50]}..."
    )
    print(f"  remediation_plan.actions: {len(plan.actions)} action(s)")
    print(f"  human_approval: {state['human_approval']}")

    # --- Execute Node ---
    print("\n📦 Running execute_node():")
    print("-" * 40)

    # BREAKPOINT 10: Step into execute_node
    # This is where all the magic happens

    # Force success for predictable debugging
    import random

    original_random = random.random
    random.random = lambda: 0.5

    try:
        result_state = await execute_node(state)

        print(f"  Current node: {result_state['current_node']}")
        print(f"  Iteration count: {result_state['iteration_count']}")

        updated_plan = result_state["remediation_plan"]
        print(f"  Execution started at: {updated_plan.execution_started_at}")
        print(f"  Execution completed at: {updated_plan.execution_completed_at}")

        print("\n  Execution Results:")
        for er in updated_plan.execution_results:
            print(f"    - {er.action_id}: {er.status}")
            if er.error_message:
                print(f"      Error: {er.error_message}")
            if er.rollback_status:
                print(f"      Rollback: {er.rollback_status}")

        # Check execution log
        print("\n  Execution Log:")
        for log in result_state["execution_log"]:
            print(
                f"    - {log.node_name}: success={log.success}, duration={log.duration_seconds:.3f}s"
            )

    finally:
        random.random = original_random

    print("\n✅ Part 4 Complete: You now understand the execute node")
    return result_state


# =============================================================================
# PART 5: Understanding Graph Integration
# =============================================================================


async def debug_part5_graph():
    """Debug Part 5: Understand how execute integrates in the full graph."""
    print("\n" + "=" * 80)
    print("PART 5: GRAPH INTEGRATION - Full Flow")
    print("=" * 80)

    from src.agents.approval import can_execute
    from src.agents.graph import create_agent_graph, should_execute
    from src.agents.schemas import (
        IncidentMetrics,
        RemediationAction,
        RemediationPlan,
        create_initial_state,
    )

    # --- should_execute() Routing Decision ---
    print("\n📦 should_execute() - Routing Decision:")
    print("-" * 40)

    # Create state without approval
    metrics = [
        IncidentMetrics(
            metric_name="memory_usage",
            current_value=95.0,
            baseline_value=70.0,
            deviation_score=3.5,
        )
    ]

    state = create_initial_state("debug-graph-001", metrics)

    # Add unapproved plan
    plan = RemediationPlan(
        actions=[
            RemediationAction(
                action_id="action-1",
                action_type="restart_service",
                target="cache-service",
                parameters={},
                estimated_downtime_seconds=30,
                risk_level="low",
                approved=False,  # ← Not approved
            )
        ],
        total_estimated_downtime_seconds=30,
    )
    state["remediation_plan"] = plan
    state["human_approval"] = False

    # BREAKPOINT 11: Step into should_execute and can_execute
    print(f"  Plan approved: {plan.is_fully_approved()}")
    print(f"  human_approval: {state['human_approval']}")
    print(f"  can_execute(): {can_execute(state)}")

    route = should_execute(state)
    print(f"  should_execute() returns: '{route}'")

    # Now approve and try again
    print("\n  After approval:")
    state["remediation_plan"].actions[0].approved = True
    state["remediation_plan"].approved_at = datetime.now(timezone.utc)
    state["remediation_plan"].approved_by = "admin"
    state["human_approval"] = True

    print(f"  Plan approved: {state['remediation_plan'].is_fully_approved()}")
    print(f"  human_approval: {state['human_approval']}")
    print(f"  can_execute(): {can_execute(state)}")

    route = should_execute(state)
    print(f"  should_execute() returns: '{route}'")

    # --- Graph Structure ---
    print("\n📦 Graph Structure:")
    print("-" * 40)

    # BREAKPOINT 12: Examine the compiled graph
    graph = create_agent_graph()

    print("  Entry point: detect")
    print("  Flow:")
    print("    detect → [should_analyze] → analyze")
    print("    analyze → [should_respond] → respond")
    print("    respond → [should_execute] → execute (if approved)")
    print("    respond → END (if not approved)")
    print("    execute → END")

    print("\n✅ Part 5 Complete: You now understand graph integration")


# =============================================================================
# MAIN - Run All Debug Parts
# =============================================================================


async def main():
    """Run all debug parts."""
    print("\n🚀 Starting Milestone 2.5 Debug Session")
    print("=" * 80)

    # Part 1: Schemas (synchronous)
    debug_part1_schemas()

    # Part 2: Executors (async)
    await debug_part2_executors()

    # Part 3: Rollback (async)
    await debug_part3_rollback()

    # Part 4: Execute Node (async)
    await debug_part4_execute_node()

    # Part 5: Graph Integration (async)
    await debug_part5_graph()

    print("\n" + "=" * 80)
    print("🎉 DEBUG SESSION COMPLETE")
    print("=" * 80)
    print(
        """
Key Breakpoints to Set in Your IDE:

1. src/agents/schemas.py:
   - Line ~40: ExecutionStatus enum definition
   - Line ~170: ExecutionResult class

2. src/agents/executor.py:
   - Line ~105: RestartServiceExecutor.execute()
   - Line ~380: get_executor() factory
   - Line ~400: execute_remediation_plan()

3. src/agents/rollback.py:
   - Line ~30: should_rollback()
   - Line ~65: execute_rollback()

4. src/agents/nodes/execute.py:
   - Line ~45: execute_node() - main entry point
   - Line ~70: asyncio.wait_for() - timeout handling

5. src/agents/graph.py:
   - Line ~100: should_execute() - routing decision
   - Line ~180: create_agent_graph() - graph construction

Happy debugging! 🔍
"""
    )


if __name__ == "__main__":
    asyncio.run(main())