Initial commit: Ebook Translation System with Docker setup

ebook_backend&admin_panel/admin-backend/utils/logger.py

@@ -0,0 +1,157 @@
+"""
+Professional logging utility for the Ebook Coupon Management System
+Provides structured logging with proper formatting and log levels.
+"""
+import logging
+import logging.handlers
+import os
+import sys
+from datetime import datetime
+from typing import Optional, Any, Dict
+import json
+
+class SafeJSONEncoder(json.JSONEncoder):
+    """Custom JSON encoder that handles non-serializable objects safely"""
+    
+    def default(self, obj):
+        """Handle non-serializable objects by converting them to strings"""
+        if hasattr(obj, '__dict__'):
+            return str(obj)
+        elif hasattr(obj, '__str__'):
+            return str(obj)
+        else:
+            return f"<{type(obj).__name__} object>"
+
+class StructuredFormatter(logging.Formatter):
+    """Custom formatter for structured logging"""
+    
+    def format(self, record: logging.LogRecord) -> str:
+        """Format log record with structured data"""
+        log_entry = {
+            "timestamp": datetime.utcnow().isoformat(),
+            "level": record.levelname,
+            "logger": record.name,
+            "message": record.getMessage(),
+            "module": record.module,
+            "function": record.funcName,
+            "line": record.lineno
+        }
+        
+        # Add extra fields if present
+        if hasattr(record, 'request_id'):
+            log_entry['request_id'] = record.request_id
+        if hasattr(record, 'method'):
+            log_entry['method'] = record.method
+        if hasattr(record, 'path'):
+            log_entry['path'] = record.path
+        if hasattr(record, 'status_code'):
+            log_entry['status_code'] = record.status_code
+        if hasattr(record, 'process_time'):
+            log_entry['process_time'] = record.process_time
+        if hasattr(record, 'client_ip'):
+            log_entry['client_ip'] = record.client_ip
+        if hasattr(record, 'user_agent'):
+            log_entry['user_agent'] = record.user_agent
+        if hasattr(record, 'error'):
+            log_entry['error'] = record.error
+        if hasattr(record, 'exception_type'):
+            log_entry['exception_type'] = record.exception_type
+        if hasattr(record, 'exception_message'):
+            log_entry['exception_message'] = record.exception_message
+        if hasattr(record, 'errors'):
+            # Handle errors list safely
+            try:
+                if isinstance(record.errors, list):
+                    log_entry['errors'] = [str(error) if not isinstance(error, (dict, str, int, float, bool)) else error for error in record.errors]
+                else:
+                    log_entry['errors'] = str(record.errors)
+            except Exception:
+                log_entry['errors'] = str(record.errors)
+        if hasattr(record, 'app_name'):
+            log_entry['app_name'] = record.app_name
+        if hasattr(record, 'version'):
+            log_entry['version'] = record.version
+        if hasattr(record, 'environment'):
+            log_entry['environment'] = record.environment
+        if hasattr(record, 'debug'):
+            log_entry['debug'] = record.debug
+        
+        # Add exception info if present
+        if record.exc_info:
+            log_entry['exception'] = self.formatException(record.exc_info)
+        
+        return json.dumps(log_entry, ensure_ascii=False, cls=SafeJSONEncoder)
+
+def setup_logger(name: str, level: Optional[str] = None) -> logging.Logger:
+    """
+    Setup a logger with proper configuration
+    
+    Args:
+        name: Logger name
+        level: Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        
+    Returns:
+        Configured logger instance
+    """
+    # Get log level from environment or use default
+    log_level = level or os.getenv("LOG_LEVEL", "INFO").upper()
+    
+    # Create logger
+    logger = logging.getLogger(name)
+    logger.setLevel(getattr(logging, log_level))
+    
+    # Avoid duplicate handlers
+    if logger.handlers:
+        return logger
+    
+    # Create formatters
+    structured_formatter = StructuredFormatter()
+    console_formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(logging.DEBUG)
+    console_handler.setFormatter(console_formatter)
+    logger.addHandler(console_handler)
+    
+    # File handler for structured logs
+    log_dir = "logs"
+    os.makedirs(log_dir, exist_ok=True)
+    
+    file_handler = logging.handlers.RotatingFileHandler(
+        os.path.join(log_dir, "app.log"),
+        maxBytes=10*1024*1024,  # 10MB
+        backupCount=5
+    )
+    file_handler.setLevel(logging.INFO)
+    file_handler.setFormatter(structured_formatter)
+    logger.addHandler(file_handler)
+    
+    # Error file handler
+    error_handler = logging.handlers.RotatingFileHandler(
+        os.path.join(log_dir, "error.log"),
+        maxBytes=10*1024*1024,  # 10MB
+        backupCount=5
+    )
+    error_handler.setLevel(logging.ERROR)
+    error_handler.setFormatter(structured_formatter)
+    logger.addHandler(error_handler)
+    
+    return logger
+
+def get_logger(name: str) -> logging.Logger:
+    """
+    Get a logger instance
+    
+    Args:
+        name: Logger name
+        
+    Returns:
+        Logger instance
+    """
+    return logging.getLogger(name)
+
+# Create default logger
+default_logger = setup_logger("ebook_coupon_system")