如何在RotatingFileHandler中检测文件名变化？多进程日志冲突求解

这个问题在多进程环境下用RotatingFileHandler太常见了——毕竟它本来就是为单进程场景设计的，每个进程各自维护自己的轮转状态，完全不知道其他进程干了啥。不过要继续用它解决冲突也不是不行，给你几个可行的方案：

1. 用文件锁同步轮转操作 + 检测文件inode变化 #

核心思路是两个点：

• 加锁确保同一时间只有一个进程执行轮转操作，避免重复轮转
• 每次写日志前检查日志文件的inode（文件唯一标识），如果发现inode变了，说明其他进程已经完成轮转，就重新打开新的日志文件

你可以自定义一个带锁的Handler，代码示例如下：

import logging
from logging.handlers import RotatingFileHandler
import fcntl
import os

class MultiProcessRotatingFileHandler(RotatingFileHandler):
    def __init__(self, filename, mode='a', maxBytes=0, backupCount=0, encoding=None, delay=False):
        super().__init__(filename, mode, maxBytes, backupCount, encoding, delay)
        # 用日志文件同名的.lock文件做锁
        self.lock_path = f"{filename}.lock"
        # 记录当前打开文件的inode
        if not delay:
            stream = self._open()
            self.current_inode = os.fstat(stream.fileno()).st_ino

    def _open(self):
        stream = super()._open()
        self.current_inode = os.fstat(stream.fileno()).st_ino
        return stream

    def emit(self, record):
        # 先检查日志文件是否被其他进程轮转了
        if os.path.exists(self.baseFilename):
            current_file_inode = os.stat(self.baseFilename).st_ino
            if current_file_inode != self.current_inode:
                # 关闭旧流，重新打开新的日志文件
                self.stream.close()
                self.stream = self._open()
        
        # 加锁确保轮转操作原子性
        with open(self.lock_path, 'w') as lock_file:
            fcntl.flock(lock_file, fcntl.LOCK_EX)
            try:
                super().emit(record)
            finally:
                fcntl.flock(lock_file, fcntl.LOCK_UN)

然后在你的Flask应用里替换原Handler：

from flask import Flask

app = Flask(__name__)
# 配置：日志文件最大1MB，保留5个备份
handler = MultiProcessRotatingFileHandler(
    'log.txt',
    maxBytes=1024 * 1024,
    backupCount=5
)
app.logger.addHandler(handler)

注意事项： #

• 锁文件会和日志文件在同一目录，要确保所有gunicorn进程都有读写权限
• 因为每个进程还是各自维护已写字节数，可能会有小误差（比如A进程刚写了一部分，B进程触发轮转），但整体不会影响轮转逻辑，误差在可接受范围内

2. 共享轮转状态（适合对精度要求更高的场景） #

如果不想依赖文件inode检测，还可以把轮转的关键状态（比如当前日志文件的大小、备份编号）存在一个共享的地方，比如一个本地状态文件：

• 每个进程在决定是否轮转前，先读取共享状态，确认当前状态是否需要轮转
• 轮转完成后，更新共享状态，让其他进程感知到

示例代码片段：

import json

class SharedStateRotatingFileHandler(RotatingFileHandler):
    def __init__(self, filename, state_file='log_state.json', **kwargs):
        super().__init__(filename, **kwargs)
        self.state_file = state_file
        self.lock_path = f"{filename}.lock"
        self._load_state()

    def _load_state(self):
        if os.path.exists(self.state_file):
            with open(self.state_file, 'r') as f:
                state = json.load(f)
                self.current_size = state.get('current_size', 0)
                self.current_backup = state.get('current_backup', 0)
        else:
            self.current_size = os.path.getsize(self.baseFilename) if os.path.exists(self.baseFilename) else 0
            self.current_backup = 0

    def _save_state(self):
        with open(self.state_file, 'w') as f:
            json.dump({
                'current_size': self.current_size,
                'current_backup': self.current_backup
            }, f)

    def shouldRollover(self, record):
        self._load_state()
        actual_size = os.path.getsize(self.baseFilename) if os.path.exists(self.baseFilename) else 0
        if actual_size >= self.maxBytes:
            self.current_size = actual_size
            self._save_state()
            return True
        return False

    def doRollover(self):
        with open(self.lock_path, 'w') as lock_file:
            fcntl.flock(lock_file, fcntl.LOCK_EX)
            self._load_state()
            super().doRollover()
            self.current_size = 0
            self.current_backup += 1
            self._save_state()
            fcntl.flock(lock_file, fcntl.LOCK_UN)

这种方法的精度更高，但会增加额外的IO操作（读写状态文件），如果日志量很大，可能会有轻微性能影响。

3. 信号通知（更高效的进程间通信） #

当一个进程完成轮转后，给所有其他gunicorn子进程发送一个自定义信号（比如SIGUSR1），其他进程收到信号后立即重新打开日志文件：

首先在Flask应用里注册信号处理函数：

import signal

def handle_rollover_signal(signum, frame):
    global handler
    if handler:
        # 关闭旧流，重新打开新的日志文件
        handler.stream.close()
        handler.stream = handler._open()

# 注册信号处理
signal.signal(signal.SIGUSR1, handle_rollover_signal)

然后在自定义Handler的doRollover方法里，完成轮转后发送信号给其他子进程：

def doRollover(self):
    super().doRollover()
    # 获取当前进程组的所有子进程PID（假设gunicorn子进程在同一个进程组）
    pgid = os.getpgrp()
    for pid in os.listdir('/proc'):
        if pid.isdigit():
            try:
                pid_int = int(pid)
                if os.getpgid(pid_int) == pgid and pid_int != os.getpid():
                    os.kill(pid_int, signal.SIGUSR1)
            except (ProcessLookupError, PermissionError):
                pass

这种方法的优点是高效，不需要频繁检查文件，但需要处理进程组和信号的细节，适合对性能要求高的场景。

总的来说，虽然RotatingFileHandler原生不支持多进程，但通过加锁、状态共享或者信号通知的方式，完全可以让它在gunicorn多进程环境下正常工作，避免你遇到的日志文件混乱问题。

内容的提问来源于stack exchange，提问作者apple