dockerbrain 1.0__py3-none-any.whl

core/optimizer/rules.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, asdict
+from datetime import datetime, timezone
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from core.utils import calc_cpu_percent
+
+if TYPE_CHECKING:
+    from docker.models.containers import Container
+
+
+class Severity(str, Enum):
+    HIGH = "HIGH"
+    MEDIUM = "MEDIUM"
+    LOW = "LOW"
+
+    @property
+    def rank(self) -> int:
+        return {"HIGH": 0, "MEDIUM": 1, "LOW": 2}[self.value]
+
+    @property
+    def style(self) -> str:
+        return {"HIGH": "bold red", "MEDIUM": "bold yellow", "LOW": "bold green"}[self.value]
+
+
+@dataclass
+class Suggestion:
+    """A single optimisation suggestion produced by a rule."""
+
+    container_name: str
+    rule_name: str
+    severity: Severity
+    message: str
+    action_command: str | None = None
+
+    def to_dict(self) -> dict:
+        d = asdict(self)
+        d["severity"] = self.severity.value
+        return d
+
+
+class Rule(ABC):
+    """Base class for all optimisation rules."""
+
+    name: str = "UnnamedRule"
+
+    @abstractmethod
+    def evaluate(self, ctr: Container, stats: dict) -> list[Suggestion]:
+        """Return zero or more suggestions for the given container."""
+        ...
+
+
+class IdleContainerRule(Rule):
+    """Flag containers that have been idle (CPU < 0.5%) for > 10 minutes.
+
+    Heuristic: if current CPU is near-zero **and** the container has been
+    running for more than 10 minutes, we flag it.  A more precise detection
+    relies on the monitor's consecutive-poll tracker, but this gives a good
+    one-shot signal during ``analyze``.
+    """
+
+    name = "IdleContainerRule"
+    _CPU_THRESHOLD = 0.5
+    _MIN_UPTIME_SECS = 600
+
+    def evaluate(self, ctr: Container, stats: dict) -> list[Suggestion]:
+        cpu = calc_cpu_percent(stats)
+        if cpu >= self._CPU_THRESHOLD:
+            return []
+
+        started_at = ctr.attrs.get("State", {}).get("StartedAt", "")
+        if started_at:
+            try:
+                start_dt = datetime.fromisoformat(started_at.replace("Z", "+00:00"))
+                uptime = (datetime.now(timezone.utc) - start_dt).total_seconds()
+                if uptime < self._MIN_UPTIME_SECS:
+                    return []
+            except (ValueError, TypeError):
+                pass
+
+        return [
+            Suggestion(
+                container_name=ctr.name,
+                rule_name=self.name,
+                severity=Severity.MEDIUM,
+                message=(
+                    f"Container is idle (CPU {cpu:.2f}%) and has been running for "
+                    f"over 10 minutes. Consider stopping it to reclaim resources."
+                ),
+                action_command=f"docker stop {ctr.name}",
+            )
+        ]
+
+
+class MemoryHogRule(Rule):
+    """Flag containers using > 80% of their memory limit."""
+
+    name = "MemoryHogRule"
+    _THRESHOLD = 80.0
+
+    def evaluate(self, ctr: Container, stats: dict) -> list[Suggestion]:
+        mem_usage = stats.get("memory_stats", {}).get("usage", 0)
+        mem_limit = stats.get("memory_stats", {}).get("limit", 0)
+
+        if not mem_limit or mem_limit <= 0:
+            return []
+
+        mem_pct = (mem_usage / mem_limit) * 100.0
+        if mem_pct <= self._THRESHOLD:
+            return []
+
+        usage_mb = mem_usage / (1024 * 1024)
+        limit_mb = mem_limit / (1024 * 1024)
+        new_limit = int(limit_mb * 1.5)
+
+        return [
+            Suggestion(
+                container_name=ctr.name,
+                rule_name=self.name,
+                severity=Severity.HIGH,
+                message=(
+                    f"Memory usage is {mem_pct:.1f}% ({usage_mb:.0f} MB / {limit_mb:.0f} MB). "
+                    f"Consider increasing the limit or profiling the application."
+                ),
+                action_command=f"docker update --memory {new_limit}m {ctr.name}",
+            )
+        ]
+
+
+class NoMemoryLimitRule(Rule):
+    """Flag containers with no memory limit (limit == total host RAM)."""
+
+    name = "NoMemoryLimitRule"
+
+    def evaluate(self, ctr: Container, stats: dict) -> list[Suggestion]:
+        mem_limit = stats.get("memory_stats", {}).get("limit", 0)
+        mem_usage = stats.get("memory_stats", {}).get("usage", 0)
+
+        _16_GIB = 16 * 1024 * 1024 * 1024
+        if mem_limit < _16_GIB:
+            return []
+
+        usage_mb = mem_usage / (1024 * 1024)
+        suggested_mb = max(256, int(usage_mb * 2))
+
+        return [
+            Suggestion(
+                container_name=ctr.name,
+                rule_name=self.name,
+                severity=Severity.MEDIUM,
+                message=(
+                    "No memory limit is set. The container can consume all host memory. "
+                    f"Current usage: {usage_mb:.0f} MB. Consider adding a --memory flag."
+                ),
+                action_command=f"docker update --memory {suggested_mb}m {ctr.name}",
+            )
+        ]
+
+
+class HighRestartRule(Rule):
+    """Flag containers with a restart count > 3."""
+
+    name = "HighRestartRule"
+    _THRESHOLD = 3
+
+    def evaluate(self, ctr: Container, stats: dict) -> list[Suggestion]:
+        restart_count = ctr.attrs.get("RestartCount", 0)
+        if restart_count <= self._THRESHOLD:
+            return []
+
+        return [
+            Suggestion(
+                container_name=ctr.name,
+                rule_name=self.name,
+                severity=Severity.HIGH,
+                message=(
+                    f"Container has restarted {restart_count} times. "
+                    "Investigate crash loops — check logs with the action command."
+                ),
+                action_command=f"docker logs --tail 50 {ctr.name}",
+            )
+        ]
+
+
+class StaleImageRule(Rule):
+    """Flag containers whose image is older than 30 days."""
+
+    name = "StaleImageRule"
+    _MAX_AGE_DAYS = 30
+
+    def evaluate(self, ctr: Container, stats: dict) -> list[Suggestion]:
+        try:
+            image = ctr.image
+            created_str = image.attrs.get("Created", "")
+            if not created_str:
+                return []
+
+            created_dt = datetime.fromisoformat(created_str.replace("Z", "+00:00"))
+            age_days = (datetime.now(timezone.utc) - created_dt).days
+
+            if age_days <= self._MAX_AGE_DAYS:
+                return []
+
+            image_tag = image.tags[0] if image.tags else image.short_id
+            return [
+                Suggestion(
+                    container_name=ctr.name,
+                    rule_name=self.name,
+                    severity=Severity.LOW,
+                    message=(
+                        f"Image '{image_tag}' is {age_days} days old. "
+                        "Consider rebuilding with the latest base to pick up security patches."
+                    ),
+                    action_command=f"docker pull {image_tag}" if image.tags else None,
+                )
+            ]
+        except Exception:
+            return []

core/storage.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import sqlite3
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from core.monitor import ContainerSnapshot
+
+_DB_PATH = Path.home() / ".dockerbrain" / "metrics.db"
+
+_METRICS_SCHEMA = """
+CREATE TABLE IF NOT EXISTS container_metrics (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    timestamp       TEXT    NOT NULL,
+    container       TEXT    NOT NULL,
+    status          TEXT,
+    cpu_percent     REAL,
+    mem_usage_mb    REAL,
+    mem_limit_mb    REAL,
+    mem_percent     REAL,
+    net_rx_bytes    INTEGER,
+    net_tx_bytes    INTEGER,
+    is_idle         INTEGER DEFAULT 0,
+    idle_polls      INTEGER DEFAULT 0
+);
+"""
+
+_AI_SCHEMA = """
+CREATE TABLE IF NOT EXISTS ai_suggestions (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    timestamp       TEXT    NOT NULL,
+    summary         TEXT    NOT NULL,
+    full_response   TEXT
+);
+"""
+
+
+def _get_connection() -> sqlite3.Connection:
+    """Return a connection, creating the database and tables if needed."""
+    _DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(_DB_PATH))
+    conn.execute(_METRICS_SCHEMA)
+    conn.execute(_AI_SCHEMA)
+    conn.commit()
+    return conn
+
+# Write
+def store_snapshot(snap: ContainerSnapshot) -> None:
+    """Persist a single ContainerSnapshot row."""
+    with _get_connection() as conn:
+        conn.execute(
+            """
+            INSERT INTO container_metrics
+                (timestamp, container, status, cpu_percent,
+                 mem_usage_mb, mem_limit_mb, mem_percent,
+                 net_rx_bytes, net_tx_bytes, is_idle, idle_polls)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                snap.timestamp,
+                snap.name,
+                snap.status,
+                snap.cpu_percent,
+                snap.mem_usage_mb,
+                snap.mem_limit_mb,
+                snap.mem_percent,
+                snap.net_rx_bytes,
+                snap.net_tx_bytes,
+                int(snap.is_idle),
+                snap.idle_polls,
+            ),
+        )
+        conn.commit()
+
+def store_metrics(row: dict) -> None:
+    """Legacy helper — accepts a plain dict (backward compat)."""
+    with _get_connection() as conn:
+        conn.execute(
+            """
+            INSERT INTO container_metrics
+                (timestamp, container, cpu_percent,
+                 mem_usage_mb, mem_limit_mb, mem_percent,
+                 net_rx_bytes, net_tx_bytes)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                datetime.now(timezone.utc).isoformat(),
+                row["name"],
+                row["cpu_percent"],
+                row.get("mem_usage_mb", row.get("mem_usage", 0) / (1024 * 1024)),
+                row.get("mem_limit_mb", row.get("mem_limit", 0) / (1024 * 1024)),
+                row["mem_percent"],
+                row.get("net_rx_bytes", row.get("net_rx", 0)),
+                row.get("net_tx_bytes", row.get("net_tx", 0)),
+            ),
+        )
+        conn.commit()
+
+# Read
+def get_recent_metrics(container: str, limit: int = 60) -> list[dict]:
+    """Retrieve the most recent *limit* rows for a given container."""
+    with _get_connection() as conn:
+        cursor = conn.execute(
+            "SELECT * FROM container_metrics WHERE container = ? ORDER BY id DESC LIMIT ?",
+            (container, limit),
+        )
+        columns = [desc[0] for desc in cursor.description]
+        return [dict(zip(columns, r)) for r in cursor.fetchall()]
+
+
+def get_metrics_since(since_iso: str, container: str | None = None) -> list[dict]:
+    """Return all rows with timestamp >= *since_iso*.
+
+    Args:
+        since_iso: ISO-8601 UTC timestamp string (lower bound, inclusive).
+        container: Optional container name filter.
+    """
+    with _get_connection() as conn:
+        if container:
+            cursor = conn.execute(
+                "SELECT * FROM container_metrics WHERE timestamp >= ? AND container = ? ORDER BY timestamp",
+                (since_iso, container),
+            )
+        else:
+            cursor = conn.execute(
+                "SELECT * FROM container_metrics WHERE timestamp >= ? ORDER BY timestamp",
+                (since_iso,),
+            )
+        columns = [desc[0] for desc in cursor.description]
+        return [dict(zip(columns, r)) for r in cursor.fetchall()]
+
+
+def get_all_container_names() -> list[str]:
+    """Return distinct container names from the metrics table."""
+    with _get_connection() as conn:
+        cursor = conn.execute("SELECT DISTINCT container FROM container_metrics ORDER BY container")
+        return [row[0] for row in cursor.fetchall()]
+
+
+# LLM suggestion cache
+def store_ai_suggestion(summary: str, full_response: str = "") -> None:
+    """Cache an AI suggestion for later retrieval."""
+    with _get_connection() as conn:
+        conn.execute(
+            "INSERT INTO ai_suggestions (timestamp, summary, full_response) VALUES (?, ?, ?)",
+            (datetime.now(timezone.utc).isoformat(), summary, full_response),
+        )
+        conn.commit()
+
+def get_last_ai_suggestion() -> dict | None:
+    """Retrieve the most recent AI suggestion row."""
+    with _get_connection() as conn:
+        cursor = conn.execute(
+            "SELECT timestamp, summary, full_response FROM ai_suggestions ORDER BY id DESC LIMIT 1"
+        )
+        row = cursor.fetchone()
+    if row:
+        return {"timestamp": row[0], "summary": row[1], "full_response": row[2]}
+    return None