做后端服务的同学肯定都遇到过这个问题：生产环境突然大量异常日志打出来，结果磁盘空间瞬间被占满，导致应用崩溃。更可怕的是，这种日志爆炸往往发生在问题排查的关键时刻——你想查日志定位问题，结果日志系统先挂了。

我之前就经历过这样一个案例：某个接口被恶意刷流量，返回了大量异常，因为异常日志太多，磁盘空间在几分钟内被完全占满。最后不仅业务停了，连日志都没留下，问题排查变得极其困难。

今天我们就来聊聊日志爆炸的防护机制，让你的系统在日志风暴中依然稳稳当当。

日志爆炸的常见场景

1. 恶意请求刷接口

攻击者或者错误配置的前端，不断请求一个会抛异常的接口：

10万次/秒 × 每次打印1KB日志 = 100GB/秒的日志量！

2. 循环打印异常

有些代码在异常处理中又抛出异常，形成死循环：

try {
    doSomething();
} catch (Exception e) {
    log.error("操作失败", e);  // 这里又触发了新异常
    throw new RuntimeException(e);  // 继续抛出
}

3. 日志配置不当

使用 e.printStackTrace() 而不是 proper 的日志框架，或者日志级别配置错误：

// 错误：直接打印到标准错误
e.printStackTrace();

// 正确：使用日志框架
log.error("操作失败", e);

4. 第三方库日志失控

引入的某些库会疯狂打日志，但没有正确配置：

某些数据库驱动：SQL日志全开 = 每秒数万条日志
某些HTTP客户端：debug日志全开 = 请求响应全记录

日志爆炸的破坏力

日志爆炸不仅仅是磁盘占满这么简单：

日志爆炸影响链：

1. 磁盘空间耗尽
   ↓
2. 日志写入失败（或切换到默认路径）
   ↓
3. 业务日志丢失
   ↓
4. 无法定位问题
   ↓
5. 应用崩溃或功能异常

更糟糕的是，如果日志目录和业务数据在同一磁盘，可能导致：

• 数据库写入失败
• 缓存同步失败
• 依赖服务超时

解决方案：多层防护机制

我们的方案采用"多层防护"策略：

┌─────────────────────────────────────────────────────────────┐
│                     多层防护体系                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   第一层：动态限频（Rate Limiter）                           │
│   ┌─────────────────────────────────────────────────────┐   │
│   │ • 按接口/模块限流                                   │   │
│   │ • 超出阈值的日志进入队列                            │   │
│   │ • 消费端慢慢消化                                    │   │
│   └─────────────────────────────────────────────────────┘   │
│                           ↓                                 │
│   第二层：采样保留（Sampling）                               │
│   ┌─────────────────────────────────────────────────────┐   │
│   │ • 相同异常只记录第一条+N条采样                       │   │
│   │ • 保留关键信息，丢弃重复                             │   │
│   └─────────────────────────────────────────────────────┘   │
│                           ↓                                 │
│   第三层：异步落盘（Async Writer）                          │
│   ┌─────────────────────────────────────────────────────┐   │
│   │ • 日志先入内存队列                                   │   │
│   │ • 异步线程批量写入磁盘                               │   │
│   │ • 应用线程不阻塞                                    │   │
│   └─────────────────────────────────────────────────────┘   │
│                           ↓                                 │
│   第四层：自动清理（Auto Cleanup）                          │
│   ┌─────────────────────────────────────────────────────┐   │
│   │ • 磁盘空间不足时自动清理旧日志                        │   │
│   │ • 保留关键日志，删除可恢复日志                        │   │
│   └─────────────────────────────────────────────────────┘   │
│                                                             │
└─────────────────────────────────────────────────────────────┘

核心组件设计

1. 动态限频器

根据日志产生速率动态调整处理策略：

核心逻辑：

class DynamicRateLimiter:
    def __init__(self):
        self.counters = {}  # 模块级别的计数器
        self.thresholds = {
            'normal': 100,      # 正常：每秒100条
            'warning': 1000,   # 警告：每秒1000条
            'critical': 5000   # 危险：每秒5000条
        }
        self.current_mode = 'normal'
    
    def check_and_record(self, module, log_entry):
        key = f"{module}:{log_entry.level}"
        now = get_current_second()
        
        if key not in self.counters:
            self.counters[key] = {'count': 0, 'second': now}
        
        entry = self.counters[key]
        if entry['second'] != now:
            entry['count'] = 0
            entry['second'] = now
        
        entry['count'] += 1
        
        if entry['count'] > self.thresholds['critical']:
            self.current_mode = 'discard'  # 丢弃模式
        elif entry['count'] > self.thresholds['warning']:
            self.current_mode = 'sampling'  # 采样模式
        else:
            self.current_mode = 'normal'   # 正常模式
        
        return self.current_mode

2. 采样保留策略

当日志过多时，保留关键信息：

核心逻辑：

class SamplingLogFilter:
    def __init__(self):
        self.seen_exceptions = LRUCache(maxsize=1000)
        self.sample_interval = 100  # 每100条采样1条
    
    def should_keep(self, log_entry):
        exception_key = self._get_exception_key(log_entry)
        
        if exception_key not in self.seen_exceptions:
            self.seen_exceptions[exception_key] = {
                'count': 0,
                'first_time': now(),
                'last_sample_time': 0
            }
            return True  # 首次出现，保留
        
        entry = self.seen_exceptions[exception_key]
        entry['count'] += 1
        
        # 采样：保留第一条、前N条、最后N条
        if entry['count'] <= 5:
            return True
        elif entry['count'] % self.sample_interval == 0:
            entry['last_sample_time'] = now()
            return True
        
        return False
    
    def _get_exception_key(self, log_entry):
        """生成异常的唯一标识"""
        return hash(log_entry.exception_type + log_entry.exception_message)

3. 异步日志写入器

将日志写入与业务逻辑解耦：

核心逻辑：

class AsyncLogWriter:
    def __init__(self):
        self.queue = LinkedBlockingQueue(maxsize=10000)
        self.batch_size = 100
        self.flush_interval = 1  # 1秒强制刷新
        self.writer_thread = Thread(target=self._flush_loop)
    
    def start(self):
        self.writer_thread.start()
    
    def write(self, log_entry):
        # 非阻塞写入队列
        if not self.queue.offer(log_entry):
            # 队列满，尝试阻塞写入
            self.queue.put(log_entry)
    
    def _flush_loop(self):
        buffer = []
        last_flush = time.time()
        
        while True:
            try:
                # 尝试获取一条日志（带超时）
                entry = self.queue.poll(timeout=0.1)
                if entry:
                    buffer.append(entry)
                
                # 批量写入条件
                should_flush = (
                    len(buffer) >= self.batch_size or
                    (len(buffer) > 0 and time.time() - last_flush > self.flush_interval)
                )
                
                if should_flush:
                    self._flush_buffer(buffer)
                    buffer = []
                    last_flush = time.time()
                    
            except Exception as e:
                self._handle_error(e)

4. 磁盘空间监控器

实时监控磁盘空间，自动触发清理：

核心逻辑：

class DiskSpaceMonitor:
    def __init__(self):
        self.min_free_space = 1 * 1024 * 1024 * 1024  # 1GB
        self.cleanup_target = 5 * 1024 * 1024 * 1024   # 清理到5GB
    
    def check_and_cleanup(self):
        free_space = get_disk_free_space()
        
        if free_space < self.min_free_space:
            logger.warn(f"磁盘空间不足: {free_space}bytes，开始清理")
            self._aggressive_cleanup()
        elif free_space < self.cleanup_target:
            logger.info(f"磁盘空间偏低: {free_space}bytes，适度清理")
            self._gentle_cleanup()
    
    def _aggressive_cleanup(self):
        """激进清理：删除所有应用日志"""
        patterns = ['app-*.log', 'application-*.log']
        for pattern in patterns:
            files = glob.glob(f"{log_dir}/{pattern}")
            for f in sorted(files, key=lambda x: os.path.getmtime(x))[:-3]:
                os.remove(f)
    
    def _gentle_cleanup(self):
        """温和清理：只删除归档日志"""
        patterns = ['*.log.gz', '*.log.bz2']
        for pattern in patterns:
            files = glob.glob(f"{log_dir}/{pattern}")
            for f in sorted(files, key=lambda x: os.path.getmtime(x))[:-10]:
                os.remove(f)

完整防护流程

日志进入系统的完整流程：

┌─────────────────────────────────────────────────────────────────┐
│                        日志处理主流程                            │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  日志产生                                                        │
│     ↓                                                           │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │ 1. 动态限频检查                                           │    │
│  │    - 检查当前QPS                                          │    │
│  │    - 决定处理模式（正常/采样/丢弃）                        │    │
│  └─────────────────────────────────────────────────────────┘    │
│     ↓                                                           │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │ 2. 采样过滤器                                             │    │
│  │    - 检查是否重复异常                                     │    │
│  │    - 决定是否保留                                         │    │
│  └─────────────────────────────────────────────────────────┘    │
│     ↓                                                           │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │ 3. 写入队列                                               │    │
│  │    - 非阻塞入队                                           │    │
│  │    - 队列满则丢弃或阻塞                                   │    │
│  └─────────────────────────────────────────────────────────┘    │
│     ↓                                                           │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │ 4. 异步批量写入                                           │    │
│  │    - 批量累积                                             │    │
│  │    - 定时/定量刷新到磁盘                                   │    │
│  └─────────────────────────────────────────────────────────┘    │
│     ↓                                                           │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │ 5. 磁盘空间监控                                           │    │
│  │    - 实时监控剩余空间                                      │    │
│  │    - 空间不足时触发清理                                   │    │
│  └─────────────────────────────────────────────────────────┘    │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

配置建议

# 日志爆炸防护配置
logging:
  explosion-protection:
    enabled: true
    
    # 限频配置
    rate-limit:
      normal-qps: 100
      warning-qps: 1000
      critical-qps: 5000
    
    # 采样配置
    sampling:
      enabled: true
      first-count: 5        # 前5条全保留
      sample-interval: 100  # 之后每100条采样1条
    
    # 异步写入配置
    async:
      queue-size: 10000
      batch-size: 100
      flush-interval-seconds: 1
    
    # 磁盘空间配置
    disk-space:
      min-free-bytes: 1073741824   # 1GB
      cleanup-target-bytes: 5368709120  # 5GB

效果对比

总结

日志爆炸防护的核心原则：

1. 多层防护：单一手段不够，需要多层防线
2. 动态调整：根据实际情况动态调整策略
3. 采样保留：丢弃重复，保留关键信息
4. 异步解耦：不能让日志影响业务
5. 自动恢复：出问题时能自动恢复

记住：日志是用来查问题的，别让日志成为新的问题。通过合理的防护机制，让日志系统在任何情况下都能稳稳当当工作。

源码获取

文章已同步至小程序博客栏目，需要源码的请关注小程序博客。

公众号：服务端技术精选

小程序码：