Monitoring Alert Agent

"""
Monitoring Alert Agent
- A plain function does the actual check (cheap, deterministic).
- On failure, the agent gathers context, diagnoses, and DRAFTS an
  alert with a suggested fix.
- A state file dedupes alerts; recovery clears the state.
- The agent never restarts, deletes, or fixes anything itself.
"""
import json
import urllib.request
from datetime import datetime
from pathlib import Path

from crewai import Agent, Task, Crew, Process
from crewai_tools import tool


TARGET_URL = "[https://your-site.example.com/health]"
LOG_FILE = Path("[/var/log/your-app/app.log]")
STATE = Path("state/alert_state.json")   # {"open_incident": bool, "since": ...}


def check_target() -> dict:
    """The deterministic check. Not a tool: the agent never decides
    whether to check. Cron decides. Returns status the code acts on."""
    try:
        req = urllib.request.Request(TARGET_URL, method="GET")
        with urllib.request.urlopen(req, timeout=10) as resp:
            return {"ok": 200 <= resp.status < 400, "status": resp.status}
    except Exception as e:
        return {"ok": False, "status": None, "error": str(e)}


# ---------- Tools the agent uses AFTER a failure ----------

@tool("read_recent_logs")
def read_recent_logs(lines: int = 100) -> str:
    """Return the last N log lines. Stub: swap for journalctl, your
    platform's log API, or `docker logs` as appropriate."""
    if not LOG_FILE.exists():
        return "(no log file found at configured path)"
    return "\n".join(LOG_FILE.read_text().splitlines()[-lines:])


@tool("read_recent_deploys")
def read_recent_deploys() -> str:
    """What changed lately? Stub: swap for `git log --since=2.days`,
    your CI history, or your platform's deploy list. 'What changed'
    answers most incidents faster than any log line."""
    return "[stub: return recent deploys/commits with timestamps]"


@tool("draft_alert")
def draft_alert(summary: str, evidence: str, suggested_fix: str) -> str:
    """Draft the alert for a human. Stub: swap for email, Slack, or
    SMS. Even wired to a real channel, it alerts a human; it does
    not act."""
    print("\n[ALERT DRAFT]")
    print(f"Summary: {summary}")
    print(f"Evidence:\n{evidence}")
    print(f"Suggested fix (for a HUMAN to apply): {suggested_fix}")
    print("[END ALERT]\n")
    return "alert drafted"


# ---------- Agent ----------

on_call_analyst = Agent(
    role="On-call Analyst",
    goal=(
        "When the check fails, figure out the most likely cause from "
        "logs and recent changes, then draft one clear alert with a "
        "suggested fix."
    ),
    backstory=(
        "You are calm at 3am. You report what the evidence shows and "
        "clearly label guesses as guesses. You NEVER run commands that "
        "change state: no restarts, no deletes, no config edits. You "
        "diagnose; a human decides."
    ),
    tools=[read_recent_logs, read_recent_deploys, draft_alert],
    verbose=True,
)

diagnose_task = Task(
    description=(
        "The health check for {url} just failed with: {failure}.\n"
        "1. Read recent logs and recent deploys.\n"
        "2. Form a most-likely cause. Cite the exact log lines or "
        "deploy that support it. If the evidence is thin, say so.\n"
        "3. Draft ONE alert: a one-line summary, the evidence, and a "
        "suggested fix a human can apply. If you genuinely cannot "
        "tell, the honest alert is 'down, cause unknown, checked X "
        "and Y'. Do not invent a confident story."
    ),
    agent=on_call_analyst,
    expected_output="Confirmation that one alert was drafted.",
)


def main():
    result = check_target()
    state = json.loads(STATE.read_text()) if STATE.exists() else {}
    STATE.parent.mkdir(parents=True, exist_ok=True)

    if result["ok"]:
        if state.get("open_incident"):
            print(f"[RECOVERED] {TARGET_URL} at {datetime.now()}")
            STATE.write_text(json.dumps({"open_incident": False}))
        return

    if state.get("open_incident"):
        # Already alerted for this incident. Stay quiet until recovery.
        print("[SUPPRESSED] incident already alerted")
        return

    STATE.write_text(json.dumps(
        {"open_incident": True, "since": str(datetime.now())}))
    crew = Crew(agents=[on_call_analyst], tasks=[diagnose_task],
                process=Process.sequential, verbose=True)
    crew.kickoff(inputs={"url": TARGET_URL, "failure": json.dumps(result)})


if __name__ == "__main__":
    main()