what's wrong with e.printStackTrace() for an unknown exception

Question

If I use a logger in the case of known exceptions, what's wrong with e.printStackTrace() for an unknown exception ?

I'm always told not to do this - but not given a reason

example below

try {
            dostuff();
        } catch (AException ae) {
            logger.error("ae happened");
        } catch (BException be) {
            logger.error("be happened");
        } catch (CException ce) {
            logger.error("ce happened");
        } catch (Exception e) {
            e.printStackTrace();
        }

Answer 1

IMHO, You should

• consistently log to a logger OR standard error, but not a mix (perhaps this is the reason for the complaint)
• always log exception with the stack trace unless you are sure you will never need it.

Answer 2

Because it doesn't use the logger system, it goes directly to the stderr which has to be avoided.

edit: why writing directly to stderr has to be avoided ?

In answer to your question, @shinynewbike, I have slightly modifed my answer. What it has to be avoided is to write directly to stderr without using a logger capability.

loggers provide useful features to change logging traces by priority and packages, among other things they also allow to redirect traces to different output mechanisms ... queues, files, databases, streams ...

When you write directly to System.err or System.out then you lose these features, and what is worse if you mix logger and System.err.write you might end up getting traces in different 'files' which will make debugging your system difficult.