Java 类ch.qos.logback.core.Appender 实例源码

@Override
public Level getAppenderThreshold(String appenderName) throws AppenderThresholdNotSupported {
    for (Map.Entry<String, Appender> entry : getAllAppenders().entrySet()) {
        if (entry.getKey().equals(appenderName)) {
            Appender appender = entry.getValue();
            for (Object filter : appender.getCopyOfAttachedFiltersList()) {
                if (filter instanceof ThresholdFilter) {
                    try {
                        Field field = filter.getClass().getDeclaredField("level");
                        field.setAccessible(true);
                        return (Level) field.get(filter);
                    } catch (NoSuchFieldException | IllegalAccessException e) {
                        log.error("Error getting appender " + appenderName + " level", e);
                        throw new AppenderThresholdNotSupported(appenderName);
                    }
                }
            }
        }
    }
    throw new AppenderThresholdNotSupported(appenderName);
}

private Appender<ILoggingEvent> fileAppender(LogbackConfigurator config,
        String logFile) {
    RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<ILoggingEvent>();
    PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    String logPattern = this.patterns.getProperty("file", FILE_LOG_PATTERN);
    encoder.setPattern(OptionHelper.substVars(logPattern, config.getContext()));
    appender.setEncoder(encoder);
    config.start(encoder);

    appender.setFile(logFile);

    FixedWindowRollingPolicy rollingPolicy = new FixedWindowRollingPolicy();
    rollingPolicy.setFileNamePattern(logFile + ".%i");
    appender.setRollingPolicy(rollingPolicy);
    rollingPolicy.setParent(appender);
    config.start(rollingPolicy);

    SizeBasedTriggeringPolicy<ILoggingEvent> triggeringPolicy = new SizeBasedTriggeringPolicy<ILoggingEvent>();
    triggeringPolicy.setMaxFileSize("10MB");
    appender.setTriggeringPolicy(triggeringPolicy);
    config.start(triggeringPolicy);

    config.appender("FILE", appender);
    return appender;
}

private void setMetricsMarkerLogbackFilter(LoggerContext context) {
    log.info("Filtering metrics logs from all appenders except the {} appender", LOGSTASH_APPENDER_NAME);
    OnMarkerEvaluator onMarkerMetricsEvaluator = new OnMarkerEvaluator();
    onMarkerMetricsEvaluator.setContext(context);
    onMarkerMetricsEvaluator.addMarker("metrics");
    onMarkerMetricsEvaluator.start();
    EvaluatorFilter<ILoggingEvent> metricsFilter = new EvaluatorFilter<>();
    metricsFilter.setContext(context);
    metricsFilter.setEvaluator(onMarkerMetricsEvaluator);
    metricsFilter.setOnMatch(FilterReply.DENY);
    metricsFilter.start();

    for (ch.qos.logback.classic.Logger logger : context.getLoggerList()) {
        for (Iterator<Appender<ILoggingEvent>> it = logger.iteratorForAppenders(); it.hasNext();) {
            Appender<ILoggingEvent> appender = it.next();
            if (!appender.getName().equals(ASYNC_LOGSTASH_APPENDER_NAME)) {
                log.debug("Filter metrics logs from the {} appender", appender.getName());
                appender.setContext(context);
                appender.addFilter(metricsFilter);
                appender.start();
            }
        }
    }
}

/**
 * Starts or stops logging to the console.
 *
 * @param start starts or stops logging to the console.
 */
@SuppressWarnings("rawtypes")
public static void logToConsole(boolean start) {
    Logger rootLogger = LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
    if (rootLogger != null && rootLogger instanceof ch.qos.logback.classic.Logger) {
        Appender appender = ((ch.qos.logback.classic.Logger) rootLogger).getAppender(CONSOLE_APPENDER_NAME);

        if (appender != null) {
            if (start) {
                appender.start();
            } else {
                appender.stop();
            }

            return;
        }
    }

    logger.warn("Unable to reconfigure Logback console logger (appender name '" + CONSOLE_APPENDER_NAME + "').");
}

private void setMetricsMarkerLogbackFilter(LoggerContext context) {
    log.info("Filtering metrics logs from all appenders except the {} appender", LOGSTASH_APPENDER_NAME);
    OnMarkerEvaluator onMarkerMetricsEvaluator = new OnMarkerEvaluator();
    onMarkerMetricsEvaluator.setContext(context);
    onMarkerMetricsEvaluator.addMarker("metrics");
    onMarkerMetricsEvaluator.start();
    EvaluatorFilter<ILoggingEvent> metricsFilter = new EvaluatorFilter<>();
    metricsFilter.setContext(context);
    metricsFilter.setEvaluator(onMarkerMetricsEvaluator);
    metricsFilter.setOnMatch(FilterReply.DENY);
    metricsFilter.start();

    for (ch.qos.logback.classic.Logger logger : context.getLoggerList()) {
        for (Iterator<Appender<ILoggingEvent>> it = logger.iteratorForAppenders(); it.hasNext(); ) {
            Appender<ILoggingEvent> appender = it.next();
            if (!appender.getName().equals(ASYNC_LOGSTASH_APPENDER_NAME)) {
                log.debug("Filter metrics logs from the {} appender", appender.getName());
                appender.setContext(context);
                appender.addFilter(metricsFilter);
                appender.start();
            }
        }
    }
}

@Override
public Appender<E> build(final LoggerContext context,
                         final String applicationName,
                         final LayoutFactory<E> layoutFactory,
                         final LevelFilterFactory<E> levelFilterFactory,
                         final AsyncAppenderFactory<E> asyncAppenderFactory) {
    final Appender<E> appender = new FifoLogbackAppender<>();

    appender.setContext(context);

    appender.addFilter(levelFilterFactory.build(threshold));
    getFilterFactories().forEach(f -> appender.addFilter(f.build()));
    appender.start();
    appender.setName(APPENDER_NAME);

    return appender;
}

private void setMetricsMarkerLogbackFilter(LoggerContext context) {
    log.info("Filtering metrics logs from all appenders except the {} appender", LOGSTASH_APPENDER_NAME);
    OnMarkerEvaluator onMarkerMetricsEvaluator = new OnMarkerEvaluator();
    onMarkerMetricsEvaluator.setContext(context);
    onMarkerMetricsEvaluator.addMarker("metrics");
    onMarkerMetricsEvaluator.start();
    EvaluatorFilter<ILoggingEvent> metricsFilter = new EvaluatorFilter<>();
    metricsFilter.setContext(context);
    metricsFilter.setEvaluator(onMarkerMetricsEvaluator);
    metricsFilter.setOnMatch(FilterReply.DENY);
    metricsFilter.start();

    for (ch.qos.logback.classic.Logger logger : context.getLoggerList()) {
        for (Iterator<Appender<ILoggingEvent>> it = logger.iteratorForAppenders(); it.hasNext();) {
            Appender<ILoggingEvent> appender = it.next();
            if (!appender.getName().equals(ASYNC_LOGSTASH_APPENDER_NAME)) {
                log.debug("Filter metrics logs from the {} appender", appender.getName());
                appender.setContext(context);
                appender.addFilter(metricsFilter);
                appender.start();
            }
        }
    }
}

@BeforeClass
@SuppressWarnings("unchecked")
public static void init() {
    loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();

    appender = new CdpAppender();
    appender.setContext(loggerContext);
    appender.start();
    appender.setName(CdpAppender.class.getName());

    Logger logger = loggerContext.getLogger("cdp4j.flow");
    logger.addAppender((Appender<ILoggingEvent>) appender);

    factory = new Launcher().launch();

    session = factory.create();

    session.enableConsoleLog();

    URL url = TestAll.class.getResource("/session-test.html");
    session.navigate(url.toString());
}

@Test
public void shouldSetConsoleAppenderForServiceAndRequestLogs() {
    final String requestLoggerName = "requestlogger";
    SecondBaseLogger.setupLoggingStdoutOnly(KEYS, VALUES, requestLoggerName);
    final ch.qos.logback.classic.Logger rootLogger
            = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(
                    org.slf4j.Logger.ROOT_LOGGER_NAME);
    final Appender<ILoggingEvent> serviceConsoleAppender = rootLogger.getAppender(
            "SERVICECONSOLEAPPENDER");

    assertThat(serviceConsoleAppender, notNullValue());

    final ch.qos.logback.classic.Logger requestLogger
            = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(requestLoggerName);
    final Appender<ILoggingEvent> requestLogConsoleAppender = requestLogger.getAppender(
            "REQUESTLOGCONSOLEAPPENDER");

    assertThat(requestLogConsoleAppender, notNullValue());
}

/**
 * Initialize the logger, in order to display all the log messages in a text
 * logger on the gui.
 */
private void initLogger() {
    LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();

    // find the appender which is an instance of the text area appender and set the text area where it should put the text
    for (ch.qos.logback.classic.Logger logger : context.getLoggerList()) {
        // iterate the appenders in order to find the wanted one
        for (Iterator<Appender<ILoggingEvent>> index = logger.iteratorForAppenders(); index.hasNext();) {
            Appender<ILoggingEvent> appender = index.next();
            // just the TextAreaAppender type is needed to be correctly initialised
            if (appender instanceof TextAreaAppender) {
                ((TextAreaAppender) appender).setTextArea(jTALog, jTAShortLog);
            }
        }
    }
}

@Override
public Appender<ILoggingEvent> build(LoggerContext context, String s, Layout<ILoggingEvent> layout) {
    Preconditions.checkNotNull(context);
    WiretapAppender appender = new WiretapAppender();

    final PatternLayoutEncoder patternEncoder = new PatternLayoutEncoder();
    patternEncoder.setContext(context);
    patternEncoder.setPattern("%-5p [%thread] [%d] %c: %m%n%rEx");
    patternEncoder.start();

    appender.setContext(context);
    appender.setName("wiretap-appender");
    appender.setEncoder(patternEncoder);

    addThresholdFilter(appender, threshold);
    appender.start();

    return wrapAsync(appender);
}

public Appender<ILoggingEvent> build(
    LoggerContext context,
    String applicationName,
    LayoutFactory<ILoggingEvent> layoutFactory,
    LevelFilterFactory<ILoggingEvent> levelFilterFactory,
    AsyncAppenderFactory<ILoggingEvent> asyncAppenderFactory
  ) {

  final LoggingEventCompositeJsonEncoder encoder = new LoggingEventCompositeJsonEncoder();
  encoder.setContext(context);

  encoder.getProviders().addProvider(withPattern("{ \"type\": \"system\" }", new LoggingEventPatternJsonProvider(), context));
  encoder.getProviders().addProvider(withName("timestamp", new LoggingEventFormattedTimestampJsonProvider(), context));
  encoder.getProviders().addProvider(new LogLevelJsonProvider() );
  encoder.getProviders().addProvider(new MessageJsonProvider() );
  encoder.getProviders().addProvider(new StackTraceJsonProvider() );

  encoder.start();

  final ConsoleAppender<ILoggingEvent> appender = new ConsoleAppender<>();
  appender.setContext(context);
  appender.setEncoder(encoder);
  appender.start();

  return wrapAsync(appender, asyncAppenderFactory);
}

private Appender<ILoggingEvent> fileAppender(LogbackConfigurator config,
        String logFile) {
    RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<ILoggingEvent>();
    PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    String logPattern = this.patterns.getProperty("file", FILE_LOG_PATTERN);
    encoder.setPattern(OptionHelper.substVars(logPattern, config.getContext()));
    appender.setEncoder(encoder);
    config.start(encoder);

    appender.setFile(logFile);

    FixedWindowRollingPolicy rollingPolicy = new FixedWindowRollingPolicy();
    rollingPolicy.setFileNamePattern(logFile + ".%i");
    appender.setRollingPolicy(rollingPolicy);
    rollingPolicy.setParent(appender);
    config.start(rollingPolicy);

    SizeBasedTriggeringPolicy<ILoggingEvent> triggeringPolicy = new SizeBasedTriggeringPolicy<ILoggingEvent>();
    triggeringPolicy.setMaxFileSize("10MB");
    appender.setTriggeringPolicy(triggeringPolicy);
    config.start(triggeringPolicy);

    config.appender("FILE", appender);
    return appender;
}

public static void startLogback() {
    long startTime = System.nanoTime();
    Config config = Configs.DEFAULT.logging();
    LogbackConfig logbackConfig = getLogbackConfig(config);
    LogbackManager logbackMgr = LogbackManager.INSTANCE;
    RollingFileAppender<ILoggingEvent> fileAppender = logbackMgr.createRollingFileAppender(logbackConfig);
    ConsoleAppender<ILoggingEvent> consoleAppender = logbackMgr
            .createConsoleAppender(APPENDER_CONSOLE, config.getString(KEY_LOG_PATTERN_CONSOLE));
    List<Appender<ILoggingEvent>> appenderList = new ArrayList<>();
    appenderList.add(consoleAppender);
    appenderList.add(fileAppender);
    logbackMgr.getAppenders().addAll(appenderList);
    LoggerContext context = logbackMgr.getLoggerContext();
    initRootLogger(context, consoleAppender, config);
    addLoggers(config, appenderList);
    addAsyncAppender(config, fileAppender);
    context.start();
    context.getLogger(LogbackInitializer.class).info(INIT_MSG, elapsedMillis(startTime));
}

/**
 * Initializes the logger and the requested log level.
 *
 * @param level Logging level threshold
 */
@SuppressWarnings("unchecked")
public static void configure(final Level level) {
    final Logger root = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
    root.setLevel(level);

    PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    encoder.setContext(root.getLoggerContext());
    encoder.setPattern("%msg%n");
    encoder.start();

    Iterator<Appender<ILoggingEvent>> iterator = root.iteratorForAppenders();

    while (iterator.hasNext()) {
        Appender<ILoggingEvent> appender = iterator.next();
        if (appender instanceof OutputStreamAppender) {
            ((OutputStreamAppender) appender).setEncoder(encoder);
        }
        appender.stop();
        appender.start();
    }
}

private Appender<ILoggingEvent> configureAppender(LoggerContext loggerContext, String name, Config config)
        throws ReflectiveOperationException {
    List<Object> children = new ArrayList<>();

    @SuppressWarnings("unchecked")
    Class<Appender<ILoggingEvent>> clazz = (Class<Appender<ILoggingEvent>>) Class
            .forName(config.getString("class"));

    Appender<ILoggingEvent> appender = this.configureObject(loggerContext, clazz, config, children);
    appender.setName(name);

    for (Object child : children) {
        if (child instanceof RollingPolicy) {
            ((RollingPolicy) child).setParent((FileAppender<?>) appender);
        }
        if (child instanceof LifeCycle) {
            ((LifeCycle) child).start();
        }
    }

    appender.start();
    return appender;

}

private void setMetricsMarkerLogbackFilter(LoggerContext context) {
    log.info("Filtering metrics logs from all appenders except the {} appender", LOGSTASH_APPENDER_NAME);
    OnMarkerEvaluator onMarkerMetricsEvaluator = new OnMarkerEvaluator();
    onMarkerMetricsEvaluator.setContext(context);
    onMarkerMetricsEvaluator.addMarker("metrics");
    onMarkerMetricsEvaluator.start();
    EvaluatorFilter<ILoggingEvent> metricsFilter = new EvaluatorFilter<>();
    metricsFilter.setContext(context);
    metricsFilter.setEvaluator(onMarkerMetricsEvaluator);
    metricsFilter.setOnMatch(FilterReply.DENY);
    metricsFilter.start();

    for (ch.qos.logback.classic.Logger logger : context.getLoggerList()) {
        for (Iterator<Appender<ILoggingEvent>> it = logger.iteratorForAppenders(); it.hasNext(); ) {
            Appender<ILoggingEvent> appender = it.next();
            if (!appender.getName().equals(ASYNC_LOGSTASH_APPENDER_NAME)) {
                log.debug("Filter metrics logs from the {} appender", appender.getName());
                appender.setContext(context);
                appender.addFilter(metricsFilter);
                appender.start();
            }
        }
    }
}

private void setMetricsMarkerLogbackFilter(LoggerContext context) {
    log.info("Filtering metrics logs from all appenders except the {} appender", LOGSTASH_APPENDER_NAME);
    OnMarkerEvaluator onMarkerMetricsEvaluator = new OnMarkerEvaluator();
    onMarkerMetricsEvaluator.setContext(context);
    onMarkerMetricsEvaluator.addMarker("metrics");
    onMarkerMetricsEvaluator.start();
    EvaluatorFilter<ILoggingEvent> metricsFilter = new EvaluatorFilter<>();
    metricsFilter.setContext(context);
    metricsFilter.setEvaluator(onMarkerMetricsEvaluator);
    metricsFilter.setOnMatch(FilterReply.DENY);
    metricsFilter.start();

    for (ch.qos.logback.classic.Logger logger : context.getLoggerList()) {
        for (Iterator<Appender<ILoggingEvent>> it = logger.iteratorForAppenders(); it.hasNext(); ) {
            Appender<ILoggingEvent> appender = it.next();
            if (!appender.getName().equals(ASYNC_LOGSTASH_APPENDER_NAME)) {
                log.debug("Filter metrics logs from the {} appender", appender.getName());
                appender.setContext(context);
                appender.addFilter(metricsFilter);
                appender.start();
            }
        }
    }
}

protected Appender buildDailyMaxRollingAppender(String name, String fileName, String pattern, int maxBackupIndex) {
    RollingFileAppender appender = new RollingFileAppender();
    appender.setContext(loggerContext);
    appender.setName(name);
    appender.setAppend(true);
    appender.setFile(new File(getLogPath(), fileName).getAbsolutePath());

    TimeBasedRollingPolicy rolling = new TimeBasedRollingPolicy();
    rolling.setContext(loggerContext);
    rolling.setFileNamePattern(new File(getLogPath(), fileName).getAbsolutePath() + ".%d{yyyy-MM-dd-HH}");
    rolling.setMaxHistory(maxBackupIndex);
    rolling.setParent(appender);
    rolling.start();
    appender.setRollingPolicy(rolling);

    PatternLayoutEncoder layout = new PatternLayoutEncoder();
    layout.setContext(loggerContext);
    layout.setPattern(pattern);
    layout.setCharset(Charset.forName(getEncoding()));
    layout.start();
    appender.setEncoder(layout);
    // 启动
    appender.start();
    return appender;
}

@org.junit.Test
public void testAppender() {
    ch.qos.logback.classic.Logger root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME);
    Appender mockAppender = mock(Appender.class);
    root.addAppender(mockAppender);
    Appender<ILoggingEvent> appender = root.getAppender("SNMP");
    LOG.info("server error", new RuntimeException("info message"));
    LOG.error("server error", new RuntimeException("error message"));

    verify(mockAppender,times(2)).doAppend(argThat(new ArgumentMatcher<ILoggingEvent>() {
        @Override
        public boolean matches(final Object argument) {
            return ((LoggingEvent) argument).getFormattedMessage().contains("server error");
        }
    }));
    Assert.assertThat(appender.getClass().getName(), is(equalTo("com.sathwik.logback.appender.SNMPTrapAppender")));


}

@Test
public void getFeatureState_should_return_null_when_name_not_found_exception_is_wrapped() throws Exception{
     final Appender<ILoggingEvent> mockAppender = TestLogUtils.addMockAppenderLog();

     // Given
     doReturn(context).when(repository).getInitialContext();
     // stub expected behavior of lookup method
     NamingException exception = new NamingException("jndi exception");
     exception.initCause(new NameNotFoundException("invalid name"));
     doThrow(exception).when(context).lookup(anyString());

     // When
     FeatureState feature = repository.getFeatureState(MyFeature.FEATURE1);

     // Then
     assertThat(feature).isNull();
}

public void initRule() {
    Appender dbTabAppender = buildAppender("TDDL_Vtab_Appender", "tddl-db-tab.log", "%m");
    Appender vSlotAppender = buildAppender("TDDL_Vtab_Appender", "tddl-vslot.log", "%m");
    Appender dynamicRuleAppender = buildAppender("TDDL_DynamicRule_Appender", "tddl-dynamic-rule.log", "%m");

    ch.qos.logback.classic.Logger logger = (Logger) LoggerInit.TDDL_LOG.getDelegate();
    logger.setAdditive(false);
    logger.detachAndStopAllAppenders();
    logger.addAppender(dbTabAppender);
    logger.setLevel(Level.INFO);

    logger = (Logger) LoggerInit.VSLOT_LOG.getDelegate();
    logger.setAdditive(false);
    logger.detachAndStopAllAppenders();
    logger.addAppender(vSlotAppender);
    logger.setLevel(Level.INFO);

    logger = (Logger) LoggerInit.DYNAMIC_RULE_LOG.getDelegate();
    logger.setAdditive(false);
    logger.detachAndStopAllAppenders();
    logger.addAppender(dynamicRuleAppender);
    logger.setLevel(Level.INFO);
}

@Override
protected void append(E event) {
  if (!isStarted()) {
    return;
  }
  String discriminatingValue = discriminator.getDiscriminatingValue(event);
  long timestamp = getTimestamp(event);

  Appender<E> appender = appenderTracker.getOrCreate(discriminatingValue, timestamp);
  // marks the appender for removal as specified by the user
  if (eventMarksEndOfLife(event)) {
    appenderTracker.endOfLife(discriminatingValue);
  }
  appenderTracker.removeStaleComponents(timestamp);
  appender.doAppend(event);
}

@SuppressWarnings("unchecked")
@Test(timeout = 5000)
public void getAppenderBoom() {
  Appender<Integer> mockAppender1 = mock(Appender.class);

  when(mockAppender1.getName()).thenThrow(new OutOfMemoryError("oops"));
  aai.addAppender(mockAppender1);
  try {
    // appender.getName called as a result of next statement
    aai.getAppender("foo");
  } catch (OutOfMemoryError e) {
    // this leaves the read lock locked.
  }

  Appender<Integer> mockAppender2=mock(Appender.class);
  // the next call used to freeze with the earlier ReadWriteLock lock
  // implementation
  aai.addAppender(mockAppender2);
}

@SuppressWarnings("unchecked")
@Test(timeout = 5000)
public void detachAppenderBoom() throws InterruptedException {
  Appender<Integer> mockAppender = mock(Appender.class);
  when(mockAppender.getName()).thenThrow(new OutOfMemoryError("oops"));
  mockAppender.doAppend(17);

  aai.addAppender(mockAppender);
  Thread t = new Thread(new Runnable() {

    public void run() {
      try {
        // appender.getName called as a result of next statement
        aai.detachAppender("foo");
      } catch (OutOfMemoryError e) {
        // this leaves the write lock locked.
      }
    }
  });
  t.start();
  t.join();

  // the next call used to freeze with the earlier ReadWriteLock lock
  // implementation
  aai.appendLoopOnAppenders(17);
}

@Test
public void getGetAppender() throws Exception {
  NOPAppender<TestEvent> test = new NOPAppender<TestEvent>();
  test.setName("test");
  test.start();
  aai.addAppender(test);

  NOPAppender<TestEvent> testOther = new NOPAppender<TestEvent>();
  testOther.setName("testOther");
  testOther.start();
  aai.addAppender(testOther);

  Appender<TestEvent> a = aai.getAppender("testOther");
  assertNotNull("Could not find appender", a);
  assertTrue("Wrong appender", a == testOther);

  a = aai.getAppender("test");
  assertNotNull("Could not find appender", a);
  assertTrue("Wrong appender", a == test);
  a = aai.getAppender("NotThere");
  assertNull("Appender was returned", a);
}

@Test
public void sessionFinalizationShouldCauseLingering() throws JoranException {
  String mdcKey = "linger";
  String mdcVal = "session" + diff;
  configure(SIFT_FOLDER_PREFIX + "lingering.xml");
  MDC.put(mdcKey, mdcVal);
  logger.debug("linger 1");
  logger.debug(ClassicConstants.FINALIZE_SESSION_MARKER, "linger 2");
  long now = System.currentTimeMillis();
  SiftingAppender sa = (SiftingAppender) root.getAppender("SIFT");
  AppenderTracker<ILoggingEvent> tracker = sa.getAppenderTracker();

  assertEquals(1, tracker.allKeys().size());
  Appender<ILoggingEvent> appender = tracker.find(mdcVal);
  assertTrue(appender.isStarted());

  tracker.removeStaleComponents(now + AppenderTracker.LINGERING_TIMEOUT + 1);
  // previously lingering appenders should be closed upon timeout
  assertFalse(appender.isStarted());
  // and they should be gone
  assertEquals(0, tracker.allKeys().size());
}

@BeforeClass
public void setUp() throws JoranException {
    URL logConfigResource = getClass().getResource("/org/artifactory/traffic/logback.xml");
    File logConfigFile = new File(logConfigResource.getFile());
    Assert.assertNotNull(logConfigFile, "Cannot locate logback configuration file.");
    Assert.assertTrue(logConfigFile.exists(), "Cannot locate logback configuration file.");

    LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
    JoranConfigurator configurator = new JoranConfigurator();
    configurator.setContext(lc);
    lc.stop();
    configurator.doConfigure(logConfigFile);
    Logger logger = lc.getLogger(TrafficLogger.class);
    Appender<ILoggingEvent> appender = logger.getAppender("TRAFFIC");

    System.out.println(appender);
}

protected Appender buildAppender(String name, String fileName, String pattern) {
    RollingFileAppender appender = new RollingFileAppender();
    appender.setContext(loggerContext);
    appender.setName(name);
    appender.setAppend(true);
    appender.setFile(new File(getLogPath(), fileName).getAbsolutePath());

    TimeBasedRollingPolicy rolling = new TimeBasedRollingPolicy();
    rolling.setContext(loggerContext);
    rolling.setParent(appender);
    rolling.setFileNamePattern(new File(getLogPath(), fileName).getAbsolutePath() + ".%d{yyyy-MM-dd}");
    rolling.start();
    appender.setRollingPolicy(rolling);

    PatternLayoutEncoder layout = new PatternLayoutEncoder();
    layout.setContext(loggerContext);
    layout.setPattern(pattern);
    layout.setCharset(Charset.forName(getEncoding()));
    layout.start();
    appender.setEncoder(layout);
    // 启动
    appender.start();
    return appender;
}

private Appender buildDailyMaxRollingAppender(String name, String fileName, String pattern, int maxBackupIndex) {
    RollingFileAppender appender = new RollingFileAppender();
    appender.setName(name);
    appender.setAppend(true);
    appender.setFile(new File(getLogPath(), fileName).getAbsolutePath());

    TimeBasedRollingPolicy rolling = new TimeBasedRollingPolicy();
    rolling.setFileNamePattern(new File(getLogPath(), fileName).getAbsolutePath() + ".%d{yyyy-MM-dd-HH}");
    rolling.setMaxHistory(maxBackupIndex);
    rolling.setParent(appender);
    appender.setRollingPolicy(rolling);

    PatternLayoutEncoder layout = new PatternLayoutEncoder();
    layout.setPattern(pattern);
    layout.setCharset(Charset.forName(getEncoding()));
    appender.setEncoder(layout);
    // 启动
    appender.start();
    return appender;
}

public void doTest(String configFile) throws JoranException {
  JoranConfigurator configurator = new JoranConfigurator();
  configurator.setContext(context);
  configurator.doConfigure(configFile);

  Appender<IAccessEvent> appender = context.getAppender("DB");

  for (int i = 0; i < 10; i++) {
    IAccessEvent event = DummyAccessEventBuilder.buildNewAccessEvent();
    appender.doAppend(event);
  }

  StatusPrinter.print(context);

  // check that there were no errors
  assertEquals(Status.INFO,  statusChecker.getHighestLevel(0));

}

private Appender<ILoggingEvent> fileAppender(LogbackConfigurator config,
        String logFile) {
    RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<ILoggingEvent>();
    PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    String logPattern = this.patterns.getProperty("file", FILE_LOG_PATTERN);
    encoder.setPattern(OptionHelper.substVars(logPattern, config.getContext()));
    appender.setEncoder(encoder);
    config.start(encoder);

    appender.setFile(logFile);

    FixedWindowRollingPolicy rollingPolicy = new FixedWindowRollingPolicy();
    rollingPolicy.setFileNamePattern(logFile + ".%i");
    appender.setRollingPolicy(rollingPolicy);
    rollingPolicy.setParent(appender);
    config.start(rollingPolicy);

    SizeBasedTriggeringPolicy<ILoggingEvent> triggeringPolicy = new SizeBasedTriggeringPolicy<ILoggingEvent>();
    triggeringPolicy.setMaxFileSize("10MB");
    appender.setTriggeringPolicy(triggeringPolicy);
    config.start(triggeringPolicy);

    config.appender("FILE", appender);
    return appender;
}

@Override
public void setVerboseMode(boolean on) {
    PatternLayoutEncoder patternLayoutEncoder = new PatternLayoutEncoder();
    patternLayoutEncoder.setPattern("[%d{HH:mm:ss.SSS}] [%highlight(%level)] %msg%n");
    patternLayoutEncoder.setContext(loggerContext);
    patternLayoutEncoder.start();

    Appender<ILoggingEvent> consoleAppender = new ConsoleAppender();
    ((OutputStreamAppender) consoleAppender).setEncoder(patternLayoutEncoder);
    consoleAppender.setContext(loggerContext);
    consoleAppender.start();

    loggerContext.getLogger("com.paypal.butterfly.cli").detachAppender("CONSOLE");
    loggerContext.getLogger("ROOT").addAppender(consoleAppender);
}

@Override
public void addAppender(Appender<ILoggingEvent> appender) {
    if (emergencyAppender == null) {
        emergencyAppender = appender;
    } else {
        addWarn("One and only one appender may be attached to " + getClass().getSimpleName());
        addWarn("Ignoring additional appender named [" + appender.getName() + "]");
    }
}

@Override
public Appender<ILoggingEvent> getAppender(String name) {
    if (emergencyAppender != null && name != null && name.equals(emergencyAppender.getName())) {
        return emergencyAppender;
    } else {
        return null;
    }
}

@Override
public boolean detachAppender(Appender<ILoggingEvent> appender) {
    if (emergencyAppender == appender) {
        emergencyAppender = null;
        return true;
    } else {
        return false;
    }
}

/**
 * Allow only selected logger to print DEBUG events to STDOUT and FILE.
 * Other loggers are allowed to print ERRORS only.
 */
private static void addSampleLogger(final String loggerName) {
    if (CUSTOM_FILTER == null) {
        CUSTOM_FILTER = new CustomFilter();
        final LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();

        Appender ca = loggerContext.getLogger("ROOT").getAppender("STDOUT");
        ca.clearAllFilters();
        ca.addFilter(CUSTOM_FILTER);
    }
    CUSTOM_FILTER.addVisibleLogger(loggerName);
}

private static void verifyLog(
        final Appender mockAppender,
        final ArgumentCaptor<LoggingEvent> captorLoggingEvent,
        final String expectedMessage) {
    verify(mockAppender, times(1)).doAppend(captorLoggingEvent.capture());
    final LoggingEvent loggingEvent = captorLoggingEvent.getValue();
    assertThat(loggingEvent.getLevel(), is(Level.INFO));

    assertThat(loggingEvent.getFormattedMessage(), is(expectedMessage));
}

private static void verifyLog(
        final Appender mockAppender,
        final ArgumentCaptor<LoggingEvent> captorLoggingEvent,
        final int expectedNumOfInvocations,
        final String expectedLogMessage) {
    verify(mockAppender, times(expectedNumOfInvocations)).doAppend(captorLoggingEvent.capture());
    final LoggingEvent loggingEvent = captorLoggingEvent.getValue();
    assertThat(loggingEvent.getLevel(), is(Level.INFO));
    assertThat(loggingEvent.getFormattedMessage(), is(expectedLogMessage));
}

private static Path getLogFromLogback( final File logbackConfig )
{
    try
    {
        LoggerContext loggerContext = new LoggerContext();
        JoranConfigurator jc = new JoranConfigurator();
        jc.setContext( loggerContext );
        loggerContext.reset();
        jc.doConfigure( logbackConfig );

        for ( Logger logger : loggerContext.getLoggerList() )
        {
            for ( Iterator<Appender<ILoggingEvent>> index = logger.iteratorForAppenders(); index.hasNext(); )
            {
                Appender<ILoggingEvent> appender = index.next();
                if ( appender instanceof FileAppender )
                {
                    return Paths.get( ( (FileAppender) appender ).getFile() );
                }
            }
        }
        return null;
    }
    catch ( Exception e )
    {
        return null;
    }
}