Java.util.logging.Logger doesn't respect java.util.logging.Level?

Question

In a simple Java SE 6 environment:

Logger l = Logger.getLogger("nameless"); l.setLevel(Level.ALL); l.fine("somemessage"); 

Nothing is displayed in the Eclipse console. l.info ("") and above works fine, but nothing below the fine just doesn't work. What could be wrong? TIA.

Answer 1

Although the Logger level is set to ALL, the ConsoleHandler (the default handler for the registrar) still has the default INFO level. This comes from the default logging.properties file in JAVA_HOME / jre / lib

Answer 2

Instead of going through all the handlers and setting the logging level, I prefer to set only the console handler level:

 //get the top Logger Logger topLogger = java.util.logging.Logger.getLogger(""); // Handler for console (reuse it if it already exists) Handler consoleHandler = null; //see if there is already a console handler for (Handler handler : topLogger.getHandlers()) { if (handler instanceof ConsoleHandler) { //found the console handler consoleHandler = handler; break; } } if (consoleHandler == null) { //there was no console handler found, create a new one consoleHandler = new ConsoleHandler(); topLogger.addHandler(consoleHandler); } //set the console handler to fine: consoleHandler.setLevel(java.util.logging.Level.FINEST); 

Answer 3

Separately, at my workplace, the following was found:

 public class Foo { private final static Logger logger = Logger.getLogger(Foo.class.getName()); public static final void main(String[] args) { ConsoleHandler ch = new ConsoleHandler(); ch.setLevel(Level.FINEST); Foo.logger.addHandler(ch); Foo.logger.setLevel(Level.FINEST); Foo.logger.finest("test"); } } 

If you just set the best (exclusively) for the root or handler, then this did not work. When I set both to FINEST , then it works. His explanation was:

Both loggers and its handlers have log levels ... The filtering order is Logger then Handlers. This means that it checks whether it sends the log message first, and then sends the message to individual handlers for filtering.

He further explained this using the following examples:

• Logger myLogger has a FINEST level and one ConsoleHandler myHandler which has an INFO level

• myLogger.fine("foo") The error message goes beyond the registrar filter, but receives the filter through the handler filter ... nothing is output.

• myLogger.info("foo") à skips both filters and displays foo .

Now...

• Logger myLogger has INFO level and one ConsoleHandler myHandler which has FINEST level

• myLogger.fine("foo") Message about the filter stopping the logs and never gets into the handler ... Displays nothing.

• myLogger.info("foo") à skips both filters and displays foo .

Now...

• Logger myLogger has a FINEST level and one ConsoleHandler myHandler which has a FINEST level

• myLogger.fine("foo") à skips both filters and displays " foo ".

• myLogger.info("foo") à skips both filters and displays foo .

Answer 4

Other users have already given a good answer why this happened (ConsoleHandler has a separate level variable). I reuse my application registrar level and copy it to the parent hiearchy. Also provides an easy way to update levels at runtime anytime.

 // Set same level all loggers and handlers up to the parent level // OFF,SEVERE,WARNING,INFO,CONFIG,FINE,FINER,FINEST,ALL Logger logger = Logger.getLogger(this.getClass().getPackage().getName()); //Level level = Level.parse("FINEST"); Level level = logger.getLevel(); Logger tempLogger = logger; while(tempLogger != null) { tempLogger.setLevel(level); for(Handler handler : tempLogger.getHandlers()) handler.setLevel(level); tempLogger = tempLogger.getParent(); } 

Answer 5

You need to set the log level for both the handlers in the log and the log itself. Logging is performed only at the "rough" level of two levels. Here is the logging class that does the job.

 import java.io.PrintWriter; import java.io.StringWriter; import java.time.Instant; import java.time.ZoneId; import java.time.ZonedDateTime; import java.time.format.DateTimeFormatter; import java.util.logging.ConsoleHandler; import java.util.logging.Formatter; import java.util.logging.Handler; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; public class Log { private static final Logger logger = Logger.getGlobal(); private static Level logLevel = Level.INFO; static { // Remove all the default handlers (usually just one console handler) Logger rootLogger = Logger.getLogger(""); Handler[] rootHandlers = rootLogger.getHandlers(); for (Handler handler : rootHandlers) { rootLogger.removeHandler(handler); } // Add our own handler ConsoleHandler handler = new ConsoleHandler(); handler.setLevel(logLevel); handler.setFormatter(new LogFormatter()); logger.addHandler(handler); logger.setLevel(logLevel); } public static class LogFormatter extends Formatter { @Override public String format(LogRecord record) { String stackTrace = ""; Throwable thrown = record.getThrown(); if (thrown != null) { StringWriter stacktraceWriter = new StringWriter(); try (PrintWriter writer = new PrintWriter(stacktraceWriter)) { thrown.printStackTrace(writer); } stackTrace = stacktraceWriter.toString(); } return ZonedDateTime.ofInstant(Instant.ofEpochMilli(record.getMillis()), ZoneId.of("UTC")).format(DateTimeFormatter.ISO_ZONED_DATE_TIME) + "\t" + record.getLevel() + "\t" + record.getMessage() + "\n" + stackTrace; } } private static final String classname = Log.class.getName(); private static String callerRef() { StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace(); if (stackTraceElements.length < 4) { return ""; } else { int i = 1; for (; i < stackTraceElements.length; i++) { if (stackTraceElements[i].getClassName().equals(classname)) { break; } } for (; i < stackTraceElements.length; i++) { if (!stackTraceElements[i].getClassName().equals(classname)) { break; } } if (i < stackTraceElements.length) { return stackTraceElements[i].toString(); } else { return "[in unknown method]"; } } } public static void setLogLevel(Level newLogLevel) { logLevel = newLogLevel; for (Handler handler : logger.getHandlers()) { handler.setLevel(newLogLevel); } Log.logger.setLevel(newLogLevel); } public static int getLevelNum() { return logLevel.intValue(); } public static int getLevelNum(Level level) { return level.intValue(); } public static void fine(String msg) { logger.log(Level.FINE, msg); } public static void info(String msg) { logger.log(Level.INFO, msg); } public static void warning(String msg) { logger.log(Level.WARNING, msg + "\t " + callerRef()); } public static void error(String msg) { logger.log(Level.SEVERE, msg + "\t " + callerRef()); } public static void exception(String msg, Throwable cause) { logger.log(Level.SEVERE, msg + "\t " + callerRef(), cause); } } 

Answer 6

 private final static Logger LOGGER = Logger.getLogger(WoTServer.class.getName()); for(Handler h : LOGGER.getParent().getHandlers()){ if(h instanceof ConsoleHandler){ h.setLevel(Level.ALL); } }