Why does java.util.logging.Logger print to stderr?

Question

I've got a simple setup to log a message: JDK 8 Update 65 and Eclipse Mars

import java.util.logging.Logger;

public class Example {

    private final static Logger LOGGER = Logger.getLogger(Example.class.getName());

    public static void main(String[] args) {
        LOGGER.info("Test");
    }

}

I would expect to get an output on the stdout, just like using System.out.println();.
But instead it gets printed out on the stderr, which results in a red font on the eclipse console:

I know that I can change this behavior by writing a custom Handler, but I wish to know why the default output appears on the stderr instead of stdout?

A logger should use stdout for fine+info and use stderr for severe level.

jmehrens · Answer 1 · 2020-05-12T15:32:14.280

The java.util.logging API was developed under JSR 47: Logging API Specification. According to the change log in the "Proposed Final Draft" the ConsoleHandler always used System.err. The JCP page also lists the original authors of the API and I think only those names truly know the answer to your question.

That said, I think the origin comes from System.err API docs.

Typically this stream corresponds to display output or another output destination specified by the host environment or user. By convention, this output stream is used to display error messages or other information that should come to the immediate attention of a user even if the principal output stream, the value of the variable out, has been redirected to a file or other destination that is typically not continuously monitored.

Opposed to System.out:

The "standard" output stream. This stream is already open and ready to accept output data. Typically this stream corresponds to display output or another output destination specified by the host environment or user.

Logging maps to diagnostics and not raw data. It is important to separate data from diagnostic error information especially when piping processes together as the downstream consumers are only ready to accept data information and not error messages. See Confused about stdin, stdout and stderr? for more detailed information.

score 3 · Answer 2 · answered Dec 08 '15 at 13:27

It is well documented. By default, loggers publish to their parent's handlers, recursively up to the tree, until the other handler has been specified. You can loop over the parent's handlers and see that the default handler of the parent's logger is ConsoleHandler which uses System.err to publish log records.

public class Main {
    public static void main(String[] args) {
        Handler[] handlers = Logger.getLogger(Main.class.getName()).getParent().getHandlers();
        for (Handler handler : handlers) {
            System.out.println(handler.getClass().getName());
        }
    }
}

score 3 · Answer 3 · answered Jul 09 '19 at 14:23

3

You can create and extended ConsoleHandler to set the out to System.out instead of System.err

Logger logger = Logger.getLoger("your_logger_name");
logger.setUseParentHandler(false);
logger.addHandler(new ConsoleHandler() {
    {setOutputStream(System.out);}
});

Now all message on this logger will appear in the System.out console.

answered Jul 09 '19 at 14:23

Gonzalo Castillo

31
3

Don't do this, this will close `System.err`. (Have a look at `setOutPutStream`). A better way would be: ``` final class MigrationsCliConsoleHandler extends StreamHandler { MigrationsCliConsoleHandler() { setOutputStream(System.out); } @Override public void close() { flush(); } } ``` – Michael Simons May 20 '20 at 11:09
1

The OP was aware of this and noted it in the original question. There is a whole different [question dedicated to topic you are trying to answer](https://stackoverflow.com/questions/194165/how-do-i-change-java-logging-console-output-from-std-err-to-std-out). – jmehrens Jun 09 '20 at 22:11

score 2 · Accepted Answer · edited Dec 08 '15 at 12:53

2

By default, the logger outputs log records of level INFO and above (i.e., INFO, WARNING and SEVERE) to standard error stream (System.err).

Source: www3.ntu.edu.sg/home/ehchua/programming/java/JavaLogging.html

edited Dec 08 '15 at 12:53

Dennis Kriechel

3,729
13
37
62

answered Dec 08 '15 at 12:42

Jose A. Rodríguez Salor

44
3

Do you have a source or proof for this statement? – Dennis Kriechel Dec 08 '15 at 12:45
Sorry, I should have provided it in the comment :) https://www3.ntu.edu.sg/home/ehchua/programming/java/JavaLogging.html – Jose A. Rodríguez Salor Dec 08 '15 at 12:49
3

That the logger does that is already known by OP, the question is: "why". – Tom Dec 08 '15 at 12:52
@Tom Yeah thats another question too, but at least I know this was done on purpose. – Dennis Kriechel Dec 08 '15 at 12:54
Found this one as well: `ConsoleHandler: A simple handler for writing formatted records to System.err` Source:https://docs.oracle.com/javase/7/docs/technotes/guides/logging/overview.html (chapter 1.5) – Dennis Kriechel Dec 08 '15 at 12:58

score 2 · Answer 5 · answered Mar 09 '19 at 09:25

2

the reason they use stderr is because this stream "is used for error messages and diagnostics issued by the program" (source: https://www.gnu.org/software/libc/manual/html_node/Standard-Streams.html).

answered Mar 09 '19 at 09:25

Laurent Picquet

1,051
11
12

Why does java.util.logging.Logger print to stderr?

5 Answers5

Linked