log4j：防止重复日志消息的标准方法？

Question

我们的生产应用程序在无法建立TCP/IP连接时记录错误。由于它不断地重试连接，它会一遍又一遍记录相同的错误消息。同样，如果一段时间内某些实时资源不可用，应用程序中的其他运行组件可能会进入错误循环。

是否有任何标准方法来控制相同错误记录的次数？ （我们使用的是log4j，所以如果有任何log4j的扩展来处理这个问题，这将是完美的。）

Answer 1

通过记录每次记录错误时的时间戳来控制这一点相当简单，如果一段时间已过，则记录下一次。

理想的情况下，这将是的log4j内的功能，但你的应用程序中的编码是不是太糟糕，你可以一个辅助类内封装，以避免整个代码样板。显然，每个重复的日志语句都需要某种唯一的ID，这样就可以合并来自同一个源的语句。

Answer 2

我刚刚创建了一个Java类，它使用log4j解决了这个确切的问题。当我要记录的消息，我只是做这样的事情：

LogConsolidated.log(logger, Level.WARN, 5000, "File: " + f + " not found.", e); 

相反的：

logger.warn("File: " + f + " not found.", e); 

这使得它记录最多的1次过5秒，并打印了多少次它应该已经记录（例如| x53 |）。很明显，你可以做到这一点，所以你没有太多的参数，或者通过做log.warn或者其他的东西来拉平关卡，但是这对我的用例起作用。

import java.util.HashMap; 

import org.apache.log4j.Level; 
import org.apache.log4j.Logger; 

public class LogConsolidated { 

    private static HashMap<String, TimeAndCount> lastLoggedTime = new HashMap<>(); 

    /** 
    * Logs given <code>message</code> to given <code>logger</code> as long as: 
    * <ul> 
    * <li>A message (from same class and line number) has not already been logged within the past <code>timeBetweenLogs</code>.</li> 
    * <li>The given <code>level</code> is active for given <code>logger</code>.</li> 
    * </ul> 
    * Note: If messages are skipped, they are counted. When <code>timeBetweenLogs</code> has passed, and a repeat message is logged, 
    * the count will be displayed. 
    * @param logger Where to log. 
    * @param level Level to log. 
    * @param timeBetweenLogs Milliseconds to wait between similar log messages. 
    * @param message The actual message to log. 
    * @param t Can be null. Will log stack trace if not null. 
    */ 
    public static void log(Logger logger, Level level, long timeBetweenLogs, String message, Throwable t) { 
     if (logger.isEnabledFor(level)) { 
      String uniqueIdentifier = getFileAndLine(); 
      TimeAndCount lastTimeAndCount = lastLoggedTime.get(uniqueIdentifier); 
      if (lastTimeAndCount != null) { 
       synchronized (lastTimeAndCount) { 
        long now = System.currentTimeMillis(); 
        if (now - lastTimeAndCount.time < timeBetweenLogs) { 
         lastTimeAndCount.count++; 
         return; 
        } else { 
         log(logger, level, "|x" + lastTimeAndCount.count + "| " + message, t); 
        } 
       } 
      } else { 
       log(logger, level, message, t); 
      } 
      lastLoggedTime.put(uniqueIdentifier, new TimeAndCount()); 
     } 
    } 

    private static String getFileAndLine() { 
     StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace(); 
     boolean enteredLogConsolidated = false; 
     for (StackTraceElement ste : stackTrace) { 
      if (ste.getClassName().equals(LogConsolidated.class.getName())) { 
       enteredLogConsolidated = true; 
      } else if (enteredLogConsolidated) { 
       // We have now file/line before entering LogConsolidated. 
       return ste.getFileName() + ":" + ste.getLineNumber(); 
      } 
     } 
     return "?"; 
    }  

    private static void log(Logger logger, Level level, String message, Throwable t) { 
     if (t == null) { 
      logger.log(level, message); 
     } else { 
      logger.log(level, message, t); 
     } 
    } 

    private static class TimeAndCount { 
     long time; 
     int count; 
     TimeAndCount() { 
      this.time = System.currentTimeMillis(); 
      this.count = 0; 
     } 
    } 
}