package com.example; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; public class Log4j2Tester { private static final Logger LOG = LogManager.getLogger(Log4j2Tester.class); public static void main(String[] args) { LOG.error("testing ERROR level"); //if you change the level of root logger to 'trace' //then you'll also see something like // 13:27:50.244 [main] TRACE com.example.Log4j2Tester - exiting application LOG.trace("exiting application"); } }
public void resetJULLevels() { LogManager lm = LogManager.getLogManager(); Enumeration<String> e = lm.getLoggerNames(); while (e.hasMoreElements()) { String loggerName = e.nextElement(); java.util.logging.Logger julLogger = lm.getLogger(loggerName); if (JULHelper.isRegularNonRootLogger(julLogger) && julLogger.getLevel() != null) { addInfo("Setting level of jul logger [" + loggerName + "] to null"); julLogger.setLevel(null); } } }
private static java.util.logging.Logger rootJULLogger() { return LogManager.getLogManager().getLogger( "" ); }
public static void setGlobalLogLevel(Level targetLogLevel) { for (Enumeration<String> loggerNames = LogManager.getLogManager().getLoggerNames(); loggerNames.hasMoreElements(); ) { String loggerName = loggerNames.nextElement(); Logger logger = LogManager.getLogManager().getLogger(loggerName); if (logger != null) { logger.setLevel(targetLogLevel); } } for (Handler handler : Logger.getLogger("").getHandlers()) { handler.setLevel(targetLogLevel); } Logger.getLogger("").setLevel(targetLogLevel); // Make sure the unwanted loggers stay quiet disableUnwantedLoggers(); }
protected Log log = LogManager.getLogger(getClass());
/** * Retrieves a list of root loggers. * * @return list of root loggers. */ private Set<Logger> getRootLoggers() { final LogManager logManager = LogManager.getLogManager(); final Enumeration<String> loggerNames = logManager.getLoggerNames(); final Set<Logger> rootLoggers = new HashSet<>(); while (loggerNames.hasMoreElements()) { Logger logger = logManager.getLogger(loggerNames.nextElement()); if (logger != null) { while (logger.getParent() != null) { logger = logger.getParent(); } rootLoggers.add(logger); } } return rootLoggers; }
private static java.util.logging.Logger getRootLogger() { return LogManager.getLogManager().getLogger(""); }
/** * Reset configuration. * * <p>All handlers are closed and removed from any named loggers. All loggers' * level is set to null, except the root logger's level is set to * {@code Level.INFO}. */ public synchronized void reset() { checkAccess(); props = new Properties(); Enumeration<String> names = getLoggerNames(); while (names.hasMoreElements()) { String name = names.nextElement(); Logger logger = getLogger(name); if (logger != null) { logger.reset(); } } Logger root = loggers.get(""); if (root != null) { root.setLevel(Level.INFO); } }
private boolean isJulUsingASingleConsoleHandlerAtMost() { Logger rootLogger = LogManager.getLogManager().getLogger(""); Handler[] handlers = rootLogger.getHandlers(); return handlers.length == 0 || (handlers.length == 1 && handlers[0] instanceof ConsoleHandler); }
@Test public void headlessModeShouldRedirectBothJDKAndGFSHLoggers() { gfsh = new Gfsh(false, null, new GfshConfig()); LogManager logManager = LogManager.getLogManager(); Enumeration<String> loggerNames = logManager.getLoggerNames(); while (loggerNames.hasMoreElements()) { String loggerName = loggerNames.nextElement(); Logger logger = logManager.getLogger(loggerName); // make sure jdk's logging goes to the gfsh log file if (loggerName.startsWith("java")) { assertThat(logger.getParent().getName()).endsWith("LogWrapper"); } // make sure Gfsh's logging goes to the gfsh log file else if (loggerName.endsWith(".Gfsh")) { assertThat(logger.getParent().getName()).endsWith("LogWrapper"); } // make sure SimpleParser's logging will still show up in the console else if (loggerName.endsWith(".SimpleParser")) { assertThat(logger.getParent().getName()).doesNotEndWith("LogWrapper"); } } } }
private void removeDefaultRootHandler() { try { Logger rootLogger = LogManager.getLogManager().getLogger(""); Handler[] handlers = rootLogger.getHandlers(); if (handlers.length == 1 && handlers[0] instanceof ConsoleHandler) { rootLogger.removeHandler(handlers[0]); } } catch (Throwable ex) { // Ignore and continue } }
protected void removeLoggingHandler() { LogManager.getLogManager().getLogger("").removeHandler(loggingHandler); }
private void initLogger() { java.util.logging.Logger rootLogger = java.util.logging.LogManager.getLogManager().getLogger(""); for (java.util.logging.Handler h : rootLogger.getHandlers()) rootLogger.removeHandler(h); SLF4JBridgeHandler.install(); }
/** * Adds a SLF4JBridgeHandler instance to jul's root logger. * <p/> * <p/> * This handler will redirect j.u.l. logging to SLF4J. However, only logs enabled * in j.u.l. will be redirected. For example, if a log statement invoking a * j.u.l. logger is disabled, then the corresponding non-event will <em>not</em> * reach SLF4JBridgeHandler and cannot be redirected. */ public static void install() { LogManager.getLogManager().getLogger("").addHandler(new SLF4JBridgeHandler()); }
private boolean isBridgeHandlerInstalled() { if (!isBridgeHandlerAvailable()) { return false; } java.util.logging.Logger rootLogger = LogManager.getLogManager().getLogger(""); Handler[] handlers = rootLogger.getHandlers(); return handlers.length == 1 && SLF4JBridgeHandler.class.isInstance(handlers[0]); }
/** * Removes the standard Android log handler due to an issue with not logging * entries lower than INFO level and adds a handler that produces * JME formatted log messages. */ protected void initializeLogHandler() { Logger log = LogManager.getLogManager().getLogger(""); for (Handler handler : log.getHandlers()) { if (log.getLevel() != null && log.getLevel().intValue() <= Level.FINE.intValue()) { Log.v("AndroidHarness", "Removing Handler class: " + handler.getClass().getName()); } log.removeHandler(handler); } Handler handler = new AndroidLogHandler(); log.addHandler(handler); handler.setLevel(Level.ALL); }
/** * Removes the standard Android log handler due to an issue with not logging * entries lower than INFO level and adds a handler that produces * JME formatted log messages. */ protected void initializeLogHandler() { Logger log = LogManager.getLogManager().getLogger(""); for (Handler handler : log.getHandlers()) { if (log.getLevel() != null && log.getLevel().intValue() <= Level.FINE.intValue()) { Log.v("AndroidHarness", "Removing Handler class: " + handler.getClass().getName()); } log.removeHandler(handler); } Handler handler = new AndroidLogHandler(); log.addHandler(handler); handler.setLevel(Level.ALL); }
/** * Returns a named logger associated with the supplied resource bundle. * * @param resourceBundleName the resource bundle to associate, or null for * no associated resource bundle. */ synchronized Logger getOrCreate(String name, String resourceBundleName) { Logger result = getLogger(name); if (result == null) { result = new Logger(name, resourceBundleName); addLogger(result); } return result; }
/** * Gets an anonymous logger to use internally in a thread. Anonymous loggers * are not registered in the log manager's namespace. No security checks * will be performed when updating an anonymous logger's control settings. * <p> * The anonymous loggers' parent is set to be the root logger. This way it * inherits default logging level and handlers from the root logger. * * @param resourceBundleName * the name of the resource bundle used to localize log messages. * @return a new instance of anonymous logger. * @throws MissingResourceException * if the specified resource bundle can not be loaded. */ public static Logger getAnonymousLogger(String resourceBundleName) { Logger result = new Logger(null, resourceBundleName); result.isNamed = false; LogManager logManager = LogManager.getLogManager(); logManager.setParent(result, logManager.getLogger("")); return result; }
@Override public Voice suppress() final Logger logger = LogManager.getLogManager().getLogger( "" ); final Level level = logger.getLevel(); final Handler[] handlers = logger.getHandlers();