Python 使用自定义时间滚动日志处理器

class CustomTimedRotatingFileHandler(TimedRotatingFileHandler):
    def doRollover(self):
        # 如果当前有打开的日志文件流，则关闭它
        if self.stream:
            self.stream.close()
            self.stream = None

        # 获取当前时间的时间戳（秒）
        currentTime = int(time.time())

        # 获取当前时间是否是夏令时（dstNow表示当前夏令时状态，1为夏令时，0为非夏令时，-1为信息无效）
        dstNow = time.localtime(currentTime)[-1]

        # 计算上一个滚动时间的时间戳
        t = self.rolloverAt - self.interval

        # 根据是否使用UTC时间来决定使用gmtime还是localtime来获取时间元组
        if self.utc:
            timeTuple = time.gmtime(t)
        else:
            timeTuple = time.localtime(t)
            # 获取上一个滚动时间是否是夏令时
            dstThen = timeTuple[-1]

            # 如果当前夏令时状态与上一个滚动时间的夏令时状态不同
            if dstNow != dstThen:
                # 如果现在是夏令时，则此处没有操作（pass）
                if dstNow:
                    pass
                # 如果现在不是夏令时，则此处也没有操作（pass）
                else:
                    pass
                # 注意：此处应该添加处理夏令时变化的逻辑，例如调整时间戳以反映夏令时变化的影响。

        # 生成新的日志文件的文件名（基于基础文件名和滚动规则）
        dfn = self.rotation_filename(self.baseFilename + ".")

        # 如果新的日志文件不存在，则调用rotate方法创建它
        if not os.path.exists(dfn):
            self.rotate(self.baseFilename, dfn)

        # 如果设置了备份文件的最大数量，则删除超过这个数量的旧文件
        if self.backupCount > 0:
            for s in self.getFilesToDelete():
                os.remove(s)

        # 如果delay标志为False，则打开新的日志文件流以继续记录日志
        if not self.delay:
            self.stream = self._open()

        # 计算下一个滚动时间的时间戳
        newRolloverAt = self.computeRollover(currentTime)

        # 确保下一个滚动时间大于当前时间，如果不是，则加上一个滚动间隔
        while newRolloverAt <= currentTime:
            newRolloverAt = newRolloverAt + self.interval

        # 更新rolloverAt属性为下一个滚动时间的时间戳
        self.rolloverAt = newRolloverAt

class LogManager:
    def __init__(self, log_dir, log_name):
        """
        初始化日志管理器
        :param log_dir: 日志文件存储的目录
        :param log_name: 日志文件的基本名称，日期会被追加到文件名中
        """
        self.log_dir = log_dir
        self.log_name = log_name
        self.setup_logger()

    def setup_logger(self):
        """
        配置并启动日志记录器
        """
        # 确保日志目录存在
        if not os.path.exists(self.log_dir):
            os.makedirs(self.log_dir)

        # 创建日志记录器
        self.logger = logging.getLogger(self.log_name)
        self.logger.setLevel(logging.DEBUG)  # 可以根据需要调整日志级别

        # 创建一个handler，用于写入日志文件，每天滚动一次
        log_file_path = os.path.join(self.log_dir, self.log_name + ".log")
        handler = CustomTimedRotatingFileHandler(log_file_path, when="midnight", backupCount=3650)

        # 创建日志格式
        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        handler.setFormatter(formatter)

        # 给logger添加handler
        self.logger.addHandler(handler)

    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)

import datetime

# 指定日志文件存储的目录和日志文件的基本名称
log_dir = './logs'
log_name = 'application'

# 创建日志管理器实例
log_manager = LogManager(log_dir, log_name)

# 记录不同级别的日志信息
log_manager.debug(f"Debug message at {datetime.datetime.now()}")
log_manager.info(f"Info message at {datetime.datetime.now()}")
log_manager.warning(f"Warning message at {datetime.datetime.now()}")
log_manager.error(f"Error message at {datetime.datetime.now()}")
log_manager.critical(f"Critical message at {datetime.datetime.now()}")