为什么TimeDrotingFileHandler不删除旧文件？

Question

我正在使用TimedRotatingFileHandler创建日志。 我希望我的日志文件被创建每分钟，最多保留2个日志文件和删除旧的。下面是示例代码：

import logging
import logging.handlers
import datetime

logger = logging.getLogger('MyLogger')
logger.setLevel(logging.DEBUG)

handler = logging.handlers.TimedRotatingFileHandler(
    "logs/{:%H-%M}.log".format(datetime.datetime.now()), 
    when="M", 
    backupCount=2)

logger.addHandler(handler)
logger.debug("PLEASE DELETE PREVIOUS FILES")

如果我多次运行此代码（以分钟为间隔），我会在日志目录中获取多个文件，如下所示：

^{pr2}$

这对我来说似乎很奇怪，因为我设置了backupCount=2，它表示最多应该保存2个文件，应该删除旧的文件。但是，当我在日志文件夹中使用2个或更多文件启动应用程序时，旧文件不会被删除。在

为什么TimeDrotingFileHandler不删除旧文件？ 有没有办法设置TimeDrotingFileHandler来删除旧文件？在

Answer 1

您不能按照设计将TimedRotatingFileHandler用于您的用例。处理程序希望“当前”日志文件名保持稳定，并将旋转定义为通过重命名将现有日志文件移动到备份。这些是保留或删除的备份。旋转备份是从基本文件名加上带有旋转时间戳的后缀创建的。因此，该实现区分了日志文件（存储在baseFilename）和旋转文件（在^{} method中生成）。请注意，只有在旋转发生时才会删除备份，因此在处理程序已使用至少一个完整间隔之后。在

相反，您希望基文件名本身携带时间信息，因此需要改变日志文件名本身。在这种情况下没有“备份”，您只需在轮换时打开一个新文件。此外，您似乎正在运行短生命的Python代码，因此您希望立即删除较旧的文件，而不仅仅是在显式旋转时，这可能永远无法达到。在

这就是为什么TimedRotatingFileHandler不会删除任何文件，因为*它永远无法创建备份文件。没有备份意味着没有要删除的备份。为了循环文件，处理程序的当前实现需要负责文件名的生成，而不能期望知道它本身不会生成的文件名。当您将其配置为"M"每分钟的旋转频率时，它被配置为以{baseFileame}.{now:%Y-%m-%d_%H_%M}模式将文件旋转到备份文件，因此只会删除与该模式匹配的旋转备份文件。请参见documentation：

The system will save old log files by appending extensions to the filename. The extensions are date-and-time based, using the strftime format %Y-%m-%d_%H-%M-%S or a leading portion thereof, depending on the rollover interval.

相反，您需要的是一个基本文件名，它本身带有时间戳，当打开一个具有不同名称的新日志文件时，旧的日志文件（不是备份文件）将被删除。为您创建一个自定义处理程序。在

幸运的是，类层次结构是专门为方便定制而设计的。您可以在此处子类^{}，并提供您自己的删除逻辑：

import os
import time
from itertools import islice
from logging.handlers import BaseRotatingHandler, TimedRotatingFileHandler

# rotation intervals in seconds
_intervals = {
    "S": 1,
    "M": 60,
    "H": 60 * 60,
    "D": 60 * 60 * 24,
    "MIDNIGHT": 60 * 60 * 24,
    "W": 60 * 60 * 24 * 7,
}

class TimedPatternFileHandler(BaseRotatingHandler):
    """File handler that uses the current time in the log filename.

    The time is quantisized to a configured interval. See
    TimedRotatingFileHandler for the meaning of the when, interval, utc and
    atTime arguments.

    If backupCount is non-zero, then older filenames that match the base
    filename are deleted to only leave the backupCount most recent copies,
    whenever opening a new log file with a different name.

    """

    def __init__(
        self,
        filenamePattern,
        when="h",
        interval=1,
        backupCount=0,
        encoding=None,
        delay=False,
        utc=False,
        atTime=None,
    ):
        self.when = when.upper()
        self.backupCount = backupCount
        self.utc = utc
        self.atTime = atTime
        try:
            key = "W" if self.when.startswith("W") else self.when
            self.interval = _intervals[key]
        except KeyError:
            raise ValueError(
                f"Invalid rollover interval specified: {self.when}"
            ) from None
        if self.when.startswith("W"):
            if len(self.when) != 2:
                raise ValueError(
                    "You must specify a day for weekly rollover from 0 to 6 "
                    f"(0 is Monday): {self.when}"
                )
            if not "0" <= self.when[1] <= "6":
                raise ValueError(
                    f"Invalid day specified for weekly rollover: {self.when}"
                )
            self.dayOfWeek = int(self.when[1])

        self.interval = self.interval * interval
        self.pattern = os.path.abspath(os.fspath(filenamePattern))

        # determine best time to base our rollover times on
        # prefer the creation time of the most recently created log file.
        t = now = time.time()
        entry = next(self._matching_files(), None)
        if entry is not None:
            t = entry.stat().st_ctime
            while t + self.interval < now:
                t += self.interval

        self.rolloverAt = self.computeRollover(t)

        # delete older files on startup and not delaying
        if not delay and backupCount > 0:
            keep = backupCount
            if os.path.exists(self.baseFilename):
                keep += 1
                delete = islice(self._matching_files(), keep, None)
                for entry in delete:
                    os.remove(entry.path)

        # Will set self.baseFilename indirectly, and then may use
        # self.baseFilename to open. So by this point self.rolloverAt and
        # self.interval must be known.
        super().__init__(filenamePattern, "a", encoding, delay)

    @property
    def baseFilename(self):
        """Generate the 'current' filename to open"""
        # use the start of *this* interval, not the next
        t = self.rolloverAt - self.interval
        if self.utc:
            time_tuple = time.gmtime(t)
        else:
            time_tuple = time.localtime(t)
            dst = time.localtime(self.rolloverAt)[-1]
            if dst != time_tuple[-1] and self.interval > 3600:
                # DST switches between t and self.rolloverAt, adjust
                addend = 3600 if dst else -3600
                time_tuple = time.localtime(t + addend)
        return time.strftime(self.pattern, time_tuple)

    @baseFilename.setter
    def baseFilename(self, _):
        # assigned to by FileHandler, just ignore this as we use self.pattern
        # instead
        pass

    def _matching_files(self):
        """Generate DirEntry entries that match the filename pattern.

        The files are ordered by their last modification time, most recent
        files first.

        """
        matches = []
        pattern = self.pattern
        for entry in os.scandir(os.path.dirname(pattern)):
            if not entry.is_file():
                continue
            try:
                time.strptime(entry.path, pattern)
                matches.append(entry)
            except ValueError:
                continue
        matches.sort(key=lambda e: e.stat().st_mtime, reverse=True)
        return iter(matches)

    def doRollover(self):
        """Do a roll-over. This basically needs to open a new generated filename.
        """
        if self.stream:
            self.stream.close()
            self.stream = None

        if self.backupCount > 0:
            delete = islice(self._matching_files(), self.backupCount, None)
            for entry in delete:
                os.remove(entry.path)

        now = int(time.time())
        rollover = self.computeRollover(now)
        while rollover <= now:
            rollover += self.interval
        if not self.utc:
            # If DST changes and midnight or weekly rollover, adjust for this.
            if self.when == "MIDNIGHT" or self.when.startswith("W"):
                dst = time.localtime(now)[-1]
                if dst != time.localtime(rollover)[-1]:
                    rollover += 3600 if dst else -3600
        self.rolloverAt = rollover

        if not self.delay:
            self.stream = self._open()

    # borrow *some* TimedRotatingFileHandler methods
    computeRollover = TimedRotatingFileHandler.computeRollover
    shouldRollover = TimedRotatingFileHandler.shouldRollover

在日志文件名中与^{} placeholders一起使用，这些将为您填写：

^{pr2}$

请注意，当您创建实例时，这会清理旧文件。在

Answer 2

正如其他人已经指出的那样，backupCount只有当你总是用相同的文件名登录到文件，然后时不时地旋转时，backupCount才有效。然后您将显示@Bsquare之类的日志文件。 但是，在我的例子中，我需要每天轮换，并让我的日志文件具有以下名称：2019-07-06.log，2019-07-07.log，2019-07-07.log。。。 我发现使用TimedRotatingFileHandler的当前实现是不可能的

所以我在FileHandler上创建了适合我需要的删除功能 这是一个logger类的简单示例，该类使用FileHandler，它将确保每次创建此类的实例时都删除旧日志文件：

import os
import datetime
import logging
import re
import pathlib


class Logger:

    # Maximum number of logs to store
    LOGS_COUNT = 3

    # Directory to log to
    LOGS_DIRECTORY = "logs"

    def __init__(self):
        # Make sure logs directory is created
        self.__create_directory(Logger.LOGS_DIRECTORY)
        # Clean old logs every time you create a logger
        self.__clean_old_logs()
        self.logger = logging.getLogger("Logger")
        # If condition will make sure logger handlers will be initialize only once when this object is created
        if not self.logger.handlers:
            self.logger.setLevel(logging.INFO)
            formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
            file_handler = logging.FileHandler("logs/{:%Y-%m-%d}.log".format(datetime.datetime.now()))
            file_handler.setFormatter(formatter)
            self.logger.addHandler(file_handler)

    def log_info(self, message):
        self.logger.info(message)

    def log_error(self, message):
        self.logger.error(message)

    def __clean_old_logs(self):
        for name in self.__get_old_logs():
            path = os.path.join(Logger.LOGS_DIRECTORY, name)
            self.__delete_file(path)

    def __get_old_logs(self):
        logs = [name for name in self.__get_file_names(Logger.LOGS_DIRECTORY)
            if re.match("([12]\d{3}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01]))\.log", name)]
        logs.sort(reverse=True)
        return logs[Logger.LOGS_COUNT:]

    def __get_file_names(self, path):
        return [item.name for item in pathlib.Path(path).glob("*") if item.is_file()]

    def __delete_file(self, path):
        os.remove(path)

    def __create_directory(self, directory):
        if not os.path.exists(directory):
            os.makedirs(directory)

然后你可以这样使用它：

^{pr2}$

Answer 3

正如您在TimedRotatingFileHandler文档中看到的那样，您的日志文件名应该是相同的，以便正确地获取旋转系统。在

在您的例子中，因为您自己附加了日期时间信息，所以每次日志文件名都是不同的，因此您可以观察结果。在

因此，在源代码中，只需调整日志文件名：

handler = logging.handlers.TimedRotatingFileHandler(
    "logs/MyLog", 
    when="M", 
    backupCount=2)

如果您想挑战它，可以将when更改为“S”（秒），并检查旋转是否正常。在

例如，它将自动生成这样的文件：

^{pr2}$

如果你需要更多的信息，不要犹豫。在