/** * @deprecated Make sure to use {@link Logger#getLogger(String)} instead. */ public static Category getInstance(String name) { return LogManager.getLogger(name); }
@SuppressWarnings("unchecked") public Log4jLoggerAdapter() { try { org.apache.log4j.Logger logger = LogManager.getRootLogger(); if (logger != null) { Enumeration<Appender> appenders = logger.getAllAppenders(); if (appenders != null) { while (appenders.hasMoreElements()) { Appender appender = appenders.nextElement(); if (appender instanceof FileAppender) { FileAppender fileAppender = (FileAppender) appender; String filename = fileAppender.getFile(); file = new File(filename); break; } } } } } catch (Throwable t) { } }
/** Reset the default hierarchy to its defaut. It is equivalent to calling <code>Category.getDefaultHierarchy().resetConfiguration()</code>. See {@link Hierarchy#resetConfiguration()} for more details. */ public static void resetConfiguration() { LogManager.resetConfiguration(); } }
public Logger getLogger(String name) { Logger slf4jLogger = loggerMap.get(name); if (slf4jLogger != null) { return slf4jLogger; } else { org.apache.log4j.Logger log4jLogger; if (name.equalsIgnoreCase(Logger.ROOT_LOGGER_NAME)) log4jLogger = LogManager.getRootLogger(); else log4jLogger = LogManager.getLogger(name); Logger newInstance = new Log4jLoggerAdapter(log4jLogger); Logger oldInstance = loggerMap.putIfAbsent(name, newInstance); return oldInstance == null ? newInstance : oldInstance; } } }
/** * Prints the configuration of the default log4j hierarchy as a Java * properties file on the specified Writer. * * <p>N.B. print() can be invoked only once! */ public void print(PrintWriter out) { printOptions(out, Logger.getRootLogger()); Enumeration cats = LogManager.getCurrentLoggers(); while (cats.hasMoreElements()) { printOptions(out, (Logger) cats.nextElement()); } }
properties.setProperty("log4j.appender.application.layout", "org.apache.log4j.PatternLayout"); properties.setProperty("log4j.appender.application.layout.ConversionPattern", "%d [%t] %-5p %C{6} (%F:%L) - %m%n"); PropertyConfigurator.configure(properties); Enumeration<org.apache.log4j.Logger> ls = LogManager.getCurrentLoggers(); while (ls.hasMoreElements()) { org.apache.log4j.Logger l = ls.nextElement(); if (l != null) { Enumeration<Appender> as = l.getAllAppenders(); while (as.hasMoreElements()) { Appender a = as.nextElement(); if (a instanceof FileAppender) {
while (drivers.hasMoreElements()) { Driver driver = drivers.nextElement(); try { if (!relinquishLoggingControl) LogManager.shutdown(); LogFactory.release(Thread.currentThread().getContextClassLoader());
Enumeration a = LogManager.getRootLogger().getAllAppenders(); while (a.hasMoreElements()) { Appender appender = (Appender) a.nextElement(); if (!(appender instanceof ConsoleAppender || appender instanceof FileAppender)) { LogManager.resetConfiguration(); PropertyConfigurator.configure(lprops); Appender gslf = org.apache.log4j.Logger.getRootLogger().getAppender("geoserverlogfile"); if (gslf instanceof org.apache.log4j.FileAppender) { if (logFileName == null) { PropertyConfigurator.configure(lprops); LoggingInitializer.LOGGER.fine("Logging output to file '" + logFileName + "'"); } else if (gslf != null) { Enumeration allAppenders = org.apache.log4j.Logger.getRootLogger().getAllAppenders(); Appender curApp; while (allAppenders.hasMoreElements()) { curApp = (Appender) allAppenders.nextElement(); if (curApp instanceof org.apache.log4j.ConsoleAppender) { LogManager.getRootLogger().addAppender(appender);
/** * Register the log4j JMX mbeans. Set environment variable * "zookeeper.jmx.log4j.disable" to true to disable registration. * @see http://logging.apache.org/log4j/1.2/apidocs/index.html?org/apache/log4j/jmx/package-summary.html * @throws JMException if registration fails */ @SuppressWarnings("rawtypes") public static void registerLog4jMBeans() throws JMException { if (Boolean.getBoolean("zookeeper.jmx.log4j.disable") == true) { return; } MBeanServer mbs = MBeanRegistry.getInstance().getPlatformMBeanServer(); // Create and Register the top level Log4J MBean HierarchyDynamicMBean hdm = new HierarchyDynamicMBean(); ObjectName mbo = new ObjectName("log4j:hiearchy=default"); mbs.registerMBean(hdm, mbo); // Add the root logger to the Hierarchy MBean Logger rootLogger = Logger.getRootLogger(); hdm.addLoggerMBean(rootLogger.getName()); // Get each logger from the Log4J Repository and add it to // the Hierarchy MBean created above. LoggerRepository r = LogManager.getLoggerRepository(); Enumeration enumer = r.getCurrentLoggers(); Logger logger = null; while (enumer.hasMoreElements()) { logger = (Logger) enumer.nextElement(); hdm.addLoggerMBean(logger.getName()); } }
Enumeration e = LogManager.getCurrentLoggers(); while (e.hasMoreElements()) { Logger logger = (Logger) e.nextElement(); buf.append(logger.getName()); buf.append(':'); buf.append(logger.getLevel()); buf.append(nl); int index = arg.indexOf('='); if (index == -1) { Logger logger = LogManager.exists(arg); if (logger == null) { buf.append("Bad log name: "); buf.append(nl); } else { buf.append(logger.getName()); buf.append(':'); buf.append(logger.getLevel()); String levelStr = nv[1]; Logger logger = LogManager.getLogger(classname);
public void setLogLevel(String clz, String level) { @SuppressWarnings("unchecked") Enumeration<Logger> loggers = LogManager.getCurrentLoggers(); while (loggers.hasMoreElements()) { Logger logger = (Logger) loggers.nextElement(); if ( logger.getName().equals(clz)) { logger.setLevel(Level.toLevel(level)); //System.out.println("---------Set New Log Level:"+level+" For Logger:"+clz); } } }
/** * Returns true if it appears that log4j have been previously configured. This code checks to see if there are any appenders * defined for log4j which is the definitive way to tell if log4j is already initialized * * @return true if appenders.hasMoreElements, false otherwise */ @SuppressWarnings("unchecked") public static boolean isLog4jConfigured() { System.setProperty("log4j.defaultInitOverride", "true"); Enumeration appenders = LogManager.getRootLogger().getAllAppenders(); if (appenders.hasMoreElements()) { return true; } return false; }
Logger log = LogManager.getLogger(logName); log.debug("log.debug1"); log.info("log.info1"); log.error("log.error1"); assertTrue(!Level.ERROR.equals(log.getEffectiveLevel())); log.info("log.info2"); log.error("log.error2"); assertTrue(Level.ERROR.equals(log.getEffectiveLevel())); String[] args = {"-setlevel", authority, logName, Level.DEBUG.toString()}; LogLevel.main(args); log.debug("log.debug3");
/** * Configures root logger, either for FILE output or just console. */ public static void configureLogger() { LogManager.shutdown(); String logFile = getConfigBoolean("log.save", false) ? "log4j.file.properties" : "log4j.properties"; try (InputStream stream = Utils.class.getClassLoader().getResourceAsStream(logFile)) { if (stream == null) { PropertyConfigurator.configure("src/main/resources/" + logFile); } else { PropertyConfigurator.configure(stream); } LOGGER.info("Loaded " + logFile); } catch (IOException e) { LOGGER.error(e.getMessage(), e); } }
public void setLevel(String level) { try { LogManager.getRootLogger().setLevel(Level.toLevel(level)); } catch (Exception e) { log.error("Unable to set level to: " + level, e); } }
public static void main(String argv[]) { if(argv.length == 2) { init(argv[0], argv[1]); } else { usage("Wrong number of arguments."); } try { cat.info("Listening on port " + port); ServerSocket serverSocket = new ServerSocket(port); while(true) { cat.info("Waiting to accept a new client."); Socket socket = serverSocket.accept(); cat.info("Connected to client at " + socket.getInetAddress()); cat.info("Starting new socket node."); new Thread(new SocketNode(socket, LogManager.getLoggerRepository()),"SimpleSocketServer-" + port).start(); } } catch(Exception e) { e.printStackTrace(); } }
LoggerRepository genericHierarchy() { if(genericHierarchy == null) { File f = new File(dir, GENERIC+CONFIG_FILE_EXT); if(f.exists()) { genericHierarchy = new Hierarchy(new RootLogger(Level.DEBUG)); new PropertyConfigurator().doConfigure(f.getAbsolutePath(), genericHierarchy); } else { cat.warn("Could not find config file ["+f+ "]. Will use the default hierarchy."); genericHierarchy = LogManager.getLoggerRepository(); } } return genericHierarchy; } }
public static void configureLogLevel(String logLevel) { Level level = Level.toLevel(logLevel); try { LogManager.getRootLogger().setLevel(level); } catch (Throwable t) { //We catch throwable as there is a case where logger level setting fails when old SLF4j library interferes. log.error("Could not set the log level to : " + level + ". Probably inconsistent Log4J class is loaded.", t); } } }
@Managed(description = "Set the log level on a per logger basis") public void setLevel(final String loggerName, final String levelString) { final Logger logger; if (!StringUtils.isEmpty(loggerName)) { logger = LogManager.getLogger(loggerName); } else { logger = LogManager.getRootLogger(); } logger.setLevel(Level.toLevel(levelString)); }
@Override public void setLevel(Level level) { LogManager.getRootLogger().setLevel(toLog4jLevel(level)); }