The begining

src/logger.py

@@ -0,0 +1,113 @@
+import logging
+import sys
+import time
+import functools
+import asyncio
+from datetime import datetime
+from typing import Any, Callable
+import traceback
+
+class KubyLogger:
+    def __init__(self, name="KubyBot"):
+        self.logger = logging.getLogger(name)
+        self.logger.setLevel(logging.DEBUG)
+        
+        # Créer le format de log
+        formatter = logging.Formatter(
+            '[%(asctime)s] [%(levelname)s] [%(name)s] [%(funcName)s:%(lineno)d] %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+        
+        # Console handler
+        console_handler = logging.StreamHandler(sys.stdout)
+        console_handler.setFormatter(formatter)
+        console_handler.setLevel(logging.DEBUG)
+        self.logger.addHandler(console_handler)
+        
+        # File handler
+        file_handler = logging.FileHandler('kuby_logs.log')
+        file_handler.setFormatter(formatter)
+        file_handler.setLevel(logging.DEBUG)
+        self.logger.addHandler(file_handler)
+        
+        # Error file handler
+        error_handler = logging.FileHandler('kuby_errors.log')
+        error_handler.setLevel(logging.ERROR)
+        error_handler.setFormatter(formatter)
+        self.logger.addHandler(error_handler)
+        
+        # Audit file handler for security events
+        audit_handler = logging.FileHandler('kuby_audit.log')
+        audit_handler.setLevel(logging.INFO)
+        audit_formatter = logging.Formatter(
+            '[AUDIT] [%(asctime)s] [%(levelname)s] [%(funcName)s] %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+        audit_handler.setFormatter(audit_formatter)
+        self.logger.addHandler(audit_handler)
+    
+    def debug(self, message, **kwargs):
+        self.logger.debug(message, **kwargs)
+    
+    def info(self, message, **kwargs):
+        self.logger.info(message, **kwargs)
+    
+    def warning(self, message, **kwargs):
+        self.logger.warning(message, **kwargs)
+    
+    def error(self, message, **kwargs):
+        self.logger.error(message, **kwargs)
+    
+    def critical(self, message, **kwargs):
+        self.logger.critical(message, **kwargs)
+    
+    def audit(self, message, **kwargs):
+        """Special audit logging for security events"""
+        self.logger.log(25, f"AUDIT: {message}", **kwargs)
+    
+    def performance(self, message, duration=None, **kwargs):
+        """Performance logging with timing information"""
+        if duration is not None:
+            self.logger.info(f"PERFORMANCE: {message} - Duration: {duration:.3f}s", **kwargs)
+        else:
+            self.logger.info(f"PERFORMANCE: {message}", **kwargs)
+
+# Performance decorator
+def log_performance(func: Callable) -> Callable:
+    """Decorator to log function performance"""
+    @functools.wraps(func)
+    async def async_wrapper(*args, **kwargs):
+        start_time = time.time()
+        kuby_logger.debug(f"Entering {func.__name__} with args: {args}, kwargs: {kwargs}")
+        try:
+            result = await func(*args, **kwargs)
+            duration = time.time() - start_time
+            kuby_logger.performance(f"Completed {func.__name__}", duration=duration)
+            return result
+        except Exception as e:
+            duration = time.time() - start_time
+            kuby_logger.error(f"Error in {func.__name__} after {duration:.3f}s: {str(e)}")
+            kuby_logger.error(traceback.format_exc())
+            raise
+    
+    @functools.wraps(func)
+    def sync_wrapper(*args, **kwargs):
+        start_time = time.time()
+        kuby_logger.debug(f"Entering {func.__name__} with args: {args}, kwargs: {kwargs}")
+        try:
+            result = func(*args, **kwargs)
+            duration = time.time() - start_time
+            kuby_logger.performance(f"Completed {func.__name__}", duration=duration)
+            return result
+        except Exception as e:
+            duration = time.time() - start_time
+            kuby_logger.error(f"Error in {func.__name__} after {duration:.3f}s: {str(e)}")
+            kuby_logger.error(traceback.format_exc())
+            raise
+    
+    if asyncio.iscoroutinefunction(func):
+        return async_wrapper
+    return sync_wrapper
+
+# Instance globale du logger
+kuby_logger = KubyLogger()