BREAKING CHANGE: Complete refactor of architecture to prepare BJORN V2 release, APIs, assets, and UI, webapp, logics, attacks, a lot of new features...

logger.py

@@ -1,27 +1,8 @@
-#logger.py
-# Description:
-# This file, logger.py, is responsible for setting up a robust logging system for the Bjorn project. It defines custom logging levels and formats,
-# integrates with the Rich library for enhanced console output, and ensures logs are written to rotating files for persistence.
-#
-# Key functionalities include:
-# - Defining a custom log level "SUCCESS" to log successful operations distinctively.
-# - Creating a vertical filter to exclude specific log messages based on their content.
-# - Setting up a logger class (`Logger`) that initializes logging handlers for both console and file output.
-# - Utilizing Rich for console logging with custom themes for different log levels, providing a more readable and visually appealing log output.
-# - Ensuring log files are written to a specified directory, with file rotation to manage log file sizes and backups.
-# - Providing methods to log messages at various levels (debug, info, warning, error, critical, success).
-# - Allowing dynamic adjustment of log levels and the ability to disable logging entirely.
-
-
-
+# logger.py
 import logging
 from logging.handlers import RotatingFileHandler
 import os
-from rich.console import Console
-from rich.logging import RichHandler
-from rich.theme import Theme
 
-# Define custom log level "SUCCESS"
 SUCCESS_LEVEL_NUM = 25
 logging.addLevelName(SUCCESS_LEVEL_NUM, "SUCCESS")
 
@@ -31,86 +12,56 @@ def success(self, message, *args, **kwargs):
 
 logging.Logger.success = success
 
+
 class VerticalFilter(logging.Filter):
     def filter(self, record):
         return 'Vertical' not in record.getMessage()
 
+
 class Logger:
     LOGS_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data', 'logs')
+    LOG_FILE = os.path.join(LOGS_DIR, "Bjorn.log")
 
-    def __init__(self, name, level=logging.DEBUG, enable_file_logging=True):
+    def __init__(self, name="Logger", level=logging.DEBUG, enable_file_logging=True):
         self.logger = logging.getLogger(name)
         self.logger.setLevel(level)
+        self.logger.propagate = False  # ✅ Évite les logs en double
         self.enable_file_logging = enable_file_logging
 
-        # Define custom log level styles
-        custom_theme = Theme({
-            "debug": "yellow",
-            "info": "blue",
-            "warning": "yellow",
-            "error": "bold red",
-            "critical": "bold magenta",
-            "success": "bold green"
-        })
+        # Évite d'ajouter plusieurs fois les mêmes handlers
+        if not self.logger.handlers:
+            console_handler = logging.StreamHandler()
+            console_handler.setLevel(level)
+            console_handler.setFormatter(logging.Formatter(
+                '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                datefmt='%Y-%m-%d %H:%M:%S'
+            ))
+            console_handler.addFilter(VerticalFilter())
+            self.logger.addHandler(console_handler)
 
-        console = Console(theme=custom_theme)
-        
-        # Create console handler with rich and set level
-        console_handler = RichHandler(console=console, show_time=False, show_level=False, show_path=False, log_time_format="%Y-%m-%d %H:%M:%S")
-        console_handler.setLevel(level)
-        console_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
-        console_handler.setFormatter(console_formatter)
+            if self.enable_file_logging:
+                os.makedirs(self.LOGS_DIR, exist_ok=True)
+                file_handler = RotatingFileHandler(self.LOG_FILE, maxBytes=5*1024*1024, backupCount=2)
+                file_handler.setLevel(level)
+                file_handler.setFormatter(logging.Formatter(
+                    '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                    datefmt='%Y-%m-%d %H:%M:%S'
+                ))
+                file_handler.addFilter(VerticalFilter())
+                self.logger.addHandler(file_handler)
 
-        # Add filter to console handler
-        vertical_filter = VerticalFilter()
-        console_handler.addFilter(vertical_filter)
-
-        # Add console handler to the logger
-        self.logger.addHandler(console_handler)
-
-        if self.enable_file_logging:
-            # Ensure the log folder exists
-            os.makedirs(self.LOGS_DIR, exist_ok=True)
-            log_file_path = os.path.join(self.LOGS_DIR, f"{name}.log")
-
-            # Create file handler and set level
-            file_handler = RotatingFileHandler(log_file_path, maxBytes=5*1024*1024, backupCount=2)
-            file_handler.setLevel(level)
-            file_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
-            file_handler.setFormatter(file_formatter)
-
-            # Add filter to file handler
-            file_handler.addFilter(vertical_filter)
-
-            # Add file handler to the logger
-            self.logger.addHandler(file_handler)
-    
     def set_level(self, level):
         self.logger.setLevel(level)
         for handler in self.logger.handlers:
             handler.setLevel(level)
-    
-    def debug(self, message):
-        self.logger.debug(message)
-    
-    def info(self, message):
-        self.logger.info(message)
-    
-    def warning(self, message):
-        self.logger.warning(message)
-    
-    def error(self, message):
-        self.logger.error(message)
-    
-    def critical(self, message):
-        self.logger.critical(message)
-    
-    def success(self, message):
-        self.logger.success('\n' + message) # Add newline for better readability
-    
-    def disable_logging(self):
-        logging.disable(logging.CRITICAL)
 
+    def debug(self, msg): self.logger.debug(msg)
+    def info(self, msg): self.logger.info(msg)
+    def warning(self, msg): self.logger.warning(msg)
+    def error(self, msg): self.logger.error(msg)
+    def critical(self, msg): self.logger.critical(msg)
+    def success(self, msg): self.logger.success(msg)
+    def disable_logging(self): logging.disable(logging.CRITICAL)
 
 # Example usage
 if __name__ == "__main__":