在 log4j 中仅记录一次相同的异常记录器

Question

I want to implement solution that only logs the exception only once a day. I created a cache manager for that as well.

But I am facing the problem that how to intercept the LOGGER.error and not execute this method again.

In my application there are so many places, this LOGGER.error statement is used and I don't want to touch everywhere to check the condition like if same exception is there in cache or not.

I want the solution like instead of touching everywhere it should done something centrally using filter or intercepting method.

We are using log4j for logging

Answer 1

Filtering log messages is not performed by the logging APIs (like SLF4J or Log4j2 API), but by the logging backends (like Logback or Log4j2 Core).

All backends define some sort of Filter , eg org.apache.logging.log4j.core.Filter for Log4j2 Core. The filter you are trying to implement would look like:

@Plugin(name = "ThrownBurstFilter", category = Node.CATEGORY, elementType = Filter.ELEMENT_TYPE, printObject = true)
public class ThrownBurstFilter extends AbstractFilter {

   private final long                         minInterval;
   private final Map<StackTraceElement, Long> locationTimeouts = new ConcurrentHashMap<>();

   private ThrownBurstFilter(final Result onMatch, final Result onMismatch, final long minInterval) {
      super(onMatch, onMismatch);
      this.minInterval = minInterval;
   }

   @PluginBuilderFactory
   public static Builder newBuilder() {
      return new Builder();
   }

   @Override
   public Result filter(LogEvent event) {
      final Throwable t = event.getThrown();
      if (t != null) {
         final StackTraceElement[] stackTrace = t.getStackTrace();
         final StackTraceElement location = stackTrace != null && stackTrace.length > 0 ? stackTrace[0] : null;
         if (location != null) {
            final long now = System.currentTimeMillis();
            final long nextTimeout = now + minInterval * 1000L;
            final Long timeout = locationTimeouts.putIfAbsent(location, nextTimeout);
            if (timeout == null || timeout <= now) {
               locationTimeouts.put(location, nextTimeout);
               return onMismatch;
            }
            return onMatch;
         }
      }
      return onMismatch;
   }

   public static class Builder extends AbstractFilterBuilder<Builder> implements org.apache.logging.log4j.core.util.Builder<ThrownBurstFilter> {

      /**
       * Minimum interval between events in seconds.
       */
      @PluginBuilderAttribute
      private long minInterval = 3600;

      public Builder setMinInterval(long minInterval) {
         this.minInterval = minInterval;
         return this;
      }

      @Override
      public ThrownBurstFilter build() {
         return new ThrownBurstFilter(getOnMatch(), getOnMismatch(), minInterval);
      }
   }
}

You need to compile it with annotation processors enabled and you can use it in a configuration file like this:

<Loggers>
    <Root level="DEBUG">
        <ThrownBurstFilter minInterval="86400" onMatch="DENY" onMismath="NEUTRAL"/>
    </Root>
</Loggers>