private void initAppenders() {

RollOverAppenderSettings debugAppender = AppendersFactory.getAppenderSettings(APPENDER.DEBUG);
assert debugAppender != null;
debugAppender.setLoggerName(application.getLoggerName());
debugAppender.setLogFile(getDebugLogFile());
LogUtil.addAppender(debugAppender);

RollOverAppenderSettings auditAppender = AppendersFactory.getAppenderSettings(APPENDER.AUDIT);
assert auditAppender != null;
auditAppender.setLoggerName("audit-" + application.getLoggerName());
auditAppender.setLogFile(getAuditLogFile());
LogUtil.addAppender(auditAppender);
LogUtil.applyLogLevel("audit-" + application.getLoggerName(), "info");

RollOverAppenderSettings trashAppender = AppendersFactory.getAppenderSettings(APPENDER.TRASH);
assert trashAppender != null;
trashAppender.setLoggerName("trash-" + application.getLoggerName());
trashAppender.setLogFile(getTrashLogFile());
LogUtil.addAppender(trashAppender);
LogUtil.applyLogLevel("trash-" + application.getLoggerName(), "info");
}

public class LogUtil {

   protected static Logger logger = LoggerFactory.getLogger(LogUtil.class);
   
   public static void applyLogLevel(String loggerName, String logLevel) {
      Logger log = LoggerFactory.getLogger(loggerName);
      if (!(log instanceof ch.qos.logback.classic.Logger)) {
         logger.debug("cannot set log level. not using logback");
         return;
      }
      ch.qos.logback.classic.Logger logger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(loggerName);
      Level level = Level.INFO;
      try {
         level = Level.valueOf(logLevel.toUpperCase(Locale.ENGLISH));
      } catch (Exception e) {
         logger.error("invalid new log level value {level='" + logLevel+ "'}");
      }
      logger.setLevel(level);
   }
   
   public static void detachAppenders(String loggerName) {
      ch.qos.logback.classic.Logger logbackLogger = getLogger(loggerName);
      
      if (logbackLogger != null) {
         Iterator<Appender<ILoggingEvent>> appenders = logbackLogger.iteratorForAppenders();
         while (appenders.hasNext()) {
            Appender<ch.qos.logback.classic.spi.ILoggingEvent> appender = appenders.next();
            logbackLogger.detachAppender(appender);
         }
       }
      
   }

   public static void removeAndStopAllAppenders(String loggerName) {
       ch.qos.logback.classic.Logger logbackLogger = getLogger(loggerName);
          
       if (logbackLogger != null) {
          logbackLogger.detachAndStopAllAppenders();
       }
   }

   /**
    * @param loggerName
    * @return
    */
   private static ch.qos.logback.classic.Logger getLogger(String loggerName) {
      ILoggerFactory factory = LoggerFactory.getILoggerFactory();
   
      if (!(factory instanceof LoggerContext)) {
         logger.debug("logging service is not using logback. skipping log initialized.");
         return null;
      }
      
     LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
      
     ch.qos.logback.classic.Logger logbackLogger = context.getLogger(loggerName);
      return logbackLogger;
   }
   
   public static void addAppender(RollOverAppenderSettings appender) {
      LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
      
      File logFile = appender.getLogFile();
      
       RollingFileAppender<ILoggingEvent> rfAppender = new RollingFileAppender<>();
       rfAppender.setName(appender.getLoggerName());
       rfAppender.setContext(loggerContext);
       rfAppender.setFile(logFile.getPath());
       
       RollingPolicy rollingPolicy = appender.getRollingPolicy();
       rollingPolicy.setParent(rfAppender);
       rollingPolicy.start();
       
       TriggeringPolicy<ILoggingEvent> triggeringPolicy = appender.getTriggeringPolicy();
       triggeringPolicy.start();

       PatternLayoutEncoder encoder = new PatternLayoutEncoder();
       encoder.setContext(loggerContext);
       encoder.setPattern(appender.getLogEntryPattern());
       encoder.start();

       rfAppender.setEncoder(encoder);
       rfAppender.setRollingPolicy(rollingPolicy);
       rfAppender.setTriggeringPolicy(triggeringPolicy);
       rfAppender.start();

       AsyncAppender asyncAppender = new AsyncAppender();
      asyncAppender.setName(appender.getLoggerName());
      asyncAppender.setContext(loggerContext);
       asyncAppender.setQueueSize(1024);
       asyncAppender.addAppender(rfAppender);
       asyncAppender.start();

       ch.qos.logback.classic.Logger logbackLogger = loggerContext.getLogger(appender.getLoggerName());
       logbackLogger.setAdditive(false);
       logbackLogger.addAppender(asyncAppender);
       
       if (System.getProperty("stdout") != null) {
           ConsoleAppender<ILoggingEvent> consoleAppender = new ConsoleAppender<>();
           PatternLayoutEncoder stdoutEncoder = new PatternLayoutEncoder();
           stdoutEncoder.setContext(loggerContext);
           stdoutEncoder.setPattern("%d{yyyy-MM-dd HH:mm:ss} %c{1} [%p] %m%n");
           stdoutEncoder.start();
           consoleAppender.setEncoder(stdoutEncoder);
           consoleAppender.start();
           logbackLogger.addAppender(consoleAppender);
       }
       
       StatusPrinter.print(loggerContext);
      logger = LoggerFactory.getLogger(appender.getLoggerName());
   }
   
}