Update utils/logging.py

utils/logging.py

@@ -1,163 +1,139 @@
 """
-Logging module for the MONA application.
-
-This module provides a centralized logging system for the application,
-replacing print statements with proper logging for better debugging and monitoring.
+Logging utilities for the application.
 """
 
 import logging
-import logging.config
-from datetime import datetime
-
-from utils.config import LOGGING_CONFIG
-
-# Configure logging based on the configuration in config.py
-logging.config.dictConfig(LOGGING_CONFIG)
-
-# Create a logger for the application
-logger = logging.getLogger("mona")
+import sys
+from pathlib import Path
+from typing import Optional
 
-
-def get_logger(name=None):
+def setup_logger(
+    name: str = "app", 
+    level: str = "INFO", 
+    log_file: Optional[str] = None,
+    format_string: Optional[str] = None
+) -> logging.Logger:
     """
-    Get a logger instance with the specified name.
+    Set up and configure a logger with console and optional file output.
     
     Args:
-        name (str, optional): The name of the logger. If None, returns the root logger.
-            For module-specific loggers, use __name__ as the name.
+        name: Logger name
+        level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        log_file: Optional file path for log output
+        format_string: Optional custom format string
     
     Returns:
-        logging.Logger: A logger instance.
+        Configured logger instance
     """
-    if name:
-        return logging.getLogger(f"mona.{name}")
-    return logger
-
-
-def log_function_call(func):
-    """
-    Decorator to log function calls with parameters and return values.
+    logger = logging.getLogger(name)
     
-    Args:
-        func (callable): The function to decorate.
+    # Clear any existing handlers to avoid duplicates
+    logger.handlers.clear()
     
-    Returns:
-        callable: The decorated function.
-    """
-    def wrapper(*args, **kwargs):
-        func_logger = get_logger(func.__module__)
-        func_name = func.__qualname__
-        
-        # Log function call with arguments
-        args_repr = [repr(a) for a in args]
-        kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]
-        signature = ", ".join(args_repr + kwargs_repr)
-        func_logger.debug(f"Calling {func_name}({signature})")
-        
-        # Call the function
-        try:
-            result = func(*args, **kwargs)
-            func_logger.debug(f"{func_name} returned {result!r}")
-            return result
-        except Exception as e:
-            func_logger.exception(f"Exception in {func_name}: {str(e)}")
-            raise
+    # Set logging level
+    logger.setLevel(getattr(logging, level.upper()))
     
-    return wrapper
-
-
-def log_error(error_msg, exc_info=None):
-    """
-    Log an error message.
+    # Create formatter
+    if format_string is None:
+        format_string = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
     
-    Args:
-        error_msg (str): The error message to log.
-        exc_info (Exception, optional): The exception information to include in the log.
-    """
-    if exc_info:
-        logger.error(error_msg, exc_info=exc_info)
-    else:
-        logger.error(error_msg)
-
-
-def log_warning(warning_msg):
-    """
-    Log a warning message.
+    formatter = logging.Formatter(format_string)
     
-    Args:
-        warning_msg (str): The warning message to log.
-    """
-    logger.warning(warning_msg)
-
-
-def log_info(info_msg):
-    """
-    Log an info message.
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
     
-    Args:
-        info_msg (str): The info message to log.
-    """
-    logger.info(info_msg)
-
-
-def log_debug(debug_msg):
-    """
-    Log a debug message.
+    # File handler (optional)
+    if log_file:
+        try:
+            # Create directory if it doesn't exist
+            log_path = Path(log_file)
+            log_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            file_handler = logging.FileHandler(log_file)
+            file_handler.setFormatter(formatter)
+            logger.addHandler(file_handler)
+        except Exception as e:
+            logger.warning(f"Could not create file handler for {log_file}: {e}")
     
-    Args:
-        debug_msg (str): The debug message to log.
-    """
-    logger.debug(debug_msg)
-
+    # Prevent propagation to avoid duplicate logs
+    logger.propagate = False
+    
+    return logger
 
-def log_user_activity(user_id, activity_type, details=None):
+def get_logger(name: str = "app") -> logging.Logger:
     """
-    Log user activity for analytics purposes.
+    Get an existing logger or create a basic one if it doesn't exist.
     
     Args:
-        user_id (str): The user identifier.
-        activity_type (str): The type of activity (e.g., 'page_view', 'task_create').
-        details (dict, optional): Additional details about the activity.
+        name: Logger name
+    
+    Returns:
+        Logger instance
     """
-    activity_log = {
-        "timestamp": datetime.now().isoformat(),
-        "user_id": user_id,
-        "activity_type": activity_type,
-    }
+    logger = logging.getLogger(name)
     
-    if details:
-        activity_log["details"] = details
+    # If logger has no handlers, set up a basic one
+    if not logger.handlers:
+        logger = setup_logger(name)
     
-    logger.info(f"User activity: {activity_log}")
-
+    return logger
 
-def log_performance(operation, duration_ms):
+def set_log_level(logger: logging.Logger, level: str) -> None:
     """
-    Log performance metrics for monitoring.
+    Set the logging level for a logger and all its handlers.
     
     Args:
-        operation (str): The operation being measured.
-        duration_ms (float): The duration of the operation in milliseconds.
+        logger: Logger instance
+        level: New logging level
     """
-    logger.info(f"Performance: {operation} took {duration_ms:.2f}ms")
-
+    logger.setLevel(getattr(logging, level.upper()))
+    for handler in logger.handlers:
+        handler.setLevel(getattr(logging, level.upper()))
 
-def log_ai_model_usage(model_name, operation, tokens_used=None):
+def add_file_handler(logger: logging.Logger, log_file: str) -> None:
     """
-    Log AI model usage for monitoring and quota management.
+    Add a file handler to an existing logger.
     
     Args:
-        model_name (str): The name of the AI model used.
-        operation (str): The operation performed with the model.
-        tokens_used (int, optional): The number of tokens used in the operation.
+        logger: Logger instance
+        log_file: Path to log file
     """
-    usage_log = {
-        "timestamp": datetime.now().isoformat(),
-        "model": model_name,
-        "operation": operation,
-    }
-    
-    if tokens_used is not None:
-        usage_log["tokens_used"] = tokens_used
-    
-    logger.info(f"AI model usage: {usage_log}")
+    try:
+        # Create directory if it doesn't exist
+        log_path = Path(log_file)
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        file_handler = logging.FileHandler(log_file)
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+    except Exception as e:
+        logger.warning(f"Could not add file handler for {log_file}: {e}")
+
+# Create a default logger instance
+default_logger = setup_logger("app", "INFO")
+
+# Convenience functions using the default logger
+def debug(message: str) -> None:
+    """Log a debug message."""
+    default_logger.debug(message)
+
+def info(message: str) -> None:
+    """Log an info message."""
+    default_logger.info(message)
+
+def warning(message: str) -> None:
+    """Log a warning message."""
+    default_logger.warning(message)
+
+def error(message: str) -> None:
+    """Log an error message."""
+    default_logger.error(message)
+
+def critical(message: str) -> None:
+    """Log a critical message."""
+    default_logger.critical(message)