Changed health_controller, DatabaseConnectionManager and added health_schema. I think I fixed it, it should work if I understand it correctly | [AntonioMrtz#283]

Author: RobyBen

Backend/app/database/DatabaseConnectionManager.py

@@ -3,7 +3,11 @@
 from pymongo.collection import Collection
 
 from app.common.app_schema import AppEnvironmentMode
-from app.database.database_schema import BaseDatabaseConnection, DatabaseCollection
+from app.database.database_schema import (
+    BaseDatabaseConnection,
+    DatabaseCollection,
+    DatabasePingFailedException,
+)
 from app.database.DatabaseProductionConnection import DatabaseProductionConnection
 from app.database.DatabaseTestingConnection import DatabaseTestingConnection
 from app.logging.logging_constants import LOGGING_DATABASE_MANAGER
@@ -41,15 +45,38 @@ def get_collection_connection(cls, collection_name: DatabaseCollection) -> Colle
     def init_database_connection(
         cls, environment: AppEnvironmentMode, connection_uri: str
     ) -> None:
-        """Initializes the database connection and loads its unique instance\
-            based on current environment value
+        """
+        Initializes the database connection.
 
         Args:
-            environment (AppEnvironmentMode): the current environment value
-            connection_uri (str): the database connection uri
+            environment (AppEnvironmentMode): The current environment mode.
+            connection_uri (str): The URI for connecting to the database.
+
+        Returns:
+            None
         """
+        from pymongo import MongoClient
+
         database_connection_class = cls.database_connection_mapping.get(
             environment, DatabaseProductionConnection
         )
         database_connection_class.init_connection(connection_uri)
         cls.connection = database_connection_class
+        cls.client = MongoClient(connection_uri)
+
+    @classmethod
+    def ping_database(cls) -> bool:
+        """Pings the database to check the connection
+
+        Raises:
+            DatabasePingFailedException: if ping has failed
+
+        Returns:
+            bool: True if the database is reachable, False otherwise
+        """
+        try:
+            cls.client.admin.command("ping")
+        except DatabasePingFailedException:
+            return False
+        else:
+            return True

Backend/app/logging/logging_constants.py

@@ -75,3 +75,4 @@
 
 # Utilities
 LOGGING_AUDIO_MANAGEMENT_UTILS = "AUDIO_MANAGEMENT_UTILS"
+LOGGING_HEALTH = "HEALTH"

Backend/app/spotify_electron/health/health_controller.py

@@ -1,103 +1,121 @@
 """
 Health controller for handling incoming HTTP Requests
 """
-from fastapi import APIRouter, HTTPException
+
+from fastapi import APIRouter
 from fastapi.responses import JSONResponse
-from pydantic import BaseModel
-from typing import Dict
 from starlette.status import HTTP_200_OK, HTTP_503_SERVICE_UNAVAILABLE
 
 from app.auth.auth_schema import AuthConfig
+from app.database.database_schema import DatabasePingFailedException
 from app.database.DatabaseConnectionManager import DatabaseConnectionManager
-from app.spotify_electron.song.providers.song_service_provider import SongServiceProvider
-from app.logging.logging_schema import SpotifyElectronLogger
 from app.logging.logging_constants import LOGGING_HEALTH
+from app.logging.logging_schema import SpotifyElectronLogger
+from app.spotify_electron.health.health_schema import HealthCheckResponse
+from app.spotify_electron.song.providers.song_service_provider import SongServiceProvider
 
 router = APIRouter(prefix="/health", tags=["health"])
 logger = SpotifyElectronLogger(LOGGING_HEALTH).getLogger()
 
-class HealthCheckResponse(BaseModel):
-    status: str
-    details: Dict[str, Dict[str, str]]
 
-async def check_database_connection() -> Dict[str, str]:
+def check_database_connection() -> dict[str, str]:
+    """Validates ping to database
+
+    Returns:
+        dict[str, str]: Dictionary with status and explanatory message
+    """
     try:
-        db_client = DatabaseConnectionManager.get_database_client()
-        await db_client.admin.command('ping')
-        return {"status": "healthy", "message": "Database connection is active"}
-    except Exception as e:
-        logger.error(f"Database health check failed: {str(e)}")
-        return {"status": "unhealthy", "message": f"Database connection failed: {str(e)}"}
-
-def check_song_service() -> Dict[str, str]:
+        if DatabaseConnectionManager.ping_database():
+            return {"status": "healthy", "message": "Database connection is active"}
+    except DatabasePingFailedException:
+        logger.exception(DatabasePingFailedException.ERROR)
+    else:
+        return {"status": "unhealthy", "message": DatabasePingFailedException.ERROR}
+
+
+def check_song_service() -> dict[str, str]:
+    """Validates if SongServiceProvider is inited
+
+    Returns:
+        dict[str, str]: Dictionary with status and explanatory message
+    """
     try:
-        service = SongServiceProvider.get_service()
+        service = SongServiceProvider.get_song_service()
+    except Exception as exception:
+        logger.exception("SongServiceProvider health check failed")
+        return {
+            "status": "unhealthy",
+            "message": f"SongServiceProvider check failed: {str(exception)}",
+        }
+    else:
         if service is None:
-            return {"status": "unhealthy", "message": "SongService is not initialized"}
-        return {"status": "healthy", "message": "SongService is properly initialized"}
-    except Exception as e:
-        logger.error(f"SongService health check failed: {str(e)}")
-        return {"status": "unhealthy", "message": f"SongService check failed: {str(e)}"}
+            return {"status": "unhealthy", "message": "SongServiceProvider is not initialized"}
+        return {"status": "healthy", "message": "SongServiceProvider is properly initialized"}
+
+
+def check_auth_config() -> dict[str, str]:
+    """Validates if auth configurations are set
 
-def check_auth_config() -> Dict[str, str]:
+    Returns:
+        dict[str, str]: Dictionary with status and explanatory message
+    """
     try:
-        if not all([
-            hasattr(AuthConfig, 'SIGNING_SECRET_KEY') and AuthConfig.SIGNING_SECRET_KEY,
-            hasattr(AuthConfig, 'VERTIFICATION_ALGORITHM') and AuthConfig.VERTIFICATION_ALGORITHM,
-            hasattr(AuthConfig, 'ACCESS_TOKEN_EXPIRE_MINUTES') and AuthConfig.ACCESS_TOKEN_EXPIRE_MINUTES,
-            hasattr(AuthConfig, 'DAYS_TO_EXPIRE_COOKIE') and AuthConfig.DAYS_TO_EXPIRE_COOKIE
-        ]):
+        if not all(
+            [
+                hasattr(AuthConfig, "VERTIFICATION_ALGORITHM")
+                and AuthConfig.VERTIFICATION_ALGORITHM,
+                hasattr(AuthConfig, "ACCESS_TOKEN_EXPIRE_MINUTES")
+                and AuthConfig.ACCESS_TOKEN_EXPIRE_MINUTES,
+                hasattr(AuthConfig, "DAYS_TO_EXPIRE_COOKIE")
+                and AuthConfig.DAYS_TO_EXPIRE_COOKIE,
+            ]
+        ):
             return {
                 "status": "unhealthy",
-                "message": "Auth configuration is not fully initialized"
+                "message": "Auth configuration is not fully initialized",
             }
-        
+    except Exception:
+        logger.exception("Auth configuration health check failed")
         return {
-            "status": "healthy",
-            "message": "Auth configuration is properly initialized"
+            "status": "unhealthy",
+            "message": "Auth configuration check failed",
         }
-    except Exception as e:
-        logger.error(f"Auth configuration health check failed: {str(e)}")
-        return {"status": "unhealthy", "message": f"Auth configuration check failed: {str(e)}"}
+    else:
+        return {"status": "healthy", "message": "Auth configuration is properly initialized"}
+
 
 @router.get(
     "/",
     response_model=HealthCheckResponse,
     summary="Health Check Endpoint",
-    description="Validates if the app and its critical components are functioning correctly"
+    description="Validates if the app and its critical components are functioning correctly",
 )
 async def get_health() -> JSONResponse:
     """Validates if the app has launched correctly and all critical components are healthy
-    
-    Returns
-    -------
-        JSONResponse with health status and details of each component
-        200 OK if all components are healthy
-        503 Service Unavailable if any component is unhealthy
+
+    Returns:
+        JSONResponse: health status with details of each component and status code
     """
-    db_health = await check_database_connection()
+    db_health = check_database_connection()
     service_health = check_song_service()
     auth_health = check_auth_config()
-    
+
     health_details = {
         "database": db_health,
         "song_service": service_health,
-        "auth_config": auth_health
+        "auth_config": auth_health,
     }
-    
+
     is_healthy = all(check["status"] == "healthy" for check in health_details.values())
-    
+
     response_data = {
         "status": "healthy" if is_healthy else "unhealthy",
-        "details": health_details
+        "details": health_details,
     }
-    
+
     status_code = HTTP_200_OK if is_healthy else HTTP_503_SERVICE_UNAVAILABLE
-    
+
     if not is_healthy:
         logger.warning(f"Health check failed: {health_details}")
-    
-    return JSONResponse(
-        content=response_data,
-        status_code=status_code
-    )
+
+    return JSONResponse(content=response_data, status_code=status_code)

Backend/app/spotify_electron/health/health_schema.py

@@ -0,0 +1,15 @@
+"""
+This module defines the schemas for health-related API responses.
+
+It includes data models and structures used for health checks and
+related functionalities in the application.
+"""
+
+from pydantic import BaseModel
+
+
+class HealthCheckResponse(BaseModel):
+    """Class that represents response of health check"""
+
+    status: str
+    details: dict[str, dict[str, str]]