added upstash

aiven_keep_alive_service.py

@@ -3,6 +3,9 @@ import logging
 from dotenv import load_dotenv
 import psycopg2  # For PostgreSQL
 import pymysql  # For MySQL
+from urllib.parse import urlparse, parse_qs
+from datetime import datetime
+from pydantic import BaseModel
 
 # Load environment variables
 load_dotenv()
@@ -10,36 +13,39 @@ load_dotenv()
 sql_uri = os.getenv("AIVEN_MYSQL_URI")
 postgres_uri = os.getenv("AIVEN_POSTGRES_URI")
 
-# Configure logging
+# Configure logging (console only)
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.StreamHandler(),
-        logging.FileHandler('keepalive.log')
-    ]
+    handlers=[logging.StreamHandler()]
 )
 logger = logging.getLogger('KeepAlive')
 
-def ping_mysql():
-    """Ping MySQL database to keep connection alive"""
+
+# ---------- Pydantic Response Model ----------
+class AivenPingResponse(BaseModel):
+    service_name: str
+    success: bool
+    error: str | None = None
+    time: str
+    host: str | None = None
+    db_type: str | None = None
+
+
+# ---------- MySQL ----------
+def ping_mysql() -> AivenPingResponse:
+    now = datetime.utcnow().isoformat()
     try:
-        from urllib.parse import urlparse, parse_qs
-        
-        # Parse the URI
         parsed_uri = urlparse(sql_uri)
-        
-        # Extract connection parameters
         host = parsed_uri.hostname
-        port = parsed_uri.port or 3306  # default MySQL port
+        port = parsed_uri.port or 3306
         user = parsed_uri.username
         password = parsed_uri.password
         database = parsed_uri.path.lstrip('/') or 'defaultdb'
-        
-        # Parse query parameters for SSL mode
+
         query_params = parse_qs(parsed_uri.query)
         ssl_mode = query_params.get('ssl-mode', ['REQUIRED'])[0]
-        
+
         connection = pymysql.connect(
             host=host,
             port=port,
@@ -50,31 +56,78 @@ def ping_mysql():
         )
         with connection.cursor() as cursor:
             cursor.execute("SELECT 1")
-            result = cursor.fetchone()
-            logger.info(f"MySQL ping successful: {result}")
+            cursor.fetchone()
         connection.close()
+
+        logger.info(f"MySQL ping successful: {host}")
+        return AivenPingResponse(
+            service_name=database,
+            success=True,
+            error=None,
+            time=now,
+            host=host,
+            db_type="mysql"
+        )
     except Exception as e:
-        logger.error(f"MySQL ping failed: {str(e)}")
+        error_msg = str(e)
+        logger.error(f"MySQL ping failed: {error_msg}")
+        return AivenPingResponse(
+            service_name="mysql_service",
+            success=False,
+            error=error_msg,
+            time=now,
+            host=None,
+            db_type="mysql"
+        )
+
 
-def ping_postgres():
-    """Ping PostgreSQL database to keep connection alive"""
+# ---------- PostgreSQL ----------
+def ping_postgres() -> AivenPingResponse:
+    now = datetime.utcnow().isoformat()
     try:
+        parsed_uri = urlparse(postgres_uri)
+        host = parsed_uri.hostname
+        db_name = parsed_uri.path.lstrip('/')
+
         connection = psycopg2.connect(postgres_uri)
         cursor = connection.cursor()
         cursor.execute("SELECT 1")
-        result = cursor.fetchone()
-        logger.info(f"PostgreSQL ping successful: {result}")
+        cursor.fetchone()
         cursor.close()
         connection.close()
-    except Exception as e:
-        logger.error(f"PostgreSQL ping failed: {str(e)}")
 
+        logger.info(f"PostgreSQL ping successful: {db_name}@{host}")
+        return AivenPingResponse(
+            service_name=db_name,
+            success=True,
+            error=None,
+            time=now,
+            host=host,
+            db_type="postgres"
+        )
+    except Exception as e:
+        error_msg = str(e)
+        logger.error(f"PostgreSQL ping failed: {error_msg}")
+        return AivenPingResponse(
+            service_name="postgres_service",
+            success=False,
+            error=error_msg,
+            time=now,
+            host=None,
+            db_type="postgres"
+        )
 
 
-def ping_aiven_projects():
-    """Ping Aiven projects to keep connections alive"""
+# ---------- Run Aiven Pings ----------
+def ping_aiven_projects() -> list[AivenPingResponse]:
     logger.info("Starting Aiven service health check")
-    ping_mysql()
-    ping_postgres()
-    
-    
+    results = []
+    if sql_uri:
+        results.append(ping_mysql())
+    if postgres_uri:
+        results.append(ping_postgres())
+    logger.info("Completed Aiven service health check")
+    return results
+
+
+

keep_projects_alive_service.py

@@ -1,5 +1,3 @@
-
-
 from aiven_keep_alive_service import ping_aiven_projects
 from mongodb_keep_alive_service import ping_mongodb_projects
 from neondb_postgres_keep_alive_service import ping_neondb_projects
@@ -9,10 +7,42 @@ from supabase_keep_alive_service import ping_all_supabase_projects
 
 
 def ping_all_projects():
-    ping_all_supabase_projects()
-    ping_neondb_projects()
-    ping_all_pinecone_indexes()
-    ping_mongodb_projects()
-    ping_aiven_projects()
-    ping_all_redis_projects()
-    
+    all_results = []
+
+    # Each function should return either a list of Pydantic models or dicts
+    services = [
+        ping_all_supabase_projects,
+        ping_neondb_projects,
+        ping_all_pinecone_indexes,
+        ping_mongodb_projects,
+        ping_aiven_projects,
+        ping_all_redis_projects,
+    ]
+
+    for service_func in services:
+        try:
+            result = service_func()
+            if isinstance(result, list):
+                # flatten list of Pydantic models
+                for r in result:
+                    if hasattr(r, "model_dump"):
+                        all_results.append(r.model_dump())
+                    else:
+                        all_results.append(r)
+            else:
+                # single Pydantic model or dict
+                if hasattr(result, "model_dump"):
+                    all_results.append(result.model_dump())
+                else:
+                    all_results.append(result)
+        except Exception as e:
+            all_results.append({
+                "service_name": service_func.__name__,
+                "success": False,
+                "error": str(e)
+            })
+
+    return all_results
+
+
+

main.py

@@ -6,6 +6,7 @@ import pandas as pd
 from aiven_keep_alive_service import ping_aiven_projects
 from cronjob_service import init_scheduler
 from dotenv import load_dotenv
+from keep_projects_alive_service import ping_all_projects
 from mongodb_keep_alive_service import ping_mongodb_projects
 from neondb_postgres_keep_alive_service import ping_neondb_projects
 from pinecone_keep_alive_service import ping_all_pinecone_indexes
@@ -54,14 +55,9 @@ def health_check():
 
 
 @app.get("/ping_all_projects")
-def ping_all_projects():
-    ping_all_supabase_projects()
-    ping_neondb_projects()
-    ping_all_pinecone_indexes()
-    ping_mongodb_projects()
-    ping_aiven_projects()
-    ping_all_redis_projects()
-    return {"status": "success", "message": "All projects pinged successfully"}
+def ping_all_projects_endpoint():
+    result = ping_all_projects()
+    return result
 
 
 

mongodb_keep_alive_service.py

@@ -3,14 +3,14 @@ import logging
 from urllib.parse import parse_qs, urlparse
 from dotenv import load_dotenv
 from pymongo import MongoClient
+from datetime import datetime
+from pydantic import BaseModel
 
 # Configure logging
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.StreamHandler()
-    ]
+    handlers=[logging.StreamHandler()]
 )
 logger = logging.getLogger(__name__)
 
@@ -18,7 +18,17 @@ load_dotenv()
 
 mongodb_uris = os.getenv('MONGODB_URIS')
 
-def extract_app_name_from_uri(uri):
+
+# ---------- Pydantic Response Model ----------
+class MongoPingResponse(BaseModel):
+    service_name: str
+    success: bool
+    error: str | None = None
+    time: str
+
+
+# ---------- Helpers ----------
+def extract_app_name_from_uri(uri: str) -> str:
     """Extracts the appName from MongoDB URI if present."""
     try:
         parsed_uri = urlparse(uri)
@@ -29,27 +39,55 @@ def extract_app_name_from_uri(uri):
         logger.debug(f"Failed to extract appName from URI: {e}")
         return "MongoDB Ping Service"  # Fallback if parsing fails
 
-def ping_mongodb():
-    """Ping MongoDB to keep the connection alive without requiring a default database."""
+
+# ---------- MongoDB Ping ----------
+def ping_mongodb() -> list[MongoPingResponse]:
+    """Ping MongoDB and return structured responses."""
+    responses: list[MongoPingResponse] = []
+
     if not mongodb_uris:
         logger.warning("No MongoDB URIs found in environment variables")
-        return
-    
+        return responses
+
     for uri in mongodb_uris.split(','):
-        uri = uri.strip()  # Remove any whitespace around the URI
+        uri = uri.strip()
         if not uri:
             continue
-            
+
         service_name = extract_app_name_from_uri(uri)
+        now = datetime.utcnow().isoformat()
+
         try:
-            client = MongoClient(uri)
+            client = MongoClient(uri, serverSelectionTimeoutMS=3000)  # 3s timeout
             client.admin.command('ping')
-            logger.info(f"{service_name}: Successfully pinged MongoDB at {uri[:50]}...")  # Truncate URI for security
+            logger.info(f"{service_name}: Successfully pinged MongoDB at {uri[:50]}...")
+            responses.append(
+                MongoPingResponse(
+                    service_name=service_name,
+                    success=True,
+                    error=None,
+                    time=now
+                )
+            )
             client.close()
         except Exception as e:
             logger.error(f"{service_name}: Error pinging MongoDB at {uri[:50]}... - {str(e)}")
+            responses.append(
+                MongoPingResponse(
+                    service_name=service_name,
+                    success=False,
+                    error=str(e),
+                    time=now
+                )
+            )
+
+    return responses
+
 
 def ping_mongodb_projects():
     logger.info("Starting MongoDB ping checks...")
-    ping_mongodb()
-    logger.info("Completed MongoDB ping checks.")
+    results = ping_mongodb()
+    logger.info("Completed MongoDB ping checks.")
+    return results
+
+

neondb_postgres_keep_alive_service.py

@@ -4,8 +4,10 @@ from dotenv import load_dotenv
 import psycopg2
 from psycopg2 import OperationalError
 from urllib.parse import urlparse
+from datetime import datetime
+from pydantic import BaseModel
 
-# Configure logging
+# Configure logging (console only)
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s'
@@ -16,68 +18,79 @@ load_dotenv()
 
 NEONDB_POSTGRES_URIS = os.getenv('NEONDB_POSTGRES_URIS', '').split(',')
 
-def ping_neondb():
-    """
-    Ping all NeonDB instances to keep connections alive.
-    Returns a dictionary with connection status for each database.
-    """
-    results = {}
-    
+
+# ---------- Pydantic Response Model ----------
+class NeonDBPingResponse(BaseModel):
+    service_name: str
+    success: bool
+    error: str | None = None
+    time: str
+    host: str | None = None
+
+
+# ---------- NeonDB Ping ----------
+def ping_neondb() -> list[NeonDBPingResponse]:
+    """Ping all NeonDB instances and return structured responses."""
+    responses: list[NeonDBPingResponse] = []
+
     for uri in filter(None, (u.strip() for u in NEONDB_POSTGRES_URIS)):
+        now = datetime.utcnow().isoformat()
         try:
-            # Parse the URI to extract database name
             parsed_uri = urlparse(uri)
             db_name = parsed_uri.path[1:]  # Remove the leading '/'
             host = parsed_uri.hostname
-            
-            # Connect to the database
+
             conn = psycopg2.connect(uri)
             cursor = conn.cursor()
-            
-            # Execute a simple query
             cursor.execute("SELECT 1")
             cursor.fetchone()
-            
-            # Close the connection
             cursor.close()
             conn.close()
-            
-            results[db_name] = {
-                'host': host,
-                'status': 'Ping successful',
-                'details': f"Successfully connected to database '{db_name}' on {host}"
-            }
+
             logger.info(f"Successfully connected to database '{db_name}' on {host}")
-            
+            responses.append(
+                NeonDBPingResponse(
+                    service_name=db_name,
+                    success=True,
+                    error=None,
+                    time=now,
+                    host=host
+                )
+            )
+
         except OperationalError as e:
-            results[db_name] = {
-                'host': host,
-                'status': 'Connection failed',
-                'details': str(e)
-            }
-            logger.error(f"Connection failed to database '{db_name}' on {host}: {str(e)}")
+            error_msg = f"Connection failed: {str(e)}"
+            logger.error(f"Connection failed to database '{db_name}' on {host}: {error_msg}")
+            responses.append(
+                NeonDBPingResponse(
+                    service_name=db_name,
+                    success=False,
+                    error=error_msg,
+                    time=now,
+                    host=host
+                )
+            )
         except Exception as e:
-            results[db_name] = {
-                'host': host,
-                'status': 'Error',
-                'details': str(e)
-            }
-            logger.error(f"Error connecting to database '{db_name}' on {host}: {str(e)}")
-    
-    return results
+            error_msg = str(e)
+            logger.error(f"Error connecting to database '{db_name}' on {host}: {error_msg}")
+            responses.append(
+                NeonDBPingResponse(
+                    service_name=db_name,
+                    success=False,
+                    error=error_msg,
+                    time=now,
+                    host=host
+                )
+            )
+
+    return responses
 
 
-# Example usage
-def ping_neondb_projects():
+def ping_neondb_projects() -> list[NeonDBPingResponse]:
     logger.info("Starting NeonDB ping checks...")
-    ping_results = ping_neondb()
-    
-    for db_name, result in ping_results.items():
-        logger.info(f"Database: {db_name}")
-        logger.info(f"Host: {result['host']}")
-        logger.info(f"Status: {result['status']}")
-        logger.info(f"Details: {result['details']}")
-        logger.info("-" * 40)
-    
+    results = ping_neondb()
     logger.info("Completed NeonDB ping checks.")
+    return results
+
+
 

redis_keep_alive_service.py

@@ -5,12 +5,13 @@ import redis
 import logging
 from datetime import datetime
 import uuid
+from pydantic import BaseModel
 
-# Logging
+# Logging (console only)
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[logging.FileHandler('redis_ping.log'), logging.StreamHandler()]
+    handlers=[logging.StreamHandler()]
 )
 logger = logging.getLogger(__name__)
 
@@ -41,8 +42,19 @@ REDIS_SERVICES = {
 }
 
 
-def ping_redis(redis_config):
-    """Ping and benchmark self-managed Redis (host/port/password)."""
+# ---------- Pydantic Response ----------
+class RedisPingResponse(BaseModel):
+    service_name: str
+    success: bool
+    error: str | None = None
+    time: str
+    latency_ms: float | None = None
+    type: str  # "self-managed" or "upstash"
+
+
+# ---------- Self-managed Redis ----------
+def ping_redis(service_name: str, redis_config: dict) -> RedisPingResponse:
+    now = datetime.utcnow().isoformat()
     try:
         start_time = datetime.now()
         r = redis.Redis(
@@ -51,99 +63,92 @@ def ping_redis(redis_config):
             password=redis_config["password"],
             ssl=True if redis_config.get("ssl") else False,
         )
+
         # PING
-        response = r.ping()
+        r.ping()
         latency = (datetime.now() - start_time).total_seconds() * 1000
-        logger.info(
-            f"PING {redis_config['host']}:{redis_config['port']} "
-            f"- Response: {response}, Latency: {latency:.2f}ms"
-        )
 
-        # Benchmark SET/GET
+        # Simple SET/GET check
         key = f"healthcheck:{uuid.uuid4()}"
-        value = "ok"
-
-        set_start = datetime.now()
-        r.set(key, value)
-        set_latency = (datetime.now() - set_start).total_seconds() * 1000
-
-        get_start = datetime.now()
+        r.set(key, "ok")
         got = r.get(key)
-        get_latency = (datetime.now() - get_start).total_seconds() * 1000
 
-        logger.info(
-            f"SET latency: {set_latency:.2f}ms, GET latency: {get_latency:.2f}ms, Value returned: {got.decode()}"
+        logger.info(f"{service_name} PING OK, latency {latency:.2f}ms, value={got.decode()}")
+        return RedisPingResponse(
+            service_name=service_name,
+            success=True,
+            error=None,
+            time=now,
+            latency_ms=latency,
+            type="self-managed"
         )
-
-        return True
     except Exception as e:
-        logger.error(f"Failed to test Redis {redis_config.get('host', 'unknown_host')}: {str(e)}")
-        return False
+        error_msg = str(e)
+        logger.error(f"{service_name} failed: {error_msg}")
+        return RedisPingResponse(
+            service_name=service_name,
+            success=False,
+            error=error_msg,
+            time=now,
+            latency_ms=None,
+            type="self-managed"
+        )
 
 
-def ping_upstash(redis_config):
-    """Ping and benchmark Upstash Redis REST API."""
+# ---------- Upstash Redis ----------
+def ping_upstash(service_name: str, redis_config: dict) -> RedisPingResponse:
+    now = datetime.utcnow().isoformat()
     try:
         headers = {"Authorization": f"Bearer {redis_config['rest_token']}"}
 
         # PING
         start_time = datetime.now()
-        url = f"{redis_config['rest_url']}/ping"
-        resp = requests.get(url, headers=headers)
+        resp = requests.get(f"{redis_config['rest_url']}/ping", headers=headers)
         latency = (datetime.now() - start_time).total_seconds() * 1000
 
-        if resp.status_code == 200 and resp.text.strip().lower() == "pong":
-            logger.info(
-                f"PING {redis_config['rest_url']} "
-                f"- Response: {resp.text.strip()}, Latency: {latency:.2f}ms"
-            )
-        else:
-            logger.error(f"Unexpected Upstash PING response: {resp.status_code} - {resp.text}")
-            return False
+        if resp.status_code != 200 or resp.text.strip().lower() != "pong":
+            raise Exception(f"Unexpected response: {resp.status_code} - {resp.text}")
 
-        # Benchmark SET/GET
+        # SET/GET
         key = f"healthcheck:{uuid.uuid4()}"
-        value = "ok"
-
-        # SET
-        set_start = datetime.now()
-        set_resp = requests.post(
-            f"{redis_config['rest_url']}/set/{key}/{value}",
-            headers=headers,
-        )
-        set_latency = (datetime.now() - set_start).total_seconds() * 1000
-
-        # GET
-        get_start = datetime.now()
+        requests.post(f"{redis_config['rest_url']}/set/{key}/ok", headers=headers)
         get_resp = requests.get(f"{redis_config['rest_url']}/get/{key}", headers=headers)
-        get_latency = (datetime.now() - get_start).total_seconds() * 1000
-
-        if get_resp.status_code == 200:
-            got_value = get_resp.json().get("result")
-            logger.info(
-                f"SET latency: {set_latency:.2f}ms, GET latency: {get_latency:.2f}ms, Value returned: {got_value}"
-            )
-        else:
-            logger.error(f"Upstash GET failed: {get_resp.status_code} - {get_resp.text}")
-            return False
-
-        return True
+        got_value = get_resp.json().get("result") if get_resp.status_code == 200 else None
+
+        logger.info(f"{service_name} PING OK, latency {latency:.2f}ms, value={got_value}")
+        return RedisPingResponse(
+            service_name=service_name,
+            success=True,
+            error=None,
+            time=now,
+            latency_ms=latency,
+            type="upstash"
+        )
     except Exception as e:
-        logger.error(f"Failed to test Upstash: {str(e)}")
-        return False
+        error_msg = str(e)
+        logger.error(f"{service_name} failed: {error_msg}")
+        return RedisPingResponse(
+            service_name=service_name,
+            success=False,
+            error=error_msg,
+            time=now,
+            latency_ms=None,
+            type="upstash"
+        )
 
 
-def ping_all_redis_projects():
+# ---------- Run All ----------
+def ping_all_redis_projects() -> list[RedisPingResponse]:
     logger.info("Starting Redis service health check")
-    results = {}
+    results: list[RedisPingResponse] = []
 
     for service_name, config in REDIS_SERVICES.items():
+        if not config or not any(config.values()):
+            continue  # skip empty configs
         if "rest_url" in config:  # Upstash
-            logger.info(f"Testing {service_name} via Upstash REST API")
-            results[service_name] = ping_upstash(config)
-        else:  # Self-managed Redis
-            logger.info(f"Testing {service_name} at {config['host']}:{config['port']}")
-            results[service_name] = ping_redis(config)
+            results.append(ping_upstash(service_name, config))
+        else:  # Self-managed
+            results.append(ping_redis(service_name, config))
 
     logger.info("Completed all Redis service checks")
     return results

supabase_keep_alive_service.py

@@ -4,6 +4,7 @@ import os
 from dotenv import load_dotenv
 from uuid import uuid4
 from datetime import datetime
+from pydantic import BaseModel
 
 # Configure logging
 logging.basicConfig(
@@ -11,10 +12,11 @@ logging.basicConfig(
     format='%(asctime)s - %(levelname)s - %(message)s',
     handlers=[
         logging.StreamHandler(),  # Output to console
-        logging.FileHandler('supabase_ping.log')  # Output to file
     ]
 )
 
+logger = logging.getLogger(__name__)
+
 load_dotenv()
 
 SUPABASE_PROJECTS = {
@@ -50,89 +52,99 @@ SUPABASE_PROJECTS = {
     }
 }
 
+
+# ---------- Pydantic Response Model ----------
+class SupabasePingResponse(BaseModel):
+    service_name: str
+    success: bool
+    error: str | None = None
+    time: str
+
+
+# ---------- CRUD Operations ----------
 def initiate_crud_operation(client: Client, table_name: str, service_name: str) -> bool:
     """
     Perform full CRUD operations on the ping_test table.
-    
-    Args:
-        client: Supabase client instance
-        table_name: Name of the table to perform operations on
-        service_name: Name of the service for logging purposes
-        
-    Returns:
-        bool: True if all operations succeeded, False otherwise
     """
     try:
-        # Generate a unique ID for this test record
         test_id = str(uuid4())
         test_service_name = f"{service_name}_crud_test"
-        
-        # CREATE operation
-        create_data = {
-            "id": test_id,
-            "service_name": test_service_name
-        }
+
+        # CREATE
+        create_data = {"id": test_id, "service_name": test_service_name}
         create_response = client.table(table_name).insert(create_data).execute()
         if not create_response.data:
-            logging.error(f"CREATE failed for {service_name}")
+            logger.error(f"CREATE failed for {service_name}")
             return False
-        
-        # READ operation
+
+        # READ
         read_response = client.table(table_name).select("*").eq("id", test_id).execute()
         if not read_response.data or read_response.data[0]["id"] != test_id:
-            logging.error(f"READ failed for {service_name}")
+            logger.error(f"READ failed for {service_name}")
             return False
-        
-        # UPDATE operation
+
+        # UPDATE
         new_service_name = f"{test_service_name}_updated"
         update_response = client.table(table_name).update({"service_name": new_service_name}).eq("id", test_id).execute()
         if not update_response.data or update_response.data[0]["service_name"] != new_service_name:
-            logging.error(f"UPDATE failed for {service_name}")
+            logger.error(f"UPDATE failed for {service_name}")
             return False
-        
-        # DELETE operation
+
+        # DELETE
         delete_response = client.table(table_name).delete().eq("id", test_id).execute()
         if not delete_response.data:
-            logging.error(f"DELETE failed for {service_name}")
+            logger.error(f"DELETE failed for {service_name}")
             return False
-        
+
         # Verify deletion
         verify_response = client.table(table_name).select("*").eq("id", test_id).execute()
         if verify_response.data:
-            logging.error(f"DELETE verification failed for {service_name} - record still exists")
+            logger.error(f"DELETE verification failed for {service_name}")
             return False
-            
+
         logging.info(f"CRUD operations completed successfully for {service_name}")
         return True
-        
+
     except Exception as e:
-        logging.error(f"CRUD operation failed for {service_name}: {str(e)}", exc_info=True)
+        logger.error(f"CRUD operation failed for {service_name}: {str(e)}", exc_info=True)
         return False
 
-def ping_supabase(service_name: str) -> bool:
-    """Ping a Supabase project to keep it active."""
+
+# ---------- Ping Supabase ----------
+def ping_supabase(service_name: str) -> SupabasePingResponse:
+    """Ping a Supabase project and return structured response."""
+    now = datetime.utcnow().isoformat()
+
     if service_name not in SUPABASE_PROJECTS:
-        logging.error(f"Service '{service_name}' not found in config.")
-        return False
+        error_msg = f"Service '{service_name}' not found in config."
+        logger.error(error_msg)
+        return SupabasePingResponse(service_name=service_name, success=False, error=error_msg, time=now)
 
     config = SUPABASE_PROJECTS[service_name]
     supabase: Client = create_client(config["url"], config["anon_key"])
 
     try:
-        # Perform full CRUD operations instead of simple query
         success = initiate_crud_operation(supabase, "ping_test", service_name)
         if not success:
-            logging.error(f"CRUD operations failed for {service_name}")
-            return False
-            
+            error_msg = f"CRUD operations failed for {service_name}"
+            logger.error(error_msg)
+            return SupabasePingResponse(service_name=service_name, success=False, error=error_msg, time=now)
+
         logging.info(f"Pinged {service_name} successfully with full CRUD operations.")
-        return True
+        return SupabasePingResponse(service_name=service_name, success=True, error=None, time=now)
+
     except Exception as e:
-        logging.error(f"Failed to ping {service_name}: {str(e)}", exc_info=True)
-        return False
+        error_msg = f"Failed to ping {service_name}: {str(e)}"
+        logger.error(error_msg, exc_info=True)
+        return SupabasePingResponse(service_name=service_name, success=False, error=error_msg, time=now)
+
 
-def ping_all_supabase_projects():
-    """Ping all Supabase projects."""
+def ping_all_supabase_projects() -> list[SupabasePingResponse]:
+    """Ping all Supabase projects and return structured responses."""
+    responses: list[SupabasePingResponse] = []
     for service_name in SUPABASE_PROJECTS:
-        ping_supabase(service_name)
-        
+        responses.append(ping_supabase(service_name))
+    return responses
+
+
+