Java Examples for ch.qos.logback.core.Appender

@Test
public void smoke() throws JoranException {
    configure(SIFT_FOLDER_PREFIX + "smoke.xml");
    logger.debug("smoke");
    Appender<ILoggingEvent> appender = getAppenderTracker().find("smokeDefault");
    assertNotNull(appender);
    ListAppender<ILoggingEvent> listAppender = (ListAppender<ILoggingEvent>) appender;
    List<ILoggingEvent> eventList = listAppender.list;
    assertEquals(1, listAppender.list.size());
    assertEquals("smoke", eventList.get(0).getMessage());
}

@Test
public void smoke() throws JoranException {
    configure(SIFT_FOLDER_PREFIX + "smoke.xml");
    logger.debug("smoke");
    Appender<ILoggingEvent> appender = getAppenderTracker().find("smokeDefault");
    assertNotNull(appender);
    ListAppender<ILoggingEvent> listAppender = (ListAppender<ILoggingEvent>) appender;
    List<ILoggingEvent> eventList = listAppender.list;
    assertEquals(1, listAppender.list.size());
    assertEquals("smoke", eventList.get(0).getMessage());
}

@Test
public void testLog() {
    LOG.info("test");
    ch.qos.logback.classic.Logger rootLogger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger("ROOT");
    Appender<ILoggingEvent> appender = rootLogger.getAppender("eventSenderAppender");
    EventSenderSlf4jAppender eventAppender = (EventSenderSlf4jAppender) appender;
    EventSender<LoggingEventExt> eventSender = eventAppender.getTargetEventSender();
    InMemoryEventSender<LoggingEventExt> inMemoryEventSender = (InMemoryEventSender<LoggingEventExt>) eventSender;
    Assert.assertNotNull(inMemoryEventSender);
}

@Override
public void start() {
    if (getPath() == null) {
        addError("Appender " + getName() + " has configuration errors and is not started!");
    } else {
        try {
            this.writer = createWriter();
            this.started = true;
        } catch (IOException e) {
            this.writer = null;
            addError("Appender " + getName() + " " + e.getMessage());
        }
    }
}

private void tryConfigCLogging() throws Exception {
    String appId = Foundation.app().getAppId();
    if (Strings.isNullOrEmpty(appId)) {
        logger.warn("App id is null or empty!");
        return;
    }
    LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
    Class clazz = Class.forName(cLoggingAppenderClass);
    Appender cLoggingAppender = (Appender) clazz.newInstance();
    ReflectionUtils.findMethod(clazz, "setAppId", String.class).invoke(cLoggingAppender, appId);
    ReflectionUtils.findMethod(clazz, "setServerIp", String.class).invoke(cLoggingAppender, cloggingUrl());
    ReflectionUtils.findMethod(clazz, "setServerPort", int.class).invoke(cLoggingAppender, Integer.parseInt(cloggingPort()));
    cLoggingAppender.setName("CentralLogging");
    cLoggingAppender.setContext(loggerContext);
    cLoggingAppender.start();
    ch.qos.logback.classic.Logger logger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger("root");
    logger.addAppender(cLoggingAppender);
}

public Optional<String> findLoggingFileLocation() {
    final Optional<String> fileLocation;
    if (LOGGER instanceof ch.qos.logback.classic.Logger) {
        final ch.qos.logback.classic.Logger logbackLogger = (ch.qos.logback.classic.Logger) LOGGER;
        final Appender<ILoggingEvent> appender = logbackLogger.getAppender("UPLOAD_REPORTER");
        if (appender != null && appender instanceof FileAppender) {
            final FileAppender fileAppender = (FileAppender) appender;
            fileLocation = Optional.of(fileAppender.getFile());
        } else {
            fileLocation = Optional.empty();
        }
    } else {
        fileLocation = Optional.empty();
    }
    return fileLocation;
}

public static void forceFlush() {
    ILoggerFactory loggerFactory = LoggerFactory.getILoggerFactory();
    if (loggerFactory instanceof LoggerContext) {
        Appender<ILoggingEvent> appender = ((LoggerContext) loggerFactory).getLogger(Logger.ROOT_LOGGER_NAME).getAppender("KAFKA");
        if (appender != null && appender instanceof KafkaAppender) {
            ((KafkaAppender) appender).forceFlush();
        }
    }
}

@Override
public Appender<ILoggingEvent> build(LoggerContext context, String applicationName, LayoutFactory<ILoggingEvent> layoutFactory, LevelFilterFactory<ILoggingEvent> levelFilterFactory, AsyncAppenderFactory<ILoggingEvent> asyncAppenderFactory) {
    if (!enabled) {
        final Appender<ILoggingEvent> appender = new NOPAppender<>();
        appender.start();
        return appender;
    }
    final GelfLogbackAppender appender = new GelfLogbackAppender();
    appender.setContext(context);
    appender.setName("dropwizard-gelf");
    appender.setFacility(facility.orElse(applicationName));
    appender.setGraylogHost(host);
    appender.setGraylogPort(port);
    appender.setVersion(GelfMessage.GELF_VERSION_1_1);
    appender.setAdditionalFields(buildFieldsSpec(additionalFields));
    appender.setAdditionalFieldTypes(buildFieldsSpec(additionalFieldTypes));
    appender.setMdcFields(buildMdcFieldsSpec(mdcFields));
    appender.setDynamicMdcFields(buildMdcFieldsSpec(dynamicMdcFields));
    appender.setIncludeFullMdc(includeFullMDC);
    appender.setMdcProfiling(mdcProfiling);
    appender.setExtractStackTrace(Boolean.toString(extractStackTrace));
    appender.setFilterStackTrace(filterStackTrace);
    appender.setMaximumMessageSize(maximumMessageSize);
    appender.setTimestampPattern(timestampPattern);
    if (originHost.isPresent()) {
        appender.setOriginHost(originHost.get());
    }
    appender.addFilter(levelFilterFactory.build(threshold));
    getFilterFactories().stream().forEach( f -> appender.addFilter(f.build()));
    appender.start();
    return wrapAsync(appender, asyncAppenderFactory);
}

@Override
public Appender<ILoggingEvent> build(LoggerContext context, String applicationName, LayoutFactory<ILoggingEvent> layoutFactory, LevelFilterFactory<ILoggingEvent> levelFilterFactory, AsyncAppenderFactory<ILoggingEvent> asyncAppenderFactory) {
    if (!enabled) {
        final Appender<ILoggingEvent> appender = new NOPAppender<>();
        appender.start();
        return appender;
    }
    final GelfLogbackAppender appender = new GelfLogbackAppender();
    appender.setContext(context);
    appender.setName("dropwizard-gelf");
    appender.setFacility(facility.orElse(applicationName));
    appender.setGraylogHost(host);
    appender.setGraylogPort(port);
    appender.setVersion(GelfMessage.GELF_VERSION_1_1);
    appender.setAdditionalFields(buildFieldsSpec(additionalFields));
    appender.setAdditionalFieldTypes(buildFieldsSpec(additionalFieldTypes));
    appender.setMdcFields(buildMdcFieldsSpec(mdcFields));
    appender.setDynamicMdcFields(buildMdcFieldsSpec(dynamicMdcFields));
    appender.setIncludeFullMdc(includeFullMDC);
    appender.setMdcProfiling(mdcProfiling);
    appender.setExtractStackTrace(Boolean.toString(extractStackTrace));
    appender.setFilterStackTrace(filterStackTrace);
    appender.setMaximumMessageSize(maximumMessageSize);
    appender.setTimestampPattern(timestampPattern);
    if (originHost.isPresent()) {
        appender.setOriginHost(originHost.get());
    }
    appender.addFilter(levelFilterFactory.build(threshold));
    getFilterFactories().stream().forEach( f -> appender.addFilter(f.build()));
    appender.start();
    return wrapAsync(appender, asyncAppenderFactory);
}

@Test
public void appenderContextIsSet() throws Exception {
    final Logger root = (Logger) LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
    final FileAppenderFactory<ILoggingEvent> appenderFactory = new FileAppenderFactory<>();
    appenderFactory.setArchivedLogFilenamePattern(folder.newFile("example-%d.log.gz").toString());
    final Appender<ILoggingEvent> appender = appenderFactory.build(root.getLoggerContext(), "test", new DropwizardLayoutFactory(), new NullLevelFilterFactory<>(), new AsyncLoggingEventAppenderFactory());
    assertThat(appender.getContext()).isEqualTo(root.getLoggerContext());
}

@Test
public void getFeatureState_should_log_a_warn_when_feature_is_not_defined_in_jndi() throws Exception {
    final Appender<ILoggingEvent> mockAppender = addMockAppenderLog();
    // Given
    doThrow(new NameNotFoundException("jndi test error")).when(context).lookup(anyString());
    // When
    FeatureState feature = repository.getFeatureState(MyFeature.FEATURE1);
    // Then
    verify(mockAppender).doAppend(logEventMatches(Level.WARN, "FEATURE1"));
}

public void configure() {
    //detach current appenders;
    getCleanRoot();
    hijackJDKLogging();
    final Logger root = configureLevels();
    for (Appender<ILoggingEvent> appender : LogbackFactory.buildAppenders(config.getServerLogConfiguration(), root.getLoggerContext())) {
        root.addAppender(AsyncAppender.wrap(appender));
    }
    final MBeanServer server = ManagementFactory.getPlatformMBeanServer();
    try {
        final ObjectName objectName = new ObjectName("grails.plugin.lightweightdeploy:type=Logging");
        if (!server.isRegistered(objectName)) {
            server.registerMBean(new JMXConfigurator(root.getLoggerContext(), server, objectName), objectName);
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

/** {@inheritDoc} */
@SuppressWarnings("rawtypes")
public Message execute() {
    //$NON-NLS-1$
    log.info("sending server log");
    ServerLogResponseMessage response = new ServerLogResponseMessage();
    // Get location of log file
    Iterator<Appender<ILoggingEvent>> appenders = new ArrayList<Appender<ILoggingEvent>>().iterator();
    FileAppender fileAppender = null;
    Logger logger = LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
    if (logger instanceof ch.qos.logback.classic.Logger) {
        appenders = ((ch.qos.logback.classic.Logger) logger).iteratorForAppenders();
    }
    while (appenders.hasNext() && fileAppender == null) {
        Object enumElement = appenders.next();
        if (enumElement instanceof FileAppender) {
            fileAppender = (FileAppender) enumElement;
        }
    }
    if (fileAppender != null) {
        final File clientLogFile = new File(fileAppender.getFile());
        BufferedReader reader = null;
        // Send log
        try {
            reader = new BufferedReader(new FileReader(clientLogFile));
            StringBuffer sb = new StringBuffer();
            String line = null;
            while ((line = reader.readLine()) != null) {
                //$NON-NLS-1$
                sb.append(line + "\n");
            }
            response.setServerLog(sb.toString());
        } catch (FileNotFoundException e) {
            response.setStatus(ServerLogResponseMessage.FILE_NOT_FOUND);
        } catch (IOException ioe) {
            response.setStatus(ServerLogResponseMessage.IO_EXCEPTION);
        } catch (SecurityException e) {
            response.setStatus(ServerLogResponseMessage.CONFIG_ERROR);
        } catch (IllegalArgumentException e) {
            response.setStatus(ServerLogResponseMessage.CONFIG_ERROR);
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    log.error(e.getLocalizedMessage());
                }
            }
        }
    } else {
        // No file logger found, set error status
        response.setStatus(ServerLogResponseMessage.FILE_NOT_ENABLED);
    }
    return response;
}

@Test
public void shouldMessure() {
    // given
    Logger logger = (Logger) LoggerFactory.getLogger(StopWatch.DEFAULT_LOGGER_NAME);
    @SuppressWarnings("unchecked") final Appender<ILoggingEvent> mockAppender = Mockito.mock(Appender.class);
    Mockito.when(mockAppender.getName()).thenReturn("MOCK");
    logger.addAppender(mockAppender);
    // when
    profiledMethod();
    // then
    Mockito.verify(mockAppender).doAppend(Mockito.argThat(new ArgumentMatcher<ILoggingEvent>() {

        @Override
        public boolean matches(Object argument) {
            String message = ((ILoggingEvent) argument).getFormattedMessage();
            int startIndex = message.indexOf("time[");
            if (startIndex == -1) {
                return false;
            }
            int endIndex = message.indexOf(']', startIndex);
            if (endIndex == -1) {
                return false;
            }
            int time = Integer.parseInt(message.substring(startIndex + "time[".length(), endIndex));
            return time >= 100;
        }
    }));
}

public void addAppender(Appender<ILoggingEvent> newAppender) {
    if (appenderCount == 0) {
        appenderCount++;
        addInfo("Attaching appender named [" + newAppender.getName() + "] to appender [" + getName() + "].");
        aai.addAppender(newAppender);
    } else {
        addWarn("One and only one appender may be attached to CassandraAppender name=[" + getName() + "].");
        addWarn("Ignoring additional appender named [" + newAppender.getName() + "]");
    }
}

public Appender<ILoggingEvent> getDefaultAppender() {
    OutputStreamAppender<ILoggingEvent> appender = new ConsoleAppender<ILoggingEvent>();
    appender.setName(DEFAULT_CONSOLE_APPENDER_NAME);
    appender.setContext(loggerContext);
    PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    encoder.setPattern(LOG_PATTERN_DEFAULT);
    encoder.setContext(loggerContext);
    encoder.start();
    appender.setEncoder(encoder);
    appender.start();
    return appender;
}

public void apply(LogbackConfigurator config) {
    synchronized (config.getConfigurationLock()) {
        base(config);
        Appender<ILoggingEvent> consoleAppender = consoleAppender(config);
        if (this.logFile != null) {
            Appender<ILoggingEvent> fileAppender = fileAppender(config, this.logFile.toString());
            config.root(Level.INFO, consoleAppender, fileAppender);
        } else {
            config.root(Level.INFO, consoleAppender);
        }
    }
}

protected void configureLogging(T configuration) {
    // set logging level and file programmatically if defined
    if (configuration.getLogging() != null) {
        ch.qos.logback.classic.Logger rootLogger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
        Appender<ILoggingEvent> appender = rootLogger.getAppender("FILE");
        if (appender != null) {
            rootLogger.detachAppender(appender);
            rootLogger.setLevel(configuration.getLogging().getLevel());
            if (configuration.getLogging().getFileName() != null && appender instanceof FileAppender) {
                ((FileAppender) appender).setFile(configuration.getLogging().getFileName());
            }
            rootLogger.addAppender(appender);
            appender.start();
        }
    }
}

protected void configureLogging(T configuration) {
    // set logging level and file programmatically if defined
    if (configuration.getLogging() != null) {
        ch.qos.logback.classic.Logger rootLogger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
        Appender<ILoggingEvent> appender = rootLogger.getAppender("FILE");
        if (appender != null) {
            rootLogger.detachAppender(appender);
            rootLogger.setLevel(configuration.getLogging().getLevel());
            if (configuration.getLogging().getFileName() != null && appender instanceof FileAppender) {
                ((FileAppender) appender).setFile(configuration.getLogging().getFileName());
            }
            rootLogger.addAppender(appender);
            appender.start();
        }
    }
}

@Test
public void appenderContextIsSet() throws Exception {
    final Logger root = (Logger) LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
    final FileAppenderFactory<ILoggingEvent> appenderFactory = new FileAppenderFactory<>();
    appenderFactory.setArchivedLogFilenamePattern(folder.newFile("example-%d.log.gz").toString());
    final Appender<ILoggingEvent> appender = appenderFactory.build(root.getLoggerContext(), "test", new DropwizardLayoutFactory(), new NullLevelFilterFactory<>(), new AsyncLoggingEventAppenderFactory());
    assertThat(appender.getContext()).isEqualTo(root.getLoggerContext());
}

private Map<String, Appender<ILoggingEvent>> createConsoleAppenders(final LoggerContext context, final LogbackModule module) {
    Map<String, Appender<ILoggingEvent>> appendersMap = new HashMap<>();
    for (ConsoleAppenderTO appender : module.getConsoleAppenderTO()) {
        Preconditions.checkState(appendersMap.containsKey(appender.getName()) == false, "Duplicate appender name %s", appender.getName());
        ch.qos.logback.core.ConsoleAppender<ILoggingEvent> app = new ch.qos.logback.core.ConsoleAppender<>();
        app.setContext(context);
        PatternLayoutEncoder encoder = new PatternLayoutEncoder();
        encoder.setContext(context);
        encoder.setPattern(appender.getEncoderPattern());
        encoder.start();
        app.setEncoder(encoder);
        ThresholdFilter filter = new ThresholdFilter();
        filter.setContext(context);
        filter.setLevel(appender.getThresholdFilter());
        filter.start();
        app.getCopyOfAttachedFiltersList().add(filter);
        app.setName(appender.getName());
        app.start();
        appendersMap.put(app.getName(), app);
    }
    return appendersMap;
}

private void addAppender() {
    LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
    JoranConfigurator jc = new JoranConfigurator();
    jc.setContext(lc);
    Appender appender = new AppenderBase<ILoggingEvent>() {

        @Override
        protected void append(ILoggingEvent event) {
            if (event.getLevel().isGreaterOrEqual(Level.INFO)) {
                lblStatus.setText(event.getFormattedMessage());
            }
        }
    };
    ch.qos.logback.classic.Logger rootLogger = lc.getLogger(Logger.ROOT_LOGGER_NAME);
    rootLogger.addAppender(appender);
    appender.start();
}

@Override
public void onStart() {
    Logger.info("Starting Arpnet standard services");
    decorateDataSources(_Application);
    play.api.Logger logger = play.api.Logger.apply("query-log");
    org.slf4j.Logger slfLogger = logger.underlyingLogger();
    boolean directLog = false;
    if (slfLogger instanceof ch.qos.logback.classic.Logger) {
        final ch.qos.logback.classic.Logger logbackLogger = (ch.qos.logback.classic.Logger) slfLogger;
        LoggerContext context = logbackLogger.getLoggerContext();
        for (Appender<ILoggingEvent> appender : new Iterable<Appender<ILoggingEvent>>() {

            @Override
            public Iterator<Appender<ILoggingEvent>> iterator() {
                return logbackLogger.iteratorForAppenders();
            }
        }) {
            directLog = true;
        }
        if (!directLog) {
            Logger.warn("It appears that there is not a logger setup for query logs.  For query logs to work, they must be directly written to an independent file.");
            Logger.warn("Add the following to your logger.xml file:");
            Logger.warn("\n" + "    <appender name=\"QUERY-LOG-FILE\" class=\"ch.qos.logback.core.rolling.RollingFileAppender\">\n" + "      <file>${application.home}/logs/query-log.log</file>\n" + "      <rollingPolicy class=\"ch.qos.logback.core.rolling.TimeBasedRollingPolicy\">\n" + "        <!-- hourly rollover -->\n" + "        <fileNamePattern>${application.home}/logs/query-log.%d{yy-MM-dd_HH}.log</fileNamePattern>\n" + "        <!-- keep 30 days of history -->\n" + "        <maxHistory>720</maxHistory>\n" + "      </rollingPolicy>\n" + "      <encoder>\n" + "        <pattern>%message%n</pattern>\n" + "      </encoder>\n" + "    </appender>" + "    <appender name=\"ASYNCQL\" class=\"ch.qos.logback.classic.AsyncAppender\">\n" + "      <appender-ref ref=\"QUERY-LOG-FILE\" />\n" + "    </appender>" + "    <logger name=\"query-log\" level=\"INFO\" additivity=\"false\">\n" + "      <appender-ref ref=\"ASYNCQL\"/>\n" + "    </logger>");
        }
    } else {
        Logger.warn("Unknown logging platform, cannot determine if query logs will work");
    }
}

/**
     * Get the actively used log file from the underlying logging mechanism
     */
private Optional<String> getActiveLogFile() {
    Logger rootLogger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
    Iterator<Appender<ILoggingEvent>> itr = rootLogger.iteratorForAppenders();
    // Iterate over the appenders
    while (itr.hasNext()) {
        Appender<ILoggingEvent> appender = itr.next();
        // found a file appender
        if (appender instanceof FileAppender) {
            FileAppender<ILoggingEvent> fileAppender = (FileAppender<ILoggingEvent>) appender;
            return Optional.of(fileAppender.getFile());
        }
    }
    // no file appender
    return Optional.absent();
}

@Override
public Appender<ILoggingEvent> build(LoggerContext context, String applicationName, LayoutFactory<ILoggingEvent> layoutFactory, LevelFilterFactory<ILoggingEvent> levelFilterFactory, AsyncAppenderFactory<ILoggingEvent> asyncAppenderFactory) {
    final SentryAppender appender = new SentryAppender();
    appender.setName(APPENDER_NAME);
    appender.setDsn(sentryDsn);
    appender.setRelease(blazarRelease);
    appender.setServerName(getHostNameOrTaskId());
    appender.setContext(context);
    appender.addFilter(levelFilterFactory.build(Level.ERROR));
    getFilterFactories().stream().forEach( f -> appender.addFilter(f.build()));
    appender.start();
    return wrapAsync(appender, asyncAppenderFactory, context);
}

/**
   * Hijacks the appenders for the root logger and replaces them with a {@link LogStageAppender} that will insert
   * the ETL stage name at the start of each message if the stage name is set. Uses {@link org.slf4j.MDC} to look up
   * the current stage name.
   */
public static void start() {
    if (!initialized.compareAndSet(false, true)) {
        return;
    }
    LogContext.enable();
    ILoggerFactory loggerFactory = LoggerFactory.getILoggerFactory();
    if (!(loggerFactory instanceof LoggerContext)) {
        LOG.warn("LoggerFactory is not a logback LoggerContext. ETLStage names will not be injected into log messages.");
        return;
    }
    LoggerContext loggerContext = (LoggerContext) loggerFactory;
    ch.qos.logback.classic.Logger rootLogger = loggerContext.getLogger(Logger.ROOT_LOGGER_NAME);
    List<Appender<ILoggingEvent>> appenders = new ArrayList<>();
    Iterator<Appender<ILoggingEvent>> appenderIterator = rootLogger.iteratorForAppenders();
    while (appenderIterator.hasNext()) {
        Appender<ILoggingEvent> appender = appenderIterator.next();
        // appender will have a different classloader than LogStageAppender...
        if (appender.getClass().getName().equals(LogStageAppender.class.getName())) {
            return;
        }
        appenders.add(appender);
    }
    Appender<ILoggingEvent> stageAppender = new LogStageAppender(appenders);
    stageAppender.setContext(loggerContext);
    stageAppender.start();
    rootLogger.addAppender(stageAppender);
    // To avoid duplicate messages, need to detach the original appenders
    for (Appender<ILoggingEvent> appender : appenders) {
        rootLogger.detachAppender(appender);
    }
}

private Map<String, Appender<ILoggingEvent>> getAppenders() {
    Map<String, Appender<ILoggingEvent>> appenders = new HashMap<>();
    for (Logger logger : getLoggers()) {
        Iterator<Appender<ILoggingEvent>> i = logger.iteratorForAppenders();
        while (i.hasNext()) {
            Appender<ILoggingEvent> appender = i.next();
            appenders.put(appender.getName(), appender);
        }
    }
    return appenders;
}

@Test
public void testIndexRuleInvalidDrl() throws IOException, InterruptedException {
    //Setup logging
    final Logger root = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
    final Appender<ILoggingEvent> mockAppender = mock(Appender.class);
    when(mockAppender.getName()).thenReturn("MOCK");
    root.addAppender(mockAppender);
    //Add test files
    final Path path = basePath.resolve("bz1269366.drl");
    final String drl = loadText("bz1269366.drl");
    ioService().write(path, drl);
    //wait for events to be consumed from jgit -> (notify changes -> watcher -> index) -> lucene index
    Thread.sleep(5000);
    final Index index = getConfig().getIndexManager().get(KObjectUtil.toKCluster(basePath.getFileSystem()));
    {
        final Query query = new SingleTermQueryBuilder(new ValueReferenceIndexTerm("org.drools.workbench.screens.drltext.backend.server.indexing.classes.Applicant", ResourceType.JAVA)).build();
        // should be 1, but parsing fails (see verify line below) so that 0 is returned..
        searchFor(index, query, 0);
        verify(mockAppender).doAppend(argThat(new ArgumentMatcher<ILoggingEvent>() {

            @Override
            public boolean matches(final Object argument) {
                return ((ILoggingEvent) argument).getMessage().startsWith("Unable to parse DRL");
            }
        }));
    }
}

/**
	 * retrieves information about the available file appenders 
	 * @return
	 */
public List<LogFile> getLogFiles() {
    List<LogFile> logFiles = new ArrayList<LogFile>();
    Logger logger = getRootLogger();
    Iterator<Appender<ILoggingEvent>> it = logger.iteratorForAppenders();
    while (it.hasNext()) {
        Appender<ILoggingEvent> appender = it.next();
        if (appender instanceof FileAppender) {
            FileAppender<ILoggingEvent> fileAppender = (FileAppender<ILoggingEvent>) appender;
            File logFile = new File(fileAppender.getFile());
            LogFile logFileInfo = new LogFile();
            logFileInfo.setLocation(logFile.getAbsolutePath());
            logFiles.add(logFileInfo);
        }
    }
    return logFiles;
}

private void startDelegateAppenders() {
    for (Iterator<Appender<Event>> appenderIter = appenders.iteratorForAppenders(); appenderIter.hasNext(); ) {
        Appender<Event> appender = appenderIter.next();
        if (appender.getContext() == null) {
            appender.setContext(getContext());
        }
        if (!appender.isStarted()) {
            appender.start();
        }
    }
}

/**
   * Dump all stored events for the given discriminator (looked up in the MDC)
   * @param discriminator the discriminator to filter on
   */
public void dump(String discriminator) {
    Appender<ILoggingEvent> dumpAppender = getDumpAppender();
    if (dumpAppender == null) {
        return;
    }
    if (discriminator == null) {
        throw new IllegalArgumentException("Discriminator cannot be null");
    }
    List<ILoggingEvent> eventsToDump = getBuffer(discriminator);
    for (ILoggingEvent event : eventsToDump) {
        dumpAppender.doAppend(event);
    }
}

private void appendOtherLoggerData(final PrintWriter pw, final LoggerStateContext ctx) throws UnsupportedEncodingException {
    if (ctx.nonOSgiConfiguredLoggers.isEmpty()) {
        return;
    }
    pw.println("<div class='table'>");
    pw.println("<div class='ui-widget-header ui-corner-top buttonGroup'>Logger (Configured via other means)</div>");
    pw.println("<table class='nicetable ui-widget'>");
    pw.println("<thead class='ui-widget-header'>");
    pw.println("<tr>");
    pw.println("<th>Log Level</th>");
    pw.println("<th>Additivity</th>");
    pw.println("<th>Name</th>");
    pw.println("<th>Appender</th>");
    pw.println("</tr>");
    pw.println("</thead>");
    pw.println("<tbody class='ui-widget-content'>");
    for (final Logger logger : ctx.nonOSgiConfiguredLoggers) {
        pw.println("<tr>");
        pw.print("<td>");
        pw.print(logger.getLevel());
        pw.println("</td>");
        pw.print("<td>");
        pw.print(Boolean.toString(logger.isAdditive()));
        pw.println("</td>");
        pw.print("<td>");
        pw.print(XmlUtil.escapeXml(logger.getName()));
        pw.println("</td>");
        pw.println("<td>");
        pw.println("<ul>");
        final Iterator<Appender<ILoggingEvent>> itr = logger.iteratorForAppenders();
        while (itr.hasNext()) {
            final Appender<ILoggingEvent> a = itr.next();
            pw.print("<li>");
            pw.print(XmlUtil.escapeXml(getName(a)));
            pw.print("</li>");
        }
        pw.println("</ul>");
        pw.println("</td>");
        pw.println("</tr>");
    }
    pw.println("</tbody>");
    pw.println("</table>");
    pw.println("</div>");
}

@Test
public void testIndexRuleInvalidDrl() throws IOException, InterruptedException {
    //Setup logging
    final Logger root = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
    final Appender<ILoggingEvent> mockAppender = mock(Appender.class);
    when(mockAppender.getName()).thenReturn("MOCK");
    root.addAppender(mockAppender);
    //Add test files
    final Path path = basePath.resolve("bz1269366.drl");
    final String drl = loadText("bz1269366.drl");
    ioService().write(path, drl);
    //wait for events to be consumed from jgit -> (notify changes -> watcher -> index) -> lucene index
    Thread.sleep(5000);
    final Index index = getConfig().getIndexManager().get(KObjectUtil.toKCluster(basePath.getFileSystem()));
    {
        final Query query = new SingleTermQueryBuilder(new ValueReferenceIndexTerm("org.drools.workbench.screens.drltext.backend.server.indexing.classes.Applicant", ResourceType.JAVA)).build();
        // should be 1, but parsing fails (see verify line below) so that 0 is returned..
        searchFor(index, query, 0);
        verify(mockAppender).doAppend(argThat(new ArgumentMatcher<ILoggingEvent>() {

            @Override
            public boolean matches(final Object argument) {
                return ((ILoggingEvent) argument).getMessage().startsWith("Unable to parse DRL");
            }
        }));
    }
}

/**
	 * Configure logging based on a list of builders provided to it. Injects the
	 * configured logging to replace the default UIMA loggers, and also sets up
	 * metrics on the logging.
	 *
	 * @param builders
	 *            The builders to use to configure the logging
	 */
public void configure(List<BaleenLoggerBuilder> builders) {
    // Install JUL to SLF4J handling (JUL is default for UIMA)
    SLF4JBridgeHandler.removeHandlersForRootLogger();
    SLF4JBridgeHandler.install();
    // Configure Logback
    LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
    Logger rootLogger = context.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME);
    // Install the level change propagator to reduce the impact of JUL logging
    context.addListener(new LevelChangePropagator());
    // Remove all the existing appenders
    rootLogger.detachAndStopAllAppenders();
    for (BaleenLoggerBuilder builder : builders) {
        PatternLayoutEncoder ple = new PatternLayoutEncoder();
        ple.setCharset(StandardCharsets.UTF_8);
        ple.setContext(context);
        ple.setPattern(builder.getPattern());
        ple.start();
        Appender<ILoggingEvent> appender = builder.build(context, ple);
        if (!appender.isStarted()) {
            appender.start();
        }
        rootLogger.addAppender(appender);
    }
    LOGGER.debug("Adding instrumented metrics for logging");
    // Add an instrumented appender so we get the information about logging
    // through metrics
    InstrumentedAppender instrumentedAppender = new InstrumentedAppender(MetricsFactory.getInstance().getRegistry());
    instrumentedAppender.setContext(context);
    instrumentedAppender.start();
    rootLogger.addAppender(instrumentedAppender);
}

/**
   * Attempts to enable SLF4J logging via logback
   * without an external configuration file.
   *
   * @param level A string indicating the desired level
   *   (i.e.: ALL, DEBUG, ERROR, FATAL, INFO, OFF, TRACE, WARN).
   * @return true iff logging was successfully enabled
   */
public static synchronized boolean enableLogging(String level) {
    Logger root = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
    LoggerContext context = root.getLoggerContext();
    if (!root.iteratorForAppenders().hasNext()) {
        context.reset();
        PatternLayoutEncoder layout = new PatternLayoutEncoder();
        layout.setContext(context);
        layout.setPattern("%m%n");
        layout.start();
        ConsoleAppender<ILoggingEvent> appender = new ConsoleAppender<ILoggingEvent>();
        appender.setContext(context);
        appender.setEncoder(layout);
        appender.start();
        root.addAppender(appender);
    } else {
        Appender defaultAppender = root.iteratorForAppenders().next();
        if (defaultAppender instanceof ConsoleAppender) {
            context.reset();
            PatternLayoutEncoder layout = new PatternLayoutEncoder();
            layout.setContext(context);
            layout.setPattern("%m%n");
            layout.start();
            defaultAppender.setContext(context);
            ((ConsoleAppender) defaultAppender).setEncoder(layout);
            defaultAppender.start();
            root.addAppender(defaultAppender);
        }
    }
    root.setLevel(Level.toLevel(level));
    return true;
}

@Test
public void simulateVersionFilter() throws Exception {
    // setup logger to see if we actually log anything
    LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
    Logger srLogger = lc.getLogger(StatusResource.class);
    Appender mockapp = mock(Appender.class);
    srLogger.addAppender(mockapp);
    srLogger.setLevel(Level.DEBUG);
    ArgumentCaptor<LoggingEvent> message = ArgumentCaptor.forClass(LoggingEvent.class);
    PrintStream ps = new PrintStream(new File(this.getClass().getClassLoader().getResource("version.properties").toURI()));
    ps.println("version=${version}");
    ps.println("release=${release}");
    StatusResource sr = new StatusResource(rulesCurator, config, jsProvider, candlepinCache, modeManager);
    Status s = sr.status();
    ps.close();
    // make sure we did not log anything which indicates
    // an exception
    verify(mockapp, never()).doAppend(message.capture());
    assertEquals("${release}", s.getRelease());
    assertEquals("${version}", s.getVersion());
    assertTrue(s.getResult());
    assertFalse(s.getStandalone());
}

/**
     * Tests the {@link ApplicationServiceImpl#getAllFeatures()} method
     * for the case where an exception is thrown in getFeatureToRepository(..)
     *
     * @throws Exception
     */
// TODO RAP 29 Aug 16: DDF-2443 - Fix test to not depend on specific log output
@Test
public void testGetAllFeaturesFTRException() throws Exception {
    ch.qos.logback.classic.Logger root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
    final Appender mockAppender = mock(Appender.class);
    when(mockAppender.getName()).thenReturn("MOCK");
    root.addAppender(mockAppender);
    Set<Repository> activeRepos = new HashSet<Repository>(Arrays.asList(mainFeatureRepo, noMainFeatureRepo1, noMainFeatureRepo2));
    FeaturesService featuresService = createMockFeaturesService(activeRepos, null, null);
    when(bundleContext.getService(mockFeatureRef)).thenReturn(featuresService);
    ApplicationService appService = createPermittedApplicationServiceImpl();
    doThrow(new NullPointerException()).when(featuresService).listRepositories();
    appService.getAllFeatures();
    verify(mockAppender, times(7)).doAppend(argThat(new ArgumentMatcher() {

        @Override
        public boolean matches(final Object argument) {
            return ((LoggingEvent) argument).getFormattedMessage().contains(MAP_FAIL_STRING);
        }
    }));
}

@Override
public Appender<ILoggingEvent> build(LoggerContext context, String applicationName, Layout<ILoggingEvent> layout) {
    final LogglyAppender<ILoggingEvent> appender = new LogglyAppender<>();
    final String tagName = tag.or(applicationName);
    appender.setName("loggly-appender");
    appender.setContext(context);
    appender.setEndpointUrl(String.format(ENDPOINT_URL_TEMPLATE, server, token, tagName));
    appender.setLayout(layout == null ? buildLayout(context) : layout);
    addThresholdFilter(appender, threshold);
    appender.start();
    return wrapAsync(appender);
}

public static void flushLogs() {
    try {
        Logger logbackLogger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
        LoggerContext lc = logbackLogger.getLoggerContext();
        Logger rootLogger = lc.getLogger(Logger.ROOT_LOGGER_NAME);
        Appender<ILoggingEvent> appender = rootLogger.getAppender("file");
        appender.stop();
        appender.start();
    } catch (Throwable e) {
        Log.e("Flickr Uploader", e.getMessage(), e);
    }
}

private void addFileLogger(Appender<ILoggingEvent> fileLogger) {
    try {
        ch.qos.logback.classic.Logger root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
        if (!root.isAttached(fileLogger)) {
            root.addAppender(fileLogger);
        }
    } catch (Throwable ex) {
        Log.e("GBApplication", "Error adding logger FILE appender", ex);
    }
}

/**
	 * Get the logfile information for the roor logger.
	 * 
	 * @return List of LogFileInfo obejcts
	 */
public static List<LogFileInfo> getLogFileInfos() {
    final LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
    final List<LogFileInfo> logFileInfos = new ArrayList<LogFileInfo>();
    final Logger logger = lc.getLogger(Logger.ROOT_LOGGER_NAME);
    final Iterator<Appender<ILoggingEvent>> it = logger.iteratorForAppenders();
    while (it.hasNext()) {
        final Appender<ILoggingEvent> appender = it.next();
        if (appender instanceof FileAppender) {
            final FileAppender<ILoggingEvent> fileAppender = (FileAppender<ILoggingEvent>) appender;
            final File logFile = new File(fileAppender.getFile());
            final LogFileInfo logFileInfo = new LogFileInfo();
            logFileInfo.setFileName(logFile.getName());
            logFileInfo.setFileLastChanged(new Date(logFile.lastModified()));
            logFileInfo.setFileSize(logFile.length());
            logFileInfos.add(logFileInfo);
        }
    }
    return logFileInfos;
}

@SuppressWarnings("unchecked")
@Before
public void before() {
    /*
		 * This is a bit funky, but it's useful for verifying that the headers actually get logged
		 */
    myMockAppender = mock(Appender.class);
    when(myMockAppender.getName()).thenReturn("MOCK");
    org.slf4j.Logger logger = LoggerFactory.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME);
    myLoggerRoot = (ch.qos.logback.classic.Logger) logger;
    myLoggerRoot.addAppender(myMockAppender);
}

/**
	 * Get the logfile information for the roor logger.
	 *
	 * @return List of LogFileInfo obejcts
	 */
public static List<LogFileInfo> getLogFileInfos() {
    final LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
    final List<LogFileInfo> logFileInfos = CollectionUtils.getArrayList();
    final Logger logger = lc.getLogger(Logger.ROOT_LOGGER_NAME);
    final Iterator<Appender<ILoggingEvent>> it = logger.iteratorForAppenders();
    while (it.hasNext()) {
        final Appender<ILoggingEvent> appender = it.next();
        if (appender instanceof FileAppender) {
            final FileAppender<ILoggingEvent> fileAppender = (FileAppender<ILoggingEvent>) appender;
            final File logFile = new File(fileAppender.getFile());
            final LogFileInfo logFileInfo = new LogFileInfo();
            logFileInfo.setFileName(logFile.getName());
            logFileInfo.setFileLastChanged(new Date(logFile.lastModified()));
            logFileInfo.setFileSize(logFile.length());
            logFileInfos.add(logFileInfo);
        }
    }
    return logFileInfos;
}

@Test
public void testIndexDrlInvalidRuleName() throws IOException, InterruptedException, ExecutionException {
    //Setup logging
    final Logger root = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
    final Appender<ILoggingEvent> mockAppender = mock(Appender.class);
    when(mockAppender.getName()).thenReturn("MOCK");
    root.addAppender(mockAppender);
    //Add test files
    final Path path1 = basePath.resolve("bz1269366.drl");
    final String drl1 = loadText("bz1269366.drl");
    ioService().write(path1, drl1);
    Thread.sleep(5000);
    final Index index = getConfig().getIndexManager().get(org.uberfire.ext.metadata.io.KObjectUtil.toKCluster(basePath.getFileSystem()));
    {
        final Query query = new SingleTermQueryBuilder(new ValueReferenceIndexTerm("org.kie.workbench.common.services.refactoring.backend.server.drl.classes.Applicant", ResourceType.JAVA)).build();
        final IndexSearcher searcher = ((LuceneIndex) index).nrtSearcher();
        final TopScoreDocCollector collector = TopScoreDocCollector.create(10);
        searcher.search(query, collector);
        final ScoreDoc[] hits = collector.topDocs().scoreDocs;
        assertEquals(0, hits.length);
        verify(mockAppender).doAppend(argThat(new ArgumentMatcher<ILoggingEvent>() {

            @Override
            public boolean matches(final Object argument) {
                return ((ILoggingEvent) argument).getMessage().startsWith("Unable to parse DRL");
            }
        }));
        ((LuceneIndex) index).nrtRelease(searcher);
    }
}

//~ Methods ----------------------------------------------------------------
//------------//
// initialize //
//------------//
/**
     * Check for (BackLog) logging configuration, and if not found,
     * define a minimal configuration.
     * This method should be called at the very beginning of the program before
     * any logging request is sent.
     *
     * @param CONFIG_FOLDER Config folder which may contain a logback.xml file
     * @param TEMP_FOLDER   Temporary folder where log file should be written
     */
public static void initialize(File CONFIG_FOLDER, File TEMP_FOLDER) {
    // 1/ Check if system property is set and points to a real file
    final String loggingProp = System.getProperty(LOGBACK_LOGGING_KEY);
    if (loggingProp != null) {
        File configFile = new File(loggingProp);
        if (configFile.exists()) {
            // Everything seems OK, let LogBack use the config file
            System.out.println("Using " + configFile.getAbsolutePath());
            return;
        } else {
            System.out.println("File " + configFile.getAbsolutePath() + " does not exist.");
        }
    } else {
        System.out.println("Property " + LOGBACK_LOGGING_KEY + " not defined.");
    }
    // 2/ Look for well-known location
    File configFile = new File(CONFIG_FOLDER, LOGBACK_FILE_NAME);
    if (configFile.exists()) {
        System.out.println("Using " + configFile.getAbsolutePath());
        // Set property for logback
        System.setProperty(LOGBACK_LOGGING_KEY, configFile.toString());
        return;
    } else {
        System.out.println("Could not find " + configFile);
    }
    // 3/ We need a default configuration
    LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
    Logger root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
    // CONSOLE
    ConsoleAppender consoleAppender = new ConsoleAppender();
    PatternLayoutEncoder consoleEncoder = new PatternLayoutEncoder();
    consoleAppender.setName("CONSOLE");
    consoleAppender.setContext(loggerContext);
    consoleEncoder.setContext(loggerContext);
    consoleEncoder.setPattern("%-5level %caller{1} - %msg%ex%n");
    consoleEncoder.start();
    consoleAppender.setEncoder(consoleEncoder);
    consoleAppender.start();
    root.addAppender(consoleAppender);
    // FILE (located in default temp directory)
    File logFile;
    FileAppender fileAppender = new FileAppender();
    PatternLayoutEncoder fileEncoder = new PatternLayoutEncoder();
    fileAppender.setName("FILE");
    fileAppender.setContext(loggerContext);
    fileAppender.setAppend(false);
    String now = new SimpleDateFormat("yyyyMMdd'T'HHmmss").format(new Date());
    logFile = Paths.get(System.getProperty("java.io.tmpdir"), "audiveris-" + now + ".log").toFile();
    fileAppender.setFile(logFile.getAbsolutePath());
    fileEncoder.setContext(loggerContext);
    fileEncoder.setPattern("%date %level \\(%file:%line\\) - %msg%ex%n");
    fileEncoder.start();
    fileAppender.setEncoder(fileEncoder);
    fileAppender.start();
    root.addAppender(fileAppender);
    // GUI (filtered in LogGuiAppender)
    Appender guiAppender = new LogGuiAppender();
    guiAppender.setName("GUI");
    guiAppender.setContext(loggerContext);
    guiAppender.start();
    root.addAppender(guiAppender);
    // STEP
    Appender stepAppender = new LogStepAppender();
    stepAppender.setName("STEP");
    stepAppender.setContext(loggerContext);
    stepAppender.start();
    root.addAppender(stepAppender);
    // Levels
    root.setLevel(Level.INFO);
    // OPTIONAL: print logback internal status messages
    StatusPrinter.print(loggerContext);
    root.info("Logging to file {}", logFile.getAbsolutePath());
}

public static ExecutorService newExecutor(Appender<?> appender, int threadPoolSize) {
    final String name = appender.getName();
    return Executors.newFixedThreadPool(threadPoolSize, new ThreadFactory() {

        private final AtomicInteger idx = new AtomicInteger(1);

        @Override
        public Thread newThread(Runnable r) {
            Thread thread = Executors.defaultThreadFactory().newThread(r);
            thread.setName(name + "-" + idx.getAndIncrement());
            thread.setDaemon(true);
            return thread;
        }
    });
}

@Override
public Appender<ILoggingEvent> build(LoggerContext context, String applicationName, Layout<ILoggingEvent> layout) {
    RedisAppender appender = new RedisAppender();
    appender.setContext(context);
    appender.setName(REDIS_APPENDER_NAME);
    appender.setPoolConfig(pool.build());
    appender.setHost(host);
    appender.setPort(port);
    appender.setTimeout((int) timeout.toMilliseconds());
    appender.setPassword(password);
    appender.setDatabase(database);
    appender.setKey(key);
    appender.setLayout(layout != null ? layout : this.layout.build());
    addThresholdFilter(appender);
    appender.start();
    return wrapAsync(context, appender);
}

@Override
public List<FileAppender<ILoggingEvent>> getFileAppenders() {
    List<FileAppender<ILoggingEvent>> fileAppenders = new LinkedList<FileAppender<ILoggingEvent>>();
    for (Logger logger : getLoggers()) {
        for (Iterator<Appender<ILoggingEvent>> index = logger.iteratorForAppenders(); index.hasNext(); ) {
            Appender<ILoggingEvent> appender = index.next();
            if (appender instanceof FileAppender)
                fileAppenders.add((FileAppender<ILoggingEvent>) appender);
        }
    }
    return fileAppenders;
}

@Test
public void testInitLoggerContextFromIncludeFolder() throws Throwable {
    LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
    Logger root = context.getLogger("root");
    Logger sakuliLogger = context.getLogger("org.sakuli");
    Appender<ILoggingEvent> stdout = root.getAppender("stdout");
    Appender<ILoggingEvent> sakuliAppender = root.getAppender("sakuli");
    //no log config in classpath
    Assert.assertNull(stdout);
    Assert.assertNull(sakuliAppender);
    Assert.assertNotNull(sakuliLogger);
    Assert.assertNotNull(root);
    when(sakuliProperties.getConfigFolder()).thenReturn(Paths.get(BaseTest.SAKULI_HOME_FOLDER_PATH + SakuliProperties.CONFIG_FOLDER_APPEDER));
    testling.initLoggerContext();
    verify(testling).getConfigFileFromClasspath();
    verify(testling).getConfigFile();
    //verify root logger
    context = (LoggerContext) LoggerFactory.getILoggerFactory();
    root = context.getLogger("root");
    sakuliLogger = context.getLogger("org.sakuli");
    stdout = root.getAppender("stdout");
    sakuliAppender = root.getAppender("sakuli");
    Assert.assertNotNull(stdout);
    Assert.assertNotNull(sakuliLogger);
    Assert.assertNotNull(sakuliAppender);
    Assert.assertNotNull(sakuliAppender);
}

public void init() {
    Appender tddlAppender = buildAppender("TDDL_Appender", "tddl.log", "%d %p [%c{10}] - %m%n");
    Appender md5sqlAppender = buildAppender("TDDL_MD5_TO_SQL_Appender", "tddl.md5sql.log", "%d %p [%c{10}] - %m%n");
    Appender nagiosAppender = buildAppender("TDDL_Nagios_Appender", "Nagios.log", "%m%n");
    Appender atomStatisticAppender = buildDailyMaxRollingAppender("TDDL_Atom_Statistic_Appender", "tddl-atom-statistic.log", "%m", 6);
    Appender matrixStatisticAppender = buildDailyMaxRollingAppender("TDDL_Matrix_Statistic_Appender", "tddl-matrix-statistic.log", "%m", 12);
    Appender connStatisticAppender = buildDailyMaxRollingAppender("TDDL_Conn_Statistic_Appender", "tddl-conn-statistic.log", "%m", 6);
    Appender statisticAppender = buildAppender("TDDL_Statistic_Appender", "tddl-statistic.log", "%m");
    Appender snapshotAppender = buildAppender("TDDL_Snapshot_Appender", "tddl-snapshot.log", "%m");
    ch.qos.logback.classic.Logger logger = (Logger) LoggerInit.TDDL_LOG.getDelegate();
    logger.setAdditive(false);
    logger.detachAndStopAllAppenders();
    logger.addAppender(tddlAppender);
    logger.setLevel(Level.WARN);
    logger = (Logger) LoggerInit.TDDL_MD5_TO_SQL_MAPPING.getDelegate();
    logger.setAdditive(false);
    logger.detachAndStopAllAppenders();
    logger.addAppender(md5sqlAppender);
    logger.setLevel(Level.DEBUG);
    logger = (Logger) LoggerInit.TDDL_Nagios_LOG.getDelegate();
    logger.setAdditive(false);
    logger.detachAndStopAllAppenders();
    logger.addAppender(nagiosAppender);
    logger.setLevel(Level.INFO);
    logger = (Logger) LoggerInit.TDDL_Atom_Statistic_LOG.getDelegate();
    logger.setAdditive(false);
    logger.detachAndStopAllAppenders();
    logger.addAppender(atomStatisticAppender);
    logger.setLevel(Level.INFO);
    logger = (Logger) LoggerInit.TDDL_Matrix_Statistic_LOG.getDelegate();
    logger.setAdditive(false);
    logger.detachAndStopAllAppenders();
    logger.addAppender(matrixStatisticAppender);
    logger.setLevel(Level.INFO);
    logger = (Logger) LoggerInit.TDDL_Conn_Statistic_LOG.getDelegate();
    logger.setAdditive(false);
    logger.detachAndStopAllAppenders();
    logger.addAppender(connStatisticAppender);
    logger.setLevel(Level.INFO);
    logger = (Logger) LoggerInit.TDDL_Statistic_LOG.getDelegate();
    logger.setAdditive(false);
    logger.detachAndStopAllAppenders();
    logger.addAppender(statisticAppender);
    logger.setLevel(Level.INFO);
    logger = (Logger) LoggerInit.TDDL_Snapshot_LOG.getDelegate();
    logger.setAdditive(false);
    logger.detachAndStopAllAppenders();
    logger.addAppender(snapshotAppender);
    logger.setLevel(Level.INFO);
}

/**
	 * Loads the (optional) Logback configuration file.
	 *
	 * It loads the file defined in the <code>project.logback</code> property from the current
	 * directory and (re-)initializes Logback with this file. If running
	 * headless (<code>System.Property("console")</code> set), then the
	 * alternative config file defined in <code>project.logback.headless</code> is tried first.
	 *
	 * If no config file can be found in the CWD, then nothing is loaded and
	 * Logback will use the logback.xml file on the classpath as a default. If
	 * this doesn't exist then a basic console appender is used as fallback.
	 *
	 * <strong>Note:</strong> Any error messages generated while parsing the
	 * config file are dumped only to <code>stdout</code>.
	 */
public static synchronized void loadFile() {
    File file = null;
    if (!setContextAndRoot()) {
        return;
    }
    if (PMS.isHeadless()) {
        file = getFile(PropertiesUtil.getProjectProperties().get("project.logback.headless").split(","));
    }
    if (file == null) {
        file = getFile(PropertiesUtil.getProjectProperties().get("project.logback").split(","));
    }
    if (file == null) {
        // Unpredictable: Any logback.xml found in the Classpath is loaded, if that fails defaulting to BasicConfigurator
        // See http://logback.qos.ch/xref/ch/qos/logback/classic/BasicConfigurator.html
        LOGGER.warn("Could not load LogBack configuration file from " + (PMS.isHeadless() ? PropertiesUtil.getProjectProperties().get("project.logback.headless") + ", " : "") + PropertiesUtil.getProjectProperties().get("project.logback"));
        LOGGER.warn("Falling back to somewhat unpredictable defaults, probably only logging to console.");
        return;
    }
    // Now get logback to actually use the config file
    JoranConfigurator configurator = new JoranConfigurator();
    configurator.setContext(loggerContext);
    try {
        // the context was probably already configured by
        // default configuration rules
        loggerContext.reset();
        loggerContext.getStatusManager().clear();
        // Do not log between loggerContext.reset() and CacheLogger.initContext()
        configurator.doConfigure(file);
        if (CacheLogger.isActive()) {
            CacheLogger.initContext();
        }
        // Save the file path after loading the file
        synchronized (filepathLock) {
            filepath = file.getAbsolutePath();
            LOGGER.debug("LogBack started with configuration file: {}", filepath);
        }
    } catch (JoranException je) {
        try {
            System.err.println("LogBack configuration failed: " + je.getLocalizedMessage());
            System.err.println("Trying to create \"emergency\" configuration");
            if (PMS.isHeadless()) {
                ConsoleAppender<ILoggingEvent> ca = new ConsoleAppender<>();
                PatternLayoutEncoder pe = new PatternLayoutEncoder();
                pe.setPattern("%-5level %d{HH:mm:ss.SSS} [%thread] %logger %msg%n");
                pe.setContext(loggerContext);
                pe.start();
                ca.setEncoder(pe);
                ca.setContext(loggerContext);
                ca.setName("Emergency Console");
                ca.start();
                loggerContext.getLogger(Logger.ROOT_LOGGER_NAME).addAppender(ca);
            } else {
                FrameAppender<ILoggingEvent> fa = new FrameAppender<>();
                PatternLayoutEncoder pe = new PatternLayoutEncoder();
                pe.setPattern("%-5level %d{HH:mm:ss.SSS} [%thread] %logger %msg%n");
                pe.setContext(loggerContext);
                pe.start();
                fa.setEncoder(pe);
                fa.setContext(loggerContext);
                fa.setName("Emergency Frame");
                fa.start();
                loggerContext.getLogger(Logger.ROOT_LOGGER_NAME).addAppender(fa);
            }
            System.err.println("LogBack \"emergency\" configuration applied.");
        } catch (Exception e) {
            System.err.println("LogBack \"emergency\" configuration failed with: " + e);
        }
        if (CacheLogger.isActive()) {
            CacheLogger.initContext();
        }
        LOGGER.error("Logback configuration failed with: {}", je.getLocalizedMessage());
        StatusPrinter.printInCaseOfErrorsOrWarnings(loggerContext);
        return;
    }
    // Build the iterator
    Iterators<Appender<ILoggingEvent>> iterators = new Iterators<>();
    // Add CacheLogger appenders if CacheLogger is active
    if (CacheLogger.isActive()) {
        iterators.addIterator(CacheLogger.iteratorForAppenders());
    }
    // non-root appenders there.
    for (Logger logger : loggerContext.getLoggerList()) {
        iterators.addIterator(logger.iteratorForAppenders());
    }
    // Iterate
    Iterator<Appender<ILoggingEvent>> it = iterators.combinedIterator();
    synchronized (logFilePathsLock) {
        while (it.hasNext()) {
            Appender<ILoggingEvent> appender = it.next();
            if (appender instanceof FileAppender) {
                FileAppender<ILoggingEvent> fa = (FileAppender<ILoggingEvent>) appender;
                logFilePaths.put(fa.getName(), fa.getFile());
            } else if (appender instanceof SyslogAppender) {
                syslogDisabled = true;
            }
        }
    }
    // Set filters for console and traces
    setConfigurableFilters(true, true);
    StatusPrinter.printInCaseOfErrorsOrWarnings(loggerContext);
    return;
}

@Before
public void setUp() throws Exception {
    ch.qos.logback.classic.Logger rootLogger = this.utils.getRootLogger();
    // Disable all appenders to avoid unnecessary log
    Filter<ILoggingEvent> filter = new Filter<ILoggingEvent>() {

        @Override
        public FilterReply decide(ILoggingEvent event) {
            if (event.getMessage() != null && event.getMessage().startsWith("[test]")) {
                return FilterReply.DENY;
            }
            return FilterReply.NEUTRAL;
        }
    };
    Iterator<Appender<ILoggingEvent>> appendersIterator = rootLogger.iteratorForAppenders();
    while (appendersIterator.hasNext()) {
        Appender<ILoggingEvent> appender = appendersIterator.next();
        appender.addFilter(filter);
    }
    // Add appender
    this.listAppender = new ListAppender<ILoggingEvent>();
    this.listAppender.start();
    rootLogger.addAppender(this.listAppender);
    this.logger = LoggerFactory.getLogger(getClass());
    this.loggerManager = this.mocker.getComponentUnderTest();
}

@Activate
protected void activate(ComponentContext ctx) {
    final Dictionary<?, ?> properties = ctx.getProperties();
    String[] loggers = PropertiesUtil.toStringArray(properties.get(PROP_LOGGERS), new String[] { ROOT });
    String suffixPattern = PropertiesUtil.toString(properties.get(PROP_SUFFIX_PATTERN), DEFAULT_SUFFIX_PATTERN);
    int port = PropertiesUtil.toInteger(properties.get(PROP_PORT), DEFAULT_PORT);
    String host = PropertiesUtil.toString(properties.get(PROP_HOST), null);
    String facility = PropertiesUtil.toString(properties.get(PROP_FACILITY), DEFAULT_FACILITY);
    String stackTracePattern = PropertiesUtil.toString(properties.get(PROP_STACK_TRACE_PATTERN), null);
    boolean throwableExcluded = PropertiesUtil.toBoolean(properties.get(PROP_THROWABLE_EXCLUDED), DEFAULT_THROWABLE_EXCLUDED);
    if (host == null || port == -1) {
        throw new IllegalArgumentException("Syslog Appender not configured correctly. Both host and port need to be provided.");
    }
    // throws a descriptive IllegalArgumentException if facility is not valid.
    SyslogAppenderBase.facilityStringToint(facility);
    BundleContext bundleContext = ctx.getBundleContext();
    appender = new ch.qos.logback.classic.net.SyslogAppender();
    appender.setSyslogHost(host);
    appender.setPort(port);
    appender.setFacility(facility);
    appender.setSuffixPattern(suffixPattern);
    if (StringUtils.isNotEmpty(stackTracePattern)) {
        appender.setStackTracePattern(stackTracePattern);
    }
    appender.setThrowableExcluded(throwableExcluded);
    Dictionary<String, Object> props = new Hashtable<String, Object>();
    props.put("loggers", loggers);
    appenderRegistration = bundleContext.registerService(Appender.class.getName(), appender, props);
}

/**
	 * Initialises dependency injection, obtains an instance of this class, and {@linkplain #run() runs} it.
	 *
	 * @param arguments array of command line arguments
	 */
public static void main(String[] arguments) {
    /**
		 * Load configuration properties from a file, if specified. If a file is specified, `properties` will refer to
		 * a copy of System.getProperties(), with the configuration file properties as its default values fallback.
		 * Otherwise, `properties` will be aliased to System.getProperties().
		 */
    final String configurationFilePath = System.getProperty("net.za.slyfox.dyn53.configurationFile");
    final Properties properties;
    if (configurationFilePath != null) {
        final Properties fileProperties = new Properties();
        try (final BufferedReader reader = Files.newBufferedReader(Paths.get(configurationFilePath))) {
            fileProperties.load(reader);
        } catch (IOException e) {
            LoggerFactory.getLogger(Dyn53.class).error("Could not load configuration properties from {}", configurationFilePath);
            System.exit(1);
        }
        properties = new Properties(fileProperties);
        properties.putAll(System.getProperties());
    } else {
        properties = System.getProperties();
    }
    final String logFile = properties.getProperty("net.za.slyfox.dyn53.logFile");
    if (logFile != null) {
        final LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
        context.putProperty("logFile", logFile);
        final ch.qos.logback.classic.Logger rootLogger = context.getLogger(Logger.ROOT_LOGGER_NAME);
        final JoranConfigurator configurator = new JoranConfigurator();
        configurator.setContext(context);
        try {
            configurator.doConfigure(Dyn53.class.getResourceAsStream("/logback-file.xml"));
        } catch (JoranException ignored) {
        }
        final Appender<ILoggingEvent> stdoutAppender = rootLogger.getAppender("stdout");
        rootLogger.detachAppender(stdoutAppender);
        stdoutAppender.stop();
        StatusPrinter.printInCaseOfErrorsOrWarnings(context);
    }
    Thread.setDefaultUncaughtExceptionHandler(( t,  e) -> LoggerFactory.getLogger(Dyn53.class).error("Thread {} terminated due to uncaught exception", t.getName(), e));
    final Logger logger = LoggerFactory.getLogger(Dyn53.class);
    logger.info("Initializing Dyn53 application");
    final Set<Module> modules = new HashSet<>();
    modules.add(new ExternalIpModule());
    modules.add(new SystemModule());
    final String hostedZoneId = properties.getProperty("net.za.slyfox.dyn53.route53.hostedZoneId");
    if (hostedZoneId == null)
        throw new IllegalArgumentException("Hosted zone ID missing");
    final String resourceRecordSetName = properties.getProperty("net.za.slyfox.dyn53.route53.resourceRecordSetName");
    if (resourceRecordSetName == null)
        throw new IllegalArgumentException("Resource record set name missing");
    final Long resourceRecordSetTtl = Long.valueOf(properties.getProperty("net.za.slyfox.dyn53.route53.resourceRecordSetTtl", "300"));
    modules.add(new Route53Module(hostedZoneId, resourceRecordSetName, resourceRecordSetTtl));
    final String pidFile = properties.getProperty("net.za.slyfox.dyn53.daemon.pidFile");
    if (pidFile != null)
        modules.add(new DaemonModule(pidFile));
    final boolean alwaysUpdate = Boolean.valueOf(properties.getProperty("net.za.slyfox.dyn53.alwaysUpdate", "false"));
    modules.add(alwaysUpdate ? new UnconditionalUpdateModule() : new StatefulUpdateModule());
    final Injector injector = Guice.createInjector(Stage.PRODUCTION, modules);
    try {
        injector.getInstance(Dyn53.class).run();
    } catch (RuntimeException e) {
        logger.error("Application terminated with error", e);
    }
}

private boolean process() {
    if (isPrintHelp()) {
        printUsage();
        return false;
    }
    try {
        if (threadsCount <= 0) {
            throw new JadxException("Threads count must be positive");
        }
        if (files != null) {
            for (String fileName : files) {
                File file = new File(fileName);
                if (file.exists()) {
                    input.add(file);
                } else {
                    throw new JadxException("File not found: " + file);
                }
            }
        }
        if (input.size() > 1) {
            throw new JadxException("Only one input file is supported");
        }
        if (outDirName != null) {
            outputDir = new File(outDirName);
        }
        if (isVerbose()) {
            ch.qos.logback.classic.Logger rootLogger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
            // remove INFO ThresholdFilter
            Appender<ILoggingEvent> appender = rootLogger.getAppender("STDOUT");
            if (appender != null) {
                appender.clearAllFilters();
            }
        }
    } catch (JadxException e) {
        System.err.println("ERROR: " + e.getMessage());
        printUsage();
        return false;
    }
    return true;
}

@Test
public void testRedisLogstashAppenderProgrammatically() throws InterruptedException {
    RedisLogstashAppender appender = new RedisLogstashAppender();
    appender.setType("test-logback-redis-logstash");
    appender.setFile("test");
    appender.setRedisHostName("localhost");
    appender.setRedisPort(6379);
    appender.setContext((LoggerContext) LoggerFactory.getILoggerFactory());
    appender.start();
    // Setup the test logger
    final Logger testLogger = (Logger) LoggerFactory.getLogger(getClass().getName() + "-test");
    testLogger.setLevel(Level.TRACE);
    testLogger.addAppender(appender);
    // Add a threshold filter to any existing loggers to lower verbosity
    Logger rootLogger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
    ThresholdFilter thresholdFilter = new ThresholdFilter();
    thresholdFilter.setLevel("INFO");
    thresholdFilter.start();
    Iterator<Appender<ILoggingEvent>> appenderIterator = rootLogger.iteratorForAppenders();
    while (appenderIterator.hasNext()) {
        appenderIterator.next().addFilter(thresholdFilter);
    }
    testLogger.info("This is a simple test.");
    testLogger.info("This is a multi-\nline\ntest.");
    testLogger.info("This is a \"quoted\" test.");
    int threadCount = 2 * Runtime.getRuntime().availableProcessors();
    ExecutorService executor = Executors.newFixedThreadPool(threadCount);
    for (int i = 0; i < threadCount; i++) {
        final int threadNum = i;
        executor.submit(new Runnable() {

            private Random random = new Random();

            @Override
            public void run() {
                testLogger.info("Starting test thread {}.", threadNum);
                for (int i = 0; i < 1000; i++) {
                    testLogger.trace("This is programmatic test {}:{}.", threadNum, i);
                    if (random.nextInt(10) < 1) {
                        try {
                            Thread.sleep((long) random.nextInt(100));
                        } catch (InterruptedException e) {
                        }
                    }
                }
                testLogger.info("Finished test thread {}.", threadNum);
            }
        });
    }
    executor.shutdown();
    // Wait an absurdly long period of time
    executor.awaitTermination(30l, TimeUnit.SECONDS);
    testLogger.info("This is a programmatic test with an exception.", new Exception());
    testLogger.info("This is a programmatic test with a multi-line exception message.", new Exception("Multi-\nline\nmessage"));
    testLogger.info("This is a programmatic test with a quoted exception message.", new Exception("\"Quoted\" message"));
    MDC.put("A key", "A value");
    MDC.put("A multi-\nline\nkey", "A multi-\nline\nvalue");
    MDC.put("A \"quoted\" key", "A \"quoted\" value");
    testLogger.info("This is a programmatic test with an MDC.");
    MDC.clear();
    testLogger.info(MarkerFactory.getMarker("A marker"), "This is a programmatic test for a marker.");
    testLogger.info(MarkerFactory.getMarker("A multi-\nline\nmarker"), "This is a programmatic test for a multi-line marker.");
    testLogger.info(MarkerFactory.getMarker("A \"quoted\" marker"), "This is a programmatic test for a quoted marker.");
    testLogger.info(MarkerFactory.getDetachedMarker("A detached marker"), "This is a programmatic test for a detached marker.");
    testLogger.info(MarkerFactory.getDetachedMarker("A detached multi-\nline\nmarker"), "This is a programmatic test for a detached multi-line marker.");
    testLogger.info(MarkerFactory.getDetachedMarker("A detached \"quoted\" marker"), "This is a programmatic test for a detached quoted marker.");
    MDC.clear();
    MDC.put("tags", "one, two, thee, multi-\nline, \"quoted\" tag");
    testLogger.info("This is a programmatic test for tags.");
    MDC.clear();
    Thread.currentThread().setName("Multi-\nline\nThread\nName");
    testLogger.info("This is a programmatic test for multi-line thread names.");
    Thread.currentThread().setName("\"Quoted\" Thread Name");
    testLogger.info("This is a programmatic test for quoted thread names.");
    appender.stop();
}

@Before
public void before() {
    templateEngineFreemarkerI18nMethod = Mockito.spy(new TemplateEngineFreemarkerI18nMethod(messages, context, result));
    ch.qos.logback.classic.Logger root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME);
    mockAppender = Mockito.mock(Appender.class);
    Mockito.when(mockAppender.getName()).thenReturn("MOCK");
    root.addAppender(mockAppender);
}

@Before
public void before() {
    templateEngineFreemarkerI18nMethod = Mockito.spy(new TemplateEngineFreemarkerI18nMethod(messages, context, result));
    ch.qos.logback.classic.Logger root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME);
    mockAppender = Mockito.mock(Appender.class);
    Mockito.when(mockAppender.getName()).thenReturn("MOCK");
    root.addAppender(mockAppender);
}

@Test
public void test() {
    String fqcn = "blarg";
    String fqcn2 = "other";
    LoggerContext context = new LoggerContext();
    Logger logger = context.getLogger("foo");
    PaxContext paxContext = new PaxContext();
    Bundle bundle = makeBundle();
    PaxLoggingService svc = EasyMock.createStrictMock(PaxLoggingService.class);
    EasyMock.expect(svc.getPaxContext()).andReturn(paxContext).anyTimes();
    PaxEventHandler eventHandler = EasyMock.createNiceMock(PaxEventHandler.class);
    Appender<ILoggingEvent> appender = EasyMock.createStrictMock(LogAppender.class);
    MDC.put("bundle.name", "bundle1");
    MDC.put("bundle.id", "1");
    MDC.put("bundle.version", "1.2.3.4");
    appender.doAppend(eqLogEvent(fqcn, logger, Level.DEBUG, "d"));
    EasyMock.expectLastCall();
    appender.doAppend(eqLogEvent(fqcn, logger, Level.INFO, "i"));
    EasyMock.expectLastCall();
    appender.doAppend(eqLogEvent(fqcn, logger, Level.WARN, "w"));
    EasyMock.expectLastCall();
    appender.doAppend(eqLogEvent(fqcn, logger, Level.ERROR, "e"));
    EasyMock.expectLastCall();
    appender.doAppend(eqLogEvent(fqcn, logger, Level.ERROR, "f"));
    EasyMock.expectLastCall();
    appender.doAppend(eqLogEvent(fqcn2, logger, Level.DEBUG, "d"));
    EasyMock.expectLastCall();
    appender.doAppend(eqLogEvent(fqcn2, logger, Level.INFO, "i"));
    EasyMock.expectLastCall();
    appender.doAppend(eqLogEvent(fqcn2, logger, Level.WARN, "w"));
    EasyMock.expectLastCall();
    appender.doAppend(eqLogEvent(fqcn2, logger, Level.ERROR, "e"));
    EasyMock.expectLastCall();
    appender.doAppend(eqLogEvent(fqcn2, logger, Level.ERROR, "f"));
    EasyMock.expectLastCall();
    MDC.clear();
    EasyMock.replay(bundle, svc, eventHandler, appender);
    logger.addAppender(appender);
    PaxLoggerImpl paxLogger = new PaxLoggerImpl(bundle, logger, fqcn, svc, eventHandler);
    Assert.assertEquals(PaxLogger.LEVEL_DEBUG, paxLogger.getLogLevel());
    Assert.assertEquals("foo", paxLogger.getName());
    Assert.assertSame(paxContext, paxLogger.getPaxContext());
    // won't be logged, default level is DEBUG
    paxLogger.trace("t", null);
    paxLogger.debug("d", null);
    paxLogger.inform("i", null);
    paxLogger.warn("w", null);
    paxLogger.error("e", null);
    paxLogger.fatal("f", null);
    // won't be logged, default level is DEBUG
    paxLogger.trace("t", null, fqcn2);
    paxLogger.debug("d", null, fqcn2);
    paxLogger.inform("i", null, fqcn2);
    paxLogger.warn("w", null, fqcn2);
    paxLogger.error("e", null, fqcn2);
    paxLogger.fatal("f", null, fqcn2);
    Assert.assertFalse(paxLogger.isTraceEnabled());
    Assert.assertTrue(paxLogger.isDebugEnabled());
    Assert.assertTrue(paxLogger.isInfoEnabled());
    Assert.assertTrue(paxLogger.isWarnEnabled());
    Assert.assertTrue(paxLogger.isErrorEnabled());
    Assert.assertTrue(paxLogger.isFatalEnabled());
    EasyMock.verify(bundle, svc, eventHandler, appender);
}

/**
	 * Loads the (optional) Logback configuration file.
	 *
	 * <p>
	 * It loads the file defined in the {@code project.logback} property
	 * (use {@code [PROFILE_DIR]} to specify profile folder) and (re-)initializes Logback with this file.
	 * </p>
	 *
	 * <p>
	 * If failed (file not found or unreadable) it tries to load {@code logback.xml} from the current directory.
	 * </p>
	 *
	 * <p>
	 * If running headless, then the alternative config file defined in {@code project.logback.headless} is tried.
	 * </p>
	 *
	 * <p>
	 * If no config file worked, then nothing is loaded and
	 * Logback will use the {@code logback.xml} file on the classpath as a default. If
	 * this doesn't exist then a basic console appender is used as fallback.
	 * </p>
	 *
	 * <strong>Note:</strong> Any error messages generated while parsing the
	 * config file are dumped only to {@code stdout}.
	 */
public static void load() {
    // Note: Do not use any logging method in this method!
    // Any status output needs to go to the console.
    File logFile = null;
    if (PMS.isHeadless()) {
        final String logFilePath = replace(PropertiesUtil.getProjectProperties().get("project.logback.headless"), "[PROFILE_DIR]", configuration.getProfileDirectory());
        if (isNotBlank(logFilePath)) {
            logFile = new File(logFilePath);
        }
    } else {
        final String logFilePath = replace(PropertiesUtil.getProjectProperties().get("project.logback"), "[PROFILE_DIR]", configuration.getProfileDirectory());
        if (isNotBlank(logFilePath)) {
            logFile = new File(logFilePath);
        }
    }
    if (logFile == null || !logFile.canRead()) {
        // Now try configs from the app folder.
        if (PMS.isHeadless()) {
            logFile = new File("logback.headless.xml");
        } else {
            logFile = new File("logback.xml");
        }
    }
    if (!logFile.canRead()) {
        // No problem, the internal logback.xml is used.
        return;
    }
    // Now get logback to actually use the config file
    ILoggerFactory ilf = LoggerFactory.getILoggerFactory();
    if (!(ilf instanceof LoggerContext)) {
        // Can't configure the logger, so just exit
        return;
    }
    LoggerContext lc = (LoggerContext) ilf;
    try {
        JoranConfigurator configurator = new JoranConfigurator();
        configurator.setContext(lc);
        // the context was probably already configured by
        // default configuration rules
        lc.reset();
        configurator.doConfigure(logFile);
        // Save the filepath after loading the file
        filepath = logFile.getAbsolutePath();
    } catch (JoranException je) {
        je.printStackTrace();
    }
    for (Logger logger : lc.getLoggerList()) {
        Iterator<Appender<ILoggingEvent>> it = logger.iteratorForAppenders();
        while (it.hasNext()) {
            Appender<ILoggingEvent> ap = it.next();
            if (ap instanceof FileAppender) {
                FileAppender<ILoggingEvent> fa = (FileAppender<ILoggingEvent>) ap;
                logFilePaths.put(fa.getName(), fa.getFile());
            }
        }
    }
    StatusPrinter.printInCaseOfErrorsOrWarnings(lc);
}

@Test
public void startup_logger_prints_to_only_to_system_out() {
    LoggerContext ctx = underTest.configure(props);
    Logger startup = ctx.getLogger("startup");
    assertThat(startup.isAdditive()).isFalse();
    Appender appender = startup.getAppender("CONSOLE");
    assertThat(appender).isInstanceOf(ConsoleAppender.class);
    ConsoleAppender<ILoggingEvent> consoleAppender = (ConsoleAppender<ILoggingEvent>) appender;
    assertThat(consoleAppender.getTarget()).isEqualTo("System.out");
    assertThat(consoleAppender.getEncoder()).isInstanceOf(PatternLayoutEncoder.class);
    PatternLayoutEncoder patternEncoder = (PatternLayoutEncoder) consoleAppender.getEncoder();
    assertThat(patternEncoder.getPattern()).isEqualTo("%d{yyyy.MM.dd HH:mm:ss} %-5level app[][%logger{20}] %msg%n");
}

@Before
public void setUp() throws Exception {
    this.testTarget = new ExceptionLogger();
    testTarget.afterPropertiesSet();
    @SuppressWarnings("unchecked") Appender<ILoggingEvent> mockApplicationLoggerAppender = mock(Appender.class);
    this.mockApplicationLoggerAppender = mockApplicationLoggerAppender;
    this.applicationLogger = (Logger) testTarget.getApplicationLogger();
    applicationLogger.addAppender(mockApplicationLoggerAppender);
    applicationLogger.setAdditive(false);
    @SuppressWarnings("unchecked") Appender<ILoggingEvent> monitoringLoggerAppender = mock(Appender.class);
    this.mockMonitoringLoggerAppender = monitoringLoggerAppender;
    this.monitoringLogger = (Logger) testTarget.getMonitoringLogger();
    monitoringLogger.addAppender(mockMonitoringLoggerAppender);
    monitoringLogger.setAdditive(false);
}

/**
     * Fixes the Chameleon logging configuration to write the logs in the logs/wisdom.log file instead of chameleon.log
     * file.
     *
     * @param basedir the base directory of the chameleon
     */
public static void fixLoggingSystem(File basedir) {
    ILoggerFactory factory = LoggerFactory.getILoggerFactory();
    if (factory instanceof LoggerContext) {
        // We know that we are using logback from here.
        LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
        ch.qos.logback.classic.Logger logbackLogger = lc.getLogger(Logger.ROOT_LOGGER_NAME);
        if (logbackLogger == null) {
            return;
        }
        Iterator<Appender<ILoggingEvent>> iterator = logbackLogger.iteratorForAppenders();
        while (iterator.hasNext()) {
            Appender<ILoggingEvent> appender = iterator.next();
            if (appender instanceof AsyncAppender) {
                appender = ((AsyncAppender) appender).getAppender("FILE");
            }
            if (appender instanceof RollingFileAppender) {
                RollingFileAppender<ILoggingEvent> fileAppender = (RollingFileAppender<ILoggingEvent>) appender;
                String file = new File(basedir, "logs/wisdom.log").getAbsolutePath();
                fileAppender.stop();
                // Remove the created log directory.
                // We do that afterwards because on Windows the file cannot be deleted while we still have a logger
                // using it.
                FileUtils.deleteQuietly(new File("logs"));
                fileAppender.setFile(file);
                fileAppender.setContext(lc);
                fileAppender.start();
            }
        }
    }
}

/**
     * Check whether ConsoleAppender was already added
     * @param logger
     * @return true   if it was already added
     *         false  if it does not contain ConsoleAppender
     */
public static void addConsoleAppenderIfNotPresent(Logger logger) {
    boolean isConsoleAppenderAdded = false;
    PatternLayout layout = null;
    Iterator<Appender<ILoggingEvent>> appenderSeries = logger.iteratorForAppenders();
    while (appenderSeries.hasNext()) {
        Appender<ILoggingEvent> appender = (Appender<ILoggingEvent>) appenderSeries.next();
        if (appender instanceof ConsoleAppender) {
            isConsoleAppenderAdded = true;
            break;
        }
    }
    if (!isConsoleAppenderAdded) {
        if (layout == null) {
            layout = LoggerUtil.getPatternLayout(logger.getLoggerContext());
        }
        if (logger.getLevel() == null) {
            logger.setLevel(Level.DEBUG);
        }
        ConsoleAppender<ILoggingEvent> consoleAppender = LoggerUtil.getConsoleAppender(layout, logger.getLoggerContext());
        logger.addAppender(consoleAppender);
    }
}

@Test
public void usersAreWarnedOfPotentialPropertyNameErrors() throws Exception {
    final String EXPECTED_LOG_ENTRY = "You have set a property called 'log_level.JMETER' which is very similar to 'log_level.jmeter'!";
    Logger root = (Logger) LoggerFactory.getLogger(ROOT_LOGGER_NAME);
    final Appender mockAppender = mock(Appender.class);
    when(mockAppender.getName()).thenReturn("MOCK");
    root.addAppender(mockAppender);
    HashMap<String, String> customProperties = new HashMap<>();
    customProperties.put("log_level.JMETER", "DEBUG");
    PropertiesFile propertiesFile = new PropertiesFile(new File(sourcePropertiesFile.toURI()));
    propertiesFile.addAndOverwriteProperties(customProperties);
    verify(mockAppender).doAppend(argThat(new ArgumentMatcher() {

        @Override
        public boolean matches(final Object argument) {
            return ((LoggingEvent) argument).getFormattedMessage().equals(EXPECTED_LOG_ENTRY);
        }
    }));
    Properties modifiedProperties = propertiesFile.getProperties();
    assertThat(modifiedProperties.getProperty("log_level.jmeter"), is(equalTo("INFO")));
    assertThat(modifiedProperties.getProperty("log_level.jmeter.junit"), is(equalTo("DEBUG")));
    assertThat(modifiedProperties.getProperty("log_level.JMETER"), is(equalTo("DEBUG")));
    assertThat(modifiedProperties.size(), is(equalTo(3)));
}

/**
     * Check whether ConsoleAppender was already added
     * @param logger
     * @return true   if it was already added
     *         false  if it does not contain ConsoleAppender
     */
public static void addConsoleAppenderIfNotPresent(Logger logger) {
    boolean isConsoleAppenderAdded = false;
    PatternLayout layout = null;
    Iterator<Appender<ILoggingEvent>> appenderSeries = logger.iteratorForAppenders();
    while (appenderSeries.hasNext()) {
        Appender<ILoggingEvent> appender = (Appender<ILoggingEvent>) appenderSeries.next();
        if (appender instanceof ConsoleAppender) {
            isConsoleAppenderAdded = true;
            break;
        }
    }
    if (!isConsoleAppenderAdded) {
        if (layout == null) {
            layout = LoggerUtil.getPatternLayout(logger.getLoggerContext());
        }
        if (logger.getLevel() == null) {
            logger.setLevel(Level.DEBUG);
        }
        ConsoleAppender<ILoggingEvent> consoleAppender = LoggerUtil.getConsoleAppender(layout, logger.getLoggerContext());
        logger.addAppender(consoleAppender);
    }
}

@Test(timeout = 10000)
@SuppressWarnings("deprecation")
public void testRegistrationAfterShutdown() throws Exception {
    loopA.shutdown();
    // Disable logging temporarily.
    Logger root = (Logger) LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
    List<Appender<ILoggingEvent>> appenders = new ArrayList<Appender<ILoggingEvent>>();
    for (Iterator<Appender<ILoggingEvent>> i = root.iteratorForAppenders(); i.hasNext(); ) {
        Appender<ILoggingEvent> a = i.next();
        appenders.add(a);
        root.detachAppender(a);
    }
    try {
        ChannelFuture f = loopA.register(new LocalChannel());
        f.awaitUninterruptibly();
        assertFalse(f.isSuccess());
        assertThat(f.cause(), is(instanceOf(RejectedExecutionException.class)));
        assertFalse(f.channel().isOpen());
    } finally {
        for (Appender<ILoggingEvent> a : appenders) {
            root.addAppender(a);
        }
    }
}

@Test(timeout = 10000)
@SuppressWarnings("deprecation")
public void testRegistrationAfterShutdown() throws Exception {
    loopA.shutdown();
    // Disable logging temporarily.
    Logger root = (Logger) LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
    List<Appender<ILoggingEvent>> appenders = new ArrayList<Appender<ILoggingEvent>>();
    for (Iterator<Appender<ILoggingEvent>> i = root.iteratorForAppenders(); i.hasNext(); ) {
        Appender<ILoggingEvent> a = i.next();
        appenders.add(a);
        root.detachAppender(a);
    }
    try {
        ChannelFuture f = loopA.register(new LocalChannel());
        f.awaitUninterruptibly();
        assertFalse(f.isSuccess());
        assertThat(f.cause(), is(instanceOf(RejectedExecutionException.class)));
        assertFalse(f.channel().isOpen());
    } finally {
        for (Appender<ILoggingEvent> a : appenders) {
            root.addAppender(a);
        }
    }
}

public void stop() {
    baseImplementation.stop();
    //close the downstream appenders
    synchronized (downstreamAppenders) {
        //FileAppender.
        for (Iterator<Appender<LoggingEvent>> iter = downstreamAppenders.iteratorForAppenders(); iter != null && iter.hasNext(); ) {
            Appender<LoggingEvent> appender = iter.next();
            if (appender instanceof Flushable) {
                try {
                    ((Flushable) appender).flush();
                } catch (Exception e) {
                }
            }
        }
        //THEN close them
        for (Iterator<Appender<LoggingEvent>> iter = downstreamAppenders.iteratorForAppenders(); iter != null && iter.hasNext(); ) {
            iter.next().stop();
        }
    }
    super.stop();
}

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

/**
	 * For the specified Logback logger context, dumps a list of all loggers, their levels, and their appenders.
	 */
public static void dumpLoggers(LoggerContext loggerContext) {
    System.out.println("Loggers:");
    List<Logger> loggers = loggerContext.getLoggerList();
    for (Logger logger : loggers) {
        System.out.printf("    %s level=%s effective=%s\n", logger, logger.getLevel(), logger.getEffectiveLevel());
        Iterator<Appender<ILoggingEvent>> it = logger.iteratorForAppenders();
        while (it.hasNext()) {
            Appender<ILoggingEvent> appender = it.next();
            System.out.println("        " + appender);
        }
    }
}

private void startLogReceiver(Appender<ILoggingEvent> appender) throws GungnirServerException, GungnirClientException {
    LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
    appender.setContext(lc);
    appender.start();
    ch.qos.logback.classic.Logger logger = lc.getLogger(LOGGER_NAME);
    logger.addAppender(appender);
    logger.setLevel(Level.INFO);
    String host = config.getString(LOG_RECEIVER_HOST);
    if (host == null) {
        host = GungnirUtils.getLocalAddress();
    }
    int port = config.getInteger(LOG_RECEIVER_PORT);
    receiver = new ServerSocketReceiver();
    receiver.setAddress(host);
    receiver.setPort(port);
    receiver.setContext(lc);
    receiver.start();
    statement.execute("SET " + LOG_RECEIVER_HOST + " = " + host);
    statement.execute("SET " + LOG_RECEIVER_PORT + " = " + port);
}

@Test(timeout = 10000)
@SuppressWarnings("deprecation")
public void testRegistrationAfterShutdown() throws Exception {
    loopA.shutdown();
    // Disable logging temporarily.
    Logger root = (Logger) LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
    List<Appender<ILoggingEvent>> appenders = new ArrayList<Appender<ILoggingEvent>>();
    for (Iterator<Appender<ILoggingEvent>> i = root.iteratorForAppenders(); i.hasNext(); ) {
        Appender<ILoggingEvent> a = i.next();
        appenders.add(a);
        root.detachAppender(a);
    }
    try {
        ChannelFuture f = loopA.register(new LocalChannel());
        f.awaitUninterruptibly();
        assertFalse(f.isSuccess());
        assertThat(f.cause(), is(instanceOf(RejectedExecutionException.class)));
        assertFalse(f.channel().isOpen());
    } finally {
        for (Appender<ILoggingEvent> a : appenders) {
            root.addAppender(a);
        }
    }
}

/**
   * Returns all configured appenders.
   */
private static Collection<Appender<ILoggingEvent>> appenders() {
    List<Appender<ILoggingEvent>> result = new ArrayList<>();
    for (Logger l : loggerContext().getLoggerList()) {
        ch.qos.logback.classic.Logger log = (ch.qos.logback.classic.Logger) l;
        Iterator<Appender<ILoggingEvent>> iter = log.iteratorForAppenders();
        while (iter.hasNext()) {
            result.add(iter.next());
        }
    }
    return result;
}

/**
   * Create a stderr appender.
   *
   * @param context The logger context to use.
   * @return An appender writing to stderr.
   */
private static Appender<ILoggingEvent> getStdErrAppender(final LoggerContext context) {
    // Setup format
    final PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    encoder.setContext(context);
    encoder.setPattern("%date{HH:mm:ss.SSS} %property{ident}[%property{pid}]: %-5level [%thread] %logger{0}: %msg%n");
    encoder.setCharset(Charsets.UTF_8);
    encoder.start();
    // Setup stderr appender
    final ConsoleAppender<ILoggingEvent> appender = new ConsoleAppender<ILoggingEvent>();
    appender.setTarget("System.err");
    appender.setName("stderr");
    appender.setEncoder(encoder);
    appender.setContext(context);
    appender.start();
    return appender;
}

// public static String getLog4jFileName(org.apache.log4j.Logger
// log4jLogger) throws Exception{
// Enumeration<org.apache.log4j.Appender> enumAppender =
// log4jLogger.getAllAppenders();
// org.apache.log4j.FileAppender fileAppender = null;
// while (enumAppender.hasMoreElements()) {
// org.apache.log4j.Appender appender = enumAppender.nextElement();
// if (appender instanceof org.apache.log4j.FileAppender) {
// fileAppender = (org.apache.log4j.FileAppender) appender;
// break;
// }
// }
// if (fileAppender != null) {
// return fileAppender.getFile();
//
// }
//
// return null;
// }
public static String getLogFileName() {
    try {
        Logger rootLogger = LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
        if (rootLogger instanceof ch.qos.logback.classic.Logger) {
            ch.qos.logback.classic.Logger logbackLogger = (ch.qos.logback.classic.Logger) rootLogger;
            // Logger framework is Logback
            for (Iterator<ch.qos.logback.core.Appender<ch.qos.logback.classic.spi.ILoggingEvent>> index = logbackLogger.iteratorForAppenders(); index.hasNext(); ) {
                ch.qos.logback.core.Appender<ch.qos.logback.classic.spi.ILoggingEvent> appender = index.next();
                if (appender instanceof ch.qos.logback.core.FileAppender) {
                    ch.qos.logback.core.FileAppender fileAppender = (ch.qos.logback.core.FileAppender) appender;
                    return fileAppender.getFile();
                }
            }
        }
    // else if (rootLogger instanceof org.slf4j.impl.Log4jLoggerAdapter)
    // {
    // // slf4j-log4j
    // org.slf4j.impl.Log4jLoggerAdapter log4jAdapter =
    // (org.slf4j.impl.Log4jLoggerAdapter) rootLogger;
    // try {
    // Field field = log4jAdapter.getClass().getDeclaredField(
    // "logger");
    // field.setAccessible(true);
    // Object obj = field.get(log4jAdapter);
    // if (obj instanceof org.apache.log4j.spi.RootLogger) {
    // return getLog4jFileName((org.apache.log4j.spi.RootLogger) obj);
    // }
    // } catch (Exception e) {
    // e.printStackTrace();
    // }
    //
    // } else if (rootLogger instanceof org.apache.log4j.Logger) {
    // return getLog4jFileName((org.apache.log4j.Logger) rootLogger);
    // }
    } catch (Throwable e) {
        LOG.info("Failed to get root logger file name", e.getMessage());
        return null;
    }
    return null;
}

// public static String getLog4jFileName(org.apache.log4j.Logger
// log4jLogger) throws Exception{
// Enumeration<org.apache.log4j.Appender> enumAppender =
// log4jLogger.getAllAppenders();
// org.apache.log4j.FileAppender fileAppender = null;
// while (enumAppender.hasMoreElements()) {
// org.apache.log4j.Appender appender = enumAppender.nextElement();
// if (appender instanceof org.apache.log4j.FileAppender) {
// fileAppender = (org.apache.log4j.FileAppender) appender;
// break;
// }
// }
// if (fileAppender != null) {
// return fileAppender.getFile();
//
// }
//
// return null;
// }
public static String getLogFileName() {
    try {
        Logger rootLogger = LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
        if (rootLogger instanceof ch.qos.logback.classic.Logger) {
            ch.qos.logback.classic.Logger logbackLogger = (ch.qos.logback.classic.Logger) rootLogger;
            // Logger framework is Logback
            for (Iterator<ch.qos.logback.core.Appender<ch.qos.logback.classic.spi.ILoggingEvent>> index = logbackLogger.iteratorForAppenders(); index.hasNext(); ) {
                ch.qos.logback.core.Appender<ch.qos.logback.classic.spi.ILoggingEvent> appender = index.next();
                if (appender instanceof ch.qos.logback.core.FileAppender) {
                    ch.qos.logback.core.FileAppender fileAppender = (ch.qos.logback.core.FileAppender) appender;
                    return fileAppender.getFile();
                }
            }
        }
    // else if (rootLogger instanceof org.slf4j.impl.Log4jLoggerAdapter)
    // {
    // // slf4j-log4j
    // org.slf4j.impl.Log4jLoggerAdapter log4jAdapter =
    // (org.slf4j.impl.Log4jLoggerAdapter) rootLogger;
    // try {
    // Field field = log4jAdapter.getClass().getDeclaredField(
    // "logger");
    // field.setAccessible(true);
    // Object obj = field.get(log4jAdapter);
    // if (obj instanceof org.apache.log4j.spi.RootLogger) {
    // return getLog4jFileName((org.apache.log4j.spi.RootLogger) obj);
    // }
    // } catch (Exception e) {
    // e.printStackTrace();
    // }
    //
    // } else if (rootLogger instanceof org.apache.log4j.Logger) {
    // return getLog4jFileName((org.apache.log4j.Logger) rootLogger);
    // }
    } catch (Throwable e) {
        LOG.info("Failed to get root logger file name", e.getMessage());
        return null;
    }
    return null;
}

@Override
public void addAppender(Appender<E> appender) {
    aai.addAppender(appender);
}

@Override
public void addAppender(Appender<E> appender) {
    aai.addAppender(appender);
}

public void addAppender(Appender<AuditEvent> newAppender) {
    aai.addAppender(newAppender);
}

public void addAppender(Appender<AuditEvent> newAppender) {
    aai.addAppender(newAppender);
}

public static Appender<ILoggingEvent> wrap(Appender<ILoggingEvent> delegate) {
    final AsyncAppender appender = new AsyncAppender(delegate);
    appender.start();
    return appender;
}

public static void addAppender2Root(Appender<ILoggingEvent> appender) {
    ch.qos.logback.classic.Logger rootLogger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
    rootLogger.addAppender(appender);
}

@Override
public void addAppender(Appender<E> appender) {
    aai.addAppender(appender);
}

public static void verifyLog(Appender<ILoggingEvent> mockAppender, final String substring) {
    verify(mockAppender, atLeastOnce()).doAppend(argThat(isEventContaining(substring)));
}

@Override
public void addAppender(Appender<ILoggingEvent> newAppender) {
    appenderAttachableDelegate.addAppender(newAppender);
}

public static Appender<ILoggingEvent> wrap(Appender<ILoggingEvent> delegate) {
    final AsyncAppender appender = new AsyncAppender(delegate);
    appender.start();
    return appender;
}

/**
     *
     */
public static void stopConsoleLogging() {
    LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
    Logger rootLogger = loggerContext.getLogger(Logger.ROOT_LOGGER_NAME);
    Appender<ILoggingEvent> appender = rootLogger.getAppender("STDOUT");
    appender.stop();
}

protected Logger getAndConfigureLogger(Appender appender) {
    ch.qos.logback.classic.Logger loggerLocal = loggerContext.getLogger(buildLoggerName());
    loggerLocal.setAdditive(false);
    loggerLocal.setLevel(Level.INFO);
    loggerLocal.addAppender(appender);
    return loggerLocal;
}

/** 
	 * Comprueba si el logger seleccionado tiene appender 
	 * 
	 * @param logger el logger a probar
	 * @return true si el logger tiene appenders.
	 */
public static boolean hasAppenders(Logger logger) {
    Iterator<Appender<ILoggingEvent>> it = ((ch.qos.logback.classic.Logger) logger).iteratorForAppenders();
    return it.hasNext();
}

@Override
public void addAppender(Appender<ILoggingEvent> newAppender) {
    aai.addAppender(newAppender);
}

private static void activateLogLevel(Level level, Appender<ILoggingEvent> appender) {
    LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
    for (ch.qos.logback.classic.Logger logger : loggerContext.getLoggerList()) {
        logger.setLevel(level);
        logger.addAppender(appender);
    }
}

private Appender mockLogbackAppender() {
    Appender mockAppender = mock(Appender.class);
    when(mockAppender.getName()).thenReturn("MockAppender");
    return mockAppender;
}

private boolean hasAppenders(ch.qos.logback.classic.Logger logger) {
    Iterator<Appender<ILoggingEvent>> it = logger.iteratorForAppenders();
    return it.hasNext();
}