Merge pull request #27 from lbedner/enhanced-health-checks

Enhanced Health Checks

Author: lbedner

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/app/components/frontend/main.py

@@ -322,6 +322,54 @@ async def refresh_status() -> None:
                         ),
                     ]
 
+                    # Add database-specific metadata display
+                    if comp_name == "database" and component.metadata:
+                        db_info = []
+                        
+                        # Show SQLite version if available
+                        if "version" in component.metadata:
+                            db_info.append(f"SQLite v{component.metadata['version']}")
+                        
+                        # Show file size if available
+                        if "file_size_human" in component.metadata:
+                            size = component.metadata['file_size_human']
+                            db_info.append(f"Size: {size}")
+                        
+                        # Show WAL status if available
+                        if "wal_enabled" in component.metadata:
+                            wal_enabled = component.metadata["wal_enabled"]
+                            wal_status = "WAL" if wal_enabled else "DELETE"
+                            db_info.append(f"Mode: {wal_status}")
+                        
+                        # Show connection pool size if available
+                        if "connection_pool_size" in component.metadata:
+                            pool_size = component.metadata['connection_pool_size']
+                            db_info.append(f"Pool: {pool_size}")
+                        
+                        # Add database info to card if we have any
+                        if db_info:
+                            card_content.append(
+                                ft.Container(
+                                    content=ft.Column(
+                                        [
+                                            ft.Text(
+                                                "Database Info:",
+                                                size=10,
+                                                weight=ft.FontWeight.BOLD,
+                                                color=text_color,
+                                            ),
+                                            ft.Text(
+                                                " • ".join(db_info),
+                                                size=10,
+                                                color=text_color,
+                                            ),
+                                        ],
+                                        spacing=2,
+                                    ),
+                                    margin=ft.margin.only(top=8),
+                                )
+                            )
+
                     # Add sub-component indicators
                     if component.sub_components:
                         sub_status = []
@@ -486,6 +534,113 @@ async def refresh_status() -> None:
                         )
                     )
 
+                # Database details card (if database component exists)
+                database_comp = components.get("database")
+                if database_comp and database_comp.metadata:
+                    db_bg_color = (
+                        ft.Colors.CYAN_100 if is_light_mode else ft.Colors.CYAN_900
+                    )
+                    db_text_color = (
+                        ft.Colors.CYAN_800 if is_light_mode else ft.Colors.CYAN_100
+                    )
+
+                    db_content = [
+                        ft.Text(
+                            "Database Details",
+                            size=14,
+                            weight=ft.FontWeight.BOLD,
+                            color=db_text_color,
+                        )
+                    ]
+
+                    # Show detailed database metadata
+                    metadata = database_comp.metadata
+                    
+                    # Version and implementation
+                    if "version" in metadata and "implementation" in metadata:
+                        db_content.append(
+                            ft.Text(
+                                f"{metadata['implementation'].upper()} "
+                                f"v{metadata['version']}",
+                                size=12,
+                                weight=ft.FontWeight.BOLD,
+                                color=db_text_color,
+                            )
+                        )
+                    
+                    # File info
+                    if "file_size_human" in metadata and "file_size_bytes" in metadata:
+                        db_content.append(
+                            ft.Text(
+                                f"File Size: {metadata['file_size_human']} "
+                                f"({metadata['file_size_bytes']:,} bytes)",
+                                size=11,
+                                color=db_text_color,
+                            )
+                        )
+                    
+                    # Connection info
+                    if "connection_pool_size" in metadata:
+                        db_content.append(
+                            ft.Text(
+                                f"Connection Pool: "
+                                f"{metadata['connection_pool_size']} connections",
+                                size=11,
+                                color=db_text_color,
+                            )
+                        )
+                    
+                    # SQLite PRAGMA settings
+                    if "pragma_settings" in metadata:
+                        pragma = metadata["pragma_settings"]
+                        pragma_info = []
+                        
+                        if "foreign_keys" in pragma:
+                            fk_status = "ON" if pragma["foreign_keys"] else "OFF"
+                            pragma_info.append(f"Foreign Keys: {fk_status}")
+                        
+                        if "journal_mode" in pragma:
+                            journal_mode = pragma["journal_mode"].upper()
+                            pragma_info.append(f"Journal: {journal_mode}")
+                        
+                        if "cache_size" in pragma:
+                            # Remove negative sign
+                            cache_size = abs(pragma["cache_size"])
+                            if cache_size > 1000:
+                                cache_display = f"{cache_size // 1000}K pages"
+                            else:
+                                cache_display = f"{cache_size} pages"
+                            pragma_info.append(f"Cache: {cache_display}")
+                        
+                        if pragma_info:
+                            db_content.append(
+                                ft.Text(
+                                    "Configuration:",
+                                    size=11,
+                                    weight=ft.FontWeight.BOLD,
+                                    color=db_text_color,
+                                )
+                            )
+                            for info in pragma_info:
+                                db_content.append(
+                                    ft.Text(
+                                        f"  • {info}",
+                                        size=10,
+                                        color=db_text_color,
+                                    )
+                                )
+
+                    bottom_cards.append(
+                        ft.Container(
+                            content=ft.Column(db_content, spacing=4),
+                            padding=15,
+                            bgcolor=db_bg_color,
+                            border=ft.border.all(1, ft.Colors.CYAN),
+                            border_radius=8,
+                            width=300,
+                        )
+                    )
+
                 details_row.content.controls = bottom_cards
 
                 page.update()

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/app/services/system/health.py.j2

@@ -9,6 +9,7 @@ import asyncio
 from collections.abc import Awaitable, Callable
 from datetime import UTC, datetime
 import os
+import sqlite3
 import sys
 from typing import Any, cast
 
@@ -24,6 +25,22 @@ from .models import ComponentStatus, ComponentStatusType, SystemStatus
 _health_checks: dict[str, Callable[[], Awaitable[ComponentStatus]]] = {}
 
 
+def format_bytes(size: int) -> str:
+    """Format bytes into human-readable string."""
+    if size == 0:
+        return "0 B"
+    
+    size_float = float(size)
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if size_float < 1024.0:
+            if unit == 'B':
+                return f"{int(size_float)} {unit}"
+            else:
+                return f"{size_float:.1f} {unit}"
+        size_float /= 1024.0
+    return f"{size_float:.1f} TB"
+
+
 def propagate_status(child_statuses: list[ComponentStatusType]) -> ComponentStatusType:
     """
     Determine parent status from child statuses using standard hierarchy.
@@ -593,28 +610,88 @@ async def check_database_health() -> ComponentStatus:
                         "database_exists": False,
                         "expected_path": db_path,
                         "url": settings.DATABASE_URL,
-                        "recommendation": "Run database migrations or create database file",
+                        "recommendation": (
+                            "Run database migrations or create database file"
+                        ),
                     },
                 )
 
-        # Test database connection with simple query
+        # Test database connection with simple query and collect enhanced metadata
+        enhanced_metadata = {
+            "implementation": "sqlite",
+            "url": settings.DATABASE_URL,
+            "database_exists": True,
+            "engine_echo": settings.DATABASE_ENGINE_ECHO,
+        }
+        
+        # Collect additional metadata for SQLite databases
+        if db_url.startswith("sqlite:///"):
+            try:
+                # Add SQLite version
+                enhanced_metadata["version"] = sqlite3.sqlite_version
+                
+                # Extract and add file size information
+                db_path = db_url.replace("sqlite:///", "").lstrip("./")
+                if Path(db_path).exists():
+                    file_size = Path(db_path).stat().st_size
+                    enhanced_metadata["file_size_bytes"] = file_size
+                    enhanced_metadata["file_size_human"] = format_bytes(file_size)
+                
+                # Get engine and connection pool information
+                from app.core.db import engine
+                if hasattr(engine.pool, 'size'):
+                    enhanced_metadata["connection_pool_size"] = engine.pool.size()
+                else:
+                    # SQLite typically uses NullPool or StaticPool with size 1
+                    enhanced_metadata["connection_pool_size"] = 1
+                    
+            except Exception as e:
+                # If any enhanced metadata collection fails, log but don't break
+                # health check
+                logger.debug("Failed to collect enhanced database metadata", exc_info=True)
+        
+        # Test database connection and collect PRAGMA settings
         with db_session(autocommit=False) as session:
             # Execute a simple query to test connectivity
             from sqlalchemy import text
             session.execute(text("SELECT 1"))
+            
+            # Collect SQLite PRAGMA settings for additional metadata
+            if db_url.startswith("sqlite:///"):
+                try:
+                    pragma_settings = {}
+                    
+                    # Get foreign keys setting
+                    result = session.execute(text("PRAGMA foreign_keys")).fetchone()
+                    if result:
+                        pragma_settings["foreign_keys"] = bool(result[0])
+                    
+                    # Get journal mode
+                    result = session.execute(text("PRAGMA journal_mode")).fetchone()
+                    if result:
+                        journal_mode = result[0].lower()
+                        pragma_settings["journal_mode"] = journal_mode
+                        enhanced_metadata["wal_enabled"] = journal_mode == "wal"
+                    
+                    # Add cache size if available
+                    result = session.execute(text("PRAGMA cache_size")).fetchone()
+                    if result:
+                        pragma_settings["cache_size"] = result[0]
+                    
+                    enhanced_metadata["pragma_settings"] = pragma_settings
+                    
+                except Exception as e:
+                    # PRAGMA queries can fail in some SQLite configurations
+                    logger.debug("Failed to collect SQLite PRAGMA settings", exc_info=True)
+            
             # No need to commit since we're just testing connectivity
 
         return ComponentStatus(
             name="database",
             status=ComponentStatusType.HEALTHY,
             message="Database connection successful",
             response_time_ms=None,  # Will be set by caller
-            metadata={
-                "implementation": "sqlite",
-                "url": settings.DATABASE_URL,
-                "database_exists": True,
-                "engine_echo": settings.DATABASE_ENGINE_ECHO,
-            },
+            metadata=enhanced_metadata,
         )
 
     except ImportError:

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/tests/conftest.py.j2

@@ -25,16 +25,16 @@ from sqlmodel import Session, SQLModel
 def engine() -> Engine:
     """
     Create in-memory SQLite database engine for tests.
-    
+
     Uses :memory: database that exists only in RAM for maximum speed
     and perfect test isolation. Each test session gets a fresh database.
-    
+
     Returns:
         SQLAlchemy Engine connected to in-memory SQLite database
     """
     engine = create_engine(
         "sqlite:///:memory:",
-        echo=False,  # Set to True for SQL debugging - can be overridden by DATABASE_ENGINE_ECHO
+        echo=False,  # Set to True for SQL debugging
         connect_args={"check_same_thread": False}  # Allow multi-threaded access
     )
 
@@ -56,21 +56,21 @@ def engine() -> Engine:
 def db_session(engine: Engine) -> Generator[Session, None, None]:
     """
     Provide transactional database session with automatic rollback.
-    
+
     Each test gets a fresh transaction that's rolled back after the test,
     ensuring perfect isolation between tests. Uses the same transaction
     pattern as PostgreSQL for consistency.
-    
+
     Args:
         engine: Database engine from session-scoped fixture
-        
+
     Yields:
         SQLModel Session for database operations
     """
     connection = engine.connect()
     transaction = connection.begin()
-    SessionLocal = sessionmaker(bind=connection)
-    session = SessionLocal()
+    session_local = sessionmaker(bind=connection)
+    session = session_local()
 
     yield session
 

…s/services/test_component_integration.py …ervices/test_component_integration.py.j2aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/tests/services/test_component_integration.py renamed to aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/tests/services/test_component_integration.py.j2 aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/tests/services/test_component_integration.py renamed to aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/tests/services/test_component_integration.py.j2

@@ -19,14 +19,22 @@
     _check_cpu_usage,
     _check_disk_space,
     _check_memory,
-    check_cache_health,
-    check_worker_health,
 )
+{% if cookiecutter.include_redis == "yes" %}
+from app.services.system.health import check_cache_health
+{% endif %}
+{% if cookiecutter.include_database == "yes" %}
+from app.services.system.health import check_database_health
+{% endif %}
+{% if cookiecutter.include_worker == "yes" %}
+from app.services.system.health import check_worker_health
+{% endif %}
 
 
 class TestComponentIntegration:
     """Test component health checks with controlled failure scenarios."""
 
+{% if cookiecutter.include_redis == "yes" %}
     @pytest.mark.asyncio
     async def test_cache_health_redis_connection_failure(self) -> None:
         """Test cache health check when Redis connection fails."""
@@ -91,7 +99,9 @@ async def mock_get(key: str) -> bytes:
             assert cache_status.metadata["implementation"] == "redis"
             assert cache_status.metadata["version"] == "7.0.0"
             assert cache_status.metadata["connected_clients"] == 2
+{% endif %}
 
+{% if cookiecutter.include_worker == "yes" %}
     @pytest.mark.asyncio
     async def test_worker_health_redis_connection_failure(self) -> None:
         """Test worker health check when Redis connection fails."""
@@ -165,6 +175,7 @@ def mock_get(key: str) -> bytes | None:
             assert (
                 queue_sub_components["load_test"].status == ComponentStatusType.HEALTHY
             )
+{% endif %}
 
     @pytest.mark.asyncio
     async def test_system_metrics_high_thresholds(self) -> None: