Update app.py

app.py

@@ -2,8 +2,17 @@ import gradio as gr
 import json
 import time
 import hashlib
+import logging
 from typing import Dict, Optional
 
+# Initialize logging for backend
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - BACKEND - %(message)s', force=True)
+logger = logging.getLogger(__name__)
+
+# Suppress asyncio warnings during shutdown
+import warnings
+warnings.filterwarnings("ignore", category=RuntimeWarning, message=".*asyncio.*")
+
 # ============================================================================
 # ZEROENGINE-BACKEND: Background Processing Service
 # ============================================================================
@@ -25,6 +34,8 @@ def tokenize_text(text: str) -> str:
     Returns: JSON string with token count estimation
     """
     try:
+        logger.info(f"[TOKENIZE] Processing text of length {len(text)}")
+        
         # Simple estimation (4 chars ≈ 1 token for English)
         # This is FAST and good enough for pre-processing
         estimated_tokens = len(text) // 4
@@ -49,9 +60,11 @@ def tokenize_text(text: str) -> str:
             "cached_at": time.time()
         }
         
+        logger.info(f"[TOKENIZE] Estimated {estimated_tokens} tokens, cached as {text_hash}")
         return json.dumps(result, indent=2)
         
     except Exception as e:
+        logger.error(f"[TOKENIZE] Error: {e}")
         return json.dumps({
             "success": False,
             "error": str(e)
@@ -62,6 +75,8 @@ def cache_prompt(key: str, value: str) -> str:
     Store prompt in cache with timestamp
     """
     try:
+        logger.info(f"[CACHE-PROMPT] Storing key: {key} (value length: {len(value)})")
+        
         prompt_cache[key] = {
             "value": value,
             "timestamp": time.time()
@@ -71,7 +86,9 @@ def cache_prompt(key: str, value: str) -> str:
         if len(prompt_cache) > 100:
             oldest_key = min(prompt_cache.keys(), key=lambda k: prompt_cache[k]["timestamp"])
             del prompt_cache[oldest_key]
+            logger.info(f"[CACHE-PROMPT] Removed oldest entry: {oldest_key}")
         
+        logger.info(f"[CACHE-PROMPT] Stored successfully. Cache size: {len(prompt_cache)}")
         return json.dumps({
             "success": True,
             "cached": key,
@@ -79,6 +96,7 @@ def cache_prompt(key: str, value: str) -> str:
         }, indent=2)
         
     except Exception as e:
+        logger.error(f"[CACHE-PROMPT] Error: {e}")
         return json.dumps({
             "success": False,
             "error": str(e)
@@ -91,18 +109,21 @@ def get_cached_prompt(key: str) -> str:
     try:
         if key in prompt_cache:
             data = prompt_cache[key]
+            logger.info(f"[CACHE-PROMPT] Retrieved key: {key} (value length: {len(data['value'])})")
             return json.dumps({
                 "success": True,
                 "value": data["value"],
                 "age_seconds": round(time.time() - data["timestamp"], 2)
             }, indent=2)
         
+        logger.info(f"[CACHE-PROMPT] Key not found: {key}")
         return json.dumps({
             "success": False,
             "error": "Cache key not found"
         }, indent=2)
         
     except Exception as e:
+        logger.error(f"[CACHE-PROMPT] Error: {e}")
         return json.dumps({
             "success": False,
             "error": str(e)
@@ -113,6 +134,8 @@ def cache_response(prompt_hash: str, response: str) -> str:
     Cache a complete response for instant retrieval
     """
     try:
+        logger.info(f"[CACHE-RESPONSE] Storing prompt hash: {prompt_hash} (response length: {len(response)})")
+        
         response_cache[prompt_hash] = {
             "response": response,
             "timestamp": time.time()
@@ -122,7 +145,9 @@ def cache_response(prompt_hash: str, response: str) -> str:
         if len(response_cache) > 50:
             oldest_key = min(response_cache.keys(), key=lambda k: response_cache[k]["timestamp"])
             del response_cache[oldest_key]
+            logger.info(f"[CACHE-RESPONSE] Removed oldest entry: {oldest_key}")
         
+        logger.info(f"[CACHE-RESPONSE] Stored successfully. Cache size: {len(response_cache)}")
         return json.dumps({
             "success": True,
             "cached": prompt_hash,
@@ -130,6 +155,7 @@ def cache_response(prompt_hash: str, response: str) -> str:
         }, indent=2)
         
     except Exception as e:
+        logger.error(f"[CACHE-RESPONSE] Error: {e}")
         return json.dumps({
             "success": False,
             "error": str(e)
@@ -142,18 +168,21 @@ def get_cached_response(prompt_hash: str) -> str:
     try:
         if prompt_hash in response_cache:
             data = response_cache[prompt_hash]
+            logger.info(f"[CACHE-RESPONSE] Retrieved prompt hash: {prompt_hash} (response length: {len(data['response'])})")
             return json.dumps({
                 "success": True,
                 "response": data["response"],
                 "age_seconds": round(time.time() - data["timestamp"], 2)
             }, indent=2)
         
+        logger.info(f"[CACHE-RESPONSE] Prompt hash not found: {prompt_hash}")
         return json.dumps({
             "success": False,
             "error": "Response not cached"
         }, indent=2)
         
     except Exception as e:
+        logger.error(f"[CACHE-RESPONSE] Error: {e}")
         return json.dumps({
             "success": False,
             "error": str(e)
@@ -165,6 +194,8 @@ def calculate_token_cost(username: str, duration_ms: float) -> str:
     Stateless - just returns the calculation
     """
     try:
+        logger.info(f"[TOKEN-COST] Calculating cost for user: {username} (duration: {duration_ms}ms)")
+        
         cost = (duration_ms / 100.0) * 0.001  # 0.001 tokens per 100ms
         
         # Track in ledger (for analytics)
@@ -179,6 +210,7 @@ def calculate_token_cost(username: str, duration_ms: float) -> str:
         token_ledger[username]["total_duration_ms"] += duration_ms
         token_ledger[username]["requests"] += 1
         
+        logger.info(f"[TOKEN-COST] Calculated cost: {cost} tokens (total: {token_ledger[username]['total_cost']})")
         return json.dumps({
             "success": True,
             "username": username,
@@ -189,6 +221,7 @@ def calculate_token_cost(username: str, duration_ms: float) -> str:
         }, indent=2)
         
     except Exception as e:
+        logger.error(f"[TOKEN-COST] Error: {e}")
         return json.dumps({
             "success": False,
             "error": str(e)
@@ -199,6 +232,8 @@ def get_cache_stats() -> str:
     Get statistics about cache usage
     """
     try:
+        logger.info("[CACHE-STATS] Retrieving cache statistics")
+        
         return json.dumps({
             "success": True,
             "prompt_cache_size": len(prompt_cache),
@@ -209,6 +244,7 @@ def get_cache_stats() -> str:
         }, indent=2)
         
     except Exception as e:
+        logger.error(f"[CACHE-STATS] Error: {e}")
         return json.dumps({
             "success": False,
             "error": str(e)
@@ -219,6 +255,8 @@ def get_backend_health() -> str:
     Get backend health status for monitoring
     """
     try:
+        logger.info("[BACKEND-HEALTH] Retrieving backend health status")
+        
         return json.dumps({
             "success": True,
             "status": "healthy",
@@ -229,6 +267,7 @@ def get_backend_health() -> str:
         }, indent=2)
         
     except Exception as e:
+        logger.error(f"[BACKEND-HEALTH] Error: {e}")
         return json.dumps({
             "success": False,
             "error": str(e)
@@ -329,20 +368,24 @@ if __name__ == "__main__":
     
     def cleanup_on_exit():
         """Cleanup function called on application exit"""
-        print("[CLEANUP] Backend shutting down...")
+        logger.info("[CLEANUP] Backend shutting down...")
         # Clear caches
         global prompt_cache, response_cache, token_ledger
+        logger.info(f"[CLEANUP] Clearing {len(prompt_cache)} prompt cache entries")
+        logger.info(f"[CLEANUP] Clearing {len(response_cache)} response cache entries")
+        logger.info(f"[CLEANUP] Clearing {len(token_ledger)} user token records")
+        
         prompt_cache.clear()
         response_cache.clear()
         token_ledger.clear()
-        print("[CLEANUP] Backend shutdown complete")
+        logger.info("[CLEANUP] Backend shutdown complete")
     
     # Register cleanup functions
     atexit.register(cleanup_on_exit)
     
     def signal_handler(signum, frame):
         """Handle shutdown signals gracefully"""
-        print(f"[CLEANUP] Received signal {signum}")
+        logger.info(f"[CLEANUP] Received signal {signum}")
         cleanup_on_exit()
         import sys
         sys.exit(0)
@@ -350,4 +393,8 @@ if __name__ == "__main__":
     signal.signal(signal.SIGTERM, signal_handler)
     signal.signal(signal.SIGINT, signal_handler)
     
+    logger.info("[INIT] ZeroEngine-Backend starting up...")
+    logger.info(f"[INIT] Cache sizes - Prompt: {len(prompt_cache)}, Response: {len(response_cache)}")
+    logger.info(f"[INIT] Users tracked: {len(token_ledger)}")
+    
     demo.launch(server_name="0.0.0.0", server_port=7860, ssr_mode=False)