Add MongoDB integration for API call logging with timestamps

app/config.py

@@ -54,6 +54,11 @@ class Settings(BaseSettings):
     UPLOAD_DIR: str = os.getenv("UPLOAD_DIR", "uploads")
     RESULT_DIR: str = os.getenv("RESULT_DIR", "results")
     
+    # MongoDB settings
+    # MONGODB_URI should be set in Hugging Face Space secrets
+    MONGODB_URI: str = os.getenv("MONGODB_URI", "")
+    MONGODB_DB_NAME: str = os.getenv("MONGODB_DB_NAME", "colorization_db")
+    
     class Config:
         env_file = ".env"
         case_sensitive = False

app/database.py

@@ -0,0 +1,209 @@
+"""
+MongoDB database connection and logging utilities
+"""
+import os
+import logging
+from datetime import datetime
+from typing import Optional, Dict, Any
+from pymongo import MongoClient
+from pymongo.errors import ConnectionFailure, ServerSelectionTimeoutError
+
+logger = logging.getLogger(__name__)
+
+# MongoDB connection
+_client: Optional[MongoClient] = None
+_db = None
+
+def get_mongodb_client() -> Optional[MongoClient]:
+    """Get or create MongoDB client"""
+    global _client
+    if _client is None:
+        mongodb_uri = os.getenv("MONGODB_URI")
+        if not mongodb_uri:
+            logger.warning("MONGODB_URI environment variable not set. MongoDB features will be disabled.")
+            return None
+        try:
+            _client = MongoClient(
+                mongodb_uri,
+                serverSelectionTimeoutMS=5000,
+                connectTimeoutMS=5000
+            )
+            # Test connection
+            _client.admin.command('ping')
+            logger.info("MongoDB connection established successfully")
+        except (ConnectionFailure, ServerSelectionTimeoutError) as e:
+            logger.error("Failed to connect to MongoDB: %s", str(e))
+            _client = None
+    return _client
+
+def get_database():
+    """Get database instance"""
+    global _db
+    if _db is None:
+        client = get_mongodb_client()
+        if client:
+            db_name = os.getenv("MONGODB_DB_NAME", "colorization_db")
+            _db = client[db_name]
+        else:
+            logger.warning("MongoDB client not available")
+    return _db
+
+def log_api_call(
+    endpoint: str,
+    method: str,
+    status_code: int = 200,
+    request_data: Optional[Dict[str, Any]] = None,
+    response_data: Optional[Dict[str, Any]] = None,
+    error: Optional[str] = None,
+    user_id: Optional[str] = None,
+    ip_address: Optional[str] = None
+) -> bool:
+    """
+    Log API call to MongoDB
+    
+    Args:
+        endpoint: API endpoint path
+        method: HTTP method (GET, POST, etc.)
+        status_code: HTTP status code
+        request_data: Request data/parameters
+        response_data: Response data
+        error: Error message if any
+        user_id: User ID if authenticated
+        ip_address: Client IP address
+    
+    Returns:
+        True if logged successfully, False otherwise
+    """
+    try:
+        db = get_database()
+        if not db:
+            logger.warning("MongoDB not available, skipping API log")
+            return False
+        
+        collection = db["api_calls"]
+        
+        log_entry = {
+            "endpoint": endpoint,
+            "method": method,
+            "status_code": status_code,
+            "timestamp": datetime.utcnow(),
+            "request_data": request_data or {},
+            "response_data": response_data or {},
+            "error": error,
+            "user_id": user_id,
+            "ip_address": ip_address
+        }
+        
+        result = collection.insert_one(log_entry)
+        logger.info("API call logged to MongoDB: %s", result.inserted_id)
+        return True
+    except Exception as e:
+        logger.error("Failed to log API call to MongoDB: %s", str(e))
+        return False
+
+def log_image_upload(
+    image_id: str,
+    filename: str,
+    file_size: int,
+    content_type: str,
+    user_id: Optional[str] = None,
+    ip_address: Optional[str] = None
+) -> bool:
+    """
+    Log image upload to MongoDB
+    
+    Args:
+        image_id: Unique image identifier
+        filename: Original filename
+        file_size: File size in bytes
+        content_type: MIME type
+        user_id: User ID if authenticated
+        ip_address: Client IP address
+    
+    Returns:
+        True if logged successfully, False otherwise
+    """
+    try:
+        db = get_database()
+        if not db:
+            logger.warning("MongoDB not available, skipping upload log")
+            return False
+        
+        collection = db["image_uploads"]
+        
+        log_entry = {
+            "image_id": image_id,
+            "filename": filename,
+            "file_size": file_size,
+            "content_type": content_type,
+            "uploaded_at": datetime.utcnow(),
+            "user_id": user_id,
+            "ip_address": ip_address
+        }
+        
+        result = collection.insert_one(log_entry)
+        logger.info("Image upload logged to MongoDB: %s", result.inserted_id)
+        return True
+    except Exception as e:
+        logger.error("Failed to log image upload to MongoDB: %s", str(e))
+        return False
+
+def log_colorization(
+    result_id: str,
+    image_id: Optional[str] = None,
+    prompt: Optional[str] = None,
+    model_type: Optional[str] = None,
+    processing_time: Optional[float] = None,
+    user_id: Optional[str] = None,
+    ip_address: Optional[str] = None
+) -> bool:
+    """
+    Log colorization request to MongoDB
+    
+    Args:
+        result_id: Unique result identifier
+        image_id: Original image identifier
+        prompt: Text prompt used (if any)
+        model_type: Model type used (fastai, pytorch, sdxl, etc.)
+        processing_time: Time taken to process in seconds
+        user_id: User ID if authenticated
+        ip_address: Client IP address
+    
+    Returns:
+        True if logged successfully, False otherwise
+    """
+    try:
+        db = get_database()
+        if not db:
+            logger.warning("MongoDB not available, skipping colorization log")
+            return False
+        
+        collection = db["colorizations"]
+        
+        log_entry = {
+            "result_id": result_id,
+            "image_id": image_id,
+            "prompt": prompt,
+            "model_type": model_type,
+            "processing_time": processing_time,
+            "created_at": datetime.utcnow(),
+            "user_id": user_id,
+            "ip_address": ip_address
+        }
+        
+        result = collection.insert_one(log_entry)
+        logger.info("Colorization logged to MongoDB: %s", result.inserted_id)
+        return True
+    except Exception as e:
+        logger.error("Failed to log colorization to MongoDB: %s", str(e))
+        return False
+
+def close_connection():
+    """Close MongoDB connection"""
+    global _client, _db
+    if _client:
+        _client.close()
+        _client = None
+        _db = None
+        logger.info("MongoDB connection closed")
+

app/main.py

@@ -1,4 +1,4 @@
-from fastapi import FastAPI, File, UploadFile, HTTPException, Header
+from fastapi import FastAPI, File, UploadFile, HTTPException, Header, Request
 from fastapi.responses import FileResponse
 from huggingface_hub import hf_hub_download
 import uuid
@@ -8,6 +8,7 @@ import json
 from PIL import Image
 import torch
 from torchvision import transforms
+from app.database import get_database, log_api_call, log_image_upload, log_colorization, close_connection
 
 # -------------------------------------------------
 # 🚀 FastAPI App
@@ -68,12 +69,42 @@ def colorize_image(img: Image.Image):
     output_img = transforms.ToPILImage()(tensor.squeeze())
     return output_img
 
+# -------------------------------------------------
+# 🗄️ MongoDB Initialization
+# -------------------------------------------------
+@app.on_event("startup")
+async def startup_event():
+    """Initialize MongoDB on startup"""
+    try:
+        db = get_database()
+        if db:
+            print("✅ MongoDB initialized successfully!")
+    except Exception as e:
+        print(f"⚠️ MongoDB initialization failed: {e}")
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup on shutdown"""
+    close_connection()
+    print("Application shutdown")
+
 # -------------------------------------------------
 # 🩺 Health Check
 # -------------------------------------------------
 @app.get("/health")
-def health_check():
-    return {"status": "healthy", "model_loaded": True}
+def health_check(request: Request):
+    response = {"status": "healthy", "model_loaded": True}
+    
+    # Log API call
+    log_api_call(
+        endpoint="/health",
+        method="GET",
+        status_code=200,
+        response_data=response,
+        ip_address=request.client.host if request.client else None
+    )
+    
+    return response
 
 # -------------------------------------------------
 # 🔐 Firebase Token Validator
@@ -88,88 +119,214 @@ def verify_app_check_token(token: str):
 # -------------------------------------------------
 @app.post("/upload")
 async def upload_image(
+    request: Request,
     file: UploadFile = File(...),
     x_firebase_appcheck: str = Header(None)
 ):
     verify_app_check_token(x_firebase_appcheck)
+    
+    ip_address = request.client.host if request.client else None
 
     if not file.content_type.startswith("image/"):
+        log_api_call(
+            endpoint="/upload",
+            method="POST",
+            status_code=400,
+            error="Invalid file type",
+            ip_address=ip_address
+        )
         raise HTTPException(status_code=400, detail="Invalid file type")
 
     image_id = f"{uuid.uuid4()}.jpg"
     file_path = os.path.join(UPLOAD_DIR, image_id)
 
+    img_bytes = await file.read()
+    file_size = len(img_bytes)
+    
     with open(file_path, "wb") as f:
-        f.write(await file.read())
+        f.write(img_bytes)
 
     base_url = "https://logicgoinfotechspaces-text-guided-image-colorization.hf.space"
 
-    return {
+    response_data = {
         "success": True,
         "image_id": image_id.replace(".jpg", ""),
         "file_url": f"{base_url}/uploads/{image_id}"
     }
+    
+    # Log to MongoDB
+    log_image_upload(
+        image_id=image_id.replace(".jpg", ""),
+        filename=file.filename or image_id,
+        file_size=file_size,
+        content_type=file.content_type or "image/jpeg",
+        ip_address=ip_address
+    )
+    
+    log_api_call(
+        endpoint="/upload",
+        method="POST",
+        status_code=200,
+        request_data={"filename": file.filename, "content_type": file.content_type},
+        response_data=response_data,
+        ip_address=ip_address
+    )
+
+    return response_data
 
 # -------------------------------------------------
 # 🎨 Colorize Image
 # -------------------------------------------------
 @app.post("/colorize")
 async def colorize(
+    request: Request,
     file: UploadFile = File(...),
     x_firebase_appcheck: str = Header(None)
 ):
+    import time
+    start_time = time.time()
+    
     verify_app_check_token(x_firebase_appcheck)
+    
+    ip_address = request.client.host if request.client else None
 
     if not file.content_type.startswith("image/"):
+        log_api_call(
+            endpoint="/colorize",
+            method="POST",
+            status_code=400,
+            error="Invalid file type",
+            ip_address=ip_address
+        )
         raise HTTPException(status_code=400, detail="Invalid file type")
 
     img = Image.open(io.BytesIO(await file.read()))
     output_img = colorize_image(img)
 
+    processing_time = time.time() - start_time
+
     result_id = f"{uuid.uuid4()}.jpg"
     output_path = os.path.join(RESULTS_DIR, result_id)
     output_img.save(output_path)
 
     base_url = "https://logicgoinfotechspaces-text-guided-image-colorization.hf.space"
 
-    return {
+    result_id_clean = result_id.replace(".jpg", "")
+    
+    response_data = {
         "success": True,
-        "result_id": result_id.replace(".jpg", ""),
+        "result_id": result_id_clean,
         "download_url": f"{base_url}/results/{result_id}",
-        "api_download": f"{base_url}/download/{result_id.replace('.jpg','')}"
+        "api_download": f"{base_url}/download/{result_id_clean}"
     }
+    
+    # Log to MongoDB
+    log_colorization(
+        result_id=result_id_clean,
+        model_type="gan",
+        processing_time=processing_time,
+        ip_address=ip_address
+    )
+    
+    log_api_call(
+        endpoint="/colorize",
+        method="POST",
+        status_code=200,
+        request_data={"filename": file.filename, "content_type": file.content_type},
+        response_data=response_data,
+        ip_address=ip_address
+    )
+
+    return response_data
 
 # -------------------------------------------------
 # ⬇️ Download via API (Secure)
 # -------------------------------------------------
 @app.get("/download/{file_id}")
-def download_result(file_id: str, x_firebase_appcheck: str = Header(None)):
+def download_result(
+    request: Request,
+    file_id: str,
+    x_firebase_appcheck: str = Header(None)
+):
     verify_app_check_token(x_firebase_appcheck)
+    
+    ip_address = request.client.host if request.client else None
 
     filename = f"{file_id}.jpg"
     path = os.path.join(RESULTS_DIR, filename)
 
     if not os.path.exists(path):
+        log_api_call(
+            endpoint=f"/download/{file_id}",
+            method="GET",
+            status_code=404,
+            error="Result not found",
+            ip_address=ip_address
+        )
         raise HTTPException(status_code=404, detail="Result not found")
 
+    log_api_call(
+        endpoint=f"/download/{file_id}",
+        method="GET",
+        status_code=200,
+        request_data={"file_id": file_id},
+        ip_address=ip_address
+    )
+
     return FileResponse(path, media_type="image/jpeg")
 
 # -------------------------------------------------
 # 🌐 Public Result File
 # -------------------------------------------------
 @app.get("/results/{filename}")
-def get_result(filename: str):
+def get_result(request: Request, filename: str):
+    ip_address = request.client.host if request.client else None
+    
     path = os.path.join(RESULTS_DIR, filename)
     if not os.path.exists(path):
+        log_api_call(
+            endpoint=f"/results/{filename}",
+            method="GET",
+            status_code=404,
+            error="Result not found",
+            ip_address=ip_address
+        )
         raise HTTPException(status_code=404, detail="Result not found")
+    
+    log_api_call(
+        endpoint=f"/results/{filename}",
+        method="GET",
+        status_code=200,
+        request_data={"filename": filename},
+        ip_address=ip_address
+    )
+    
     return FileResponse(path, media_type="image/jpeg")
 
 # -------------------------------------------------
 # 🌐 Public Uploaded File
 # -------------------------------------------------
 @app.get("/uploads/{filename}")
-def get_upload(filename: str):
+def get_upload(request: Request, filename: str):
+    ip_address = request.client.host if request.client else None
+    
     path = os.path.join(UPLOAD_DIR, filename)
     if not os.path.exists(path):
+        log_api_call(
+            endpoint=f"/uploads/{filename}",
+            method="GET",
+            status_code=404,
+            error="File not found",
+            ip_address=ip_address
+        )
         raise HTTPException(status_code=404, detail="File not found")
+    
+    log_api_call(
+        endpoint=f"/uploads/{filename}",
+        method="GET",
+        status_code=200,
+        request_data={"filename": filename},
+        ip_address=ip_address
+    )
+    
     return FileResponse(path, media_type="image/jpeg")

app/main_fastai.py

@@ -37,6 +37,7 @@ from huggingface_hub import from_pretrained_fastai
 
 from app.config import settings
 from app.pytorch_colorizer import PyTorchColorizer
+from app.database import get_database, log_api_call, log_image_upload, log_colorization, close_connection
 
 # Configure logging
 logging.basicConfig(
@@ -103,8 +104,17 @@ model_type: str = "none"  # "fastai", "pytorch", or "none"
 
 @app.on_event("startup")
 async def startup_event():
-    """Load FastAI or PyTorch model on startup"""
+    """Load FastAI or PyTorch model on startup and initialize MongoDB"""
     global learn, pytorch_colorizer, model_load_error, model_type
+    
+    # Initialize MongoDB
+    try:
+        db = get_database()
+        if db:
+            logger.info("✅ MongoDB initialized successfully!")
+    except Exception as e:
+        logger.warning("⚠️ MongoDB initialization failed: %s", str(e))
+    
     model_id = os.getenv("MODEL_ID", "Hammad712/GAN-Colorization-Model")
     
     # Try FastAI first
@@ -141,6 +151,7 @@ async def shutdown_event():
         del learn
     if pytorch_colorizer:
         del pytorch_colorizer
+    close_connection()
     logger.info("Application shutdown")
 
 def _extract_bearer_token(authorization_header: str | None) -> str | None:
@@ -190,18 +201,34 @@ async def verify_request(request: Request):
     return True
 
 @app.get("/api")
-async def api_info():
+async def api_info(request: Request):
     """API info endpoint"""
-    return {
+    response_data = {
         "app": "FastAI Image Colorizer API",
         "version": "1.0.0",
         "health": "/health",
         "colorize": "/colorize",
         "gradio": "/"
     }
+    
+    # Log API call
+    user_id = None
+    if hasattr(request, 'state') and hasattr(request.state, 'user'):
+        user_id = request.state.user.get("uid")
+    
+    log_api_call(
+        endpoint="/api",
+        method="GET",
+        status_code=200,
+        response_data=response_data,
+        user_id=user_id,
+        ip_address=request.client.host if request.client else None
+    )
+    
+    return response_data
 
 @app.get("/health")
-async def health_check():
+async def health_check(request: Request):
     """Health check endpoint"""
     model_loaded = (learn is not None) or (pytorch_colorizer is not None)
     response = {
@@ -218,6 +245,16 @@ async def health_check():
         response["message"] = "No model loaded. Using fallback colorization method."
     else:
         response["message"] = f"Model loaded successfully ({model_type})"
+    
+    # Log API call
+    log_api_call(
+        endpoint="/health",
+        method="GET",
+        status_code=200,
+        response_data=response,
+        ip_address=request.client.host if request.client else None
+    )
+    
     return response
 
 def simple_colorize_fallback(image: Image.Image) -> Image.Image:
@@ -318,6 +355,7 @@ def colorize_pil(image: Image.Image) -> Image.Image:
 
 @app.post("/colorize")
 async def colorize_api(
+    request: Request,
     file: UploadFile = File(...),
     verified: bool = Depends(verify_request)
 ):
@@ -325,11 +363,28 @@ async def colorize_api(
     Upload a black & white image -> returns colorized image.
     Requires Firebase authentication unless DISABLE_AUTH=true
     """
+    import time
+    start_time = time.time()
+    
+    user_id = None
+    if hasattr(request, 'state') and hasattr(request.state, 'user'):
+        user_id = request.state.user.get("uid")
+    
+    ip_address = request.client.host if request.client else None
+    
     # Allow fallback colorization even if model isn't loaded
     # if learn is None and pytorch_colorizer is None:
     #     raise HTTPException(status_code=503, detail="Colorization model not loaded")
     
     if not file.content_type or not file.content_type.startswith("image/"):
+        log_api_call(
+            endpoint="/colorize",
+            method="POST",
+            status_code=400,
+            error="File must be an image",
+            user_id=user_id,
+            ip_address=ip_address
+        )
         raise HTTPException(status_code=400, detail="File must be an image")
     
     try:
@@ -339,12 +394,35 @@ async def colorize_api(
         logger.info("Colorizing image...")
         colorized = colorize_pil(image)
         
+        processing_time = time.time() - start_time
+        
         output_filename = f"{uuid.uuid4()}.png"
         output_path = RESULT_DIR / output_filename
         colorized.save(output_path, "PNG")
         
         logger.info("Colorized image saved: %s", output_filename)
         
+        result_id = output_filename.replace(".png", "")
+        
+        # Log to MongoDB
+        log_colorization(
+            result_id=result_id,
+            model_type=model_type,
+            processing_time=processing_time,
+            user_id=user_id,
+            ip_address=ip_address
+        )
+        
+        log_api_call(
+            endpoint="/colorize",
+            method="POST",
+            status_code=200,
+            request_data={"filename": file.filename, "content_type": file.content_type},
+            response_data={"result_id": result_id, "filename": output_filename},
+            user_id=user_id,
+            ip_address=ip_address
+        )
+        
         # Return the image file
         return FileResponse(
             output_path,
@@ -352,8 +430,17 @@ async def colorize_api(
             filename=f"colorized_{output_filename}"
         )
     except Exception as e:
-        logger.error("Error colorizing image: %s", str(e))
-        raise HTTPException(status_code=500, detail=f"Error colorizing image: {str(e)}")
+        error_msg = str(e)
+        logger.error("Error colorizing image: %s", error_msg)
+        log_api_call(
+            endpoint="/colorize",
+            method="POST",
+            status_code=500,
+            error=error_msg,
+            user_id=user_id,
+            ip_address=ip_address
+        )
+        raise HTTPException(status_code=500, detail=f"Error colorizing image: {error_msg}")
 
 # ==========================================================
 # Gradio Interface (for Space UI)

app/main_sdxl.py

@@ -25,6 +25,7 @@ from pydantic import BaseModel, EmailStr
 from huggingface_hub import InferenceClient
 
 from app.config import settings
+from app.database import get_database, log_api_call, log_image_upload, log_colorization, close_connection
 
 # Configure logging
 logging.basicConfig(
@@ -181,9 +182,17 @@ def remove_unlikely_words(prompt: str) -> str:
 
 @app.on_event("startup")
 async def startup_event():
-    """Initialize Hugging Face Inference API client"""
+    """Initialize Hugging Face Inference API client and MongoDB"""
     global inference_client, model_load_error
     
+    # Initialize MongoDB
+    try:
+        db = get_database()
+        if db:
+            logger.info("✅ MongoDB initialized successfully!")
+    except Exception as e:
+        logger.warning("⚠️ MongoDB initialization failed: %s", str(e))
+    
     try:
         logger.info("🔄 Initializing Hugging Face Inference API client...")
         
@@ -214,6 +223,7 @@ async def shutdown_event():
     global inference_client
     if inference_client:
         inference_client = None
+    close_connection()
     logger.info("Application shutdown")
 
 
@@ -481,9 +491,9 @@ async def refresh_token(refresh_token: str = Body(..., embed=True)):
 # ========== API Endpoints ==========
 
 @app.get("/api")
-async def api_info():
+async def api_info(request: Request):
     """API info endpoint"""
-    return {
+    response_data = {
         "app": "Text-Guided Image Colorization API",
         "version": "1.0.0",
         "endpoints": {
@@ -502,10 +512,26 @@ async def api_info():
             "gradio": "/"
         }
     }
+    
+    # Log API call
+    user_id = None
+    if hasattr(request, 'state') and hasattr(request.state, 'user'):
+        user_id = request.state.user.get("uid")
+    
+    log_api_call(
+        endpoint="/api",
+        method="GET",
+        status_code=200,
+        response_data=response_data,
+        user_id=user_id,
+        ip_address=request.client.host if request.client else None
+    )
+    
+    return response_data
 
 
 @app.get("/health")
-async def health_check():
+async def health_check(request: Request):
     """Health check endpoint"""
     response = {
         "status": "healthy",
@@ -515,6 +541,16 @@ async def health_check():
     }
     if model_load_error:
         response["model_error"] = model_load_error
+    
+    # Log API call
+    log_api_call(
+        endpoint="/health",
+        method="GET",
+        status_code=200,
+        response_data=response,
+        ip_address=request.client.host if request.client else None
+    )
+    
     return response
 
 
@@ -588,6 +624,7 @@ def colorize_image_sdxl(
 
 @app.post("/upload")
 async def upload_image(
+    request: Request,
     file: UploadFile = File(...),
     verified: bool = Depends(verify_request)
 ):
@@ -595,7 +632,21 @@ async def upload_image(
     Upload an image and get the uploaded image URL.
     Requires Firebase App Check authentication.
     """
+    user_id = None
+    if hasattr(request, 'state') and hasattr(request.state, 'user'):
+        user_id = request.state.user.get("uid")
+    
+    ip_address = request.client.host if request.client else None
+    
     if not file.content_type or not file.content_type.startswith("image/"):
+        log_api_call(
+            endpoint="/upload",
+            method="POST",
+            status_code=400,
+            error="File must be an image",
+            user_id=user_id,
+            ip_address=ip_address
+        )
         raise HTTPException(status_code=400, detail="File must be an image")
     
     try:
@@ -606,6 +657,7 @@ async def upload_image(
         
         # Save uploaded file
         img_bytes = await file.read()
+        file_size = len(img_bytes)
         with open(file_path, "wb") as f:
             f.write(img_bytes)
         
@@ -617,19 +669,51 @@ async def upload_image(
             # Try to get from request
             base_url = "https://logicgoinfotechspaces-text-guided-image-colorization.hf.space"
         
-        return JSONResponse({
+        response_data = {
             "success": True,
             "image_id": image_id.replace(f".{file_extension}", ""),
             "image_url": f"{base_url}/uploads/{image_id}",
             "filename": image_id
-        })
+        }
+        
+        # Log to MongoDB
+        log_image_upload(
+            image_id=image_id.replace(f".{file_extension}", ""),
+            filename=file.filename or image_id,
+            file_size=file_size,
+            content_type=file.content_type or "image/jpeg",
+            user_id=user_id,
+            ip_address=ip_address
+        )
+        
+        log_api_call(
+            endpoint="/upload",
+            method="POST",
+            status_code=200,
+            request_data={"filename": file.filename, "content_type": file.content_type},
+            response_data=response_data,
+            user_id=user_id,
+            ip_address=ip_address
+        )
+        
+        return JSONResponse(response_data)
     except Exception as e:
-        logger.error("Error uploading image: %s", str(e))
-        raise HTTPException(status_code=500, detail=f"Error uploading image: {str(e)}")
+        error_msg = str(e)
+        logger.error("Error uploading image: %s", error_msg)
+        log_api_call(
+            endpoint="/upload",
+            method="POST",
+            status_code=500,
+            error=error_msg,
+            user_id=user_id,
+            ip_address=ip_address
+        )
+        raise HTTPException(status_code=500, detail=f"Error uploading image: {error_msg}")
 
 
 @app.post("/colorize")
 async def colorize_api(
+    request: Request,
     file: UploadFile = File(...),
     positive_prompt: Optional[str] = None,
     negative_prompt: Optional[str] = None,
@@ -641,10 +725,35 @@ async def colorize_api(
     Upload a grayscale image -> returns colorized image.
     Uses SDXL + ControlNet with automatic captioning.
     """
+    import time
+    start_time = time.time()
+    
+    user_id = None
+    if hasattr(request, 'state') and hasattr(request.state, 'user'):
+        user_id = request.state.user.get("uid")
+    
+    ip_address = request.client.host if request.client else None
+    
     if inference_client is None:
+        log_api_call(
+            endpoint="/colorize",
+            method="POST",
+            status_code=503,
+            error="Inference API client not initialized",
+            user_id=user_id,
+            ip_address=ip_address
+        )
         raise HTTPException(status_code=503, detail="Inference API client not initialized")
     
     if not file.content_type or not file.content_type.startswith("image/"):
+        log_api_call(
+            endpoint="/colorize",
+            method="POST",
+            status_code=400,
+            error="File must be an image",
+            user_id=user_id,
+            ip_address=ip_address
+        )
         raise HTTPException(status_code=400, detail="File must be an image")
     
     try:
@@ -660,6 +769,8 @@ async def colorize_api(
             num_inference_steps=num_inference_steps
         )
         
+        processing_time = time.time() - start_time
+        
         output_filename = f"{uuid.uuid4()}.png"
         output_path = RESULT_DIR / output_filename
         colorized.save(output_path, "PNG")
@@ -673,37 +784,119 @@ async def colorize_api(
         
         result_id = output_filename.replace(".png", "")
         
-        return JSONResponse({
+        response_data = {
             "success": True,
             "result_id": result_id,
             "download_url": f"{base_url}/results/{output_filename}",
             "api_download_url": f"{base_url}/download/{result_id}",
             "filename": output_filename,
             "caption": caption
-        })
+        }
+        
+        # Log to MongoDB
+        log_colorization(
+            result_id=result_id,
+            prompt=positive_prompt,
+            model_type="sdxl",
+            processing_time=processing_time,
+            user_id=user_id,
+            ip_address=ip_address
+        )
+        
+        log_api_call(
+            endpoint="/colorize",
+            method="POST",
+            status_code=200,
+            request_data={
+                "filename": file.filename,
+                "positive_prompt": positive_prompt,
+                "negative_prompt": negative_prompt,
+                "seed": seed,
+                "num_inference_steps": num_inference_steps
+            },
+            response_data=response_data,
+            user_id=user_id,
+            ip_address=ip_address
+        )
+        
+        return JSONResponse(response_data)
     except Exception as e:
-        logger.error("Error colorizing image: %s", str(e))
-        raise HTTPException(status_code=500, detail=f"Error colorizing image: {str(e)}")
+        error_msg = str(e)
+        logger.error("Error colorizing image: %s", error_msg)
+        log_api_call(
+            endpoint="/colorize",
+            method="POST",
+            status_code=500,
+            error=error_msg,
+            user_id=user_id,
+            ip_address=ip_address
+        )
+        raise HTTPException(status_code=500, detail=f"Error colorizing image: {error_msg}")
 
 
 @app.get("/download/{file_id}")
-def download_result(file_id: str, verified: bool = Depends(verify_request)):
+def download_result(
+    request: Request,
+    file_id: str,
+    verified: bool = Depends(verify_request)
+):
     """Download colorized image by file ID"""
+    user_id = None
+    if hasattr(request, 'state') and hasattr(request.state, 'user'):
+        user_id = request.state.user.get("uid")
+    
+    ip_address = request.client.host if request.client else None
+    
     filename = f"{file_id}.png"
     path = RESULT_DIR / filename
     
     if not path.exists():
+        log_api_call(
+            endpoint=f"/download/{file_id}",
+            method="GET",
+            status_code=404,
+            error="Result not found",
+            user_id=user_id,
+            ip_address=ip_address
+        )
         raise HTTPException(status_code=404, detail="Result not found")
     
+    log_api_call(
+        endpoint=f"/download/{file_id}",
+        method="GET",
+        status_code=200,
+        request_data={"file_id": file_id},
+        user_id=user_id,
+        ip_address=ip_address
+    )
+    
     return FileResponse(path, media_type="image/png")
 
 
 @app.get("/results/{filename}")
-def get_result(filename: str):
+def get_result(request: Request, filename: str):
     """Public endpoint to access colorized images"""
+    ip_address = request.client.host if request.client else None
+    
     path = RESULT_DIR / filename
     if not path.exists():
+        log_api_call(
+            endpoint=f"/results/{filename}",
+            method="GET",
+            status_code=404,
+            error="Result not found",
+            ip_address=ip_address
+        )
         raise HTTPException(status_code=404, detail="Result not found")
+    
+    log_api_call(
+        endpoint=f"/results/{filename}",
+        method="GET",
+        status_code=200,
+        request_data={"filename": filename},
+        ip_address=ip_address
+    )
+    
     return FileResponse(path, media_type="image/png")
 
 

requirements.txt

@@ -16,4 +16,5 @@ diffusers
 safetensors
 ftfy
 httpx
-email-validator
+email-validator
+pymongo