Java 类ch.qos.logback.core.filter.Filter 实例源码

/**
 * 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 void startAndAddFilter(Filter<ILoggingEvent> filter) {
    if (filter != null) {
        if (!filter.isStarted()) {
            filter.start();
        }
        addFilter(filter);
    }
}

/**
 * Loop through the filters in the list. As soon as a filter decides on
 * ACCEPT or DENY, then that value is returned. If all of the filters return
 * NEUTRAL, then NEUTRAL is returned.
 */
public FilterReply getFilterChainDecision(E event) {
  for (Filter<E> f : filterList) {
    final FilterReply r = f.decide(event);
    if (r == FilterReply.DENY || r == FilterReply.ACCEPT) {
      return r;
    }
  }
  return FilterReply.NEUTRAL;
}

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 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));
    }
}

@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);
}

@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
}

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

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

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

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

public void addFilter(Filter<E> newFilter) {
  fai.addFilter(newFilter);
}

public List<Filter<E>> getCopyOfAttachedFiltersList() {
  return fai.getCopyOfAttachedFiltersList();
}

/**
 * Add a filter to end of the filter list.
 */
public void addFilter(Filter<E> newFilter) {
  filterList.add(newFilter);
}

public List<Filter<E>> getCopyOfAttachedFiltersList() {
  return new ArrayList<Filter<E>>(filterList);
}

public void addFilter(Filter<E> newFilter) {
  fai.addFilter(newFilter);
}

public List<Filter<E>> getCopyOfAttachedFiltersList() {
  return fai.getCopyOfAttachedFiltersList();
}

@Override
public void addFilter(Filter<IAccessEvent> newFilter) {
  fai.addFilter(newFilter);
}

@Override
public List<Filter<IAccessEvent>> getCopyOfAttachedFiltersList() {
  return fai.getCopyOfAttachedFiltersList();
}

@Override
public void addFilter(Filter<IAccessEvent> newFilter) {
  fai.addFilter(newFilter);
}

@Override
public List<Filter<IAccessEvent>> getCopyOfAttachedFiltersList() {
  return fai.getCopyOfAttachedFiltersList();
}

@Override
public void addFilter(Filter<IAccessEvent> newFilter) {
  fai.addFilter(newFilter);
}

@Override
public List<Filter<IAccessEvent>> getCopyOfAttachedFiltersList() {
  return fai.getCopyOfAttachedFiltersList();
}

/**
 * Creates an {@link OutputStreamAppender} for the required filter, pattern and logger output.
 *
 * @param context Logger context to associate the appender with.
 * @param filter Event log filter.
 * @param logOutput Logger output information for the destination to write logger events to.
 * @param patternProperty Logger context property that defines the pattern for formatting logger event output.
 * @param name The name of the appender.
 * @return An {@link OutputStreamAppender} for the required parameters.
 */
private static OutputStreamAppender<ILoggingEvent> createAppender(LoggerContext context, Filter<ILoggingEvent> filter, LoggerOutput logOutput, String patternProperty, String name) {
  final PatternLayoutEncoder patternLayoutEncoder = createPatternLayoutEncoder(context, patternProperty);
  final OutputStreamAppender<ILoggingEvent> appender;
  if (logOutput.isConsole()) {
    appender = new OutputStreamAppender<>();
    appender.setContext(context);
    appender.setEncoder(patternLayoutEncoder);
    appender.setOutputStream(logOutput.getPrintStream());
    appender.setName(name);
    appender.addFilter(filter);
    appender.start();
  } else {
    RollingFileAppender<ILoggingEvent> rAppender = new RollingFileAppender<>();
    rAppender.setContext(context);
    rAppender.setEncoder(patternLayoutEncoder);
    rAppender.setFile(logOutput.getOutputName()+"."+logOutput.getOutputType());
    rAppender.setName(name);
    rAppender.addFilter(filter);

    final FixedWindowRollingPolicy rollingPolicy = new FixedWindowRollingPolicy();
    rollingPolicy.setContext(context);
    rollingPolicy.setParent(rAppender);
    rollingPolicy.setFileNamePattern(logOutput.getOutputName()+"%i"+"."+logOutput.getOutputType());
    rollingPolicy.setMinIndex(1);
    rollingPolicy.setMaxIndex(logOutput.getFileCount());
    rollingPolicy.start();

    final SizeBasedTriggeringPolicy<ILoggingEvent> triggeringPolicy = new SizeBasedTriggeringPolicy<>();
    triggeringPolicy.setContext(context);
    triggeringPolicy.setMaxFileSize(logOutput.getFileLimit());
    triggeringPolicy.start();

    rAppender.setRollingPolicy(rollingPolicy);
    rAppender.setTriggeringPolicy(triggeringPolicy);
    rAppender.start();

    appender = rAppender;
  }
  return appender;
}

private AttachLogFilter(Filter<ILoggingEvent> filter, String configKey) {
    this.filter = filter;
    this.configKey = configKey;
}

public static AttachLogFilter attach(Filter<ILoggingEvent> filter, String configKey) {
    return new AttachLogFilter(filter, configKey);
}

@Override
public void addFilter(Filter<ILoggingEvent> arg0) {
  // TODO Auto-generated method stub

}

@Override
public List<Filter<ILoggingEvent>> getCopyOfAttachedFiltersList() {
  // TODO Auto-generated method stub
  return null;
}

public static void configureStdOutLogging( String loglevel ) {

        if (!(LoggerFactory.getILoggerFactory() instanceof LoggerContext)) {
            System.err.println("Logger is not using logback, skipping logging configuration");
            return;
        }

        try {
            LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
            lc.reset();
            Logger rootLogger = getRootLogger( loglevel );
            PatternLayoutEncoder ple = getPatternLayoutEncoder( lc );

            // ops would like us to log to console unless an app
            // has a specific need not to
            ConsoleAppender<ILoggingEvent> stdOutAppender = new ConsoleAppender<ILoggingEvent>();
            stdOutAppender.setContext( lc );
            stdOutAppender.setName( "stdlib-console-out" );
            stdOutAppender.setTarget( "System.out" );
            stdOutAppender.setEncoder( ple );

            Filter<ILoggingEvent> stdOutFilter = new StdOutFilter();
            stdOutAppender.addFilter( stdOutFilter );
            stdOutFilter.start();
            stdOutAppender.start();

            ple = getPatternLayoutEncoder( lc );

            ConsoleAppender<ILoggingEvent> errorAppender = new ConsoleAppender<ILoggingEvent>();
            errorAppender.setContext( lc );
            errorAppender.setName( "stdlib-console-err" );
            errorAppender.setTarget( "System.err" );
            errorAppender.setEncoder( ple );

            Filter<ILoggingEvent> stdErrFilter = new ErrOutFilter();
            errorAppender.addFilter( stdErrFilter );
            stdErrFilter.start();
            errorAppender.start();

            // Wrap the console appenders in an async appenders
            AsyncAppender asyncStdOutWrapper = new AsyncAppender();
            asyncStdOutWrapper.setContext( lc );
            asyncStdOutWrapper.setDiscardingThreshold( 0 );
            asyncStdOutWrapper.setQueueSize( 500 );
            asyncStdOutWrapper.addAppender( stdOutAppender );
            asyncStdOutWrapper.setName( "stdlib-async-out" );
            asyncStdOutWrapper.start();

            // Wrap the console appenders in an async appenders
            AsyncAppender asyncStdErrWrapper = new AsyncAppender();
            asyncStdErrWrapper.setContext( lc );
            asyncStdErrWrapper.setDiscardingThreshold( 0 );
            asyncStdErrWrapper.setQueueSize( 500 );
            asyncStdErrWrapper.addAppender( errorAppender ); 
            asyncStdErrWrapper.setName( "stdlib-async-err-2" );
            asyncStdErrWrapper.start();

            // Add the appenders to root logger
            rootLogger.addAppender( asyncStdOutWrapper );
            rootLogger.addAppender( asyncStdErrWrapper );

        } catch ( Exception e ) {
            System.err.println( "Failed to add appender!!" );
            e.printStackTrace();
        }

        // wrap stdout & stderr in log4j appenders 
        StdOutErrLog.tieSystemOutAndErrToLog();

    }

protected AbstractAwsEncodingStringAppender(AwsSupport awsSupport, Filter<E> sdkLoggingFilter) {
    this.awsSupport = awsSupport;
    this.sdkLoggingFilter = sdkLoggingFilter;
    addFilter(sdkLoggingFilter);
}

protected SqsAppender(AwsSupport awsSupport, Filter<E> sdkLoggingFilter) {
    super(awsSupport, sdkLoggingFilter);
}

protected DynamoDbAppender(AwsSupport awsSupport, Filter<ILoggingEvent> sdkLoggingFilter) {
    super(awsSupport, sdkLoggingFilter);
    setMaxPayloadSize(DEFAULT_MAX_PAYLOAD_SIZE);
}

protected CloudWatchAppender(AwsSupport awsSupport, Filter<ILoggingEvent> sdkLoggingFilter) {
    super(awsSupport, sdkLoggingFilter);
}

protected AbstractCloudWatchAppender(AwsSupport awsSupport, Filter<E> sdkLoggingFilter) {
    super(awsSupport, sdkLoggingFilter);
}

protected CloudWatchAccessAppender(AwsSupport awsSupport, Filter<IAccessEvent> sdkLoggingFilter) {
    super(awsSupport, sdkLoggingFilter);
}

protected SnsAppender(AwsSupport awsSupport, Filter<E> sdkLoggingFilter) {
    super(awsSupport, sdkLoggingFilter);
}

private void addDroppingRavenLoggingFilter(Appender<ILoggingEvent> appender) {
  final Filter<ILoggingEvent> filter = new DroppingRavenLoggingFilter();
  filter.start();
  appender.addFilter(filter);
}

@Override
public void addFilter(final Filter<ILoggingEvent> filter) {
    throw new UnsupportedOperationException("Not implemented");
}

@Override
public List<Filter<ILoggingEvent>> getCopyOfAttachedFiltersList() {
    throw new UnsupportedOperationException("Not implemented");
}

public void addFilter(Filter<ILoggingEvent> filter) {
    this.ca.addFilter(filter);
}