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

/**
 * Start a specific file logging, typically for the processing of a given book.
 *
 * @param name      appender name (typically the book radix)
 * @param logFolder target folder where the log file is to be written
 */
public static void addAppender (String name,
                                Path logFolder)
{
    LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
    Logger root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(
            Logger.ROOT_LOGGER_NAME);
    FileAppender fileAppender = new FileAppender();
    PatternLayoutEncoder fileEncoder = new PatternLayoutEncoder();
    fileAppender.setName(name);
    fileAppender.setContext(loggerContext);
    fileAppender.setAppend(false);

    String now = new SimpleDateFormat("yyyyMMdd'T'HHmm").format(new Date());
    Path logFile = logFolder.resolve(name + "-" + now + ".log");
    fileAppender.setFile(logFile.toAbsolutePath().toString());
    fileEncoder.setContext(loggerContext);
    fileEncoder.setPattern("%date %level [%X{BOOK}%X{SHEET}] %25file:%-4line | %msg%n%ex");
    fileEncoder.start();
    fileAppender.setEncoder(fileEncoder);
    fileAppender.start();
    root.addAppender(fileAppender);
}

/**
 * Add a specific appender meant for FILE.
 */
public static void addFileAppender ()
{
    LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
    Logger root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(
            Logger.ROOT_LOGGER_NAME);
    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());
    Path logPath = WellKnowns.LOG_FOLDER.resolve(now + ".log").toAbsolutePath();
    fileAppender.setFile(logPath.toString());
    fileEncoder.setContext(loggerContext);
    fileEncoder.setPattern("%date %-5level [%X{BOOK}%X{SHEET}] %25replace(%file){'\\.java$',''} %-4line | %msg%n%ex");
    fileEncoder.start();
    fileAppender.setEncoder(fileEncoder);
    fileAppender.start();
    root.addAppender(fileAppender);

    System.out.println("LogUtil. Logging to " + logPath);
}

public FileAppender<ILoggingEvent> buildFileAppender(LoggerContext context, String file) {
  FileAppender<ILoggingEvent> fileAppender = new FileAppender<>();
  fileAppender.setFile(file);
  fileAppender.setContext(context);
  fileAppender.setPrudent(true);

  PatternLayoutEncoder encoder = new PatternLayoutEncoder();
  encoder.setContext(context);
  encoder.setPattern(primaryConfiguration.getLoggingPattern().or(baseConfiguration.getLoggingPattern()).or(JavaUtils.LOGBACK_LOGGING_PATTERN));
  encoder.start();

  fileAppender.setEncoder(encoder);
  fileAppender.start();

  return fileAppender;
}

static void logToFile(Parameters parameters) {
    LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
    PatternLayoutEncoder ple = new PatternLayoutEncoder();

    ple.setPattern("%date %level [%thread] %logger{10} [%file:%line] %msg%n");
    ple.setContext(lc);
    ple.start();
    FileAppender<ILoggingEvent> fileAppender = new FileAppender<>();
    fileAppender.setFile(parameters.getWorkingDirectory() + "/jlineup.log");
    fileAppender.setEncoder(ple);
    fileAppender.setContext(lc);
    fileAppender.start();

    ch.qos.logback.classic.Logger logger = (ch.qos.logback.classic.Logger)LoggerFactory.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME);
    logger.addAppender(fileAppender);
    logger.setLevel(Level.DEBUG);
}

private static void setupLogging(TestConfig testConfig) {
    val logFile = new java.io.File(testConfig.getTestLogPath());
    if (logFile.delete()) {
        TestLogger.log("Main", "Deleted log file %s.", logFile.getAbsolutePath());
    }

    // Configure slf4j to not log anything (console or whatever). This interferes with the console interaction.
    LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
    context.getLoggerList().get(0).detachAndStopAllAppenders();

    val fa = new FileAppender<ILoggingEvent>();
    fa.setContext(context);
    fa.setName("selftest");
    fa.setFile(logFile.getAbsolutePath());

    val encoder = new PatternLayoutEncoder();
    encoder.setContext(context);
    encoder.setPattern("%date{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %level - %msg%n");
    encoder.start();
    fa.setEncoder(encoder);
    fa.start();

    context.getLoggerList().get(0).addAppender(fa);
    context.getLoggerList().get(0).setLevel(Level.INFO);
    //context.reset();
}

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

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

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

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

    appender.start();
    return appender;

}

private Logger createLogger(File logFile) {
    LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
    ch.qos.logback.classic.Logger log = loggers.get();
    log.setAdditive(false);

    FileAppender fileAppender = new FileAppender();
    fileAppender.setContext(context);
    fileAppender.setName(Thread.currentThread().getName());
    fileAppender.setFile(logFile.getAbsolutePath());

    PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    encoder.setContext(context);
    encoder.setPattern(LOG_PATTERN);
    encoder.start();

    fileAppender.setEncoder(encoder);
    fileAppender.start();

    log.detachAndStopAllAppenders();
    log.addAppender(fileAppender);

    return log;
}

/**
 * Creates a new logger.
 *
 * @param name a name for the logger
 * @param level the logging level for the logger
 * @param file the file to output all logging to
 * @return the created logger
 */
public static Logger createLogger(String name, Level level, String file) {
  LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
  PatternLayoutEncoder ple = new PatternLayoutEncoder();
  ple.setPattern("%date %level [%thread] %logger{10} [%file:%line]%n%msg%n%n");
  ple.setContext(lc);
  ple.start();
  FileAppender<ILoggingEvent> fileAppender = new FileAppender<ILoggingEvent>();
  fileAppender.setFile(file);
  fileAppender.setEncoder(ple);
  fileAppender.setAppend(false);
  fileAppender.setContext(lc);
  fileAppender.start();
  logger = (Logger) LoggerFactory.getLogger(name);
  logger.detachAndStopAllAppenders(); // detach console (doesn't seem to work)
  logger.addAppender(fileAppender); // attach file appender
  logger.setLevel(level);
  logger.setAdditive(true); // set to true if root should log too

  return logger;
}

@Test
public void smoke() {
  String filename = CoreTestConstants.OUTPUT_DIR_PREFIX + "/fat-smoke.log";

  FileAppender<Object> appender = new FileAppender<Object>();
  appender.setEncoder(new DummyEncoder<Object>());
  appender.setAppend(false);
  appender.setFile(filename);
  appender.setName("smoke");
  appender.setContext(context);
  appender.start();
  appender.doAppend(new Object());
  appender.stop();

  File file = new File(filename);
  assertTrue(file.exists());
  assertTrue("failed to delete " + file.getAbsolutePath(), file.delete());
}

@Test
public void testCreateParentFolders() {
  String filename = CoreTestConstants.OUTPUT_DIR_PREFIX + "/fat-testCreateParentFolders-" + diff
      + "/testCreateParentFolders.txt";
  File file = new File(filename);
  assertFalse(file.getParentFile().exists());
  assertFalse(file.exists());

  FileAppender<Object> appender = new FileAppender<Object>();
  appender.setEncoder(new DummyEncoder<Object>());
  appender.setAppend(false);
  appender.setFile(filename);
  appender.setName("testCreateParentFolders");
  appender.setContext(context);
  appender.start();
  appender.doAppend(new Object());
  appender.stop();
  assertTrue(file.getParentFile().exists());
  assertTrue(file.exists());

  // cleanup
  assertTrue("failed to delete " + file.getAbsolutePath(), file.delete());
  File parent = file.getParentFile();
  assertTrue("failed to delete " + parent.getAbsolutePath(), parent.delete());
}

static LoggerContext buildLoggerContext(String stamp, String filename,
    boolean safetyMode) {
  LoggerContext loggerContext = new LoggerContext();

  FileAppender<ILoggingEvent> fa = new FileAppender<ILoggingEvent>();

  PatternLayoutEncoder patternLayout = new PatternLayoutEncoder();
  patternLayout.setPattern(stamp + " %5p - %m%n");
  patternLayout.setContext(loggerContext);
  patternLayout.start();

  fa.setEncoder(patternLayout);
  fa.setFile(filename);
  fa.setAppend(true);
  fa.setPrudent(safetyMode);
  fa.setContext(loggerContext);
  fa.start();

  ch.qos.logback.classic.Logger root = loggerContext
      .getLogger(Logger.ROOT_LOGGER_NAME);
  root.addAppender(fa);

  return loggerContext;
}

static LoggerContext buildLoggerContext(String filename, boolean safetyMode) {
  LoggerContext loggerContext = new LoggerContext();

  FileAppender<ILoggingEvent> fa = new FileAppender<ILoggingEvent>();

  PatternLayoutEncoder patternLayout = new PatternLayoutEncoder();
  patternLayout.setPattern("%5p %c - %m%n");
  patternLayout.setContext(loggerContext);
  patternLayout.start();

  fa.setEncoder(patternLayout);
  fa.setFile(filename);
  fa.setAppend(false);
  fa.setPrudent(safetyMode);
  fa.setContext(loggerContext);
  fa.start();

  ch.qos.logback.classic.Logger root = loggerContext
      .getLogger(Logger.ROOT_LOGGER_NAME);
  root.addAppender(fa);

  return loggerContext;
}

@SuppressWarnings("rawtypes")
@Test
public void conditionalConsoleApp_IF_THEN_True() throws JoranException,
        IOException, InterruptedException {
  InetAddress localhost = InetAddress.getLocalHost();
  System.out.println("In conditionalConsoleApp_IF_THEN_True, canonicalHostName=\"" + localhost.getCanonicalHostName() + "] and hostNmae=\"" + localhost.getHostName() + "\"");
  context.putProperty("aHost", localhost.getHostName());

  String configFileAsStr = ClassicTestConstants.JORAN_INPUT_PREFIX
          + "conditional/conditionalConsoleApp.xml";
  configure(configFileAsStr);
  FileAppender fileAppender = (FileAppender) root.getAppender("FILE");
  assertNotNull(fileAppender);

  ConsoleAppender consoleAppender = (ConsoleAppender) root.getAppender("CON");
  assertNotNull(consoleAppender);
  StatusChecker checker = new StatusChecker(context);
  checker.assertIsErrorFree();
}

@SuppressWarnings("rawtypes")
@Test
public void conditionalConsoleApp_IF_THEN_False() throws JoranException,
        IOException, InterruptedException {

  String configFileAsStr = ClassicTestConstants.JORAN_INPUT_PREFIX
          + "conditional/conditionalConsoleApp.xml";
  configure(configFileAsStr);
  FileAppender fileAppender = (FileAppender) root.getAppender("FILE");
  assertNotNull(fileAppender);

  ConsoleAppender consoleAppender = (ConsoleAppender) root.getAppender("CON");
  assertNull(consoleAppender);
  StatusChecker checker = new StatusChecker(context);
  checker.assertIsErrorFree();
}

@SuppressWarnings("rawtypes")
 @Test
 public void conditionalConsoleApp_IF_THEN_ELSE() throws JoranException,
         IOException, InterruptedException {

   String configFileAsStr = ClassicTestConstants.JORAN_INPUT_PREFIX
           + "conditional/conditionalConsoleApp_ELSE.xml";
   configure(configFileAsStr);

FileAppender fileAppender = (FileAppender) root.getAppender("FILE");
   assertNotNull(fileAppender);

   ConsoleAppender consoleAppender = (ConsoleAppender) root.getAppender("CON");
   assertNull(consoleAppender);

   ListAppender listAppender = (ListAppender) root.getAppender("LIST");
   assertNotNull(listAppender);

   // StatusPrinter.printIfErrorsOccured(context);
   StatusChecker checker = new StatusChecker(context);
   checker.assertIsErrorFree();
 }

static Logger buildLoggerContext(LoggerContext lc) {
  Logger root = lc.getLogger(Logger.ROOT_LOGGER_NAME);

  PatternLayoutEncoder patternLayout = new PatternLayoutEncoder();
  patternLayout.setContext(lc);
  patternLayout.setPattern("%d %l [%t] - %msg%n");
  patternLayout.start();
  FileAppender<ILoggingEvent> fileAppender = new FileAppender<ILoggingEvent>();
  fileAppender.setContext(lc);
  fileAppender.setFile("target/lbclassic135.log");
  fileAppender.setEncoder(patternLayout);
  fileAppender.setAppend(false);
  fileAppender.start();
  root.addAppender(fileAppender);
  return lc.getLogger(LoggingToFileThroughput.class);
}

public IOPerformance(boolean _immediateFlush, long _len) {
  this.len = _len;
  this.immediateFlush = _immediateFlush;
  context = new LoggerContext();
  logger = context.getLogger("logger-" + getName());

  // A FileAppender is created according to the buffering and
  // immediate flush setting of this IO instance.
  FileAppender<ILoggingEvent> fa = new FileAppender<ILoggingEvent>();
  fa.setName("FILE");
  PatternLayoutEncoder pa = new PatternLayoutEncoder();
  pa.setPattern("%r %5p %c [%t] - %m%n");
  pa.setContext(context);
  pa.start();
  fa.setEncoder(pa);

  fa.setFile(LOG_FILE);
  fa.setAppend(true);
  fa.setContext(context);
  fa.start();

  ((ch.qos.logback.classic.Logger) logger).addAppender(fa);

  StatusPrinter.print(context);
}

/**
 * @{inheritDoc}
 */
public void store(Item item, String alias) {
    if (initialized) {
        FileAppender<ILoggingEvent> appender = appenders.get(alias);
        if (appender==null) {
            synchronized(appenders) {
                // do a second check in case one exists by now
                if (!appenders.containsKey(alias)) {
                    appender = createNewAppender(alias);
                    appenders.put(alias, appender);
                }
            }
        }

        ItemLoggingEvent event = new ItemLoggingEvent(item);
        appender.doAppend(event);
        logger.debug("Logged item '{}' to file '{}.log'", new String[] { item.getName(), alias });
    }
}

protected FileAppender<ILoggingEvent> createNewAppender(String alias) {
    LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();

    PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    encoder.setContext(context);
    encoder.setPattern(pattern);
    encoder.start();

    FileAppender<ILoggingEvent> appender = new FileAppender<ILoggingEvent>();
    appender.setAppend(true);
    appender.setFile(LOG_FOLDER + File.separator + alias + LOG_FILEEXT);
    appender.setEncoder(encoder);
    appender.setContext(context);
    appender.start();

    return appender;
}

@Override
public Appender<ILoggingEvent> buildAppender(Context logcingContext, String fileName) throws JoranException {
    // first sets up the paterns for log layout
    PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    encoder.setPattern(logTemplate);
    encoder.setContext(logcingContext);
    encoder.start();
    // then create a file appender for the given filename
    FileAppender<ILoggingEvent> appender = new FileAppender<ILoggingEvent>();
    appender.setContext(logcingContext);
    appender.setAppend(false);
    appender.setFile(logFolderName + "/" + fileName + ".log");
    appender.setEncoder(encoder);
    appender.start();

    return appender;
}

/**
 * Finds or creates a logger for the test case called tcName with an appender writing 
 * to file named <tcName>.log
 * 
 * @param tcName
 * @return
 */
private Logger getTestCaseLogger(String tcName, String sutName, String sutDir, String testScheduleName) {
    FileAppender<ILoggingEvent> fileAppender = appenderMap.get(tcName);
    if (fileAppender == null) {
        LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
        PatternLayoutEncoder ple = new PatternLayoutEncoder();

        ple.setPattern("%date %level [%logger{36}] [%file:%line] %X{testcase}: %msg%n");
        ple.setContext(lc);
        ple.start();
        fileAppender = new FileAppender<ILoggingEvent>();
        fileAppender.setFile(sutDir + '/' + testScheduleName + '/' + tcName + ".log");
        fileAppender.setEncoder(ple);
        fileAppender.setContext(lc);
        fileAppender.start();
        appenderMap.put(tcName, fileAppender);
    }

    Logger logger = (Logger) LoggerFactory.getLogger(tcName);
    logger.addAppender(fileAppender);
    return logger;
}

protected FileAppender<ILoggingEvent> createRollingFileAppender(Encoder<ILoggingEvent> encoder,
                                                                LoggerContext context,
                                                                RollingPolicyFactory rollingPolicy) {

    RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<>();
    appender.setFile(file);
    appender.setContext(context);
    appender.setEncoder(encoder);
    // Setup rolling policy
    RollingPolicy policy = rollingPolicy.createRollingPolicy(context);
    appender.setRollingPolicy(policy);
    policy.setParent(appender);
    // Setup triggering policy
    TriggeringPolicy<ILoggingEvent> triggeringPolicy = rollingPolicy.createTriggeringPolicy(context);
    if (triggeringPolicy != null) {
        appender.setTriggeringPolicy(triggeringPolicy);
        triggeringPolicy.start();
    }
    policy.start();
    appender.start();

    return appender;
}

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

private static void setOutput(final String... paths) throws IOException {
    LOG_ROOT.getLoggerContext().reset();

    final PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    encoder.setPattern("%date %level [%thread] [%file:%line] %msg%n");
    encoder.setContext(LOG_ROOT.getLoggerContext());
    encoder.start();

    for (final String path : paths) {
        // create FileAppender
        final FileAppender<ILoggingEvent> logfileOut = new FileAppender<>();
        logfileOut.setAppend(false);
        logfileOut.setFile(path);
        logfileOut.setContext(LOG_ROOT.getLoggerContext());
        logfileOut.setEncoder(encoder);
        logfileOut.start();

        // attach the rolling file appender to the root logger
        LOG_ROOT.addAppender(logfileOut);
    }
}

private static void initializeLogFile() {
    final LoggerContext loggerContext = ROOT_LOGGER.getLoggerContext();

    final PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    encoder.setPattern("%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n");
    encoder.setContext(loggerContext);
    encoder.start();

    final FileAppender<ILoggingEvent> fileAppender = new FileAppender<ILoggingEvent>();
    fileAppender.setFile("migration.log");
    fileAppender.setName("file");
    fileAppender.setEncoder(encoder);
    fileAppender.setContext(loggerContext);
    fileAppender.start();

    ROOT_LOGGER.addAppender(fileAppender);
}

private static void setupFileLogging(Logger root, ThresholdFilter filter, String logfilePath) {
    MinimalLayout formatter = new MinimalLayout(root.getLoggerContext());
    formatter.start();

    // setup the file appender
    FileAppender<ILoggingEvent> appender = new FileAppender<>();
    appender.setFile(logfilePath);
    appender.setContext(root.getLoggerContext());
    appender.setLayout(formatter);
    appender.start();

    // wrap it in an async appender
    final AsyncAppender asyncAppender = new AsyncAppender();
    asyncAppender.setContext(root.getLoggerContext());
    asyncAppender.addAppender(appender);
    asyncAppender.addFilter(filter);
    asyncAppender.start();

    // now, add it to the root logger
    root.addAppender(asyncAppender);
}

/**
 * Configure file logging and stop console logging.
 * 
 * @param filename
 *            Log to this file.
 */
@SuppressWarnings("unchecked")
static void logToFile(String filename) {
    Logger rootLogger = (Logger) LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);

    FileAppender<ILoggingEvent> fileappender = new FileAppender<>();
    fileappender.setContext(rootLogger.getLoggerContext());
    fileappender.setFile(filename);
    fileappender.setName("FILE");

    ConsoleAppender<?> console = (ConsoleAppender<?>) rootLogger.getAppender("STDOUT");
    fileappender.setEncoder((Encoder<ILoggingEvent>) console.getEncoder());

    fileappender.start();

    rootLogger.addAppender(fileappender);

    console.stop();
}

private Appender<ILoggingEvent> createAppender(String loggerName, String prefix) {
    Appender<ILoggingEvent> appender;
    FileAppender<ILoggingEvent> fileAppender = new FileAppender<ILoggingEvent>();
    fileAppender.setName(loggerName);
    File file = new File(logDir, prefix + "-" + loggerName + ".log");
    fileAppender.setFile(file.getPath());
    fileAppender.setContext(loggerFactory);
    PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    encoder.setContext(loggerFactory);
    encoder.setPattern("%-5level %d{HH:mm:ss.SSS} [%t] %logger{36} - %msg%n%rEx");
    fileAppender.setEncoder(encoder);
    appender = fileAppender;
    encoder.start();
    appender.start();
    return appender;
}

private FileAppender<ILoggingEvent> getAppender(String pluginId) {
    File pluginLogFileLocation = pluginLogFile(pluginId);

    RollingFileAppender<ILoggingEvent> rollingFileAppender = new RollingFileAppender<>();
    rollingFileAppender.setEncoder(LogHelper.encoder());
    rollingFileAppender.setContext(LogHelper.LOGGER_CONTEXT);
    rollingFileAppender.setFile(pluginLogFileLocation.getPath());
    rollingFileAppender.setName(rollingFileAppenderName(pluginId));

    LogHelper.rollingPolicyForAppender(
            rollingFileAppender,
            "5 MB",
            "20 MB",
            7
    );

    rollingFileAppender.start();
    return rollingFileAppender;
}

private void assertPluginLogFile(String pluginId, String expectedPluginLogFileName) {
    SystemEnvironment systemEnvironment = mock(SystemEnvironment.class);

    DefaultPluginLoggingService loggingService = new DefaultPluginLoggingService(systemEnvironment);
    loggingService.debug(pluginId, "some-logger-name", "message");

    ch.qos.logback.classic.Logger logger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger("plugin." + pluginId);
    ArrayList<Appender<ILoggingEvent>> appenders = new ArrayList<>();
    logger.iteratorForAppenders().forEachRemaining(new Consumer<Appender<ILoggingEvent>>() {
        @Override
        public void accept(Appender<ILoggingEvent> iLoggingEventAppender) {
            appenders.add(iLoggingEventAppender);
        }
    });

    String loggingDirectory = loggingService.getCurrentLogDirectory();
    assertThat(appenders.size(), is(1));
    assertThat(new File(((FileAppender) appenders.get(0)).rawFileProperty()), is(new File(loggingDirectory, expectedPluginLogFileName)));
}

@Override
public Map<String, Object> asJson() {
    LinkedHashMap<String, Object> json = new LinkedHashMap<>();
    json.put("loc.config.dir", systemEnvironment.configDir().getAbsolutePath());

    List<Logger> loggers = LOGGER_CONTEXT.getLoggerList();

    Appender[] appenders = getAppenders(loggers);

    for (int i = 0; i < appenders.length; i++) {
        Appender appender = appenders[i];
        if (!isFileAppender(appender)) {
            continue;
        }
        FileAppender fileAppender = (FileAppender) appender;
        File logFile = new File(fileAppender.rawFileProperty());
        json.put("loc.log.root." + i, new File(logFile.getAbsolutePath()).getParent());
        json.put("loc.log.basename." + i, logFile.getName());
    }

    return json;
}

private static String createRootLogger() {
    LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
    PatternLayoutEncoder ple = new PatternLayoutEncoder();

    ple.setPattern("%d{HH:mm:ss} %-12.-12([%thread])[%-5level] %logger{0} -%msg%n");
    ple.setContext(loggerContext);
    ple.start();

    String fileName = String.format("logs/h2h-log %s.txt",
            new SimpleDateFormat("yyyy-MM-dd_HH-mm-ss").format(System.currentTimeMillis()));
    FileAppender<ILoggingEvent> fileAppender = new FileAppender<ILoggingEvent>();
    fileAppender.setFile(fileName);
    fileAppender.setEncoder(ple);
    fileAppender.setContext(loggerContext);
    fileAppender.start();

    Logger logbackLogger = loggerContext.getLogger(Logger.ROOT_LOGGER_NAME);
    logbackLogger.addAppender(fileAppender);
    logbackLogger.setLevel(Level.DEBUG);
    logbackLogger.setAdditive(false);

    return fileName;
}

public FileAppender<ILoggingEvent> buildFileAppender(LoggerContext context, String file) {
  FileAppender<ILoggingEvent> fileAppender = new FileAppender<>();
  fileAppender.setFile(file);
  fileAppender.setContext(context);
  fileAppender.setPrudent(true);

  PatternLayoutEncoder encoder = new PatternLayoutEncoder();
  encoder.setContext(context);
  encoder.setPattern(primaryConfiguration.getLoggingPattern().or(baseConfiguration.getLoggingPattern()).or(JavaUtils.LOGBACK_LOGGING_PATTERN));
  encoder.start();

  fileAppender.setEncoder(encoder);
  fileAppender.start();

  return fileAppender;
}

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 addFileAppender(String filePath, boolean append) {
    LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
    FileAppender<ILoggingEvent> fileAppender = new FileAppender<ILoggingEvent>();
    fileAppender.setContext(loggerContext);
    fileAppender.setName("css-analyzer");
    // set the file name
    fileAppender.setFile(filePath);
    fileAppender.setAppend(append);

    PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    encoder.setContext(loggerContext);
    //encoder.setPattern("%d{HH:mm:ss.SSS} [%thread] %-5level - %msg [%C{1}]%n");
    encoder.setPattern("%d{HH:mm:ss.SSS} [%thread] %-5level - %msg%n");
    encoder.start();

    fileAppender.setEncoder(encoder);
    fileAppender.start();

    appenders.add(fileAppender);

    logBackLogger.addAppender(fileAppender);
}

/**
 * @{inheritDoc}
 */
@Override
public void store(Item item, String alias) {
    if (initialized) {
        FileAppender<ILoggingEvent> appender = appenders.get(alias);
        if (appender == null) {
            synchronized (appenders) {
                // do a second check in case one exists by now
                if (!appenders.containsKey(alias)) {
                    appender = createNewAppender(alias);
                    appenders.put(alias, appender);
                }
            }
        }

        ItemLoggingEvent event = new ItemLoggingEvent(item);
        appender.doAppend(event);
        logger.debug("Logged item '{}' to file '{}.log'", new String[] { item.getName(), alias });
    }
}

protected FileAppender<ILoggingEvent> createNewAppender(String alias) {
    LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();

    PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    encoder.setContext(context);
    encoder.setPattern(pattern);
    encoder.start();

    FileAppender<ILoggingEvent> appender = new FileAppender<ILoggingEvent>();
    appender.setAppend(true);
    appender.setFile(LOG_FOLDER + File.separator + alias + LOG_FILEEXT);
    appender.setEncoder(encoder);
    appender.setContext(context);
    appender.start();

    return appender;
}

public static Logger createLogger(Path pathLogs, String clientName)
{
    Logger log = (Logger) LoggerFactory.getLogger("Botico-" + clientName);
    log.setLevel(Level.DEBUG);

    LoggerContext cont = (LoggerContext) LoggerFactory.getILoggerFactory();
    PatternLayoutEncoder pat = new PatternLayoutEncoder();
    pat.setPattern("[%date] [%logger{10}|%thread] [%level] %msg%n");
    pat.setContext(cont);
    pat.start();

    FileAppender<ILoggingEvent> fapp = new FileAppender<>();
    fapp.setFile(pathLogs.resolve("botico-" + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd_HH-mm-ss")) + ".log").toString());
    fapp.setEncoder(pat);
    fapp.setContext(cont);
    fapp.start();

    ConsoleAppender<ILoggingEvent> capp = new ConsoleAppender<>();
    capp.setTarget("System.out");
    capp.setContext(cont);
    capp.setEncoder(pat);
    capp.start();

    log.addAppender(fapp);
    log.addAppender(capp);
    log.setAdditive(false);
    return log;
}

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

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

private Logger getNewLogger(String jobID,String fileLogLocation) {
    LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();

    FileAppender<ILoggingEvent> fileAppender = new FileAppender<>();
    fileAppender.setContext(loggerContext);
    fileAppender.setFile(fileLogLocation);

       /*SizeBasedTriggeringPolicy<ILoggingEvent> triggeringPolicy = new SizeBasedTriggeringPolicy<ILoggingEvent>();
       triggeringPolicy.setMaxFileSize("10MB");
       triggeringPolicy.start();*/

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

       fileAppender.setEncoder(encoder);
       fileAppender.start();

       // attach the rolling file appender to the logger of your choice
       Logger logbackLogger = loggerContext.getLogger(jobID);
       ((ch.qos.logback.classic.Logger) logbackLogger).addAppender(fileAppender);

       executionTrackingLoggers.put(jobID, logbackLogger);

    return logbackLogger;
}