在日常开发工作中，过于频繁的日志记录会带来以下问题：
• 存储空间的浪费：冗余日志会迅速占用大量磁盘空间，增加运维负担。
• 性能的损耗：频繁的 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 库提供了更简便的限流配置，直接定义速率限制，适合希望快速实现日志限流的场景。
在实际应用中，开发者可以根据系统的日志输出需求和限流要求选择合适的方法。在高并发环境下，限流策略还需经过性能测试以避免性能瓶颈。此外，定期清理日志缓存数据、防止内存泄漏也是保持日志系统健康的关键。
通过合理应用日志限流策略，可以有效降低重复日志的频率，优化系统资源占用，为系统性能和维护效率提供了保障。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
