Java Examples for org.slf4j.Logger

/**
	 * Checks that slf4j is configured to use a single instance of AcsLogger.
	 * @TODO: check log levels etc
	 */
public void testAcsLoggerFromSlf4j() {
    // hibernate SQL logger 1
    org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger("org.hibernate.SQL");
    validateSlf4jLogger(logger, HibernateLoggerHelper.HIBERNATE_SQL_LOGGER_NAME_PREFIX);
    // hibernate SQL logger 2
    org.slf4j.Logger logger2 = org.slf4j.LoggerFactory.getLogger("org.hibernate.type.XYZ");
    validateSlf4jLogger(logger2, HibernateLoggerHelper.HIBERNATE_SQL_LOGGER_NAME_PREFIX);
    assertSame(logger, logger2);
    // hibernate standard logger
    org.slf4j.Logger logger3 = org.slf4j.LoggerFactory.getLogger("org.hibernate.cfg.Ejb3Column");
    validateSlf4jLogger(logger3, HibernateLoggerHelper.HIBERNATE_LOGGER_NAME_PREFIX);
    assertNotSame(logger, logger3);
    // jacorb logger
    org.slf4j.Logger logger4 = org.slf4j.LoggerFactory.getLogger("org.jacorb.whatever");
    validateSlf4jLogger(logger4, JacorbLoggerHelper.JACORB_LOGGER_NAME);
    // unrecognized logger
    org.slf4j.Logger logger5 = org.slf4j.LoggerFactory.getLogger("myNewFramework.logger3736");
    validateSlf4jLogger(logger5, "UnknownSlf4j");
}

public static void debug(OperationContext opContext, String format, Object... args) {
    if (shouldLog(opContext)) {
        org.slf4j.Logger logger = opContext == null ? LoggerFactory.getLogger(OperationContext.defaultLoggerName) : opContext.getLogger();
        if (logger.isDebugEnabled()) {
            logger.debug(formatLogEntry(opContext, format, args));
        }
    }
}

public static void main(String[] args) {
    Option gOpt = new Option("g", "Generalized end points");
    Option eroOpt = new Option("ero", "Explicit Route Object");
    Option iniOpt = new Option("ini", "Send init message");
    Option ofOpt = OptionBuilder.withArgName("value").hasArg().withDescription("set of value").create("of");
    Option rgbwOpt = OptionBuilder.withArgName("value").hasArg().withDescription("set rgbw value").create("rgbw");
    Option liOpt = OptionBuilder.withArgName("value").hasArg().withDescription("local interface").create("li");
    Options options = new Options();
    options.addOption(liOpt);
    options.addOption(gOpt);
    options.addOption(eroOpt);
    options.addOption(iniOpt);
    options.addOption(ofOpt);
    options.addOption(rgbwOpt);
    if (args.length < 4) {
        //Log.info("Usage: ClientTester <host> <port> <src> <dst> [options]");
        HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp("PCC-QuickClient <host> <port> <src> <dst> [options]", options);
        return;
    }
    CommandLineParser parser = new DefaultParser();
    try {
        CommandLine line = parser.parse(options, args);
        //FileHandler fh2;
        try {
            //fh=new FileHandler("PCCClient2.log");
            //fh2=new FileHandler("PCEPClientParser2.log");
            //fh.setFormatter(new SimpleFormatter());
            //fh2.setFormatter(new SimpleFormatter());
            //Log.addHandler(fh);
            //Log.setLevel(Level.ALL);
            Logger log2 = LoggerFactory.getLogger("PCEPParser");
        //log2.addHandler(fh2);
        //log2.setLevel(Level.ALL);
        } catch (Exception e1) {
            e1.printStackTrace();
            System.exit(1);
        }
        String ip = args[0];
        int port = Integer.valueOf(args[1]).intValue();
        QuickClientObj qcObj = new QuickClientObj(Log, ip, port);
        if (line.hasOption("li")) {
            qcObj.setLocalAddress(line.getOptionValue("li"));
        }
        qcObj.start();
        System.out.println("Creando el mensaje");
        Request req = qcObj.createReqMessage(args[2], args[3], line);
        System.out.println("Peticion " + req.toString());
        PCEPRequest p_r = new PCEPRequest();
        p_r.addRequest(req);
        LinkedList<PCEPMessage> messageList = new LinkedList<PCEPMessage>();
        System.out.println("Enviando mensaje");
        PCEPResponse res = qcObj.sendReqMessage(p_r, messageList);
        System.out.println("Enviado!!!");
        System.out.println("Respuesta " + res.toString());
    } catch (ParseException exp) {
        System.err.println("Parsing failed.  Reason: " + exp.getMessage());
        HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp("PCC-QuickClient <host> <port> <src> <dst> [options]", options);
    }
    System.exit(-1);
}

/**
	 * 打�信�
	 * @param log
	 * @param level
	 * @param msg
	 */
public static void print(org.slf4j.Logger log, String level, String msg) {
    try {
        Method method = org.slf4j.Logger.class.getMethod(level, String.class);
        if (isOnServer) {
            method.invoke(log, msg);
        } else {
            System.out.println(msg);
        }
    } catch (Exception e) {
        if (isOnServer) {
            log.error(e.getMessage());
        } else {
            e.printStackTrace();
        }
    }
}

public static void main(String[] args) {
    Logger logger = LoggerFactory.getLogger(Main.class);
    logger.info("test : {}", System.getProperty("logback.configurationFile", "null"));
    logger.info("info message : {}", "TESTING.");
    logger.debug("debug message : {}", "TESTING.");
    logger.warn("warn message : {}", "TESTING.");
    logger.error("error message : {}", "TESTING.");
}

@Test
public void testTraceMethods() {
    // given
    org.slf4j.Logger slf4jLogger = mock(org.slf4j.Logger.class);
    Logger logger = new LoggerImpl(slf4jLogger);
    Throwable t = new Throwable();
    // when
    logger.isTraceEnabled();
    logger.trace("a");
    logger.trace("a: {}", "b");
    logger.trace("a: {},{}", "b", "c");
    logger.trace("a: {},{},{}", "b", "c", "d");
    logger.trace("a", t);
    // then
    InOrder inOrder = Mockito.inOrder(slf4jLogger);
    inOrder.verify(slf4jLogger).isTraceEnabled();
    inOrder.verify(slf4jLogger).trace("a");
    inOrder.verify(slf4jLogger).trace("a: {}", "b");
    inOrder.verify(slf4jLogger).trace("a: {},{}", "b", "c");
    inOrder.verify(slf4jLogger).trace("a: {},{},{}", "b", "c", "d");
    inOrder.verify(slf4jLogger).trace("a", t);
    verifyNoMoreInteractions(slf4jLogger);
}

/**
     * 获å?– 创建Logger 的时候的实例，æ??供利用率
     *
     * @param className loggerçš„å??称
     * @return
     */
private static org.slf4j.Logger getLoggerInstance(String className) {
    if (loggerHashMap == null)
        loggerHashMap = new WeakHashMap<String, org.slf4j.Logger>();
    if (loggerHashMap.containsKey(className)) {
        return loggerHashMap.get(className);
    } else {
        org.slf4j.Logger logger = LoggerFactory.getLogger(className);
        loggerHashMap.put(className, logger);
        return logger;
    }
}

public static void writeLog(Logger logger, SLF4JLogLevel logLevel, String message) {
    switch(logLevel) {
        case DEBUG:
            logger.debug(message);
            break;
        case ERROR:
            logger.error(message);
            break;
        case INFO:
            logger.info(message);
            break;
        case TRACE:
            logger.trace(message);
            break;
        case WARN:
            logger.warn(message);
            break;
    }
}

/**
     * Gets an {@link XMLResourceBundle} wrapped SLF4J {@link org.slf4j.Logger}.
     *
     * @param aName A class to use for the logger name
     * @param aBundleName The name of the resource bundle to use
     * @return A resource bundle aware logger
     */
public static final Logger getLogger(final String aName, final String aBundleName) {
    final ILoggerFactory factory = org.slf4j.LoggerFactory.getILoggerFactory();
    final Logger logger;
    if (aBundleName != null) {
        logger = new Logger(factory.getLogger(aName), aBundleName);
    } else {
        logger = new Logger(factory.getLogger(aName));
    }
    return logger;
}

public Logger getLogger(String name) {
    Logger simpleLogger = loggerMap.get(name);
    if (simpleLogger != null) {
        return simpleLogger;
    } else {
        Logger newInstance = new JPOSLogger(name);
        Logger oldInstance = loggerMap.putIfAbsent(name, newInstance);
        return oldInstance == null ? newInstance : oldInstance;
    }
}

@Test
public void doTest() {
    System.out.println("message 1");
    System.err.println("message 2");
    final Logger sysOutLogger = spy(Logger.class);
    final Logger sysErrLogger = spy(Logger.class);
    SecurityUtil.bindSystemStreamsToSLF4J(sysOutLogger, sysErrLogger);
    System.out.println("message 3");
    System.err.println("message 4");
    SecurityUtil.unbindSystemStreams();
    System.out.println("message 5");
    System.err.println("message 6");
    verify(sysOutLogger, only()).info("message 3");
    verify(sysErrLogger, only()).error("message 4");
}

@Test
public void emptyMessages() {
    ValidationMessages messages = ValidationMessages.create();
    assertThat(messages.hasErrors()).isFalse();
    assertThat(messages.hasWarnings()).isFalse();
    assertThat(messages.hasInfos()).isFalse();
    Logger logger = mock(Logger.class);
    messages.log(logger);
    verify(logger, never()).error(anyString());
    verify(logger, never()).warn(anyString());
    verify(logger, never()).info(anyString());
    org.slf4j.Logger slf4j = mock(org.slf4j.Logger.class);
    messages.log(slf4j);
    verify(slf4j, never()).error(anyString());
    verify(slf4j, never()).warn(anyString());
    verify(slf4j, never()).info(anyString());
}

public void runTests(RunnableTest<U> runnableTest, U[] testData) throws Exception {
    StackTraceElement ste = Thread.currentThread().getStackTrace()[2];
    Logger LOG = LoggerFactory.getLogger(ste.getClassName());
    for (U testDatum : testData) {
        if (LOG.isDebugEnabled()) {
            LOG.debug(String.format("Running test with data %1$s", testDatum));
        }
        runnableTest.runTest(testDatum);
    }
}

public static void main(String[] args) {
    Logger logger = LoggerFactory.getLogger(SampleLogging.class);
    LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
    try {
        JoranConfigurator configurator = new JoranConfigurator();
        lc.reset();
        configurator.setContext(lc);
        configurator.doConfigure(args[0]);
    } catch (JoranException je) {
    }
    StatusPrinter.printInCaseOfErrorsOrWarnings(lc);
    logger.debug("Everything's going well");
    logger.error("maybe not quite...");
}

/////////////////////////////////////////////////////////
@Test
public void testGdsHashChange() throws IOException {
    GribIosp.setDebugFlags(new DebugFlagsImpl("Grib/debugGbxIndexOnly"));
    FeatureCollectionConfig config = new FeatureCollectionConfig("NDFD-CONUS_noaaport", "test/NDFD-CONUS_noaaport", FeatureCollectionType.GRIB2, TestDir.cdmUnitTestDir + "gribCollections/gdsHashChange/noaaport/.*gbx9", null, null, null, "file", null);
    // 	  <gdsHash from='-1506003048' to='-1505079527'/>
    config.gribConfig.addGdsHash("-1506003048", "-1505079527");
    org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger("test");
    boolean changed = GribCdmIndex.updateGribCollection(config, updateMode, logger);
    System.out.printf("changed = %s%n", changed);
    // LOOK add check that records were combined
    try (NetcdfFile ncfile = NetcdfFile.open(TestDir.cdmUnitTestDir + "gribCollections/gdsHashChange/noaaport/NDFD-CONUS_noaaport.ncx3", null)) {
        Group root = ncfile.getRootGroup();
        Assert.assertEquals(2, root.getGroups().size());
        Group twoD = root.findGroup("TwoD");
        assert twoD != null;
        Assert.assertEquals(0, twoD.getGroups().size());
    }
    GribIosp.setDebugFlags(new DebugFlagsImpl(""));
}

@Test
public void syslog() {
    final JewelCliLoggingOptions mockOptions = Mockito.mock(JewelCliLoggingOptions.class);
    when(mockOptions.syslog()).thenReturn(true);
    when(mockOptions.logFileName()).thenReturn("");
    when(mockOptions.ident()).thenReturn("test");
    JewelCliLoggingConfigurator.configure(mockOptions);
    final org.slf4j.Logger logger = LoggerFactory.getLogger(JewelCliLoggingConfiguratorTest.class);
    logger.error("this is an error message", new Exception());
}

@SuppressWarnings("unchecked")
public void logHashCodes(DBObject dbObject, Logger log) {
    Object id = dbObject.get(MongoConstants.ID);
    log.trace("Object ID [{}]: hashCode [{}]", id, dbObject.hashCode());
    Map<String, Object> dbMap = dbObject.toMap();
    for (String key : Ordering.natural().sortedCopy(dbMap.keySet())) {
        Object value = dbMap.get(key);
        Integer hashCode = value != null ? value.hashCode() : null;
        log.trace("Object ID [{}]: Key [{}], hashCode [{}], Value: [{}]", new Object[] { id, key, hashCode, value });
    }
    log.trace("Done logging hashes for {}", id);
}

public static void main(String[] args) throws IOException {
    Logger logger = LoggerFactory.getLogger(Main.class);
    ClassPathResource rsc = new ClassPathResource("config.properties");
    logger.info(IOUtils.toString(rsc.getInputStream()));
    Main m = new Main();
    logger.info(Integer.toString(m.add(1, 2)));
    logger.info(m.repeat('A', 3));
}

/* Use with the provided logger, so that logging appear in the correct context. */
public static void traceClassLoaderHierarchy(Logger logger) {
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    logger.trace("Classloader hierarchy starting from Thread Context Class Loader:");
    try {
        do {
            logger.trace("    -> " + cl);
        } while ((cl = cl.getParent()) != null);
    } catch (Exception e) {
        logger.trace("Failed to list all classloaders", e);
    }
}

@Test
public void appenderContextIsSet() throws Exception {
    final Logger root = (Logger) LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
    final SyslogAppenderFactory appenderFactory = new SyslogAppenderFactory();
    final Appender<ILoggingEvent> appender = appenderFactory.build(root.getLoggerContext(), "test", new DropwizardLayoutFactory(), new NullLevelFilterFactory<>(), new AsyncLoggingEventAppenderFactory());
    assertThat(appender.getContext()).isEqualTo(root.getLoggerContext());
}

public static void main(String[] args) throws Exception {
    final EgonetUncaughtExceptionHandler eueh = new EgonetUncaughtExceptionHandler();
    Thread.setDefaultUncaughtExceptionHandler(eueh);
    Logger logger = LoggerFactory.getLogger(EgonetRunner.class);
    // track!
    EgonetAnalytics.track("application startup");
    SwingUtilities.invokeLater(new Runnable() {

        public void run() {
            Thread.currentThread().setUncaughtExceptionHandler(eueh);
        }
    });
    logger.debug("Configuring L&F to default system L&F");
    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
    logger.info("EgonetRunner is building EgonetFrame");
    EgonetFrame egonetFrame = new EgonetFrame();
    egonetFrame.setSize(800, 600);
    egonetFrame.setExtendedState(JFrame.NORMAL | JFrame.MAXIMIZED_BOTH);
    egonetFrame.setVisible(true);
}

/* Use with the provided logger, so that logging appear in the correct context. */
public static void traceClassLoaderHierarchy(Logger logger) {
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    logger.trace("Classloader hierarchy starting from Thread Context Class Loader:");
    try {
        do {
            logger.trace("    -> " + cl);
        } while ((cl = cl.getParent()) != null);
    } catch (Exception e) {
        logger.trace("Failed to list all classloaders", e);
    }
}

@Override
public Logger getLogger(String name) {
    Logger logger = map.get(name);
    if (logger != null) {
        return logger;
    } else {
        Log log = LogFactory.getInstance().getLog(name);
        if (log != null) {
            Logger newInstance = new LoggerImpl(log);
            Logger oldInstance = map.putIfAbsent(name, newInstance);
            return oldInstance == null ? newInstance : oldInstance;
        } else {
            return null;
        }
    }
}

public static void main(String[] args) {
    final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(HearthSimMain.class);
    if (args.length < 1) {
        log.error("Usage: java -jar hearthsim.jar setupFilePath");
        System.exit(0);
    }
    String simDefinitionPath = args[0];
    log.info("starting sim from file: {}", simDefinitionPath);
    Path simParamFilePath = FileSystems.getDefault().getPath(simDefinitionPath);
    try {
        HearthSimBase sim = new HearthSimConstructed(simParamFilePath);
        sim.run();
    } catch (IOException e) {
        log.error("Can't find some files! {}", e);
    } catch (HSException e) {
        log.error("Something went wrong with the simulation: {}" + e);
    } catch (InterruptedException e) {
        log.error("Interrupted: {}" + e);
    }
}

public static void main(String[] args) {
    final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(HearthSimMain.class);
    if (args.length < 1) {
        log.error("Usage: java -jar hearthsim.jar setupFilePath");
        System.exit(0);
    }
    String simDefinitionPath = args[0];
    log.info("starting sim from file: {}", simDefinitionPath);
    Path simParamFilePath = FileSystems.getDefault().getPath(simDefinitionPath);
    try {
        HearthSimBase sim = new HearthSimConstructed(simParamFilePath);
        sim.run();
    } catch (IOException e) {
        log.error("Can't find some files! {}", e);
    } catch (HSException e) {
        log.error("Something went wrong with the simulation: {}" + e);
    } catch (InterruptedException e) {
        log.error("Interrupted: {}" + e);
    }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.home_layout);
    findViewById(R.id.press_me_button).setOnClickListener(new View.OnClickListener() {

        @Override
        public void onClick(View view) {
            Logger log = LoggerFactory.getLogger(HomeActivity.class);
            log.info("hello world");
            startActivity(NamesActivity.class);
        }
    });
}

public static Logger getLogger(String name) {
    Platform platform = Platform.getLocalInstance();
    if (platform.isDalvik()) {
        String android = name.substring(name.lastIndexOf(".") + 1);
        if (android.length() > 23)
            android = android.substring(0, 23);
        // Bug-173-New-slf4j-android-Android-throws-an-IllegalArgumentException-when-Log-Tag-length-exceeds-23-s-td443886.html
        return org.slf4j.LoggerFactory.getLogger(android);
    } else {
        return org.slf4j.LoggerFactory.getLogger(name);
    }
}

@Override
protected int compare(T e1, T e2) {
    try {
        Double d1 = fn.apply(e1);
        Double d2 = fn.apply(e2);
        if (d1 == null && d2 == null)
            return 0;
        if (d1 == null || d2 == null)
            return d1 == null ? -1 : 1;
        return d1.compareTo(d2);
    } catch (Exception e) {
        Logger log = LoggerFactory.getLogger(getClass());
        log.error("failed to compare " + e1 + " and " + e2 + " with double function on column " + column, e);
        return 0;
    }
}

private void mapGeometry(Location location, JsonObject obj) {
    if (location.getKmz() == null)
        return;
    try {
        byte[] bin = BinUtils.unzip(location.getKmz());
        String kml = new String(bin, "utf-8");
        JsonObject geoJson = Kml2GeoJson.convert(kml);
        Out.put(obj, "geometry", geoJson);
    } catch (Exception e) {
        Logger log = LoggerFactory.getLogger(getClass());
        log.error("failed to convert KML to GeoJSON", e);
    }
}

public static List<ResourceModelEncoder.DocsProvider> findDocProviders(Logger log, boolean loadAdditionalDocProviders) {
    List<ResourceModelEncoder.DocsProvider> providers = new ArrayList<>();
    if (loadAdditionalDocProviders) {
        try {
            providers.add((ResourceModelEncoder.DocsProvider) Class.forName("com.linkedin.restli.tools.scala.ScalaDocsProvider").newInstance());
        } catch (ClassNotFoundExceptionInstantiationException | IllegalAccessException |  ignored) {
            log.warn("Attempted to load ScalaDocsProvider but it was not found. Please add 'com.linkedin.pegasus:restli-tools-scala_<scala-version>:<pegasus-version>' to your classpath.");
        } catch (Throwable t) {
            log.info("Failed to initialize ScalaDocsProvider class", t);
        }
    }
    return providers;
}

@Override
@NotNull
public List<String> getClassPath() {
    List<String> classpath = new ArrayList<>();
    classpath.add(PathUtil.getJarPathForClass(Ant.class));
    classpath.add(PathUtil.getJarPathForClass(GroovyObject.class));
    classpath.add(PathUtil.getJarPathForClass(Gson.class));
    classpath.add(PathUtil.getJarPathForClass(Logger.class));
    classpath.add(PathUtil.getJarPathForClass(Log4jLoggerFactory.class));
    return classpath;
}

/**
     * Starts an S4 server.
     * 
     * @param args
     */
public static void main(String[] args) {
    final Logger logger = LoggerFactory.getLogger(Main.class);
    /*
         * Need to get name of plugin module. Load ControllerModule to get
         * configuration.
         */
    Injector injector = Guice.createInjector(new org.apache.s4.core.Module());
    Server server = injector.getInstance(Server.class);
    try {
        server.start();
    } catch (Exception e) {
        logger.error("Failed to start the controller.", e);
    }
}

public EntityManagerFactory entityManagerFactory() {
    try {
        // assuming single threaded startup
        if (emfInstance == null) {
            emfInstance = Persistence.createEntityManagerFactory("transactions-optional");
        }
        return emfInstance;
    } catch (RuntimeException e) {
        Logger log = LoggerFactory.getLogger(getClass());
        log.error("Couldn't create EntityManagerFactory", e);
        throw e;
    } catch (Error e) {
        Logger log = LoggerFactory.getLogger(getClass());
        log.error("Couldn't create EntityManagerFactory", e);
        throw e;
    }
}

@Override
public Logger getLogger(String name) {
    AndroidLoggerAdapter adapter = loggerAdaptersMap.get(name);
    if (adapter == null) {
        synchronized (loggerAdaptersMap) {
            adapter = loggerAdaptersMap.get(name);
            if (adapter == null) {
                adapter = createLogger(name);
                loggerAdaptersMap.put(name, adapter);
            }
        }
    }
    return adapter;
}

@Override
public Logger getLogger(String name) {
    if (name == null) {
        throw new NullPointerException();
    }
    // the root logger is called "" in JUL
    if (Logger.ROOT_LOGGER_NAME.equalsIgnoreCase(name)) {
        name = "";
    }
    Logger logger = loggers.get(name);
    if (logger == null) {
        logger = new GWTLoggerAdapter(name);
        loggers.put(name, logger);
    }
    return logger;
}

public static void main(String[] args) throws IOException {
    File logFile = new File(LOG_FILE);
    logFile.delete();
    AppConfig appConfig = SdkAppConfig.getInstance();
    appConfig.set(AppConfig.TC_TOKEN, "1:301:a2f6c6e7-2952-4c07-8249-4c75c477cb40:1468248049:Ok35Q:2vmDWmqJoSQKAFdwfzeLViYJBByD/0qBArJaspvLPgM=");
    LoggerUtil.reconfigureGlobalLogger(logFile, appConfig);
    Logger logger = LoggerFactory.getLogger(ServerLogMain.class);
    logger.info("Log Test 1");
    logger.info("Log Test 2");
    Exception e = new IllegalArgumentException("Some argument was not valid");
    logger.error(e.getMessage(), e);
    logger.info("Log Test 3");
    Assert.assertTrue(logFile.length() > 0);
    ServerLogger.getInstance().flushToServer();
    logger.debug("Log Test 4");
    logger.debug("Log Test 5");
    ServerLogger.getInstance().flushToServer();
}

@Test
public void testLogException() throws Exception {
    Logger logger = mock(Logger.class);
    LoggingSQLExceptionMapper sqlExceptionMapper = new LoggingSQLExceptionMapper();
    LoggingSQLExceptionMapper.setLogger(logger);
    RuntimeException runtimeException = new RuntimeException("DB is down");
    SQLException sqlException = new SQLException("DB error", runtimeException);
    sqlExceptionMapper.logException(4981, sqlException);
    verify(logger).error("Error handling a request: 0000000000001375", sqlException);
    verify(logger).error("Error handling a request: 0000000000001375", runtimeException);
}

public EntityManagerFactory entityManagerFactory() {
    try {
        // assuming single threaded startup
        if (emfInstance == null) {
            emfInstance = Persistence.createEntityManagerFactory("transactions-optional");
        }
        return emfInstance;
    } catch (RuntimeException e) {
        Logger log = LoggerFactory.getLogger(getClass());
        log.error("Couldn't create EntityManagerFactory", e);
        throw e;
    } catch (Error e) {
        Logger log = LoggerFactory.getLogger(getClass());
        log.error("Couldn't create EntityManagerFactory", e);
        throw e;
    }
}

@Test
public void testLogMessageIsDisplayed() throws Exception {
    ZooDirectorLogDialog logDialog = new ZooDirectorLogDialog();
    Logger testLogger = LoggerFactory.getLogger(ZooDirectorLogDialogTest.class);
    String testMessage = "test message";
    testLogger.error(testMessage);
    testLogger.info(testMessage);
    Matcher testErrorMessageMatcher = CoreMatchers.containsString("ERROR : " + testMessage);
    Matcher testInfoMessageMatcher = CoreMatchers.containsString("INFO  : " + testMessage);
    Assert.assertThat(logDialog.logTextArea.getText(), testErrorMessageMatcher);
    Assert.assertThat(logDialog.logTextArea.getText(), testInfoMessageMatcher);
    Assert.assertThat(logDialog.lastLogTextField.getText(), testInfoMessageMatcher);
}

public ConnectionPoolConfigurationPublisher createPublisher(String applicationName, String clusterName, ConnectionPoolConfiguration config) {
    if (config.getConfigurationPublisherConfig() != null) {
        try {
            JSONObject json = new JSONObject(config.getConfigurationPublisherConfig());
            String vip = json.getString("vip");
            if (vip != null) {
                String type = json.getString("type");
                if (type != null) {
                    ConnectionPoolConfigurationPublisher.PublisherType publisherType = ConnectionPoolConfigurationPublisher.PublisherType.valueOf(type.toUpperCase(Locale.ENGLISH));
                    if (ConnectionPoolConfigurationPublisher.PublisherType.ELASTIC == publisherType) {
                        return new ElasticConnectionPoolConfigurationPublisher(applicationName, clusterName, vip, config);
                    }
                }
            }
        } catch (JSONException e) {
            Logger.warn("Invalid json specified for config publisher: " + e.getMessage());
        }
    }
    return null;
}

@SuppressWarnings("unchecked")
public static void main(String... args) {
    Cli.CliBuilder<Callable<?>> builder = Cli.builder("grub");
    builder.withDescription("generates projects from templates").withDefaultCommand(Help.class).withCommands(GenerateCommand.class, VersionCommand.class, Help.class);
    Cli<Callable<?>> parser = builder.build();
    int exitValue;
    try {
        Callable<?> callable = null;
        try {
            callable = parser.parse(args);
        } catch (ParseException e) {
            List<String> argList = Arrays.asList(args);
            if (argList.contains("-v") || argList.contains("--verbose")) {
                throw e;
            }
            logger.error("{}", e.getMessage());
            System.exit(-1);
        }
        boolean verbose = false;
        try {
            if (callable instanceof GenerateCommand) {
                GenerateCommand command = (GenerateCommand) callable;
                Logger rootLogger = (Logger) LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
                if (command.isVerbose()) {
                    rootLogger.setLevel(Level.DEBUG);
                    verbose = true;
                } else if (command.isQuiet()) {
                    rootLogger.setLevel(Level.WARN);
                }
            }
            Object result = callable.call();
            if (result instanceof Integer) {
                exitValue = (Integer) result;
            } else {
                exitValue = 0;
            }
        } catch (GrubException e) {
            if (verbose) {
                throw e;
            }
            logGrubExceptions(e);
            exitValue = -1;
        }
    } catch (Exception e) {
        logger.error("Exception:", e);
        exitValue = -1;
    }
    System.exit(exitValue);
}

@Test
public void configuredWithFile() {
    final URL url = getClass().getClassLoader().getResource("logback-amqp.xml");
    try {
        final JoranConfigurator configurator = new JoranConfigurator();
        configurator.setContext(this.context);
        this.context.reset();
        configurator.doConfigure(new File(url.getFile()));
    } catch (final JoranException e) {
        fail(e.getMessage());
    }
    final Logger root = this.context.getLogger(Logger.ROOT_LOGGER_NAME);
    root.error(this.message);
}

@Test
public void read() throws Exception {
    URL location = Logger.class.getProtectionDomain().getCodeSource().getLocation();
    JarFile jarFile = new JarFile(location.getPath());
    logger.debug("jarFile:{}", jarFile.getName());
    JarReader jarReader = new JarReader(jarFile);
    List<FileBinary> fileBinaries = jarReader.read(ExtensionFilter.CLASS_FILTER);
    logger.debug("file:{}", fileBinaries);
    for (FileBinary fileBinary : fileBinaries) {
        Assert.assertThat(fileBinary.getFileName(), Matchers.endsWith(".class"));
    }
}

@Test
public void read() throws Exception {
    URL location = Logger.class.getProtectionDomain().getCodeSource().getLocation();
    JarFile jarFile = new JarFile(location.getPath());
    logger.debug("jarFile:{}", jarFile.getName());
    JarReader jarReader = new JarReader(jarFile);
    List<FileBinary> fileBinaries = jarReader.read(ExtensionFilter.CLASS_FILTER);
    logger.debug("file:{}", fileBinaries);
    for (FileBinary fileBinary : fileBinaries) {
        Assert.assertThat(fileBinary.getFileName(), Matchers.endsWith(".class"));
    }
}

/**
   * The Logger is a special case because it knows the injection point of the injected member. It's
   * the only binding that does this.
   */
private static void bindLogger(InjectorImpl injector) {
    Key<Logger> key = Key.get(Logger.class);
    LoggerFactory loggerFactory = new LoggerFactory();
    injector.state.putBinding(key, new ProviderInstanceBindingImpl<Logger>(injector, key, SourceProvider.UNKNOWN_SOURCE, loggerFactory, Scoping.UNSCOPED, loggerFactory, ImmutableSet.<InjectionPoint>of()));
    try {
        Key<org.slf4j.Logger> slf4jKey = Key.get(org.slf4j.Logger.class);
        SLF4JLoggerFactory slf4jLoggerFactory = new SLF4JLoggerFactory(injector);
        injector.state.putBinding(slf4jKey, new ProviderInstanceBindingImpl<org.slf4j.Logger>(injector, slf4jKey, SourceProvider.UNKNOWN_SOURCE, slf4jLoggerFactory, Scoping.UNSCOPED, slf4jLoggerFactory, ImmutableSet.<InjectionPoint>of()));
    } catch (Throwable e) {
    }
}

@VisibleForTesting
public void initialize(String rootLoggerName) {
    ILoggerFactory loggerFactory = LoggerFactory.getILoggerFactory();
    // TODO: fix logging issue in mapreduce:  ENG-3279
    if (!(loggerFactory instanceof LoggerContext)) {
        LOG.warn("LoggerFactory is not a logback LoggerContext. No log appender is added. " + "Logback might not be in the classpath");
        return;
    }
    LoggerContext loggerContext = (LoggerContext) loggerFactory;
    Logger rootLogger = loggerContext.getLogger(rootLoggerName);
    LOG.info("Initializing log appender {}", logAppender.getName());
    // Display any errors during initialization of log appender to console
    StatusManager statusManager = loggerContext.getStatusManager();
    OnConsoleStatusListener onConsoleListener = new OnConsoleStatusListener();
    statusManager.add(onConsoleListener);
    logAppender.setContext(loggerContext);
    logAppender.start();
    rootLogger.addAppender(logAppender);
}

public Logger getChildLogger(String name) {
    String current = this.slf4jLogger.getName();
    org.slf4j.Logger child = null;
    if (current == null || current.trim().length() == 0) {
        child = LoggerFactory.getLogger(name);
    } else {
        child = LoggerFactory.getLogger(slf4jLogger.getName() + "." + name);
    }
    return new SLF4JLoggerAdapter(child);
}

/**
     * Returns the client log file and handles occurring errors.
     * @return The client log file, if file logging is activated. Otherwise
     *         null is returned.
     */
public File getClientLogFile() {
    final File clientLogFile;
    // Get location of log file
    Logger logger = LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
    Iterator<Appender<ILoggingEvent>> appenders = new ArrayList<Appender<ILoggingEvent>>().iterator();
    if (logger instanceof ch.qos.logback.classic.Logger) {
        appenders = ((ch.qos.logback.classic.Logger) logger).iteratorForAppenders();
    }
    FileAppender<?> fileAppender = null;
    while (appenders.hasNext() && fileAppender == null) {
        Object enumElement = appenders.next();
        if (enumElement instanceof FileAppender) {
            fileAppender = (FileAppender<?>) enumElement;
        }
    }
    if (fileAppender != null) {
        clientLogFile = new File(fileAppender.getFile());
    } else {
        clientLogFile = null;
        // Ask user to turn on file logging
        ErrorHandlingUtil.createMessageDialog(MessageIDs.I_FILE_LOGGING_NOT_ENABLED, new String[] { "Jubula" }, //$NON-NLS-1$
        null);
    }
    return clientLogFile;
}

public static void bootstrap() {
    // Initially configure for DEBUG console logging
    final LoggingConfiguration.ConsoleConfiguration console = new LoggingConfiguration.ConsoleConfiguration();
    console.setEnabled(true);
    console.setTimeZone(TimeZone.getDefault());
    console.setThreshold(Level.DEBUG);
    final Logger root = getCleanRoot();
    root.addAppender(LogbackFactory.buildConsoleAppender(console, root.getLoggerContext(), null));
    final LoggingConfiguration.FileConfiguration file = new LoggingConfiguration.FileConfiguration();
    root.addAppender(LogbackFactory.buildFileAppender(file, root.getLoggerContext(), null));
    // Add this to indicate that logging has bootstrapped with synchronous default settings
    log.info("LoggingFactory bootstrap completed.");
}

public static void main(String[] args) throws IOException, InterruptedException {
    Logger log = LoggerFactory.getLogger(Publisher.class);
    String publishName = "test";
    String localFile = "red5.flv";
    String host = "192.168.1.200";
    int port = 1935;
    String app = "live";
    IMessage msg = null;
    int timestamp = 0;
    int lastTS = 0;
    PublishClient client = new PublishClient();
    client.setHost(host);
    client.setPort(port);
    client.setApp(app);
    client.start(publishName, "live", null);
    while (client.getState() != PublishClient.PUBLISHED) {
        Thread.sleep(500);
    }
    FileProvider fp = new FileProvider(new File(localFile));
    while (true) {
        msg = fp.pullMessage(null);
        if (msg == null) {
            log.debug("done!");
            break;
        }
        timestamp = ((RTMPMessage) msg).getBody().getTimestamp();
        Thread.sleep((timestamp - lastTS));
        lastTS = timestamp;
        client.pushMessage(msg);
    }
    client.stop();
}

@PostConstruct
public void init() {
    logger.info(">> Create CamelContext and register Camel Route.");
    try {
        context.addRoutes(new RouteBuilder() {

            @Override
            public void configure() {
                from("timer://timer1?period=1000").setBody().simple("Camel").beanRef("helloCamel", "sayHello").log(">> Response : ${body}");
            }
        });
        context.addRoutes(new UserRouteBuilder());
    } catch (Exception ex) {
        java.util.logging.Logger.getLogger(Bootstrap.class.getName()).log(Level.SEVERE, null, ex);
    }
    // Start Camel Context
    context.start();
    logger.info(">> CamelContext created and camel route started.");
}

@Override
public void init() {
    Logger logger = LoggerFactory.getLogger(getClass());
    if (!config.isEnabled()) {
        logger.warn("Swagger scanner not enabled");
        return;
    }
    logger.info("Swagger scanner enabled");
    final BeanConfig beanConfig = new BeanConfig();
    beanConfig.setResourcePackage(config.getResourcePackage());
    beanConfig.setBasePath(config.getBasePath());
    beanConfig.setLicense(config.getLicense());
    beanConfig.setLicenseUrl(config.getLicenseUrl());
    beanConfig.setScan(true);
    beanConfig.setVersion(config.getVersion());
}

@Override
public void log(Logger log) {
    if (this.getExitReason() != null && this.getExitReason().getResult() == ProcessResult.SUCCESS) {
        return;
    } else if (this.getExitReason().isRethrow()) {
        if (this.getExitReason().isError()) {
            log.error("Exiting with code [{}] : {} : [{}]", this.getExitReason(), this.getCause().getClass().getSimpleName(), this.getCause().getMessage());
        } else {
            log.debug("Exiting with code [{}] : {} : [{}]", this.getExitReason(), this.getCause().getClass().getSimpleName(), this.getCause().getMessage());
        }
    } else if (this.getExitReason().isError()) {
        log.error("Exiting with code [{}] : {}", this.getExitReason(), this.getMessage(), this.getCause());
    } else {
        log.debug("Exiting with code [{}] : {}", this.getExitReason(), this.getMessage(), this.getCause() != null ? this.getCause().getMessage() : StringUtils.EMPTY);
    }
}

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

@Override
protected void onHandleIntent(Intent intent) {
    GoogleApiClient client = new GoogleApiClient.Builder(this).addApi(Wearable.API).build();
    client.blockingConnect();
    NodeApi.GetConnectedNodesResult connectedNodes = Wearable.NodeApi.getConnectedNodes(client).await();
    Logger logger = LoggerFactory.getLogger("Android_Wear_Detection_Service");
    List<Node> devices = connectedNodes.getNodes();
    for (Node device : devices) {
        logger.debug("Android Wear " + device.getId() + " connected");
        AndroidWearDevices.setDeviceConnected(device, true);
    }
    PebbleLockerApplication.getBus().post(new StatusChangedEvent());
}

public static void showInfo(LockResponse lr, IPersistentObject object, Logger log) {
    if (object == null) {
        if (log == null) {
            log = LoggerFactory.getLogger(LockResponseHelper.class);
        }
        log.warn("showInfo for null object", new Throwable());
    }
    if (LockResponse.Status.DENIED_PERMANENT == lr.getStatus()) {
        SWTHelper.showError(Messages.DenyLockPermanent_Title, Messages.DenyLockPermanent_Message);
    } else {
        if (log != null) {
            log.warn("Unable to acquire lock for " + ((object != null) ? object.storeToString() : "null") + " - " + lr.getLockInfo().getUser() + "@" + lr.getLockInfo().getSystemUuid());
        }
        String format = MessageFormat.format(Messages.DenyLock_Message, lr.getLockInfo().getUser() + "@" + lr.getLockInfo().getSystemUuid());
        SWTHelper.showError(Messages.DenyLock_Title, format);
    }
}

public static void main(String[] args) throws InterruptedException {
    //Topology definition
    TopologyBuilder builder = new TopologyBuilder();
    builder.setSpout("word-reader", new TestSpout());
    builder.setBolt("word-normalizer", new TestBolt()).shuffleGrouping("word-reader");
    builder.setBolt("word-counter", new PrintTestBolt(), 1).fieldsGrouping("word-normalizer", new Fields("word"));
    Logger logger = LoggerFactory.getLogger("test");
    logger.info("Test");
    //Configuration
    Config conf = new Config();
    conf.put("wordsFile", "/Users/ravi/Documents/github/others/examples-ch02-getting_started/src/main/resources/words.txt");
    conf.setDebug(false);
    //Topology run
    conf.put(Config.TOPOLOGY_MAX_SPOUT_PENDING, 1);
    LocalCluster cluster = new LocalCluster();
    cluster.submitTopology("Getting-Started-Toplogie", conf, builder.createTopology());
    logger.info("waiting for 10 seconds to finish");
    Thread.sleep(10000);
    logger.info("shutdown started");
    cluster.shutdown();
}

@PostConstruct
@Override
public void configure() {
    LOGGER.info("Start configuring logging system using Zookeeper");
    String serviceName = serviceAdvertiser.getServiceProperties().getServiceName().toLowerCase();
    String hostname = readHostname(serviceAdvertiser);
    Logger applicationRootLogger = Logger.getRootLogger();
    loggerUpdater.update(applicationRootLogger, APPLICATION_INSTANCE_NAME_MARKER, hostname);
    loggerUpdater.addKafkaAppender(applicationRootLogger, kafkaBrokerList, kafkaTopicName, serviceName, hostname);
    LOGGER.info("Logging system configuration finished");
}

public static void main(final String[] args) throws Exception {
    org.apache.log4j.Logger.getRootLogger().setLevel(org.apache.log4j.Level.WARN);
    final String instanceName = (System.getProperty("instanceName") != null) ? System.getProperty("instanceName") : "geowave";
    final String password = (System.getProperty("password") != null) ? System.getProperty("password") : "password";
    final String[] shellArgs = new String[] { "-u", "root", "-p", password, "-z", instanceName, "localhost:2181" };
    /*
		 * ConsoleReader reader = new ConsoleReader(System.in, System.out, new
		 * WindowsTerminal()); Shell s = new Shell(reader, new
		 * PrintWriter(System.out)); s.execute(shellArgs);
		 */
    Shell.main(shellArgs);
}

public static <T> T process(FailoverConf conf, Logger logger, FailoverQuery<T> query) throws HectorException {
    if (conf.getMaxRetries() == 0) {
        throw new IllegalArgumentException("Invalid retries count: " + conf.getMaxRetries());
    }
    int retryCount = 0;
    int currSleepBetweenRetries = Math.min(conf.getStartSleepBetweenRetriesMs(), conf.getMaxSleepBetweenRetriesMs());
    while (true) {
        HectorException exception;
        try {
            return query.query();
        } catch (HTimedOutException e) {
            exception = e;
        } catch (HUnavailableException e) {
            exception = e;
        }
        retryCount++;
        if (conf.getMaxRetries() > 0 && retryCount >= conf.getMaxRetries()) {
            throw exception;
        }
        if (logger != null) {
            logger.error(String.format("Failovering: retries count - %1$s, sleep between - %2$s\n", retryCount, currSleepBetweenRetries), exception);
        }
        try {
            Thread.sleep(currSleepBetweenRetries);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        currSleepBetweenRetries = Math.min((int) (currSleepBetweenRetries * conf.getSleepBetweenRetriesIncreaseRatio() + 0.5), conf.getMaxSleepBetweenRetriesMs());
    }
}

/**
	 * {@inheritDoc}
	 */
@Override
public Object postProcessBeforeInitialization(final Object bean, String beanName) {
    ReflectionUtils.doWithFields(bean.getClass(), new FieldCallback() {

        @Override
        public void doWith(Field field) throws IllegalAccessException {
            if (field.getAnnotation(Log.class) != null) {
                Logger log = LoggerFactory.getLogger(bean.getClass());
                ReflectionUtils.makeAccessible(field);
                field.set(bean, log);
            }
        }
    });
    return bean;
}

//-------------------------------------------------------------
// Methods - Public
//-------------------------------------------------------------
public Object manageMongoDBSession(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    try {
        Logger logger = LoggerFactory.getLogger(proceedingJoinPoint.getSourceLocation().getWithinType());
        MongoDBSession.create(logger, proceedingJoinPoint.getSignature().toShortString());
        Object result = proceedingJoinPoint.proceed();
        MongoDBSession.flush();
        return result;
    } finally {
        MongoDBSession.remove();
    }
}

/**
	 * @param args
	 */
public static void main(String[] args) {
    //		System.out.println("TempMain");
    //		System.out.println(628331966747D);
    //throw new UnsupportedOperationException();
    Logger logger = LoggerFactory.getLogger(TempMain.class);
    //levels of logging in order from most to least
    System.out.println("Trace enabled? " + logger.isTraceEnabled());
    System.out.println("Debug enabled? " + logger.isDebugEnabled());
    System.out.println("Info enabled? " + logger.isInfoEnabled());
    System.out.println("Warn enabled? " + logger.isWarnEnabled());
    System.out.println("Error enabled? " + logger.isErrorEnabled());
    Marker fatal = MarkerFactory.getMarker("FATAL");
    logger.info("Hello World");
    int i = 20;
    logger.debug("test {} go", i);
    logger.error("error type");
    logger.error(fatal, "custom marker--?? (how do I actually see the marker?)");
    logger.warn("warn");
    logger.trace("trace");
    // print internal state
    LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
    StatusPrinter.print(lc);
}

@Test
public void log() {
    logger.log(Logger.Level.DEBUG, "Foobar");
    logger.log(Logger.Level.DEBUG, "Params {}{}", "Arg1", "Arg2");
    try {
        throw new RuntimeException("Bar");
    } catch (RuntimeException ex) {
        logger.log(Logger.Level.DEBUG, "Params with Throwable {}{}", "Arg1", "Arg2", ex);
        slf4jLogger.debug("SLF4J-Message with Throwable", ex);
    }
    try {
        throw new RuntimeException("Bar", new IOException("Foo"));
    } catch (RuntimeException ex) {
        logger.log(Logger.Level.DEBUG, "Params with Throwable & Cause {}{}", "Arg1", "Arg2", ex);
        slf4jLogger.debug("SLF4J-Message with Throwable & Cause", ex);
    }
}

@Override
public Logger getLogger(final String name) {
    if (name == null) {
        throw new IllegalArgumentException("name must not be null");
    }
    final Logger logger = loggers.get(name);
    if (logger != null) {
        return logger;
    } else {
        Logger newInstance = new EgymLogger(name);
        Logger oldInstance = loggers.putIfAbsent(name, newInstance);
        return oldInstance == null ? newInstance : oldInstance;
    }
}

public static void initializeEXPath(Processor p) {
    Logger log = LoggerFactory.getLogger(Compiler.class);
    // initialize the EXPath package manager
    Class<?> pkgInitializerClass;
    try {
        pkgInitializerClass = Class.forName("org.expath.pkg.saxon.PkgInitializer");
        Object pkgInitializer = null;
        try {
            pkgInitializer = pkgInitializerClass.newInstance();
        } catch (InstantiationException e) {
            log.error(e.getMessage());
            return;
        } catch (IllegalAccessException e) {
            log.error(e.getMessage());
            return;
        }
        Method initialize = pkgInitializerClass.getMethod("initialize", Configuration.class);
        initialize.invoke(pkgInitializer, p.getUnderlyingConfiguration());
    } catch (ClassNotFoundException e) {
        log.error("EXPath repository declared, but EXPath Saxon package support classes are not available", e);
    } catch (SecurityException e) {
        log.error(e.getMessage());
    } catch (NoSuchMethodException e) {
        log.error(e.getMessage());
    } catch (IllegalArgumentException e) {
        log.error(e.getMessage());
    } catch (IllegalAccessException e) {
        log.error(e.getMessage());
    } catch (InvocationTargetException e) {
        log.error(e.getMessage());
    }
}

public static void logJavaProperties(Logger log) {
    Properties javaProperties = System.getProperties();
    SortedMap<String, String> sortedProperties = new TreeMap<String, String>();
    for (String key : javaProperties.stringPropertyNames()) {
        sortedProperties.put(key, javaProperties.getProperty(key));
    }
    //$NON-NLS-1$
    log.debug("Java properties (ordered by property name):");
    for (String key : sortedProperties.keySet()) {
        log.debug("   {}={}", key, sortedProperties.get(key));
    }
}

@Scheduled(fixedRateString = "${logback.root.logger.checker.fixed.rate:5000}")
public void check() {
    if (active) {
        Logger root = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
        Level actualLevel = root.getLevel();
        if (!actualLevel.toString().equals(correctLevelStr)) {
            root.setLevel(Level.toLevel(correctLevelStr));
            logger.warn("Logback log level {} was incorrect. Changed to {}", actualLevel.toString(), correctLevelStr);
        }
    }
}

@Test
public void testGetLoggerExistingInstance() {
    Logger logger1 = slf4jLoggerRepository.getLogger(Slf4jLoggerRepositoryTest.class.getName());
    Logger logger2 = slf4jLoggerRepository.getLogger(Slf4jLoggerRepositoryTest.class.getName());
    assertEquals(logger1.getName(), logger2.getName());
    assertEquals(logger1, logger2);
    assertEquals(1, slf4jLoggerRepository.numberOfLeafNodes());
}

@Test
public void testGetLoggerExistingInstance() {
    Logger logger1 = slf4jLoggerRepository.getLogger(Slf4jLoggerRepositoryTest.class.getName());
    Logger logger2 = slf4jLoggerRepository.getLogger(Slf4jLoggerRepositoryTest.class.getName());
    assertEquals(logger1.getName(), logger2.getName());
    assertEquals(logger1, logger2);
    assertEquals(1, slf4jLoggerRepository.numberOfLeafNodes());
}

@Test
public void shouldFormatLogMessages() {
    // given
    Logger mockLogger = mock(Logger.class);
    LogFormatter logFormatter = new LogFormatter(mockLogger);
    when(mockLogger.isInfoEnabled()).thenReturn(true);
    // when
    logFormatter.infoLog("some random message with {} and {}", "some" + System.getProperty("line.separator") + "multi-line" + System.getProperty("line.separator") + "object", "another" + System.getProperty("line.separator") + "multi-line" + System.getProperty("line.separator") + "object");
    // then
    verify(mockLogger).isInfoEnabled();
    verify(mockLogger).info("some random message with {} and {}" + System.getProperty("line.separator"), new Object[] { System.getProperty("line.separator") + System.getProperty("line.separator") + "\tsome" + System.getProperty("line.separator") + "\tmulti-line" + System.getProperty("line.separator") + "\tobject" + System.getProperty("line.separator"), System.getProperty("line.separator") + System.getProperty("line.separator") + "\tanother" + System.getProperty("line.separator") + "\tmulti-line" + System.getProperty("line.separator") + "\tobject" + System.getProperty("line.separator") });
}

@Test
public void test() {
    final Logger log = LoggerFactory.getLogger(SimpleTimerTest.class);
    log.info("Calling some work!");
    timer.startTimer();
    timer.startTimer();
    pointlessWork();
    log.info("elapsed time " + timer.elapsedTime() + " ns");
    log.info("Calling some work!");
    pointlessWork();
    log.info("elapsed time " + timer.elapsedTime() + " ns");
    timer.stopTimer();
    log.info("Test run, total time " + timer.totalTime() + " ns");
}

public static PrintStream getPrintStream(String category, PrintStream orignal) {
    final Logger logger = LoggerFactory.getLogger(category);
    return new PrintStream(new OutputStream() {

        StringBuilder currentLine = new StringBuilder();

        @Override
        public synchronized void write(int b) throws IOException {
            if (b == '\r' || b == '\n') {
                //Line is complete, log it
                if (currentLine.toString().trim().length() > 0) {
                    String s = currentLine.toString();
                    if (Character.isWhitespace(s.charAt(0))) {
                        logger.trace(Markers.STDERR_MARKER, currentLine.toString());
                    } else {
                        logger.debug(Markers.STDERR_MARKER, currentLine.toString());
                    }
                }
                currentLine = new StringBuilder();
            } else {
                //append to the line being built
                currentLine.append((char) b);
            }
        }
    });
}

/**
     * This method should be used only at {@link BackendUtils} code for creating
     * and execution {@link BackendUtils} objects directly.
     * @return proxy object to create the {@link BackendUtils} objects and run them
     */
public static BackendCommandObjectsHandler getBackendCommandObjectsHandler(Logger log) {
    InitialContext ctx = null;
    try {
        ctx = new InitialContext();
        return (BackendCommandObjectsHandler) ctx.lookup(BACKEND_COMMAND_OBJECTS_HANDLER_JNDI_NAME);
    } catch (NamingException e) {
        log.error("Getting backend command objects handler failed: {}", e.getMessage());
        log.debug("Exception", e);
        return null;
    } finally {
        closeContext(log, ctx);
    }
}

@Override
public void contextInitialized(ServletContextEvent sce) {
    // Jersey uses java.util.logging - bridge to slf4
    java.util.logging.Logger rootLogger = LogManager.getLogManager().getLogger("");
    Handler[] handlers = rootLogger.getHandlers();
    for (int i = 0; i < handlers.length; i++) {
        rootLogger.removeHandler(handlers[i]);
    }
    SLF4JBridgeHandler.install();
    LOGGER.info("jul-to-slf4j installed");
}

public RuntimeConfigBuilder defaultsWithLogger(Command command, org.slf4j.Logger logger) {
    defaults(command);
    processOutput().overwriteDefault(PostgresProcessOutputConfig.getInstance(command, logger));
    IDownloadConfig downloadConfig = new PostgresDownloadConfigBuilder().defaultsForCommand(command).progressListener(new Slf4jProgressListener(logger)).build();
    artifactStore().overwriteDefault(storeBuilder().defaults(command).download(downloadConfig).build());
    return this;
}

@Override
public Logger getLogger(String name) {
    Logger logger = null;
    try {
        // protect against concurrent access of the loggerMap
        synchronized (this) {
            logger = loggerMap.get(name);
            if (logger == null) {
                if (file == null) {
                    file = openFile();
                }
                logger = new CsvLogger(name, file);
                loggerMap.put(name, logger);
            }
        }
    } catch (FileNotFoundException e) {
        logger = nopLoggerFactory.getLogger(name);
    }
    return logger;
}

public void init(Config cfg) {
    org.slf4j.Logger slf4jRoot = LoggerFactory.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME);
    if (!(slf4jRoot instanceof Logger))
        return;
    String logLevel = System.getProperty("qdbLogLevel", cfg.getString("logLevel"));
    Logger root = (Logger) slf4jRoot;
    root.setLevel(Level.toLevel(logLevel));
    String graylog2 = cfg.getString("graylog2");
    if (graylog2 != null && graylog2.length() > 0) {
        int i = graylog2.indexOf(":");
        int port;
        if (i > 0) {
            port = Integer.parseInt(graylog2.substring(i + 1));
            graylog2 = graylog2.substring(0, i);
        } else {
            port = 12201;
        }
        GelfAppender<ILoggingEvent> ga = new GelfAppender<ILoggingEvent>();
        ga.setName("graylog2");
        ga.setFacility("qdb");
        ga.setGraylog2ServerHost(graylog2);
        ga.setGraylog2ServerPort(port);
        ga.setGraylog2ServerVersion(cfg.getString("graylog2ServerVersion"));
        ga.setUseLoggerName(true);
        ga.setUseThreadName(true);
        root.addAppender(ga);
        ga.start();
    }
}

@Test
@PrepareForTest(LoggerFactory.class)
public void listenerThrowsException() throws Exception {
    // given
    Logger loggerMock = Mockito.mock(Logger.class);
    PowerMockito.mockStatic(LoggerFactory.class);
    Mockito.when(LoggerFactory.getLogger(ListenerNotifier.class)).thenReturn(loggerMock);
    AbstractRdp4jListener listenerMock = Mockito.mock(AbstractRdp4jListener.class);
    Mockito.doThrow(RuntimeException.class).when(listenerMock).beforeStart(Mockito.any(BeforeStartEvent.class));
    PolledDirectory directoryMock = Mockito.mock(PolledDirectory.class);
    // when
    DirectoryPoller dp = DirectoryPoller.newBuilder().addListener(listenerMock).addPolledDirectory(directoryMock).start();
    dp.stop();
    // then
    Mockito.verify(loggerMock).error(Mockito.anyString(), Mockito.any(Throwable.class));
}

public final void initLogger() {
    LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
    lc.reset();
    ch.qos.logback.classic.Logger root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
    if (BuildConfig.DEBUG) {
        // setup LogcatAppender
        PatternLayoutEncoder logCatEncoder = new PatternLayoutEncoder();
        logCatEncoder.setContext(lc);
        logCatEncoder.setPattern("monk-[%thread] %msg%n");
        logCatEncoder.start();
        LogcatAppender logcatAppender = new LogcatAppender();
        logcatAppender.setContext(lc);
        logcatAppender.setEncoder(logCatEncoder);
        logcatAppender.start();
        root.addAppender(logcatAppender);
    }
    if (mSettingsHelper.getDebugFlag()) {
        // setup FileAppender
        File logFile = new File(mSettingsHelper.getDataDirectoryPath(), SettingsHelper.DEBUG_FILE);
        PatternLayoutEncoder fileEncoder = new PatternLayoutEncoder();
        fileEncoder.setContext(lc);
        fileEncoder.setPattern("%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n");
        fileEncoder.start();
        FileAppender<ILoggingEvent> fileAppender = new FileAppender<>();
        fileAppender.setContext(lc);
        File save = new File(logFile.getAbsolutePath());
        fileAppender.setFile(save.getAbsolutePath());
        fileAppender.setEncoder(fileEncoder);
        fileAppender.setPrudent(true);
        fileAppender.setLazy(false);
        fileAppender.start();
        root.addAppender(fileAppender);
    }
}

@Override
public <T> void hear(TypeLiteral<T> typeLiteral, TypeEncounter<T> typeEncounter) {
    Set<Field> fields = new HashSet<>();
    for (Class<?> c = typeLiteral.getRawType(); c != Object.class; c = c.getSuperclass()) {
        for (Field field : c.getDeclaredFields()) {
            if (field.getType() == Logger.class && field.isAnnotationPresent(Logging.class)) {
                fields.add(field);
            }
        }
    }
    if (!fields.isEmpty()) {
        typeEncounter.register(new LoggingMembersInjector<>(fields));
    }
}

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

/**
     * {@inheritDoc}
     * 
     * @return
     */
@Override
public int verify(String identifier, char[] secret) {
    RegistrationService registrationService = BeanFactory.getRegistrationServiceBean();
    // log.info("SeqWare Verifier called");
    Registration registration = registrationService.findByEmailAddress(identifier);
    Logger.getLogger(SeqWareVerifier.class).debug(registration);
    if (registration != null) {
        String pass = new String(secret).trim();
        if (registration.getPassword() == null) {
            if (pass.isEmpty() || pass.equals("null")) {
                return RESULT_VALID;
            } else {
                return RESULT_INVALID;
            }
        } else if (registration.getPassword().equals(pass)) {
            return RESULT_VALID;
        } else {
            return RESULT_INVALID;
        }
    } else {
        return RESULT_MISSING;
    }
}

protected void handleError(String action, String rolename, String username, ClientResponse clientResponse, Logger logger) {
    clientResponse.bufferEntity();
    int status = clientResponse.getStatus();
    if (status >= 300) {
        String message = clientResponse.getEntity(String.class);
        logger.error("Action {}\nRolename {}\nUsername {}\nStatus {}\nMessage {}", action, rolename, username, status, message);
        throw new WebApplicationException(Response.status(status).entity(message).build());
    }
}

@SuppressFBWarnings("DM_EXIT")
public void sendStatusUpdate(ExecutorDriver driver, Protos.TaskInfo taskInfo, Protos.TaskState taskState, String message, Logger logger) {
    logger.info("Sending status update \"{}\" ({})", message, taskState.name());
    message = message.substring(0, Math.min(configuration.getMaxTaskMessageLength(), message.length()));
    try {
        final Protos.TaskStatus.Builder builder = Protos.TaskStatus.newBuilder().setTaskId(taskInfo.getTaskId()).setState(taskState).setMessage(message);
        driver.sendStatusUpdate(builder.build());
    } catch (Throwable t) {
        try {
            logger.error("Exception while sending status updates, exiting", t);
        } finally {
            System.exit(4);
        }
    }
}

/**
   * Return an appropriate {@link TimberLoggerAdapter} instance by name.
   */
@Override
public Logger getLogger(String name) {
    String tag = createTag(name);
    Logger logger = loggerMap.get(tag);
    if (logger == null) {
        Logger newInstance = new TimberLoggerAdapter(tag);
        Logger oldInstance = loggerMap.putIfAbsent(tag, newInstance);
        logger = oldInstance == null ? newInstance : oldInstance;
    }
    return logger;
}

public static void validateView(ViewDefinition view, Logger logger) {
    Set<Var> patternVars = QuadPatternUtils.getVarsMentioned(view.getTemplate());
    Set<Var> bindingVars = new HashSet<Var>();
    for (Node bindingVar : view.getMapping().getVarDefinition().getMap().keySet()) {
        bindingVars.add((Var) bindingVar);
    }
    Set<Var> unboundPatternVars = Sets.difference(patternVars, bindingVars);
    if (!unboundPatternVars.isEmpty()) {
        //throw new RuntimeException("View " + view.getName() + ": Unbound pattern variables: " + unboundPatternVars);
        logger.error("View " + view.getName() + ": Unbound pattern variables: " + unboundPatternVars);
    }
    Set<Var> unreferencedBindingVars = Sets.difference(bindingVars, patternVars);
    if (!unreferencedBindingVars.isEmpty()) {
        logger.warn("View " + view.getName() + ": Unreferenced binding variables: " + unreferencedBindingVars);
    }
}

/**
	 * 对有@Traced标记的方法,记录其执行�数�返回结果.
	 */
@Around("execution(@Traced * *(..))")
public Object logAground(ProceedingJoinPoint pjp) throws Throwable {
    Class<?> sourceClass = pjp.getSignature().getDeclaringType();
    Logger logger = LoggerFactory.getLogger(sourceClass);
    Object result = null;
    try {
        logger.debug(pjp.toShortString());
        result = pjp.proceed();
        return result;
    } finally {
        if (result != null && logger.isDebugEnabled()) {
            logger.debug("{} return {}", pjp.getSignature().toShortString(), result.toString());
        }
    }
}

@Test
public void test() {
    try {
        DummyClock clock = ClockUtil.useDummyClock();
        Logger realLogger = LoggerFactory.getLogger(ThrottledSlf4jLoggerTest.class);
        LogbackListAppender appender = LogbackListAppender.create(ThrottledSlf4jLoggerTest.class);
        // 间隔10毫秒
        ThrottledSlf4jLogger logger = new ThrottledSlf4jLogger(realLogger, 10, TimeUnit.MILLISECONDS);
        logger.warn("haha");
        assertThat(appender.getLogsCount()).isEqualTo(1);
        // still 1
        logger.warn("haha {}", 1);
        assertThat(appender.getLogsCount()).isEqualTo(1);
        // still 1
        logger.error("haha {}", 1);
        assertThat(appender.getLogsCount()).isEqualTo(1);
        // still 1
        clock.increaseTime(5);
        logger.error("haha, {} {} {}", 1, 2, 3);
        assertThat(appender.getLogsCount()).isEqualTo(1);
        // 10ms pass
        clock.increaseTime(5);
        logger.warn("haha");
        assertThat(appender.getLogsCount()).isEqualTo(2);
        // still 2
        logger.warn("haha {} {} {}", 1, 2, 3);
        assertThat(appender.getLogsCount()).isEqualTo(2);
        // still 2
        clock.increaseTime(7);
        logger.warn("haha");
        assertThat(appender.getLogsCount()).isEqualTo(2);
    } finally {
        ClockUtil.useDefaultClock();
    }
}

@Test
public void test() {
    try {
        DummyClock clock = ClockUtil.useDummyClock();
        Logger realLogger = LoggerFactory.getLogger(ThrottledSlf4jLoggerTest.class);
        LogbackListAppender appender = LogbackListAppender.create(ThrottledSlf4jLoggerTest.class);
        // 间隔10毫秒
        ThrottledSlf4jLogger logger = new ThrottledSlf4jLogger(realLogger, 10, TimeUnit.MILLISECONDS);
        logger.warn("haha");
        assertThat(appender.getLogsCount()).isEqualTo(1);
        // still 1
        logger.warn("haha {}", 1);
        assertThat(appender.getLogsCount()).isEqualTo(1);
        // still 1
        logger.error("haha {}", 1);
        assertThat(appender.getLogsCount()).isEqualTo(1);
        // still 1
        clock.increaseTime(5);
        logger.error("haha, {} {} {}", 1, 2, 3);
        assertThat(appender.getLogsCount()).isEqualTo(1);
        // 10ms pass
        clock.increaseTime(5);
        logger.warn("haha");
        assertThat(appender.getLogsCount()).isEqualTo(2);
        // still 2
        logger.warn("haha {} {} {}", 1, 2, 3);
        assertThat(appender.getLogsCount()).isEqualTo(2);
        // still 2
        clock.increaseTime(7);
        logger.warn("haha");
        assertThat(appender.getLogsCount()).isEqualTo(2);
    } finally {
        ClockUtil.useDefaultClock();
    }
}

public static void log(LogLevel level, String event) {
    Logger logger = LoggerFactory.getLogger(ImgLogger.class);
    switch(level) {
        case DEBUG:
            logger.debug(event);
            break;
        case WARN:
            logger.warn(event);
            break;
        case INFO:
            logger.info(event);
            break;
        default:
            break;
    }
}

public static Object newInstance(String className, String name, Logger logger) {
    if (StringUtils.isBlank(className)) {
        logger.error("A {} must be provided", name);
        throw new RuntimeException("You must provide a parser class");
    }
    try {
        Class<?> classObject = Class.forName(className);
        return classObject.newInstance();
    } catch (ClassNotFoundException ex) {
        String error = String.format(NOT_FOUND_ERROR, name, className);
        logger.error(error, ex);
        throw new RuntimeException(error, ex);
    } catch (IllegalAccessException ex) {
        String error = String.format(ILLEGAL_ACCESS_ERROR, name, className);
        logger.error(error, ex);
        throw new RuntimeException(error, ex);
    } catch (InstantiationException ex) {
        String error = String.format(INSTANTIATION_ERROR, name, className);
        logger.error(error, ex);
        throw new RuntimeException(error, ex);
    }
}

public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
    // make the field accessible if defined private
    ReflectionUtils.makeAccessible(field);
    if (field.getAnnotation(Log.class) != null) {
        Logger log = LoggerFactory.getLogger(bean.getClass().getName());
        field.set(bean, log);
    } else if (field.getAnnotation(DbLog.class) != null) {
        String loggerName = "db." + bean.getClass().getName();
        Logger log = LoggerFactory.getLogger(loggerName);
        field.set(bean, log);
    }
}

/**
     * For debugging purpose
     * 
     * @param criteria
     */
public static void printParsedMatchCriteria(Logger log, MatchCriteria criteria, String indent) {
    if (criteria instanceof Comparison) {
        log.debug(indent + criteria.toString());
    } else if (criteria instanceof ComparisonList) {
        log.debug(indent + "ComparisonList (");
        for (Comparison c : ((ComparisonList) criteria).comparisons) {
            log.debug(indent + "  " + c.toString());
        }
        log.debug(indent + ")");
    } else if (criteria instanceof Condition) {
        log.debug(indent + criteria.toString());
    } else if (criteria instanceof ANDedConditions) {
        log.debug(indent + "AND (");
        for (MatchCriteria c : ((ExpressionList) criteria).expressions) {
            printParsedMatchCriteria(log, c, indent + "  ");
        }
        log.debug(indent + ")");
    } else if (criteria instanceof ORedConditions) {
        log.debug(indent + "OR (");
        for (MatchCriteria c : ((ExpressionList) criteria).expressions) {
            printParsedMatchCriteria(log, c, indent + "  ");
        }
        log.debug(indent + ")");
    }
}

/**
     * Logs the request headers, if debug is enabled.
     *
     * @param request - Request to Check
     * @param logger - logger to use when logging
     */
public static void logRequestHeaders(final Logger logger, final HttpServletRequest request) {
    if (logger.isDebugEnabled()) {
        Enumeration enumeration = request.getHeaderNames();
        StringBuffer logLine = new StringBuffer();
        logLine.append("Request Headers");
        while (enumeration.hasMoreElements()) {
            String name = (String) enumeration.nextElement();
            String headerValue = request.getHeader(name);
            logLine.append(": ").append(name).append(" -> ").append(headerValue);
        }
        logger.debug(logLine.toString());
    }
}

private void configureLogbackDirectly() {
    // reset the default context (which may already have been initialized)
    // since we want to reconfigure it
    LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
    lc.reset();
    // setup FileAppender
    PatternLayoutEncoder encoder1 = new PatternLayoutEncoder();
    encoder1.setContext(lc);
    encoder1.setPattern("%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n");
    encoder1.start();
    FileAppender<ILoggingEvent> fileAppender = new FileAppender<>();
    fileAppender.setContext(lc);
    fileAppender.setFile(this.getFileStreamPath("app.log").getAbsolutePath());
    fileAppender.setEncoder(encoder1);
    fileAppender.start();
    // setup LogcatAppender
    PatternLayoutEncoder encoder2 = new PatternLayoutEncoder();
    encoder2.setContext(lc);
    encoder2.setPattern("[%thread] %msg%n");
    encoder2.start();
    LogcatAppender logcatAppender = new LogcatAppender();
    logcatAppender.setContext(lc);
    logcatAppender.setEncoder(encoder2);
    logcatAppender.start();
    // backup the newly created appenders to the root logger;
    // qualify Logger to disambiguate from org.slf4j.Logger
    ch.qos.logback.classic.Logger root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
    root.addAppender(fileAppender);
    root.addAppender(logcatAppender);
    if (BuildConfig.DEBUG) {
        root.setLevel(Level.ALL);
    } else {
        root.setLevel(Level.INFO);
    }
}

public static LoggingSetupReset disableLogging(org.slf4j.Logger... loggers) {
    Map<Logger, Level> levels = Maps.newHashMap();
    for (org.slf4j.Logger logger : loggers) {
        Logger l = Logger.getLogger(logger.getName());
        Logger original = l;
        Level oldLevel = original.getLevel();
        while (oldLevel == null) {
            if (l.getParent() != null) {
                l = l.getParent();
                oldLevel = l.getLevel();
            } else {
                // No parent and no levels - PANIC; just assume that the logger is using it's default of INFO
                oldLevel = Level.INFO;
                l = original;
            }
        }
        l.setLevel(Level.OFF);
        levels.put(l, oldLevel);
    }
    return new LoggingSetupReset(levels);
}

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} */
@Override
public void log(Logger.Level level, String message) {
    switch(level) {
        case Trace:
            logger.trace(message);
            break;
        case Debug:
            logger.debug(message);
            break;
        case Error:
            logger.error(message);
            break;
        case Fatal:
            logger.error(message);
            break;
        case Info:
            logger.info(message);
            break;
        default:
            /* Warn */
            logger.warn(message);
    }
}

private void silenceJettyLogger() {
    final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger("org.eclipse.jetty");
    if (!(logger instanceof ch.qos.logback.classic.Logger)) {
        return;
    }
    ch.qos.logback.classic.Logger logbackLogger = (ch.qos.logback.classic.Logger) logger;
    logbackLogger.setLevel(ch.qos.logback.classic.Level.INFO);
}

@Override
public Logger<ServerListPlusException> log(Level level, String message) {
    if (level == ERROR) {
        logger.error(LOG_PREFIX + message);
    } else if (level == WARN) {
        logger.warn(LOG_PREFIX + message);
    } else if (level == INFO) {
        logger.info(LOG_PREFIX + message);
    } else if (level == REPORT) {
        logger.debug(LOG_PREFIX + message);
    } else {
        logger.trace(LOG_PREFIX + message);
    }
    return this;
}