keep alive all services

cronjob_service.py

@@ -9,6 +9,8 @@ import os
 from twilio.rest import Client
 from twilio.base.exceptions import TwilioRestException
 
+from keep_projects_alive_service import ping_all_projects
+
 load_dotenv()
 
 # --- Twilio Configuration (New Additions) ---
@@ -104,6 +106,12 @@ def init_scheduler():
         id='daily_chat_limit_reset_api_users'
     )
     
+    scheduler.add_job(
+        ping_all_projects,
+        trigger=CronTrigger(hour=0, minute=10, second=0),
+        id='ping_all_projects'
+    )
+    
     scheduler.start()
     
     # New: Optional startup notification

keep_projects_alive_service.py

@@ -0,0 +1,14 @@
+
+
+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
+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()
+    

mongodb_keep_alive_service.py

@@ -0,0 +1,55 @@
+import os
+import logging
+from urllib.parse import parse_qs, urlparse
+from dotenv import load_dotenv
+from pymongo import MongoClient
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+load_dotenv()
+
+mongodb_uris = os.getenv('MONGODB_URIS')
+
+def extract_app_name_from_uri(uri):
+    """Extracts the appName from MongoDB URI if present."""
+    try:
+        parsed_uri = urlparse(uri)
+        query_params = parse_qs(parsed_uri.query)
+        app_name = query_params.get('appName', ['MongoDB Ping Service'])[0]
+        return app_name
+    except Exception as e:
+        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."""
+    if not mongodb_uris:
+        logger.warning("No MongoDB URIs found in environment variables")
+        return
+    
+    for uri in mongodb_uris.split(','):
+        uri = uri.strip()  # Remove any whitespace around the URI
+        if not uri:
+            continue
+            
+        service_name = extract_app_name_from_uri(uri)
+        try:
+            client = MongoClient(uri)
+            client.admin.command('ping')
+            logger.info(f"{service_name}: Successfully pinged MongoDB at {uri[:50]}...")  # Truncate URI for security
+            client.close()
+        except Exception as e:
+            logger.error(f"{service_name}: Error pinging MongoDB at {uri[:50]}... - {str(e)}")
+
+def ping_mongodb_projects():
+    logger.info("Starting MongoDB ping checks...")
+    ping_mongodb()
+    logger.info("Completed MongoDB ping checks.")

neondb_postgres_keep_alive_service.py

@@ -0,0 +1,83 @@
+import os
+import logging
+from dotenv import load_dotenv
+import psycopg2
+from psycopg2 import OperationalError
+from urllib.parse import urlparse
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+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 = {}
+    
+    for uri in filter(None, (u.strip() for u in NEONDB_POSTGRES_URIS)):
+        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}")
+            
+        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)}")
+        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
+
+
+# Example usage
+def ping_neondb_projects():
+    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)
+    
+    logger.info("Completed NeonDB ping checks.")
+

pinecone_keep_alive_service.py

@@ -0,0 +1,34 @@
+import os
+import time
+import logging
+from dotenv import load_dotenv
+from pinecone import Pinecone
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+load_dotenv()
+
+# Read comma-separated list of API keys
+keys = os.getenv("PINECONE_API_KEYS", "").split(",")
+
+def ping_all_pinecone_indexes():
+    for key in filter(None, (k.strip() for k in keys)):
+        pc = Pinecone(api_key=key)
+        try:
+            indexes = pc.list_indexes()  # This returns IndexModel objects
+        except Exception as e:
+            logger.error(f"[{key[:5]}…] failed to list indexes: {e}")
+            continue
+
+        for index in indexes:
+            try:
+                index_stats = pc.Index(index.name).describe_index_stats()
+                logger.info(f"[{key[:5]}…] ping {index.name} ✓")
+            except Exception as e:
+                logger.error(f"[{key[:5]}…] ping {index.name} ✗: {e}")
+

requirements.txt

@@ -4,4 +4,8 @@ fastapi
 uvicorn
 requests
 dotenv
-twilio
+twilio
+pymongo==4.11.2
+psycopg2-binary==2.9.10
+pinecone==6.0.2
+supabase==2.13.0

supabase_keep_alive_service.py

@@ -0,0 +1,74 @@
+from supabase import create_client, Client
+import logging
+import os
+from dotenv import load_dotenv
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),  # Output to console
+        logging.FileHandler('supabase_ping.log')  # Output to file
+    ]
+)
+
+load_dotenv()
+
+SUPABASE_PROJECTS = {
+    "chat_csv_and_pdf": {
+        "url": os.getenv("CHAT_CSV_AND_PDF_SUPABASE_URL"),
+        "anon_key": os.getenv("CHAT_CSV_AND_PDF_SUPABASE_ANON_KEY"),
+        "table": os.getenv("CHAT_CSV_AND_PDF_TABLE_NAME")  
+    },
+    "customer_support_assistant": {
+        "url": os.getenv("CUSTOMER_SUPPORT_ASSISTANT_SUPABASE_URL"),
+        "anon_key": os.getenv("CUSTOMER_SUPPORT_ASSISTANT_SUPABASE_ANON_KEY"),
+        "table": os.getenv("CUSTOMER_SUPPORT_ASSISTANT_TABLE_NAME")
+    },
+    "csv_charts": {
+        "url": os.getenv("CSV_CHARTS_SUPABASE_URL"),
+        "anon_key": os.getenv("CSV_CHARTS_SUPABASE_ANON_KEY"),
+        "table": os.getenv("CSV_CHARTS_TABLE_NAME")
+    },
+    "database_chat": {
+        "url": os.getenv("DATABASE_CHAT_SUPABASE_URL"),
+        "anon_key": os.getenv("DATABASE_CHAT_SUPABASE_ANON_KEY"),
+        "table": os.getenv("DATABASE_CHAT_TABLE_NAME")
+    },
+    "pixeldream_ai": {
+        "url": os.getenv("PIXELDREAM_AI_SUPABASE_URL"),
+        "anon_key": os.getenv("PIXELDREAM_AI_SUPABASE_ANON_KEY"),
+        "table": os.getenv("PIXELDREAM_AI_TABLE_NAME")
+    }
+}
+
+def ping_supabase(service_name: str) -> bool:
+    """Ping a Supabase project to keep it active."""
+    if service_name not in SUPABASE_PROJECTS:
+        logging.error(f"Service '{service_name}' not found in config.")
+        return False
+
+    config = SUPABASE_PROJECTS[service_name]
+    supabase: Client = create_client(config["url"], config["anon_key"])
+
+    try:
+        # Simple query to prevent deactivation
+        response = supabase.table(config["table"]).select("*").limit(1).execute()
+        if not response.data:
+            logging.error(f"Failed to ping {service_name}: No data returned.")
+            return False
+        logging.info(f"Pinged {service_name} successfully.")
+        return True
+    except Exception as e:
+        logging.error(f"Failed to ping {service_name}: {str(e)}", exc_info=True)
+        return False
+
+
+def ping_all_supabase_projects():
+    """Ping all Supabase projects."""
+    logging.info("Pinging all Supabase projects...")
+    for service_name in SUPABASE_PROJECTS:
+        ping_supabase(service_name)
+        
+