feat: add MongoDB logging for all application logs

- Add mongodb_logging.py with custom logging handler
- Update server.py to integrate MongoDB logging
- Add new endpoints: /logs, /logs/stats, /logs/clear
- Fix MongoDB database boolean check issue
- All application logs now stored in MongoDB HairSwapDB.logs collection
- Add deployment guide for Hugging Face Spaces

DEPLOYMENT_GUIDE.md

@@ -0,0 +1,141 @@
+# 🚀 MongoDB Logging Deployment Guide for Hugging Face Spaces
+
+## ✅ What's Ready for Deployment
+
+### 📁 Files Added/Modified:
+- ✅ `mongodb_logging.py` - Custom MongoDB logging handler
+- ✅ `server.py` - Updated with MongoDB logging integration
+- ✅ `requirements.txt` - Already includes `pymongo[srv]`
+
+### 🔧 New API Endpoints:
+- `GET /logs` - View all logs (metadata + application logs)
+- `GET /logs/stats` - View logging statistics
+- `GET /logs/clear?days_older_than=7` - Clear old logs
+
+## 🌐 Hugging Face Spaces Deployment Steps
+
+### 1. Set Environment Variables in Hugging Face Spaces
+
+Go to your Space settings and add these environment variables:
+
+```
+MONGO_URI=mongodb+srv://harilogicgo_db_user:SSbZ55jNUsVerWKI@hairswapdb.7r2ghs4.mongodb.net/?retryWrites=true&w=majority&appName=HairSwapDB
+```
+
+### 2. Push Changes to Hugging Face
+
+```bash
+# Add all changes
+git add .
+
+# Commit changes
+git commit -m "feat: add MongoDB logging for all application logs
+
+- Add mongodb_logging.py with custom logging handler
+- Update server.py to integrate MongoDB logging
+- Add new endpoints: /logs, /logs/stats, /logs/clear
+- All application logs now stored in MongoDB HairSwapDB.logs collection"
+
+# Push to Hugging Face
+git push origin main
+```
+
+### 3. Verify Deployment
+
+After deployment, test these endpoints:
+
+1. **Health Check**: `GET /health`
+2. **View Logs**: `GET /logs`
+3. **Log Statistics**: `GET /logs/stats`
+4. **Clear Old Logs**: `GET /logs/clear?days_older_than=7`
+
+## 📊 MongoDB Collections Structure
+
+### `HairSwapDB.logs` Collection:
+```json
+{
+  "_id": "ObjectId",
+  "timestamp": "2025-09-27T12:30:45.123Z",
+  "level": "INFO|WARNING|ERROR",
+  "logger": "hair_server",
+  "message": "Log message content",
+  "module": "server",
+  "function": "get_hairswap",
+  "line": 168,
+  "thread": 12345,
+  "process": 6789,
+  "exception": "Exception traceback (if error)"
+}
+```
+
+### `HairSwapDB.uploads` Collection:
+```json
+{
+  "_id": "image-uuid",
+  "filename": "image.png",
+  "path": "/data/uploads/image-uuid.png"
+}
+```
+
+### `HairSwapDB.results` Collection:
+```json
+{
+  "_id": "result-uuid",
+  "filename": "result.png",
+  "path": "/data/results/result-uuid.png",
+  "source_id": "source-uuid",
+  "reference_id": "reference-uuid"
+}
+```
+
+## 🔍 Testing the Deployment
+
+### 1. Test Log Generation:
+```bash
+# Upload an image
+curl -X POST "https://your-space-url/upload" \
+  -F "image=@test_image.jpg"
+
+# Perform hair swap
+curl -X POST "https://your-space-url/get-hairswap" \
+  -H "Content-Type: application/json" \
+  -d '{"source_id": "source-uuid", "reference_id": "reference-uuid"}'
+```
+
+### 2. Check Logs:
+```bash
+# View all logs
+curl "https://your-space-url/logs"
+
+# View log statistics
+curl "https://your-space-url/logs/stats"
+
+# Clear logs older than 7 days
+curl "https://your-space-url/logs/clear?days_older_than=7"
+```
+
+## 🎯 What Gets Logged
+
+### ✅ Application Logs (NEW):
+- Model loading messages
+- Hair transfer progress
+- Error messages and stack traces
+- API request/response logs
+- System status messages
+
+### ✅ Metadata Logs (EXISTING):
+- Image uploads
+- Hair swap results
+- File paths and IDs
+
+## 🚨 Important Notes
+
+1. **MongoDB Connection**: Make sure `MONGO_URI` is set in Space environment variables
+2. **Log Rotation**: Use `/logs/clear` endpoint to manage log storage
+3. **Performance**: MongoDB logging is asynchronous and won't slow down the API
+4. **Fallback**: If MongoDB fails, logs still go to console
+5. **Security**: MongoDB URI contains credentials - keep it secure
+
+## 🎉 Ready to Deploy!
+
+Your MongoDB logging system is ready for Hugging Face Spaces deployment. All application logs will be automatically stored in MongoDB and accessible via the new API endpoints.

mongodb_logging.py

@@ -0,0 +1,141 @@
+import logging
+import os
+from datetime import datetime
+from typing import Dict, Any
+from pymongo import MongoClient
+from pymongo.collection import Collection
+
+
+class MongoDBLogHandler(logging.Handler):
+    """Custom logging handler that stores logs in MongoDB"""
+    
+    def __init__(self, collection: Collection):
+        super().__init__()
+        self.collection = collection
+        
+    def emit(self, record: logging.LogRecord):
+        """Emit a log record to MongoDB"""
+        try:
+            # Create log document
+            log_doc = {
+                "timestamp": datetime.utcnow(),
+                "level": record.levelname,
+                "logger": record.name,
+                "message": record.getMessage(),
+                "module": record.module,
+                "function": record.funcName,
+                "line": record.lineno,
+                "thread": record.thread,
+                "process": record.process,
+            }
+            
+            # Add exception info if present
+            if record.exc_info:
+                log_doc["exception"] = self.formatException(record.exc_info)
+                
+            # Add extra fields if present
+            if hasattr(record, 'extra_fields'):
+                log_doc.update(record.extra_fields)
+                
+            # Insert into MongoDB
+            self.collection.insert_one(log_doc)
+            
+        except Exception as e:
+            # Fallback to console if MongoDB fails
+            print(f"MongoDB logging failed: {e}")
+            print(f"Original log: {record.getMessage()}")
+
+
+def setup_mongodb_logging(mongo_uri: str, database_name: str = "HairSwapDB", collection_name: str = "logs"):
+    """Setup MongoDB logging for the application"""
+    
+    try:
+        # Connect to MongoDB
+        client = MongoClient(mongo_uri)
+        db = client.get_database(database_name)
+        logs_collection = db.get_collection(collection_name)
+        
+        # Create MongoDB log handler
+        mongo_handler = MongoDBLogHandler(logs_collection)
+        mongo_handler.setLevel(logging.INFO)
+        
+        # Create formatter
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        mongo_handler.setFormatter(formatter)
+        
+        # Get root logger and add handler
+        root_logger = logging.getLogger()
+        root_logger.addHandler(mongo_handler)
+        
+        # Also add to specific logger
+        hair_logger = logging.getLogger("hair_server")
+        hair_logger.addHandler(mongo_handler)
+        
+        print(f"✅ MongoDB logging enabled - storing logs in {database_name}.{collection_name}")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Failed to setup MongoDB logging: {e}")
+        return False
+
+
+def get_logs_from_mongodb(mongo_uri: str, database_name: str = "HairSwapDB", 
+                         collection_name: str = "logs", limit: int = 100, 
+                         level: str = None, logger_name: str = None):
+    """Retrieve logs from MongoDB"""
+    
+    try:
+        client = MongoClient(mongo_uri)
+        db = client.get_database(database_name)
+        logs_collection = db.get_collection(collection_name)
+        
+        # Build query
+        query = {}
+        if level:
+            query["level"] = level
+        if logger_name:
+            query["logger"] = logger_name
+            
+        # Get logs sorted by timestamp (newest first)
+        logs = list(logs_collection.find(query)
+                   .sort("timestamp", -1)
+                   .limit(limit))
+        
+        # Convert ObjectId to string for JSON serialization
+        for log in logs:
+            log["_id"] = str(log["_id"])
+            if "timestamp" in log:
+                log["timestamp"] = log["timestamp"].isoformat()
+                
+        return logs
+        
+    except Exception as e:
+        print(f"❌ Failed to retrieve logs from MongoDB: {e}")
+        return []
+
+
+def clear_logs_from_mongodb(mongo_uri: str, database_name: str = "HairSwapDB", 
+                          collection_name: str = "logs", days_older_than: int = None):
+    """Clear old logs from MongoDB"""
+    
+    try:
+        client = MongoClient(mongo_uri)
+        db = client.get_database(database_name)
+        logs_collection = db.get_collection(collection_name)
+        
+        if days_older_than:
+            from datetime import timedelta
+            cutoff_date = datetime.utcnow() - timedelta(days=days_older_than)
+            result = logs_collection.delete_many({"timestamp": {"$lt": cutoff_date}})
+            print(f"✅ Deleted {result.deleted_count} logs older than {days_older_than} days")
+        else:
+            result = logs_collection.delete_many({})
+            print(f"✅ Deleted all {result.deleted_count} logs")
+            
+        return result.deleted_count
+        
+    except Exception as e:
+        print(f"❌ Failed to clear logs from MongoDB: {e}")
+        return 0

server.py

@@ -14,9 +14,8 @@ from PIL import Image
 
 # Lazy import performed in get_model() to avoid import-time failures on Space
 
-
-LOGGER = logging.getLogger("hair_server")
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(name)s - %(message)s")
+# Import MongoDB logging
+from mongodb_logging import setup_mongodb_logging, get_logs_from_mongodb, clear_logs_from_mongodb
 
 EXPECTED_BEARER = "logicgo@123"
 
@@ -24,9 +23,17 @@ EXPECTED_BEARER = "logicgo@123"
 from pymongo import MongoClient
 MONGO_URI = os.environ.get("MONGO_URI", "")
 mongo_client = MongoClient(MONGO_URI) if MONGO_URI else None
-mongo_db = mongo_client.get_database("HairSwapDB") if mongo_client else None
-uploads_col = mongo_db.get_collection("uploads") if mongo_db else None
-results_col = mongo_db.get_collection("results") if mongo_db else None
+mongo_db = mongo_client.get_database("HairSwapDB") if mongo_client is not None else None
+uploads_col = mongo_db.get_collection("uploads") if mongo_db is not None else None
+results_col = mongo_db.get_collection("results") if mongo_db is not None else None
+logs_col = mongo_db.get_collection("logs") if mongo_db is not None else None
+
+# Setup MongoDB logging
+if MONGO_URI:
+    setup_mongodb_logging(MONGO_URI, "HairSwapDB", "logs")
+
+LOGGER = logging.getLogger("hair_server")
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(name)s - %(message)s")
 
 
 def verify_bearer(authorization: Optional[str] = Header(None)):
@@ -224,11 +231,90 @@ def download(filename: str):
 
 
 @app.get("/logs")
-def logs():
+def logs(limit: int = 50, level: str = None, logger_name: str = None):
+    """Get logs from MongoDB including both metadata and application logs"""
+    response_data = {}
+    
+    # Get metadata (uploads and results)
     if uploads_col and results_col:
         uploads = list(uploads_col.find({}, {"_id": 1, "filename": 1}).limit(20))
         results = list(results_col.find({}, {"_id": 1, "filename": 1, "source_id": 1, "reference_id": 1}).limit(20))
-        return JSONResponse({"uploads": uploads, "results": results})
-    return JSONResponse({"logs": ["service running"], "db": "not_configured"})
+        response_data["metadata"] = {"uploads": uploads, "results": results}
+    else:
+        response_data["metadata"] = {"uploads": [], "results": []}
+    
+    # Get application logs from MongoDB
+    if MONGO_URI:
+        try:
+            app_logs = get_logs_from_mongodb(MONGO_URI, "HairSwapDB", "logs", limit, level, logger_name)
+            response_data["application_logs"] = app_logs
+            response_data["mongodb_status"] = "connected"
+        except Exception as e:
+            response_data["application_logs"] = []
+            response_data["mongodb_status"] = f"error: {str(e)}"
+    else:
+        response_data["application_logs"] = []
+        response_data["mongodb_status"] = "not_configured"
+    
+    return JSONResponse(response_data)
+
+
+@app.get("/logs/clear")
+def clear_logs(days_older_than: int = None):
+    """Clear old logs from MongoDB"""
+    if not MONGO_URI:
+        raise HTTPException(status_code=400, detail="MongoDB not configured")
+    
+    try:
+        deleted_count = clear_logs_from_mongodb(MONGO_URI, "HairSwapDB", "logs", days_older_than)
+        return JSONResponse({
+            "message": f"Cleared {deleted_count} logs",
+            "days_older_than": days_older_than
+        })
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to clear logs: {str(e)}")
+
+
+@app.get("/logs/stats")
+def logs_stats():
+    """Get logging statistics"""
+    if not MONGO_URI:
+        return JSONResponse({"mongodb_status": "not_configured"})
+    
+    try:
+        client = MongoClient(MONGO_URI)
+        db = client.get_database("HairSwapDB")
+        logs_collection = db.get_collection("logs")
+        
+        # Get total count
+        total_logs = logs_collection.count_documents({})
+        
+        # Get count by level
+        pipeline = [
+            {"$group": {"_id": "$level", "count": {"$sum": 1}}},
+            {"$sort": {"count": -1}}
+        ]
+        logs_by_level = list(logs_collection.aggregate(pipeline))
+        
+        # Get count by logger
+        pipeline = [
+            {"$group": {"_id": "$logger", "count": {"$sum": 1}}},
+            {"$sort": {"count": -1}},
+            {"$limit": 10}
+        ]
+        logs_by_logger = list(logs_collection.aggregate(pipeline))
+        
+        return JSONResponse({
+            "total_logs": total_logs,
+            "logs_by_level": logs_by_level,
+            "top_loggers": logs_by_logger,
+            "mongodb_status": "connected"
+        })
+        
+    except Exception as e:
+        return JSONResponse({
+            "mongodb_status": f"error: {str(e)}",
+            "total_logs": 0
+        })