log_manager.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
日志管理器模块

负责管理 KeyMouse 应用程序的日志配置，包括日志级别、格式、文件滚动等。
"""

import logging
import logging.handlers
import os
from typing import Optional, Dict, Any

from config_loader import get_base_path


class LogManager:
    """日志管理器 - 管理日志配置和滚动策略"""

    def __init__(self, config: Optional[Dict[str, Any]] = None):
        """
        初始化日志管理器

        Args:
            config: 日志配置字典，包含日志级别、格式、文件路径等设置
        """
        self.config = config or {}
        self._setup_logging()

    def _setup_logging(self) -> None:
        """设置日志系统"""
        # 清除现有的处理器
        for handler in logging.root.handlers[:]:
            logging.root.removeHandler(handler)

        # 获取日志配置
        log_level = self.config.get('log_level', 'INFO')
        log_format = self.config.get('log_format',
            '%(asctime)s - [%(levelname)s] - %(message)s')
        log_file_path = self.config.get('log_file_path',
            os.path.join(get_base_path(), 'main.log'))

        # 创建日志目录
        log_dir = os.path.dirname(log_file_path)
        if log_dir and not os.path.exists(log_dir):
            try:
                os.makedirs(log_dir)
            except OSError as e:
                print(f"Failed to create log directory {log_dir}: {e}")

        # 设置日志级别
        level_map = {
            'DEBUG': logging.DEBUG,
            'INFO': logging.INFO,
            'WARNING': logging.WARNING,
            'ERROR': logging.ERROR,
            'CRITICAL': logging.CRITICAL
        }
        level = level_map.get(log_level.upper(), logging.INFO)

        # 创建处理器
        handlers = []

        # 文件处理器（带滚动）
        max_size = int(self.config.get('log_max_size', 10485760))  # 10MB
        backup_count = int(self.config.get('log_backup_count', 5))

        try:
            file_handler = logging.handlers.RotatingFileHandler(
                log_file_path,
                maxBytes=max_size,
                backupCount=backup_count,
                encoding='utf-8'
            )
            handlers.append(file_handler)
        except Exception as e:
            print(f"Failed to create file handler: {e}")

        # 控制台处理器（如果明确要求输出到控制台）
        if self.config.get('enable_console', False):
            try:
                console_handler = logging.StreamHandler()
                handlers.append(console_handler)
            except Exception as e:
                print(f"Failed to create console handler: {e}")

        # 错误日志处理器（如果配置了）
        error_log_file = self.config.get('error_log_file')
        if error_log_file:
            try:
                error_log_path = os.path.join(get_base_path(), error_log_file)
                error_dir = os.path.dirname(error_log_path)
                if error_dir and not os.path.exists(error_dir):
                    os.makedirs(error_dir)

                error_handler = logging.handlers.RotatingFileHandler(
                    error_log_path,
                    maxBytes=max_size,
                    backupCount=backup_count,
                    encoding='utf-8'
                )
                error_handler.setLevel(logging.ERROR)
                handlers.append(error_handler)
            except Exception as e:
                print(f"Failed to create error log handler: {e}")

        # 设置格式
        try:
            formatter = logging.Formatter(log_format)
            for handler in handlers:
                handler.setFormatter(formatter)
                handler.setLevel(level)
        except Exception as e:
            print(f"Failed to set formatter: {e}")

        # 配置根日志记录器
        try:
            logging.basicConfig(
                level=level,
                handlers=handlers
            )
        except Exception as e:
            print(f"Failed to configure logging: {e}")

    def update_config(self, new_config: Dict[str, Any]) -> None:
        """
        更新日志配置

        Args:
            new_config: 新的日志配置字典
        """
        self.config = new_config
        self._setup_logging()

    def get_current_level(self) -> str:
        """
        获取当前日志级别

        Returns:
            str: 当前日志级别名称
        """
        level = logging.getLogger().getEffectiveLevel()
        level_map = {
            logging.DEBUG: 'DEBUG',
            logging.INFO: 'INFO',
            logging.WARNING: 'WARNING',
            logging.ERROR: 'ERROR',
            logging.CRITICAL: 'CRITICAL'
        }
        return level_map.get(level, 'INFO')

    def set_level(self, level: str) -> bool:
        """
        设置日志级别

        Args:
            level: 日志级别字符串 (DEBUG, INFO, WARNING, ERROR, CRITICAL)

        Returns:
            bool: 设置是否成功
        """
        try:
            level_map = {
                'DEBUG': logging.DEBUG,
                'INFO': logging.INFO,
                'WARNING': logging.WARNING,
                'ERROR': logging.ERROR,
                'CRITICAL': logging.CRITICAL
            }
            level_value = level_map.get(level.upper(), logging.INFO)
            logging.getLogger().setLevel(level_value)
            return True
        except Exception as e:
            print(f"Failed to set log level: {e}")
            return False


# 全局日志管理器实例
_log_manager: Optional[LogManager] = None


def get_log_manager(config: Optional[Dict[str, Any]] = None) -> LogManager:
    """
    获取全局日志管理器实例

    Args:
        config: 日志配置字典

    Returns:
        LogManager: 日志管理器实例
    """
    global _log_manager
    if _log_manager is None:
        _log_manager = LogManager(config)
    return _log_manager


def setup_logging(config: Optional[Dict[str, Any]] = None) -> None:
    """
    设置日志系统

    Args:
        config: 日志配置字典
    """
    log_manager = get_log_manager(config)
    # 日志管理器在初始化时已经设置好了日志系统


def setup_module_logging(module_name: str, enable_console: bool = False) -> logging.Logger:
    """
    为特定模块设置日志记录器

    Args:
        module_name: 模块名称（如 'gui', 'event_handler', 'process_manager'等）
        enable_console: 是否启用控制台输出，默认False

    Returns:
        logging.Logger: 配置好的日志记录器
    """
    # 创建模块特定的日志记录器
    logger = logging.getLogger(module_name)
    logger.handlers.clear()  # 清除现有处理器

    # 设置日志级别
    logger.setLevel(logging.INFO)

    # 创建日志目录
    logs_dir = os.path.join(get_base_path(), 'logs')
    if not os.path.exists(logs_dir):
        os.makedirs(logs_dir)

    # 创建文件处理器
    log_file_path = os.path.join(logs_dir, f'{module_name}.log')
    try:
        file_handler = logging.handlers.RotatingFileHandler(
            log_file_path,
            maxBytes=10485760,  # 10MB
            backupCount=5,
            encoding='utf-8'
        )

        # 设置格式
        formatter = logging.Formatter(
            '%(asctime)s - [%(levelname)s] - %(name)s - %(message)s'
        )
        file_handler.setFormatter(formatter)
        logger.addHandler(file_handler)

    except Exception as e:
        print(f"Failed to create file handler for {module_name}: {e}")

    # 可选的控制台处理器
    if enable_console:
        try:
            console_handler = logging.StreamHandler()
            console_handler.setFormatter(formatter)
            logger.addHandler(console_handler)
        except Exception as e:
            print(f"Failed to create console handler for {module_name}: {e}")

    # 防止日志传播到根记录器
    logger.propagate = False

    return logger


def get_module_logger(module_name: str) -> logging.Logger:
    """
    获取或创建模块日志记录器

    Args:
        module_name: 模块名称

    Returns:
        logging.Logger: 日志记录器
    """
    logger = logging.getLogger(module_name)
    if not logger.handlers:
        # 如果还没有处理器，创建一个
        return setup_module_logging(module_name)
    return logger


if __name__ == "__main__":
    # 测试模块化日志记录
    gui_logger = setup_module_logging('gui')
    event_logger = setup_module_logging('event_handler')

    gui_logger.info("GUI module test message")
    event_logger.info("Event handler module test message")

    print("Check logs/ directory for module-specific log files.")