org.apache.log4j.spi.Filter Java Examples

@Override
public Filter parseFilter(Element filterElement, XmlConfiguration config) {
    final Holder<Boolean> acceptOnMatch = new BooleanHolder();
    final Holder<String> text = new Holder<>();
    forEachElement(filterElement.getElementsByTagName("param"), (currentElement) -> {
        if (currentElement.getTagName().equals("param")) {
            switch (currentElement.getAttribute(NAME_ATTR)) {
                case STRING_TO_MATCH:
                    text.set(currentElement.getAttribute(VALUE_ATTR));
                    break;
                case ACCEPT_ON_MATCH:
                    acceptOnMatch.set(Boolean.parseBoolean(currentElement.getAttribute(VALUE_ATTR)));
                    break;

            }
        }
    });
    return createFilter(text.get(), acceptOnMatch.get());
}
 

/**
    Returns {@link Filter#NEUTRAL} is there is no string match.
  */
 public
 int decide(LoggingEvent event) {
   String msg = event.getRenderedMessage();

   if(msg == null ||  stringToMatch == null)
     return Filter.NEUTRAL;
   

   if( msg.indexOf(stringToMatch) == -1 ) {
     return Filter.NEUTRAL;
   } else { // we've got a match
     if(acceptOnMatch) {
return Filter.ACCEPT;
     } else {
return Filter.DENY;
     }
   }
 }
 

private Filter createFilter(String levelMax, String levelMin, boolean acceptOnMatch) {
    Level max = Level.FATAL;
    Level min = Level.TRACE;
    if (levelMax != null) {
        max = Level.toLevel(levelMax, Level.FATAL);
    }
    if (levelMin != null) {
        min = Level.toLevel(levelMin, Level.DEBUG);
    }
    org.apache.logging.log4j.core.Filter.Result onMatch = acceptOnMatch
            ? org.apache.logging.log4j.core.Filter.Result.ACCEPT
            : org.apache.logging.log4j.core.Filter.Result.NEUTRAL;

    return new FilterWrapper(LevelRangeFilter.createFilter(min, max, onMatch,
            org.apache.logging.log4j.core.Filter.Result.DENY));
}
 

@Override
public Result filter(LogEvent event) {
    LoggingEvent loggingEvent = new LogEventAdapter(event);
    Filter next = filter;
    while (next != null) {
        switch (filter.decide(loggingEvent)) {
            case Filter.ACCEPT:
                return Result.ACCEPT;
            case Filter.DENY:
                return Result.DENY;
            default:
        }
        next = filter.getNext();
    }
    return Result.NEUTRAL;
}
 

/**
   Return the decision of this filter.

   Returns {@link Filter#NEUTRAL} if the <b>LevelToMatch</b> option
   is not set or if there is not match.  Otherwise, if there is a
   match, then the returned decision is {@link Filter#ACCEPT} if the
   <b>AcceptOnMatch</b> property is set to <code>true</code>. The
   returned decision is {@link Filter#DENY} if the
   <b>AcceptOnMatch</b> property is set to false.

*/
public
int decide(LoggingEvent event) {
  if(this.levelToMatch == null) {
    return Filter.NEUTRAL;
  }
  
  boolean matchOccured = false;
  if(this.levelToMatch.equals(event.getLevel())) {
    matchOccured = true;
  } 

  if(matchOccured) {  
    if(this.acceptOnMatch)
 return Filter.ACCEPT;
    else
 return Filter.DENY;
  } else {
    return Filter.NEUTRAL;
  }
}
 

/**
  * This method performs threshold checks and invokes filters before
  * delegating actual logging to the subclasses specific {@link
  * AppenderSkeleton#append} method.
  * */
public
synchronized 
void doAppend(LoggingEvent event) {
  if(closed) {
    LogLog.error("Attempted to append to closed appender named ["+name+"].");
    return;
  }
  
  if(!isAsSevereAsThreshold(event.getLevel())) {
    return;
  }

  Filter f = this.headFilter;
  
  FILTER_LOOP:
  while(f != null) {
    switch(f.decide(event)) {
    case Filter.DENY: return;
    case Filter.ACCEPT: break FILTER_LOOP;
    case Filter.NEUTRAL: f = f.getNext();
    }
  }
  
  this.append(event);    
}
 

@Override
public Filter parseFilter(Element filterElement, XmlConfiguration config) {
    final Holder<String> level = new Holder<>();
    final Holder<Boolean> acceptOnMatch = new BooleanHolder();
    forEachElement(filterElement.getElementsByTagName("param"), (currentElement) -> {
        if (currentElement.getTagName().equals("param")) {
            switch (currentElement.getAttribute(NAME_ATTR)) {
                case LEVEL:
                    level.set(currentElement.getAttribute(VALUE_ATTR));
                    break;
                case ACCEPT_ON_MATCH:
                    acceptOnMatch.set(Boolean.parseBoolean(currentElement.getAttribute(VALUE_ATTR)));
                    break;
            }
        }
    });
    return createFilter(level.get(), acceptOnMatch.get());
}
 

/**
 * Used internally to parse a filter element.
 * @param filterElement The Filter Element.
 * @return The Filter.
 */
public Filter parseFilters(Element filterElement) {
    String className = subst(filterElement.getAttribute(CLASS_ATTR));
    LOGGER.debug("Class name: [" + className + ']');
    Filter filter = manager.parseFilter(className, filterElement, this);
    if (filter == null) {
        PropertySetter propSetter = new PropertySetter(filter);
        forEachElement(filterElement.getChildNodes(), (currentElement) -> {
            String tagName = currentElement.getTagName();
            if (tagName.equals(PARAM_TAG)) {
                setParameter(currentElement, propSetter);
            } else {
                quietParseUnrecognizedElement(filter, currentElement, props);
            }
        });
        propSetter.activate();
    }
    return filter;
}
 

private static void removeFilter(final Appender appender, final Filter filter) {
  Filter _filter = appender.getFilter();
  boolean _equals = Objects.equal(_filter, filter);
  if (_equals) {
    appender.clearFilters();
    appender.addFilter(filter.getNext());
  } else {
    for (Filter current = appender.getFilter(); (current != null); current = current.getNext()) {
      Filter _next = current.getNext();
      boolean _equals_1 = Objects.equal(_next, filter);
      if (_equals_1) {
        current.setNext(filter.getNext());
        return;
      }
    }
  }
}
 

@Override
public Appender parseAppender(final String name, final String appenderPrefix, final String layoutPrefix,
        final String filterPrefix, final Properties props, final PropertiesConfiguration configuration) {
    String appenderRef = getProperty(APPENDER_REF_TAG);
    Filter filter = configuration.parseAppenderFilters(props, filterPrefix, name);
    String policyPrefix = appenderPrefix + ".rewritePolicy";
    String className = getProperty(policyPrefix);
    RewritePolicy policy = configuration.getBuilderManager().parseRewritePolicy(className, policyPrefix,
            props, configuration);
    String level = getProperty(THRESHOLD_PARAM);
    if (appenderRef == null) {
        LOGGER.warn("No appender references configured for AsyncAppender {}", name);
        return null;
    }
    Appender appender = configuration.parseAppender(props, appenderRef);
    if (appender == null) {
        LOGGER.warn("Cannot locate Appender {}", appenderRef);
        return null;
    }
    return createAppender(name, level, new String[] {appenderRef}, policy, filter, configuration);
}
 

private <T extends Log4j1Configuration> Appender createAppender(String name, Layout layout, Filter filter,
        String level, String target, T configuration) {
    org.apache.logging.log4j.core.Layout<?> consoleLayout = null;

    if (layout instanceof LayoutWrapper) {
        consoleLayout = ((LayoutWrapper) layout).getLayout();
    } else if (layout != null) {
        consoleLayout = new LayoutAdapter(layout);
    }
    org.apache.logging.log4j.core.Filter consoleFilter = buildFilters(level, filter);
    ConsoleAppender.Target consoleTarget = SYSTEM_ERR.equals(target)
            ? ConsoleAppender.Target.SYSTEM_ERR : ConsoleAppender.Target.SYSTEM_OUT;
    return new AppenderWrapper(ConsoleAppender.newBuilder()
            .setName(name)
            .setTarget(consoleTarget)
            .setLayout(consoleLayout)
            .setFilter(consoleFilter)
            .setConfiguration(configuration)
            .build());
}
 

/**
 * 覆写doAppend, 去掉closed的log日志
 * @param event
 */
@Override
public synchronized void doAppend(LoggingEvent event) {
    if (closed) {
        return;
    }

    if (!isAsSevereAsThreshold(event.getLevel())) {
        return;
    }

    Filter f = this.headFilter;

    FILTER_LOOP:
    while(f != null) {
        switch(f.decide(event)) {
            case Filter.DENY: return;
            case Filter.ACCEPT: break FILTER_LOOP;
            case Filter.NEUTRAL: f = f.getNext();
        }
    }

    this.append(event);
}
 

private static void removeFilter(final Appender appender, final Filter filter) {
  Filter _filter = appender.getFilter();
  boolean _equals = Objects.equal(_filter, filter);
  if (_equals) {
    appender.clearFilters();
    appender.addFilter(filter.getNext());
  } else {
    for (Filter current = appender.getFilter(); (current != null); current = current.getNext()) {
      Filter _next = current.getNext();
      boolean _equals_1 = Objects.equal(_next, filter);
      if (_equals_1) {
        current.setNext(filter.getNext());
        return;
      }
    }
  }
}
 

@Test
public void addFilter() {
  Appender appender = getAppender();
  Filter filter = mock( Filter.class );
  appender.addFilter( filter );
  assertThat( appender.getFilter(), is( filter ) );
}
 

/**
   Return the decision of this filter.
 */
public
int decide(LoggingEvent event) {
  if(this.levelMin != null) {
    if (event.getLevel().isGreaterOrEqual(levelMin) == false) {
      // level of event is less than minimum
      return Filter.DENY;
    }
  }

  if(this.levelMax != null) {
    if (event.getLevel().toInt() > levelMax.toInt()) {
      // level of event is greater than maximum
      // Alas, there is no Level.isGreater method. and using
      // a combo of isGreaterOrEqual && !Equal seems worse than
      // checking the int values of the level objects..
      return Filter.DENY;
    }
  }

  if (acceptOnMatch) {
    // this filter set up to bypass later filters and always return
    // accept if level in range
    return Filter.ACCEPT;
  }
  else {
    // event is ok for this filter; allow later filters to have a look..
    return Filter.NEUTRAL;
  }
}
 

private Filter createFilter(String text, boolean acceptOnMatch) {
    if (text == null) {
        LOGGER.warn("No text provided for StringMatchFilter");
        return null;
    }
    org.apache.logging.log4j.core.Filter.Result onMatch = acceptOnMatch
            ? org.apache.logging.log4j.core.Filter.Result.ACCEPT
            : org.apache.logging.log4j.core.Filter.Result.DENY;
    return new FilterWrapper(StringMatchFilter.newBuilder()
            .setMatchString(text)
            .setOnMatch(onMatch)
            .setOnMismatch(org.apache.logging.log4j.core.Filter.Result.NEUTRAL)
            .build());
}
 

@Override
public int decide (LoggingEvent e) {
	Level	l = e.getLevel ();

	if ((l == Level.DEBUG) || (l == Level.INFO) || (l == Level.WARN) || (l == Level.ERROR) || (l == Level.FATAL)) {
		return Filter.ACCEPT;
	}
	return Filter.NEUTRAL;
}
 

public Filter parseFilter(String className, Element filterElement, XmlConfigurationFactory factory) {
    PluginType<?> plugin = plugins.get(className.toLowerCase());
    if (plugin != null) {
        try {
            @SuppressWarnings("unchecked")
            FilterBuilder builder = (FilterBuilder) LoaderUtil.newInstanceOf(plugin.getPluginClass());
            return builder.parseFilter(filterElement, factory);
        } catch (InstantiationException | IllegalAccessException | InvocationTargetException ex) {
            LOGGER.warn("Unable to load plugin: {} due to: {}", plugin.getKey(), ex.getMessage());
        }
    }
    return null;
}
 

@Override
public int decide(final LoggingEvent event) {
  int _xifexpression = (int) 0;
  String _loggerName = event.getLoggerName();
  String _name = this.source.getName();
  boolean _equals = Objects.equal(_loggerName, _name);
  if (_equals) {
    _xifexpression = Filter.DENY;
  } else {
    _xifexpression = Filter.NEUTRAL;
  }
  return _xifexpression;
}
 

@Override
public Appender parseAppender(final String name, final String appenderPrefix, final String layoutPrefix,
        final String filterPrefix, final Properties props, final PropertiesConfiguration configuration) {
    Layout layout = configuration.parseLayout(layoutPrefix, name, props);
    Filter filter = configuration.parseAppenderFilters(props, filterPrefix, name);
    String fileName = getProperty(FILE_PARAM);
    String level = getProperty(THRESHOLD_PARAM);
    boolean append = getBooleanProperty(APPEND_PARAM);
    boolean immediateFlush = false;
    boolean bufferedIo = getBooleanProperty(BUFFERED_IO_PARAM);
    int bufferSize = Integer.parseInt(getProperty(BUFFER_SIZE_PARAM, "8192"));
    return createAppender(name, layout, filter, fileName, append, immediateFlush,
            level, bufferedIo, bufferSize, configuration);
}
 

@Override
public Filter parseFilter(Element filterElement, XmlConfigurationFactory factory) {
    final Holder<Boolean> acceptOnMatch = new BooleanHolder();
    final Holder<String> text = new Holder<>();
    forEachElement(filterElement.getElementsByTagName("param"), (currentElement) -> {
        if (currentElement.getTagName().equals("param")) {
            switch (currentElement.getAttribute(NAME_ATTR).toLowerCase()) {
                case STRING_TO_MATCH:
                    text.set(currentElement.getAttribute(VALUE_ATTR));
                    break;
                case ACCEPT_ON_MATCH:
                    acceptOnMatch.set(Boolean.parseBoolean(currentElement.getAttribute(VALUE_ATTR)));
                    break;

            }
        }
    });
    if (text.get() == null) {
        LOGGER.warn("No text provided for StringMatchFilter");
        return null;
    }
    org.apache.logging.log4j.core.Filter.Result onMatch = acceptOnMatch.get() != null && acceptOnMatch.get()
            ? org.apache.logging.log4j.core.Filter.Result.ACCEPT
            : org.apache.logging.log4j.core.Filter.Result.DENY;
    return new FilterWrapper(StringMatchFilter.newBuilder()
            .setMatchString(text.get())
            .setOnMatch(onMatch)
            .setOnMismatch(org.apache.logging.log4j.core.Filter.Result.NEUTRAL)
            .build());
}
 

@Test
public void testShardSyncerMessage() throws ClassNotFoundException {
    Logger log = Logger.getRootLogger();
    Appender a = log.getAppender("CONSOLE");
    Filter f = a.getFilter();
    assertEquals(null, f.getNext());
    assertEquals(StringMatchFilter.class, f.getClass());
    assertEquals(Filter.NEUTRAL, a.getFilter().decide(new LoggingEvent(Logger.class.toString(), log, Level.ERROR, "TestMessage", null)));
    assertEquals(Filter.DENY, a.getFilter().decide(new LoggingEvent(Logger.class.toString(), log, Level.ERROR, SHARD_SYNC_MESSAGE, null)));
    assertEquals(Filter.DENY,
        a.getFilter().decide(new LoggingEvent(Logger.class.toString(), log, Level.ERROR, "Shard shard-1234-5432-1234 " + SHARD_SYNC_MESSAGE, null)));
}
 

@Override
public int decide(LoggingEvent event) {
	Object oRunId = event.getMDC(LogUtils.MDC_RUNID_KEY);
	if (!(oRunId instanceof Long))
		return Filter.DENY;
	Long rId = (Long)oRunId;
	if (this.runId != rId.longValue())
		return Filter.DENY;
	else {
		if (event.getLevel().isGreaterOrEqual(logLevel))
			return Filter.ACCEPT;
		else
			return Filter.DENY;
	}
}
 

@Override
public Filter parseFilter(PropertiesConfiguration config) {
    String levelMax = getProperty(LEVEL_MAX);
    String levelMin = getProperty(LEVEL_MIN);
    boolean acceptOnMatch = getBooleanProperty(ACCEPT_ON_MATCH);
    return createFilter(levelMax, levelMin, acceptOnMatch);
}
 

@Override
public Appender parseAppender(final String name, final String appenderPrefix, final String layoutPrefix,
        final String filterPrefix, final Properties props, final PropertiesConfiguration configuration) {
    Layout layout = configuration.parseLayout(layoutPrefix, name, props);
    Filter filter = configuration.parseAppenderFilters(props, filterPrefix, name);
    String level = getProperty(THRESHOLD_PARAM);
    String fileName = getProperty(FILE_PARAM);
    boolean append = getBooleanProperty(APPEND_PARAM);
    boolean immediateFlush = false;
    boolean bufferedIo = getBooleanProperty(BUFFERED_IO_PARAM);
    int bufferSize = Integer.parseInt(getProperty(BUFFER_SIZE_PARAM, "8192"));
    return createAppender(name, configuration, layout, filter, fileName, level, immediateFlush,
            append, bufferedIo, bufferSize);
}
 

private Appender createAppender(final String name, final Log4j1Configuration configuration, final Layout layout,
        final Filter filter, final String fileName, String level, boolean immediateFlush, final boolean append,
        final boolean bufferedIo, final int bufferSize) {
    org.apache.logging.log4j.core.Layout<?> fileLayout = null;
    if (bufferedIo) {
        immediateFlush = true;
    }
    if (layout instanceof LayoutWrapper) {
        fileLayout = ((LayoutWrapper) layout).getLayout();
    } else if (layout != null) {
        fileLayout = new LayoutAdapter(layout);
    }
    org.apache.logging.log4j.core.Filter fileFilter = buildFilters(level, filter);
    if (fileName == null) {
        LOGGER.warn("Unable to create File Appender, no file name provided");
        return null;
    }
    return new AppenderWrapper(FileAppender.newBuilder()
            .setName(name)
            .setConfiguration(configuration)
            .setLayout(fileLayout)
            .setFilter(fileFilter)
            .setFileName(fileName)
            .setImmediateFlush(immediateFlush)
            .setAppend(append)
            .setBufferedIo(bufferedIo)
            .setBufferSize(bufferSize)
            .build());
}
 

@Override
public Filter parseFilter(Element filterElement, XmlConfigurationFactory factory) {
    final Holder<String> levelMax = new Holder<>();
    final Holder<String> levelMin = new Holder<>();
    final Holder<Boolean> acceptOnMatch = new BooleanHolder();
    forEachElement(filterElement.getElementsByTagName("param"), (currentElement) -> {
        if (currentElement.getTagName().equals("param")) {
            switch (currentElement.getAttribute(NAME_ATTR).toLowerCase()) {
                case LEVEL_MAX:
                    levelMax.set(currentElement.getAttribute(VALUE_ATTR));
                    break;
                case LEVEL_MIN:
                    levelMax.set(currentElement.getAttribute(VALUE_ATTR));
                    break;
                case ACCEPT_ON_MATCH:
                    acceptOnMatch.set(Boolean.parseBoolean(currentElement.getAttribute(VALUE_ATTR)));
                    break;
            }
        }
    });
    Level max = Level.FATAL;
    Level min = Level.TRACE;
    if (levelMax.get() != null) {
        max = Level.toLevel(levelMax.get(), Level.FATAL);
    }
    if (levelMin.get() != null) {
        min = Level.toLevel(levelMin.get(), Level.DEBUG);
    }
    org.apache.logging.log4j.core.Filter.Result onMatch = acceptOnMatch.get() != null && acceptOnMatch.get()
            ? org.apache.logging.log4j.core.Filter.Result.ACCEPT
            : org.apache.logging.log4j.core.Filter.Result.NEUTRAL;

    return new FilterWrapper(LevelRangeFilter.createFilter(min, max, onMatch,
            org.apache.logging.log4j.core.Filter.Result.DENY));
}
 

@Override
public void addFilter(Filter newFilter) {
    if (appender instanceof AbstractFilterable) {
        if (newFilter instanceof FilterWrapper) {
            ((AbstractFilterable) appender).addFilter(((FilterWrapper) newFilter).getFilter());
        } else {
            ((AbstractFilterable) appender).addFilter(new FilterAdapter(newFilter));
        }
    } else {
        LOGGER.warn("Unable to add filter to appender {}, it does not support filters", appender.getName());
    }
}
 

@Override
public Appender parseAppender(final String name, final String appenderPrefix, final String layoutPrefix,
        final String filterPrefix, final Properties props, final PropertiesConfiguration configuration) {
    Layout layout = configuration.parseLayout(layoutPrefix, name, props);
    Filter filter = configuration.parseAppenderFilters(props, filterPrefix, name);
    String fileName = getProperty(FILE_PARAM);
    String level = getProperty(THRESHOLD_PARAM);
    boolean immediateFlush = false;
    boolean bufferedIo = getBooleanProperty(BUFFERED_IO_PARAM);
    String maxSize = getProperty(MAX_SIZE_PARAM);
    String maxBackups = getProperty(MAX_BACKUP_INDEX);
    return createAppender(name, configuration, layout, filter, bufferedIo, immediateFlush, fileName, level, maxSize,
            maxBackups);
}
 

private Filter buildFilter(String className, String appenderName, List<NameValue> props) {
    Filter filter = newInstanceOf(className, "Filter");
    if (filter != null) {
        PropertySetter propSetter = new PropertySetter(filter);
        for (NameValue property : props) {
            propSetter.setProperty(property.key, property.value);
        }
        propSetter.activate();
    }
    return filter;
}