Upload db_manager.py

database/db_manager.py

@@ -1537,3 +1537,126 @@ if __name__ == "__main__":
         if table != 'database_size_mb':
             print(f"  {table}: {count}")
     print(f"  Database Size: {stats.get('database_size_mb', 0)} MB")
+
+
+# === Monkey-patch compatibility methods for legacy health logging ===
+# These provide the same interface as the older `Database` class from database.py
+# so that calls like `db.log_provider_status` and `db.get_uptime_percentage`
+# used in app.py continue to work when using DatabaseManager with SQLAlchemy.
+
+from sqlalchemy import text as _sa_text
+from datetime import datetime as _dt, timedelta as _td
+
+def _dm_log_provider_status(
+    self,
+    provider_name: str,
+    category: str,
+    status: str,
+    response_time: Optional[float] = None,
+    status_code: Optional[int] = None,
+    endpoint_tested: Optional[str] = None,
+    error_message: Optional[str] = None,
+):
+    """Log provider status into a simple `status_log` table.
+
+    This mirrors the behavior of the older sqlite-based `Database.log_provider_status`
+    implementation so that existing code paths in app.py keep working.
+    """
+    try:
+        # Ensure table exists (idempotent)
+        create_sql = _sa_text("""
+            CREATE TABLE IF NOT EXISTS status_log (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                provider_name TEXT NOT NULL,
+                category TEXT NOT NULL,
+                status TEXT NOT NULL,
+                response_time REAL,
+                status_code INTEGER,
+                error_message TEXT,
+                endpoint_tested TEXT,
+                timestamp REAL NOT NULL,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        insert_sql = _sa_text("""
+            INSERT INTO status_log
+                (provider_name, category, status, response_time, status_code,
+                 error_message, endpoint_tested, timestamp)
+            VALUES (:provider_name, :category, :status, :response_time, :status_code,
+                    :error_message, :endpoint_tested, :timestamp)
+        """)
+        with self.engine.begin() as conn:
+            conn.execute(create_sql)
+            conn.execute(
+                insert_sql,
+                {
+                    "provider_name": provider_name,
+                    "category": category,
+                    "status": status,
+                    "response_time": response_time,
+                    "status_code": status_code,
+                    "error_message": error_message,
+                    "endpoint_tested": endpoint_tested,
+                    "timestamp": _dt.now().timestamp(),
+                },
+            )
+    except Exception as e:  # pragma: no cover - logging safeguard
+        logger.error(f"Failed to log provider status for {provider_name}: {e}", exc_info=True)
+
+
+def _dm_get_uptime_percentage(
+    self,
+    provider_name: str,
+    hours: int = 24,
+) -> float:
+    """Calculate uptime percentage from `status_log` table.
+
+    This approximates the legacy behavior:
+    uptime = (online_rows / total_rows) * 100
+    where `status = 'online'` is treated as healthy.
+    """
+    try:
+        cutoff = _dt.now() - _td(hours=hours)
+        # Ensure table exists before querying
+        create_sql = _sa_text("""
+            CREATE TABLE IF NOT EXISTS status_log (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                provider_name TEXT NOT NULL,
+                category TEXT NOT NULL,
+                status TEXT NOT NULL,
+                response_time REAL,
+                status_code INTEGER,
+                error_message TEXT,
+                endpoint_tested TEXT,
+                timestamp REAL NOT NULL,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        query_sql = _sa_text("""
+            SELECT
+                COUNT(*) AS total,
+                SUM(CASE WHEN status = 'online' THEN 1 ELSE 0 END) AS online
+            FROM status_log
+            WHERE provider_name = :provider_name
+              AND created_at >= :cutoff
+        """)
+        with self.engine.begin() as conn:
+            conn.execute(create_sql)
+            result = conn.execute(
+                query_sql,
+                {"provider_name": provider_name, "cutoff": cutoff},
+            ).first()
+        if result and result[0]:
+            total = result[0] or 0
+            online = result[1] or 0
+            if total > 0:
+                return round((online / total) * 100.0, 2)
+        return 0.0
+    except Exception as e:  # pragma: no cover - logging safeguard
+        logger.error(f"Failed to compute uptime for {provider_name}: {e}", exc_info=True)
+        return 0.0
+
+
+# Attach methods to DatabaseManager so existing code can call them.
+DatabaseManager.log_provider_status = _dm_log_provider_status  # type: ignore[attr-defined]
+DatabaseManager.get_uptime_percentage = _dm_get_uptime_percentage  # type: ignore[attr-defined]