Set loglevel for some Loggers, but not others

Question

I'm developing a Java application that uses java.util.logging for its logging needs. This application uses a multitude of external libraries (JDBC, JMS clients, JSR-160 implementation, etc), some of which also use java.util.logging.

I want to set the log level for my Loggers to ALL when I specify a flag on the command line, but so far I have only found ways to set the level for all loggers, not just mine.

My loggers are all called "com.mycompany.myapp.SomeClass" and when I set the level for "com.mycompany.myapp" to ALL, no extra information is logged. When I set the level for the root logger to ALL, all information for all loggers is logged to the console, which is way too much information!

How can I set my own loggers to ALL without having all those other loggers flood my logfiles?

Answer 1

Each Logger has a Handler with it's own log Level.

Is it possible that the Handler for your logger is not also set to ALL and is ignoring the messages? (This is messy, I know).

Here's a 2002 article on Java logging from O'Reilly.

Answer 2

Setting the property

com.mycompany.myapp.level = ALL

should do what you want.

But all the loggers will need to be named correcly with the relevant class names! E.g.

package com.mycompany.myapp;

public class MyClass{
    private static Logger theLogger =
         Logger.getLogger(MyClass.class.getName());
    ...
}

Another possible explanation is that your configurations aren't being passed correctly to the logging framework. Try feeding

LogManager.getLogManager().readConfiguration(InputStream);

your logging configuration right at startup. That is what I do and this works for me.

Answer 3

Yeah, the JDK’s own logging framework can be a real bitch sometimes. As you correctly noticed the log levels of the root logger’s handlers are the problem. The solution you are proposing in your question is almost a good one:

Logger logger = Logger.getLogger("com.mycompany.myapp");
Handler handler = new ConsoleHandler(); /* or whatever you like. */
handler.setLevel(Level.ALL);
logger.addHandler(handler);
logger.setLevel(Level.ALL);
logger.setUseParentHandlers(false); /* <- important. */

When you create logger “below” that logger, i.e. with names like “com.mycompany.myapp.foo.Foo", they will log only to the logger you created. The parent logger of that logger (the root logger) will not get any log messages from your application but will receive messages from other parts of the JDK such as Swing or AWT.

Answer 4

Actually, I'm not sure why your having the problems you've described. I've created a simple JUnit test (below) and setting the log levels works exactly as I expect (which also seems inline with the way you expected them to work).

Are you trying to log messages with levels set below INFO in your custom logger? As you can see from the tests I've included, the default logging handler is set to INFO by default. You need to change that Handler's level to see FINE messages (also shown).

import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.junit.Test;

public class SimpleLoggerTest {

    private void logMessages(Logger logger) {
        logger.warning(getLoggerName(logger) + ": warning message");
        logger.info(getLoggerName(logger) + ": info message");
        logger.fine(getLoggerName(logger) + ": fine message");
    }


    private String getLoggerName(Logger logger) {
        String loggerName = logger.getName();
        if (loggerName.isEmpty()) {
            return "[root logger]";
        }
        return loggerName;
    }

    private void listHandlerLevels(Logger logger) {
        for (Handler handler : logger.getHandlers()) {
            logger.info(getLoggerName(logger) + ": handler level = " + handler.getLevel());
        }
        Logger parentLogger = logger.getParent();
        if (null != parentLogger) {
            for (Handler handler : parentLogger.getHandlers()) {
                logger.info("parent logger handler (" + getLoggerName(parentLogger) + "): handler level = " + handler.getLevel());
            }
        }
    }

    private void setHandlerLevels(Logger logger, Level level) {
        for (Handler handler : logger.getHandlers()) {
            handler.setLevel(level);
        }
        Logger parentLogger = logger.getParent();
        if (null != parentLogger) {
            for (Handler handler : parentLogger.getHandlers()) {
                handler.setLevel(level);
            }
        }
    }
    @Test
    public void testLoggingLevel() {
        Logger myLogger = Logger.getLogger(SimpleLoggerTest.class.getName());
        Logger rootLogger = myLogger.getParent();

        // list the default handler levels
        listHandlerLevels(myLogger);
        listHandlerLevels(rootLogger);

        // log some messages
        logMessages(myLogger);
        logMessages(rootLogger);

        // change the logger levels
        myLogger.setLevel(Level.ALL);
        rootLogger.setLevel(Level.WARNING);

        // list the handler levels again
        listHandlerLevels(myLogger);
        listHandlerLevels(rootLogger);

        // log some messages (again)
        logMessages(myLogger);
        logMessages(rootLogger);

        // change Handler levels to FINE
        setHandlerLevels(myLogger, Level.FINE);

        // list the handler levels (last time)
        listHandlerLevels(myLogger);
        listHandlerLevels(rootLogger);

        // log some messages (last time)
        logMessages(myLogger);
        logMessages(rootLogger);
    }
}

Produces this output...

May 13, 2009 10:46:53 AM SimpleLoggerTest listHandlerLevels
INFO: parent logger handler ([root logger]): handler level = INFO
May 13, 2009 10:46:53 AM java.util.logging.LogManager$RootLogger log
INFO: [root logger]: handler level = INFO
May 13, 2009 10:46:53 AM SimpleLoggerTest logMessages
WARNING: SimpleLoggerTest: warning message
May 13, 2009 10:46:53 AM SimpleLoggerTest logMessages
INFO: SimpleLoggerTest: info message
May 13, 2009 10:46:53 AM java.util.logging.LogManager$RootLogger log
WARNING: [root logger]: warning message
May 13, 2009 10:46:53 AM java.util.logging.LogManager$RootLogger log
INFO: [root logger]: info message
May 13, 2009 10:46:53 AM SimpleLoggerTest listHandlerLevels
INFO: parent logger handler ([root logger]): handler level = INFO
May 13, 2009 10:46:53 AM SimpleLoggerTest logMessages
WARNING: SimpleLoggerTest: warning message
May 13, 2009 10:46:53 AM SimpleLoggerTest logMessages
INFO: SimpleLoggerTest: info message
May 13, 2009 10:46:53 AM java.util.logging.LogManager$RootLogger log
WARNING: [root logger]: warning message
May 13, 2009 10:46:53 AM SimpleLoggerTest listHandlerLevels
INFO: parent logger handler ([root logger]): handler level = FINE
May 13, 2009 10:46:53 AM SimpleLoggerTest logMessages
WARNING: SimpleLoggerTest: warning message
May 13, 2009 10:46:53 AM SimpleLoggerTest logMessages
INFO: SimpleLoggerTest: info message
May 13, 2009 10:46:53 AM SimpleLoggerTest logMessages
FINE: SimpleLoggerTest: fine message
May 13, 2009 10:46:53 AM java.util.logging.LogManager$RootLogger log
WARNING: [root logger]: warning message

This is what I was trying to convey in my other response.