logger.py

"""
Logging Module

Structured logging system with file rotation and different log levels.
"""

import logging
import os
from logging.handlers import RotatingFileHandler
from typing import Optional
from datetime import datetime

import config


class TradingLogger:
    """
    Custom logger for the trading platform.
    Provides separate loggers for different components.
    """
    
    _instances = {}
    
    def __init__(self, name: str, log_file: Optional[str] = None):
        """
        Initialize logger.
        
        Args:
            name: Logger name
            log_file: Optional log file path
        """
        self.name = name
        self.log_file = log_file or config.LOG_FILE
        self.logger = self._setup_logger()
    
    def _setup_logger(self) -> logging.Logger:
        """
        Setup logger with file and console handlers.
        
        Returns:
            Configured logger instance
        """
        # Create logger
        logger = logging.getLogger(self.name)
        logger.setLevel(logging.DEBUG)
        
        # Avoid adding handlers multiple times
        if logger.handlers:
            return logger
        
        # Ensure log directory exists
        config.ensure_directories()
        
        # File handler with rotation
        file_handler = RotatingFileHandler(
            self.log_file,
            maxBytes=config.LOG_MAX_BYTES,
            backupCount=config.LOG_BACKUP_COUNT
        )
        file_handler.setLevel(logging.DEBUG)
        
        # Console handler
        console_handler = logging.StreamHandler()
        console_handler.setLevel(logging.INFO)
        
        # Formatter
        formatter = logging.Formatter(
            config.LOG_FORMAT,
            datefmt=config.LOG_DATE_FORMAT
        )
        
        file_handler.setFormatter(formatter)
        console_handler.setFormatter(formatter)
        
        # Add handlers
        logger.addHandler(file_handler)
        logger.addHandler(console_handler)
        
        return logger
    
    @classmethod
    def get_logger(cls, name: str, log_file: Optional[str] = None) -> 'TradingLogger':
        """
        Get or create logger instance.
        
        Args:
            name: Logger name
            log_file: Optional log file path
            
        Returns:
            TradingLogger instance
        """
        if name not in cls._instances:
            cls._instances[name] = cls(name, log_file)
        return cls._instances[name]
    
    def debug(self, msg: str, **kwargs):
        """Log debug message."""
        self.logger.debug(msg, **kwargs)
    
    def info(self, msg: str, **kwargs):
        """Log info message."""
        self.logger.info(msg, **kwargs)
    
    def warning(self, msg: str, **kwargs):
        """Log warning message."""
        self.logger.warning(msg, **kwargs)
    
    def error(self, msg: str, **kwargs):
        """Log error message."""
        self.logger.error(msg, **kwargs)
    
    def critical(self, msg: str, **kwargs):
        """Log critical message."""
        self.logger.critical(msg, **kwargs)
    
    def trade(self, action: str, symbol: str, quantity: int, price: float, **kwargs):
        """
        Log trade execution.
        
        Args:
            action: Trade action (BUY/SELL)
            symbol: Stock symbol
            quantity: Quantity
            price: Execution price
        """
        msg = f"TRADE - {action} {quantity} {symbol} @ ${price:.2f}"
        if kwargs:
            msg += f" | {kwargs}"
        self.logger.info(msg)
    
    def performance(self, metric: str, value: float, **kwargs):
        """
        Log performance metric.
        
        Args:
            metric: Metric name
            value: Metric value
        """
        msg = f"PERFORMANCE - {metric}: {value}"
        if kwargs:
            msg += f" | {kwargs}"
        self.logger.info(msg)
    
    def security(self, event: str, details: str = ""):
        """
        Log security event.
        
        Args:
            event: Security event type
            details: Event details
        """
        msg = f"SECURITY - {event}"
        if details:
            msg += f": {details}"
        self.logger.warning(msg)


# Pre-configured loggers for different components
system_logger = TradingLogger.get_logger('system')
trading_logger = TradingLogger.get_logger('trading', os.path.join(config.LOG_DIR, 'trading.log'))
security_logger = TradingLogger.get_logger('security', os.path.join(config.LOG_DIR, 'security.log'))
performance_logger = TradingLogger.get_logger('performance', os.path.join(config.LOG_DIR, 'performance.log'))