ch.qos.logback.core.filter.Filter Java Examples

private void assertActionProducesLogMessage(final Runnable action, final String loggerName,
                                            final Level logLevel, final String message) throws Exception
{
    final CountDownLatch logMessageReceivedLatch = new CountDownLatch(1);
    ch.qos.logback.classic.Logger rootLogger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
    ListAppender<ILoggingEvent> appender = new ListAppender<>();
    appender.addFilter(new Filter<ILoggingEvent>()
    {
        @Override
        public FilterReply decide(final ILoggingEvent event)
        {
            if (event.getLoggerName().equals(loggerName) && event.getLevel().equals(logLevel) && event.getFormattedMessage().contains(message))
            {
                logMessageReceivedLatch.countDown();
            }
            return FilterReply.NEUTRAL;
        }
    });
    appender.setContext(rootLogger.getLoggerContext());
    appender.start();
    rootLogger.addAppender(appender);

    action.run();
    assertTrue("Did not receive expected log message", logMessageReceivedLatch.await(2, TimeUnit.SECONDS));
}
 

/** Test abstract functions (using console implementation) and the functions of console */
@Test
public void testAbstractAndConsole() {
  BaleenConsoleLoggerBuilder builder =
      new BaleenConsoleLoggerBuilder(
          NAME, BaleenLogging.DEFAULT_PATTERN, new MinMaxFilter(Level.INFO, Level.WARN));

  LoggerContext context = new LoggerContext();
  Encoder<ILoggingEvent> encoder = new PatternLayoutEncoder();

  Appender<ILoggingEvent> appender = builder.build(context, encoder);

  assertEquals(NAME, builder.getName());

  assertTrue(appender instanceof ConsoleAppender);
  assertEquals(encoder, ((ConsoleAppender<ILoggingEvent>) appender).getEncoder());

  assertNotNull(appender);
  assertEquals(NAME, appender.getName());
  Filter<ILoggingEvent> filter = appender.getCopyOfAttachedFiltersList().get(0);
  assertTrue(filter instanceof MinMaxFilter);
  assertEquals(Level.INFO, ((MinMaxFilter) filter).getMin());
  assertEquals(Level.WARN, ((MinMaxFilter) filter).getMax());
}
 

private KafkaAppender getKafkaAppender(LoggerContext context) {
  KafkaAppender kafkaAppender = new KafkaAppender();
  kafkaAppender.setName("KAFKA");
  kafkaAppender.setTopic(Constants.LOG_TOPIC);
  kafkaAppender.setHostname(getHostname());
  // The Kafka ZK Connection shouldn't be null as this method only get called if log collection is enabled
  kafkaAppender.setZookeeper(getTwillRuntimeSpecification().getKafkaZKConnect());
  String runnableName = getRunnableName();
  if (runnableName != null) {
    kafkaAppender.setRunnableName(runnableName);
  }

  kafkaAppender.addFilter(new Filter<ILoggingEvent>() {
    @Override
    public FilterReply decide(ILoggingEvent event) {
      return event.getLoggerName().startsWith("kafka.") ? FilterReply.DENY : FilterReply.ACCEPT;
    }
  });
  kafkaAppender.setContext(context);

  return kafkaAppender;
}
 

public void logToConsole()
{
    Context context = getContext();
    ConsoleAppender<ILoggingEvent> consoleAppender = new ConsoleAppender<>();
    consoleAppender.setContext(context);
    PatternLayoutEncoder patternLayoutEncoder = new PatternLayoutEncoder();
    patternLayoutEncoder.setContext(context);

    // added MDC variable 'qpid.log.prefix' for test purposes
    patternLayoutEncoder.setPattern("%X{qpid.log.prefix}%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n");
    patternLayoutEncoder.start();

    consoleAppender.addFilter(new Filter<ILoggingEvent>()
    {
        @Override
        public FilterReply decide(final ILoggingEvent event)
        {
            return event.getLevel().isGreaterOrEqual(_consoleAppenderAcceptLogLevel) ? FilterReply.ACCEPT : FilterReply.DENY;
        }
    });

    consoleAppender.setEncoder(patternLayoutEncoder);
    consoleAppender.start();
    replayAccumulatedEvents(consoleAppender);
    consoleAppender.stop();
}
 

@NotNull
private Filter<ILoggingEvent> createFilter(final CountDownLatch countDownLatch, final String text) {
    return new Filter<ILoggingEvent>() {
        @Override
        public FilterReply decide(final ILoggingEvent event) {
            if (event.getLevel().equals(Level.DEBUG)) {
                if (event.getFormattedMessage().equals(text)) {
                    countDownLatch.countDown();
                    return FilterReply.NEUTRAL;
                }
            }
            return FilterReply.NEUTRAL;
        }
    };
}
 

@Test
public void testAbstractAndConsoleMultipleFilters() {
  BaleenConsoleLoggerBuilder builder =
      new BaleenConsoleLoggerBuilder(
          NAME,
          BaleenLogging.DEFAULT_PATTERN,
          Arrays.asList(
              new MinMaxFilter(Level.INFO, Level.ERROR),
              new MinMaxFilter(Level.INFO, Level.WARN)));

  LoggerContext context = new LoggerContext();
  Encoder<ILoggingEvent> encoder = new PatternLayoutEncoder();

  Appender<ILoggingEvent> appender = builder.build(context, encoder);

  assertEquals(NAME, builder.getName());

  assertTrue(appender instanceof ConsoleAppender);
  assertEquals(encoder, ((ConsoleAppender<ILoggingEvent>) appender).getEncoder());

  assertNotNull(appender);
  assertEquals(NAME, appender.getName());
  assertEquals(2, appender.getCopyOfAttachedFiltersList().size());
  Filter<ILoggingEvent> filter = appender.getCopyOfAttachedFiltersList().get(0);
  assertTrue(filter instanceof MinMaxFilter);
  assertEquals(Level.INFO, ((MinMaxFilter) filter).getMin());
  assertEquals(Level.ERROR, ((MinMaxFilter) filter).getMax());

  filter = appender.getCopyOfAttachedFiltersList().get(1);
  assertTrue(filter instanceof MinMaxFilter);
  assertEquals(Level.INFO, ((MinMaxFilter) filter).getMin());
  assertEquals(Level.WARN, ((MinMaxFilter) filter).getMax());

  // TODO: Test that both filters are being applied
}
 

@Test
public void testNullFilters() {
  BaleenConsoleLoggerBuilder singleBuilder =
      new BaleenConsoleLoggerBuilder(BaleenLogging.DEFAULT_PATTERN, (Filter<ILoggingEvent>) null);
  List<Filter<ILoggingEvent>> list = null;
  BaleenConsoleLoggerBuilder listBuilder =
      new BaleenConsoleLoggerBuilder(BaleenLogging.DEFAULT_PATTERN, list);

  singleBuilder.build(null, null);
  listBuilder.build(null, null);
}
 

/**
 * Create a new instance of the BaleenFileLoggerBuilder
 *
 * @param name The name of the logger
 * @param pattern The logging pattern, even though it isn't set explicitly by this builder it is
 *     passed to the super() which might set it
 * @param file The file to write to (absolute or relative path)
 * @param filters A list of filters to apply to logging events
 * @param dailyLogFiles Should the log files be rotated each day?
 * @param maxSize What is the max size of file (in kb) before rotating? Defaults to no maximum
 * @param maxNumberLogs The max number of log files to keep. Defaults to 1
 */
public BaleenFileLoggerBuilder(
    String name,
    String pattern,
    String file,
    List<Filter<ILoggingEvent>> filters,
    boolean dailyLogFiles,
    Optional<Integer> maxSize,
    Optional<Integer> maxNumberLogs) {
  super(name, pattern, filters);
  this.file = file;
  this.dailyLogFiles = dailyLogFiles;
  this.maxSize = maxSize;
  this.maxNumberLogs = maxNumberLogs;
}
 

/**
 * Create a new instance of the BaleenFileLoggerBuilder
 *
 * @param name The name of the logger
 * @param pattern The logging pattern, even though it isn't set explicitly by this builder it is
 *     passed to the super() which might set it
 * @param file The file to write to (absolute or relative path)
 * @param filter A filter, for example a MinMaxFilter, to apply to logging events
 * @param dailyLogFiles Should the log files be rotated each day?
 * @param maxSize What is the max size of file (in MB) before rotating? Defaults to no maximum
 * @param maxNumberLogs The max number of log files to keep. Defaults to 1
 */
public BaleenFileLoggerBuilder(
    String name,
    String pattern,
    String file,
    Filter<ILoggingEvent> filter,
    boolean dailyLogFiles,
    Optional<Integer> maxSize,
    Optional<Integer> maxNumberLogs) {
  super(name, pattern, filter);
  this.file = file;
  this.dailyLogFiles = dailyLogFiles;
  this.maxSize = maxSize;
  this.maxNumberLogs = maxNumberLogs;
}
 

private BaleenLoggerBuilder configureLogger(Map<String, Object> config)
    throws InvalidParameterException {
  // Extract the specified configuration parameters
  String name = (String) config.get("name");
  String pattern = (String) config.getOrDefault("pattern", DEFAULT_PATTERN);

  String file = (String) config.get("file");
  Boolean rolling = (Boolean) config.getOrDefault("daily", false);

  Double maxSize = parseToDouble(config.get("size"));
  Integer maxHistory = (Integer) config.get("history");

  List<Filter<ILoggingEvent>> filters = configureFilters(config);

  // Do we have a name, and if so is it a special case (e.g. console)
  if (Strings.isNullOrEmpty(name)) {
    LOGGER.warn("Required parameter 'name' not specified for logger - logger will be skipped");
    return null;
  } else if ("console".equalsIgnoreCase(name)) {
    return new BaleenConsoleLoggerBuilder(name, pattern, filters);
  } else {
    if (Strings.isNullOrEmpty(file)) {
      file = name;
    }

    Optional<Integer> integerMaxSize = Optional.empty();
    if (maxSize != null) {
      integerMaxSize = Optional.of((int) (maxSize * 1024));
    }
    return new BaleenFileLoggerBuilder(
        name, pattern, file, filters, rolling, integerMaxSize, Optional.ofNullable(maxHistory));
  }
}
 

private List<Filter<ILoggingEvent>> configureFilters(Map<String, Object> config)
    throws InvalidParameterException {
  List<Filter<ILoggingEvent>> filters = new ArrayList<>();

  List<String> includeLoggers = yamlToList(config.get("includeLoggers"));
  List<String> excludeLoggers = yamlToList(config.get("excludeLoggers"));

  if (!includeLoggers.isEmpty()) {
    LoggerFilter includeFilter = new LoggerFilter(includeLoggers, false);
    filters.add(includeFilter);
  }

  if (!excludeLoggers.isEmpty()) {
    LoggerFilter excludeFilter = new LoggerFilter(excludeLoggers, true);
    filters.add(excludeFilter);
  }

  String minLevelStr = (String) config.get("minLevel");
  String maxLevelStr = (String) config.get("maxLevel");

  Level minLevel = convertToLevel(minLevelStr);
  Level maxLevel = convertToLevel(maxLevelStr);

  MinMaxFilter levelFilter = new MinMaxFilter(minLevel, maxLevel);
  filters.add(levelFilter);

  return filters;
}
 

private LogBackLogInclusionRule createRule(final FilterReply decision, String name)
{
    LogBackLogInclusionRule rule = mock(LogBackLogInclusionRule.class);
    when(rule.getName()).thenReturn(name);
    Filter filter = mock(Filter.class);
    when(filter.getName()).thenReturn(name);
    when(filter.decide(any(ILoggingEvent.class))).thenReturn(decision);
    when(rule.asFilter()).thenReturn(filter);
    return rule;
}
 

@Test
public void testAsFilter()
{
    VirtualHostNameAndLevelLogInclusionRule<?> rule = createRule("org.apache.qpid", LogLevel.INFO);

    Filter<ILoggingEvent> filter = rule.asFilter();

    final boolean condition = filter instanceof LoggerNameAndLevelFilter;
    assertTrue("Unexpected filter instance", condition);

    LoggerNameAndLevelFilter f = (LoggerNameAndLevelFilter)filter;
    assertEquals("Unexpected log level", Level.INFO, f.getLevel());
    assertEquals("Unexpected logger name", "org.apache.qpid", f.getLoggerName());
}
 

@Test
public void testAsFilter()
{
    BrokerNameAndLevelLogInclusionRule<?> rule = createRule("org.apache.qpid", LogLevel.INFO);

    Filter<ILoggingEvent> filter = rule.asFilter();

    final boolean condition = filter instanceof LoggerNameAndLevelFilter;
    assertTrue("Unexpected filter instance", condition);

    LoggerNameAndLevelFilter f = (LoggerNameAndLevelFilter)filter;
    assertEquals("Unexpected log level", Level.INFO, f.getLevel());
    assertEquals("Unexpected logger name", "org.apache.qpid", f.getLoggerName());
}
 

@NotNull
private Filter<ILoggingEvent> createFilter(final CountDownLatch countDownLatch, final String text) {
    return new Filter<ILoggingEvent>() {
        @Override
        public FilterReply decide(final ILoggingEvent event) {
            if (event.getLevel().equals(Level.TRACE)) {
                if (event.getFormattedMessage().equals(text)) {
                    countDownLatch.countDown();
                    return FilterReply.NEUTRAL;
                }
            }
            return FilterReply.NEUTRAL;
        }
    };
}
 

@Override
public FilterReply decide(ILoggingEvent event)
{
    FilterReply reply = DENY;
    for(Filter<ILoggingEvent> filter : _filterList)
    {
        FilterReply filterReply = filter.decide(event);
        if (filterReply == DENY)
        {
            reply = filterReply;
            break;
        }
        if (filterReply == ACCEPT)
        {
            reply = filterReply;
        }
    }
    if(reply == ACCEPT)
    {
        switch(event.getLevel().toInt())
        {
            case WARN_INT:
                _warnCount.incrementAndGet();
                break;
            case ERROR_INT:
                _errorCount.incrementAndGet();
                break;
            default:
                // do nothing
        }
        return ACCEPT;
    }
    return DENY;
}
 

public void removeLogInclusionRule(LogBackLogInclusionRule logInclusionRule)
{
    Iterator<Filter<ILoggingEvent>> it = _filterList.iterator();
    while(it.hasNext())
    {
        Filter f = it.next();
        if (f.getName().equals(logInclusionRule.getName()))
        {
            _filterList.remove(f);
            break;
        }
    }
}
 

@NotNull
private Filter<ILoggingEvent> createFilter(final CountDownLatch countDownLatch, final String text) {
    return new Filter<ILoggingEvent>() {
        @Override
        public FilterReply decide(final ILoggingEvent event) {
            if (event.getLevel().equals(Level.DEBUG)) {
                if (event.getFormattedMessage().equals(text)) {
                    countDownLatch.countDown();
                    return FilterReply.NEUTRAL;
                }
            }
            return FilterReply.NEUTRAL;
        }
    };
}
 

private void startAndAddFilter(Filter<ILoggingEvent> filter) {
    if (filter != null) {
        if (!filter.isStarted()) {
            filter.start();
        }
        addFilter(filter);
    }
}
 

@Override
protected Filter<ILoggingEvent> createFilter(final String loggerName)
{
    final Filter<ILoggingEvent> filter = super.createFilter(loggerName);
    return new Filter<ILoggingEvent>()
    {
        @Override
        public FilterReply decide(final ILoggingEvent event)
        {
            final FilterReply result = filter.decide(event);
            if (result == FilterReply.ACCEPT)
            {
                if (_predicate.evaluate(event))
                {
                    return FilterReply.ACCEPT;
                }
                else
                {
                    return FilterReply.NEUTRAL;
                }
            }
            else
            {
                return result;
            }
        }
    };
}
 

@Override
public Filter<ILoggingEvent> asFilter()
{
    return this;
}
 

@Override
public List<Filter<E>> getCopyOfAttachedFiltersList() {
	return Collections.emptyList();
}
 

@Override
public void addFilter(Filter<E> newFilter) {
}
 

@Test
public void filterSpotifyAtInfoOthersAtWarn() {
    List<Filter<ILoggingEvent>> filters = new ArrayList<Filter<ILoggingEvent>>();

    LoggerThresholdFilter filter = new LoggerThresholdFilter();
    filter.setLogger(spotifyLog);
    filter.setLevel(INFO);
    filter.start();
    filters.add(filter);

    filter = new LoggerThresholdFilter();
    filter.setExceptLogger(spotifyLog);
    filter.setLevel(WARN);
    filter.start();
    filters.add(filter);

    for(Level level : allLevels) {
        final LoggingEvent evt = new LoggingEvent();
        evt.setLevel(level);

        for(String logger : variousLoggers) {
            evt.setLoggerName(logger);

            FilterReply expected;
            FilterReply actual = FilterReply.NEUTRAL;

            if(spotifyLoggers.contains(logger)) {
                if(level.isGreaterOrEqual(INFO))
                    expected = FilterReply.NEUTRAL;
                else
                    expected = FilterReply.DENY;
            } else {
                if(level.isGreaterOrEqual(WARN))
                    expected = FilterReply.NEUTRAL;
                else
                    expected = FilterReply.DENY;
            }

            for(Filter<ILoggingEvent> logFilter : filters) {
                FilterReply nextReply = logFilter.decide(evt);
                actual = andFilterReplies(actual, nextReply);
            }

            assertEquals(String.format("Logger: %s, Level: %s", logger, level.toString()), expected, actual);
        }
    }
}
 

public LambdaConsoleAppender(String pattern, Filter<ILoggingEvent> filter) {
    this();
    addPattern(pattern);
    startAndAddFilter(filter);
}
 

@SuppressWarnings("unused")
public Filter<ILoggingEvent> asFilter()
{
    return _filter;
}
 

public Filter<ILoggingEvent> asFilter()
{
    return _filter;
}
 

@Override
public List<Filter<ILoggingEvent>> getCopyOfAttachedFiltersList() {
    return null;
}
 

@Override
public void addFilter(Filter<ILoggingEvent> newFilter) {
}
 

public void addLogInclusionRule(LogBackLogInclusionRule logInclusionRule)
{
    Filter<ILoggingEvent> f = logInclusionRule.asFilter();
    f.setName(logInclusionRule.getName());
    _filterList.add(f);
}