日志限流和去重的必要性

微技术

于 2024-11-05 08:00:20 发布

阅读量1k

点赞数 15

文章标签： java python 开发语言

本文链接：https://blog.csdn.net/zhangkunls/article/details/143546543

版权

在日常开发工作中，过于频繁的日志记录会带来以下问题：

• 存储空间的浪费：冗余日志会迅速占用大量磁盘空间，增加运维负担。

• 性能的损耗：频繁的 I/O 操作会消耗系统资源，尤其是在高并发环境下。

• 信息淹没：关键日志信息可能被淹没在大量的重复日志中，难以快速定位问题。

因此，日志限流和去重在大型系统的日志管理中起到了关键作用。限流可以控制每秒输出的日志条数，而去重则确保重复的日志信息在指定时间间隔内只输出一次。要减少频繁的重复日志打印，可以考虑以下几种方法：

1. 使用条件日志打印：在代码中加入条件判断，只有当某些条件满足时才打印日志。例如，只在缓存未命中时记录日志，而在命中时忽略打印。

2. 限频打印：通过计数器或者时间间隔来控制日志的输出频率。例如，可以设置一个时间间隔（比如每5分钟）来限制相同内容的日志打印。以下是一个基于时间间隔的示例：

import java.util.HashMap;
import java.util.Map;


public class LogThrottler {
    private static final long INTERVAL_MS = 5 * 60 * 1000; // 5分钟
    private Map<String, Long> lastLoggedTimes = new HashMap<>();


    public synchronized void log(String message) {
        long now = System.currentTimeMillis();
        Long lastLoggedTime = lastLoggedTimes.get(message);


        if (lastLoggedTime == null || now - lastLoggedTime >= INTERVAL_MS) {
            System.out.println(message); // 或者使用你的日志框架打印日志
            lastLoggedTimes.put(message, now);
        }
    }
}


// 使用示例
public class Main {
    public static void main(String[] args) {
        LogThrottler logger = new LogThrottler();


        // 模拟重复的日志消息
        for (int i = 0; i < 10; i++) {
            logger.log("这是一个重复的信息");
            try {
                Thread.sleep(1000); // 模拟操作之间的延迟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3. 分级日志级别：根据日志内容的重要程度设置不同的日志级别，比如 INFO、WARN、ERROR 等。对于不重要的重复日志，可以将其级别设置为 DEBUG，然后在生产环境中仅打印较高优先级的日志。

4. 去重日志：使用类似于缓存的机制记录已经打印过的日志内容，避免重复输出。例如，可以使用一个 Set 来记录已经打印的内容，只在 Set 中不存在时打印日志。

5. 日志框架自带的限流功能：一些日志框架如logback、 Log4j 或 SLF4J 可能有自带的限流插件（如EvaluatorFilter、 BurstFilter），可以用来自动控制日志输出频率。

我们可以根据具体情况，选择一种或组合使用几种方法，来减少重复日志的打印。接下来以logback为例子来详细看看使用方法。

1. 使用 Logback 的 EvaluatorFilter 进行日志限流

Logback 提供了 EvaluatorFilter 过滤器，它允许我们根据自定义的规则来控制日志输出。我们可以结合 TimestampEvaluators 实现基于时间的限流。

配置示例

在 logback.xml 中定义 EvaluatorFilter，实现每 5 秒最多输出一条指定日志：

<configuration>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%date %-5level [%thread] %logger{0} - %msg%n</pattern>
        </encoder>
        
        <!-- EvaluatorFilter 配置 -->
        <filter class="ch.qos.logback.classic.filter.EvaluatorFilter">
            <evaluator class="ch.qos.logback.core.boolex.EventEvaluatorBase">
                <expression>
                    (TimeUnit.MILLISECONDS.toSeconds(currentTime) % 5) == 0
                </expression>
            </evaluator>
            <OnMismatch>DENY</OnMismatch>
            <OnMatch>ACCEPT</OnMatch>
        </filter>
    </appender>


    <root level="INFO">
        <appender-ref ref="CONSOLE" />
    </root>
</configuration>

参数解释

• EvaluatorFilter：用于执行自定义表达式来控制日志的输出频率。

• expression：定义了一个基于时间的规则，每隔 5 秒允许一条日志通过。在这里，使用了 currentTime 的秒数进行模运算，确保只有当秒数能被 5 整除时，才允许日志输出。

2. 自定义 Logback 过滤器实现日志去重和限流

如果需要更灵活的日志去重和限流，我们可以创建自定义过滤器，使用 ConcurrentHashMap 记录每条日志的上次输出时间，从而实现基于时间间隔的限流。

自定义过滤器示例

首先，创建一个自定义过滤器类 RateLimitFilter：

import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.filter.Filter;
import ch.qos.logback.core.spi.FilterReply;


import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;


public class RateLimitFilter extends Filter<ILoggingEvent> {
    private final ConcurrentHashMap<String, Long> messageTimestampMap = new ConcurrentHashMap<>();
    private long intervalInMillis = TimeUnit.SECONDS.toMillis(30); // 默认间隔 30 秒


    // 设置时间间隔
    public void setInterval(long interval) {
        this.intervalInMillis = interval;
    }


    @Override
    public FilterReply decide(ILoggingEvent event) {
        String message = event.getFormattedMessage();
        long currentTime = System.currentTimeMillis();


        // 获取上次输出时间
        Long lastLogTime = messageTimestampMap.getOrDefault(message, 0L);


        // 检查是否超过时间间隔
        if (currentTime - lastLogTime >= intervalInMillis) {
            messageTimestampMap.put(message, currentTime); // 更新打印时间
            return FilterReply.NEUTRAL; // 允许日志通过
        } else {
            return FilterReply.DENY; // 拒绝重复日志输出
        }
    }
}

配置文件 logback.xml

在 logback.xml 中添加自定义过滤器：

<configuration>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%date %-5level [%thread] %logger{0} - %msg%n</pattern>
        </encoder>


        <!-- 使用自定义 RateLimitFilter -->
        <filter class="com.example.logging.RateLimitFilter">
            <interval>30000</interval> <!-- 设置日志间隔为 30 秒 -->
        </filter>
    </appender>


    <root level="INFO">
        <appender-ref ref="CONSOLE" />
    </root>
</configuration>

参数解释

• <interval>：自定义的限流间隔，单位为毫秒。在此示例中，每 30 秒允许相同内容的日志输出一次。

3. 使用第三方库 logback-throttle

logback-throttle 是一个专门用于日志限流的第三方库。它提供了类似 BurstFilter 的功能，可以方便地控制日志输出速率。

添加依赖

首先，在 pom.xml 中添加 logback-throttle 依赖：

<dependency>
    <groupId>com.github.tony19</groupId>
    <artifactId>logback-throttle</artifactId>
    <version>1.0.0</version>
</dependency>

配置示例

在 logback.xml 中配置 ThrottleFilter：

<configuration>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%date %-5level [%thread] %logger{0} - %msg%n</pattern>
        </encoder>


        <!-- 使用 ThrottleFilter 进行限流 -->
        <filter class="com.github.tony19.logback.throttle.ThrottleFilter">
            <maxRate>5/10s</maxRate> <!-- 每 10 秒最多输出 5 条日志 -->
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>


    <root level="INFO">
        <appender-ref ref="CONSOLE" />
    </root>
</configuration>

参数解释

• <maxRate>：限流速率，在此示例中，每 10 秒最多输出 5 条日志。

• <onMatch> 和 <onMismatch>：用于设置日志是否通过限流过滤器。

4. 实践建议

• 定期清理日志缓存：在自定义过滤器中，ConcurrentHashMap 会存储大量日志的时间戳信息，建议定期清理过期的数据，防止内存泄漏。

• 调整限流频率：根据系统的实际需求合理设置日志的限流频率，避免过度限制导致关键日志被过滤掉。

• 测试性能：在高并发环境下使用限流机制前，建议进行性能测试，确保限流机制不会成为性能瓶颈。

总结

在日志管理中，频繁的重复日志不仅影响系统性能，还增加了日志文件的存储负担。本文介绍了在 Logback 中实现日志限流和去重的几种方法，帮助开发者更高效地管理日志输出。主要方法包括：

1. EvaluatorFilter：通过 Logback 内置的 EvaluatorFilter 实现基于时间的限流控制，适合简单的时间间隔控制。

2. 自定义过滤器：通过自定义 RateLimitFilter 过滤器，利用 ConcurrentHashMap 记录日志的上次输出时间，实现灵活的限流和去重控制，适合复杂的限流逻辑需求。

3. logback-throttle 第三方库：logback-throttle 库提供了更简便的限流配置，直接定义速率限制，适合希望快速实现日志限流的场景。