Java logger that automatically determines caller's class name

Question

public static Logger getLogger() {
    final Throwable t = new Throwable();
    final StackTraceElement methodCaller = t.getStackTrace()[1];
    final Logger logger = Logger.getLogger(methodCaller.getClassName());
    logger.setLevel(ResourceManager.LOGLEVEL);
    return logger;
}

This method would return a logger that knows the class it's logging for. Any ideas against it?

Many years later: https://github.com/yanchenko/droidparts/blob/master/droidparts/src/org/droidparts/util/L.java

This code example is great, if you want to log method and line number (and put this code in method log(...) of a class, derived from Logger). Using `Throwable` is a great idea! **Thank you a lot!** - Since logging means overhead anyway, I don't care about overhead. BTW: calling `Throwable` in log(...) method would only mean overhead, when the log record is allowed. — java.is.for.desktop, Mar 13 '10 at 23:02
This code does not work with every Java VM. There exist Java VMs that include in the stacktrace the constructors of the exceptions. This means the first entry is: java.lang.Throwable. — Horcrux7, Mar 14 '11 at 13:25
@Horcrux7 agree. I've seen JVM's not reporting all lines in stack traces due to optimization. Anyway, you are not guaranteed anything about which lines show up in the stack trace, meaning that your program is now vendor dependent. — Thorbjørn Ravn Andersen, Aug 20 '12 at 16:47

score 31 · Answer 1 · edited May 03 '16 at 17:58

31

The MethodHandles class (as of Java 7) includes a Lookup class that, from a static context, can find and return the name of the current class. Consider the following example:

import java.lang.invoke.MethodHandles;

public class Main {
  private static final Class clazz = MethodHandles.lookup().lookupClass();
  private static final String CLASSNAME = clazz.getSimpleName();

  public static void main( String args[] ) {
    System.out.println( CLASSNAME );
  }
}

When run this produces:

Main

For a logger, you could use:

private static Logger LOGGER = 
  Logger.getLogger(MethodHandles.lookup().lookupClass().getSimpleName());

edited May 03 '16 at 17:58

Dave Jarvis

30,436
41
178
315

answered Aug 21 '15 at 04:21

Neeraj

1,163
2
18
32

2

Why this is not included by default in logger API's like slf4j as for example: LoggerFactory.getLogger(); – Daniel Hári Mar 18 '17 at 17:44
4

getSimpleName is not needed in the expression. private static Logger logger = Logger.getLogger(MethodHandles.lookup().lookupClass()); – Daniel Hári Mar 18 '17 at 18:28

erickson · Answer 2 · 2008-09-19T19:50:15.367

Creating a stack trace is a relatively slow operation. Your caller already knows what class and method it is in, so the effort is wasted. This aspect of your solution is inefficient.

Even if you use static class information, you should not fetch the Logger again for each message. From the author of Log4j,Ceki Gülcü:

The most common error in wrapper classes is the invocation of the Logger.getLogger method on each log request. This is guaranteed to wreak havoc on your application's performance. Really!!!

This is the conventional, efficient idiom for getting a Logger is during class initialization:

private static final Logger log = Logger.getLogger(MyClass.class);

Note that this gives you a separate Logger for each type in a hierarchy. If you come up with a method that invokes getClass() on an instance, you will see messages logged by a base type showing up under the subtype's logger. Maybe this is desirable in some cases, but I find it confusing (and I tend to favor composition over inheritance anyway).

Obviously, using the dynamic type via getClass() will require you to obtain the logger at least once per instance, rather than once per class like the recommended idiom using static type information.

Standard idiom's are standard for a reason. If you do something different make sure that the additional maintenence hit of having to understand the difference is worth the effort. — Michael Rutherfurd, Nov 20 '08 at 05:25
I think that getLogger method can use a class as parameter at least in java 6. But you can use MyClass.class.getCanonicalName() since java 5. — PhoneixS, Apr 25 '12 at 15:59
Didn't work for me. `The method getLogger(String) in the type Logger is not applicable for the arguments (Class)` — Tim Abell, Jun 10 '12 at 00:17

score 19 · Accepted Answer · answered Sep 17 '08 at 07:21

19

I guess it adds a lot of overhead for every class. Every class has to be 'looked up'. You create new Throwable objects to do that... These throwables don't come for free.

answered Sep 17 '08 at 07:21

Daan

9,984
2
30
36

1

Isn't logging an overhead anyway? ;) – java.is.for.desktop Mar 13 '10 at 22:44
3

"A lot of overhead"? This code will be executed once for every class (not object) using this method. I think is negligible. – sinuhepop Nov 04 '10 at 15:15
@sinuhepop you have no way of knowing how many times it will be called. This is only a static method, and without knowing how it's used you can't make that statement. It may be that he'll call it and hold onto it, or he may call it every time he needs to issue a log statement. – Matt Aug 13 '12 at 16:00
2

@Matt: You're right. But this method is usually declared as an static and final field, as loggers usually are. – sinuhepop Aug 13 '12 at 22:59
We have a similar function, after removing that we were able to increase performance – Krish May 06 '20 at 01:20

score 18 · Answer 4 · answered Nov 10 '09 at 04:54

We actually have something quite similar in a LogUtils class. Yes, it's kind of icky, but the advantages are worth it as far as I'm concerned. We wanted to make sure we didn't have any overhead from it being repeatedly called though, so ours (somewhat hackily) ensures that it can ONLY be called from a static initializer context, a la:

private static final Logger LOG = LogUtils.loggerForThisClass();

It will fail if it's invoked from a normal method, or from an instance initializer (i.e. if the 'static' was left off above) to reduce the risk of performance overhead. The method is:

public static Logger loggerForThisClass() {
    // We use the third stack element; second is this method, first is .getStackTrace()
    StackTraceElement myCaller = Thread.currentThread().getStackTrace()[2];
    Assert.equal("<clinit>", myCaller.getMethodName());
    return Logger.getLogger(myCaller.getClassName());
}

Anyone who asks what advantage does this have over

= Logger.getLogger(MyClass.class);

has probably never had to deal with someone who copies and pastes that line from somewhere else and forgets to change the class name, leaving you dealing with a class which sends all its stuff to another logger.

so ours (somewhat hackily) ensures that it can ONLY be called from a static initializer context: So what happens when someone decides to use your code differently, say: LogUtils.loggerForThisClass().info(....). You can't guarantee it will be used properly. I don't see how your solution does anything but solve the copy and paste issue, while opening up a whole other can of worms. — Matt, Aug 13 '12 at 16:03
Matt: if they use it improperly (like in the case you say) the assertion will fail and throw a RuntimeException. This generally encourages fixing the problem. :) (In reality, AFAIK this never happened while I was at that company; yet copy-and-pasting a logger and logging something with the wrong logger name happened at least a dozen times in my tenure there) — Cowan, Aug 20 '12 at 01:37
Do you use "Assert" from the "com.sun.tools.javac.util" package? If yes, can the same then be achieved without using a class from a "com.sun" package? — Benny Code, Jun 10 '14 at 22:24

score 8 · Answer 5 · answered Aug 12 '09 at 20:44

8

Assuming you are keeping static refs to the loggers, here's a standalone static singleton:

public class LoggerUtils extends SecurityManager
{
    public static Logger getLogger()
    {
        String className = new LoggerUtils().getClassName();
        Logger logger = Logger.getLogger(className);
        return logger;
    }

    private String getClassName()
    {
        return getClassContext()[2].getName();
    }
}

Usage is nice and clean:

Logger logger = LoggerUtils.getLogger();

answered Aug 12 '09 at 20:44

EGB

266
4
5

2

Nice trick. I would suggest keeping around the SecurityManager though. When you create an instance of it, it goes and checks a permission each time. Also you would have to instantiate your LoggerUtils inside a doPrivileged() block because of that. – Hakanai Oct 14 '09 at 22:07

score 6 · Answer 6 · answered Sep 17 '08 at 14:30

For every class that you use this with, you're going to have to look up the Logger anyway, so you might as well just use a static Logger in those classes.

private static final Logger logger = Logger.getLogger(MyClass.class.getName());

Then you just reference that logger when you need to do your log messages. Your method does the same thing that the static Log4J Logger does already so why reinvent the wheel?

score 4 · Answer 7 · answered Sep 12 '16 at 08:57

4

A good alternative is to use (one of) the lombok logs annotations : https://projectlombok.org/features/Log.html

It generate the corresponding log statement with the current class.

answered Sep 12 '16 at 08:57

user2189998

718
6
10

score 3 · Answer 8 · answered Mar 08 '10 at 09:10

Then the best thing is mix of two .

public class LoggerUtil {

    public static Level level=Level.ALL;

    public static java.util.logging.Logger getLogger() {
        final Throwable t = new Throwable();
        final StackTraceElement methodCaller = t.getStackTrace()[1];
        final java.util.logging.Logger logger = java.util.logging.Logger.getLogger(methodCaller.getClassName());
        logger.setLevel(level);

        return logger;
    }
}

And then in every class:

private static final Logger LOG = LoggerUtil.getLogger();

in code :

LOG.fine("debug that !...");

You get static logger that you can just copy&paste in every class and with no overhead ...

Alaa

score 3 · Answer 9 · answered Jun 23 '11 at 18:47

From reading through all the other feedback on this site, I created the following for use with Log4j:

package com.edsdev.testapp.util;

import java.util.concurrent.ConcurrentHashMap;

import org.apache.log4j.Level;
import org.apache.log4j.Priority;

public class Logger extends SecurityManager {

private static ConcurrentHashMap<String, org.apache.log4j.Logger> loggerMap = new ConcurrentHashMap<String, org.apache.log4j.Logger>();

public static org.apache.log4j.Logger getLog() {
    String className = new Logger().getClassName();
    if (!loggerMap.containsKey(className)) {
        loggerMap.put(className, org.apache.log4j.Logger.getLogger(className));
    }
    return loggerMap.get(className);
}
public String getClassName() {
    return getClassContext()[3].getName();
}
public static void trace(Object message) {
    getLog().trace(message);
}
public static void trace(Object message, Throwable t) {
    getLog().trace(message, t);
}
public static boolean isTraceEnabled() {
    return getLog().isTraceEnabled();
}
public static void debug(Object message) {
    getLog().debug(message);
}
public static void debug(Object message, Throwable t) {
    getLog().debug(message, t);
}
public static void error(Object message) {
    getLog().error(message);
}
public static void error(Object message, Throwable t) {
    getLog().error(message, t);
}
public static void fatal(Object message) {
    getLog().fatal(message);
}
public static void fatal(Object message, Throwable t) {
    getLog().fatal(message, t);
}
public static void info(Object message) {
    getLog().info(message);
}
public static void info(Object message, Throwable t) {
    getLog().info(message, t);
}
public static boolean isDebugEnabled() {
    return getLog().isDebugEnabled();
}
public static boolean isEnabledFor(Priority level) {
    return getLog().isEnabledFor(level);
}
public static boolean isInfoEnabled() {
    return getLog().isInfoEnabled();
}
public static void setLevel(Level level) {
    getLog().setLevel(level);
}
public static void warn(Object message) {
    getLog().warn(message);
}
public static void warn(Object message, Throwable t) {
    getLog().warn(message, t);
}

}

Now in your code all you need is

Logger.debug("This is a test");

or

Logger.error("Look what happened Ma!", e);

If you need more exposure to log4j methods, just delegate them from the Logger class listed above.

score 2 · Answer 10 · answered Nov 19 '08 at 20:58

2

You don't need to create a new Throwable object. You can just call Thread.currentThread().getStackTrace()[1]

answered Nov 19 '08 at 20:58

ykaganovich

14,736
8
59
96

3

Look at the source code of Thread. It actually creates an exception if the thread you call getStrackTrace on is the same as the current one. So it's even (very slightly) more expensive. – Eelco Feb 02 '10 at 05:15

score 2 · Answer 11 · answered Sep 17 '08 at 07:18

2

You could of course just use Log4J with the appropriate pattern layout:

For example, for the class name "org.apache.xyz.SomeClass", the pattern %C{1} will output "SomeClass".

http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/PatternLayout.html

answered Sep 17 '08 at 07:18

Ian

4,208
21
33

1

Don't over look the WARNING the use of %C. It will impact your performance. – Brian Matthews Sep 17 '08 at 07:35
Using the standard idiom will give you the same result from the appender name *without* the performance impact. It is also subject to the StackTrace format being parsable e.g. AS400 Java had a weird stacktrace, it was human readable but sufficiently different as to be unusable for this purpose. – Michael Rutherfurd Nov 20 '08 at 05:23

score 2 · Answer 12 · answered Sep 17 '08 at 07:46

2

I prefer creating a (static) Logger for each class (with it's explicit class name). I than use the logger as is.

answered Sep 17 '08 at 07:46

Philip Helger

1,814
18
28

score 1 · Answer 13 · answered Aug 14 '15 at 12:41

I just have the following line at the beginning of most of my classes.

  private static final Logger log = 
     LoggerFactory.getLogger(new Throwable().getStackTrace()[0].getClassName());

yes there is some overhead the very first time an object of that class is created, but I work mostly in webapps, so adding microseconds onto a 20 second startup isn't really a problem.

score 1 · Answer 14 · answered Oct 10 '18 at 15:59

1

Google Flogger logging API supports this e.g.

private static final FluentLogger logger = FluentLogger.forEnclosingClass();

See https://github.com/google/flogger for more details.

answered Oct 10 '18 at 15:59

James Mudd

1,816
1
20
25

2

This is just internally using a stack trace as well. https://github.com/google/flogger/blob/master/api/src/main/java/com/google/common/flogger/backend/system/StackBasedCallerFinder.java#L34 – Wisteso Dec 06 '18 at 16:10

score 1 · Answer 15 · answered Feb 20 '19 at 13:13

A nice way to do this from Java 7 onwards:

private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());

The logger can be static and that fine. Here its using the SLF4J API

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

But in principal can be used with any logging framework. If the logger needs a string argument add toString()

score 1 · Answer 16 · answered Jun 20 '19 at 10:30

Simple and trivial OLD SCHOOL:

Just create your own class and pass there class name, method name + comment (if class /method changed they're refactored automatically Shift+F6)

public class MyLogs {    
    public static void LOG(String theClass, String theMethod, String theComment) {
        Log.d("MY_TAG", "class: " + theClass + " meth : " + theMethod + " comm : " + theComment);
    }
}

and just use it anywhere in the app (no context required, no initialzation, no extra libs and no look up) - can be used for any programing language!

MyLogs.LOG("MainActivity", "onCreate", "Hello world");

this will print in your console:

MY_TAG class: MainActivity meth: onCreate comm: Hello world

joseaio · Answer 17 · 2012-08-20T16:44:30.063

Please see my static getLogger() implementation (use same "sun.*" magic on JDK 7 as default java Logger doit)

note static logging methods (with static import) without ugly log property...

import static my.pakg.Logger.*;

And their speed is equivalent to native Java implementation (checked with 1 million of log traces)

package my.pkg;

import java.text.MessageFormat;
import java.util.Arrays;
import java.util.IllegalFormatException;
import java.util.logging.Level;
import java.util.logging.LogRecord;

import sun.misc.JavaLangAccess;
import sun.misc.SharedSecrets;


public class Logger {
static final int CLASS_NAME = 0;
static final int METHOD_NAME = 1;

// Private method to infer the caller's class and method names
protected static String[] getClassName() {
    JavaLangAccess access = SharedSecrets.getJavaLangAccess();
    Throwable throwable = new Throwable();
    int depth = access.getStackTraceDepth(throwable);

    boolean lookingForLogger = true;
    for (int i = 0; i < depth; i++) {
        // Calling getStackTraceElement directly prevents the VM
        // from paying the cost of building the entire stack frame.
        StackTraceElement frame = access.getStackTraceElement(throwable, i);
        String cname = frame.getClassName();
        boolean isLoggerImpl = isLoggerImplFrame(cname);
        if (lookingForLogger) {
            // Skip all frames until we have found the first logger frame.
            if (isLoggerImpl) {
                lookingForLogger = false;
            }
        } else {
            if (!isLoggerImpl) {
                // skip reflection call
                if (!cname.startsWith("java.lang.reflect.") && !cname.startsWith("sun.reflect.")) {
                    // We've found the relevant frame.
                    return new String[] {cname, frame.getMethodName()};
                }
            }
        }
    }
    return new String[] {};
    // We haven't found a suitable frame, so just punt.  This is
    // OK as we are only committed to making a "best effort" here.
}

protected static String[] getClassNameJDK5() {
    // Get the stack trace.
    StackTraceElement stack[] = (new Throwable()).getStackTrace();
    // First, search back to a method in the Logger class.
    int ix = 0;
    while (ix < stack.length) {
        StackTraceElement frame = stack[ix];
        String cname = frame.getClassName();
        if (isLoggerImplFrame(cname)) {
            break;
        }
        ix++;
    }
    // Now search for the first frame before the "Logger" class.
    while (ix < stack.length) {
        StackTraceElement frame = stack[ix];
        String cname = frame.getClassName();
        if (isLoggerImplFrame(cname)) {
            // We've found the relevant frame.
            return new String[] {cname, frame.getMethodName()};
        }
        ix++;
    }
    return new String[] {};
    // We haven't found a suitable frame, so just punt.  This is
    // OK as we are only committed to making a "best effort" here.
}


private static boolean isLoggerImplFrame(String cname) {
    // the log record could be created for a platform logger
    return (
            cname.equals("my.package.Logger") ||
            cname.equals("java.util.logging.Logger") ||
            cname.startsWith("java.util.logging.LoggingProxyImpl") ||
            cname.startsWith("sun.util.logging."));
}

protected static java.util.logging.Logger getLogger(String name) {
    return java.util.logging.Logger.getLogger(name);
}

protected static boolean log(Level level, String msg, Object... args) {
    return log(level, null, msg, args);
}

protected static boolean log(Level level, Throwable thrown, String msg, Object... args) {
    String[] values = getClassName();
    java.util.logging.Logger log = getLogger(values[CLASS_NAME]);
    if (level != null && log.isLoggable(level)) {
        if (msg != null) {
            log.log(getRecord(level, thrown, values[CLASS_NAME], values[METHOD_NAME], msg, args));
        }
        return true;
    }
    return false;
}

protected static LogRecord getRecord(Level level, Throwable thrown, String className, String methodName, String msg, Object... args) {
    LogRecord record = new LogRecord(level, format(msg, args));
    record.setSourceClassName(className);
    record.setSourceMethodName(methodName);
    if (thrown != null) {
        record.setThrown(thrown);
    }
    return record;
}

private static String format(String msg, Object... args) {
    if (msg == null || args == null || args.length == 0) {
        return msg;
    } else if (msg.indexOf('%') >= 0) {
        try {
            return String.format(msg, args);
        } catch (IllegalFormatException esc) {
            // none
        }
    } else if (msg.indexOf('{') >= 0) {
        try {
            return MessageFormat.format(msg, args);
        } catch (IllegalArgumentException exc) {
            // none
        }
    }
    if (args.length == 1) {
        Object param = args[0];
        if (param != null && param.getClass().isArray()) {
            return msg + Arrays.toString((Object[]) param);
        } else if (param instanceof Throwable){
            return msg;
        } else {
            return msg + param;
        }
    } else {
        return msg + Arrays.toString(args);
    }
}

public static void severe(String msg, Object... args) {
    log(Level.SEVERE, msg, args);
}

public static void warning(String msg, Object... args) {
    log(Level.WARNING, msg, args);
}

public static void info(Throwable thrown, String format, Object... args) {
    log(Level.INFO, thrown, format, args);
}

public static void warning(Throwable thrown, String format, Object... args) {
    log(Level.WARNING, thrown, format, args);
}

public static void warning(Throwable thrown) {
    log(Level.WARNING, thrown, thrown.getMessage());
}

public static void severe(Throwable thrown, String format, Object... args) {
    log(Level.SEVERE, thrown, format, args);
}

public static void severe(Throwable thrown) {
    log(Level.SEVERE, thrown, thrown.getMessage());
}

public static void info(String msg, Object... args) {
    log(Level.INFO, msg, args);
}

public static void fine(String msg, Object... args) {
    log(Level.FINE, msg, args);
}

public static void finer(String msg, Object... args) {
    log(Level.FINER, msg, args);
}

public static void finest(String msg, Object... args) {
    log(Level.FINEST, msg, args);
}

public static boolean isLoggableFinest() {
    return isLoggable(Level.FINEST);
}

public static boolean isLoggableFiner() {
    return isLoggable(Level.FINER);
}

public static boolean isLoggableFine() {
    return isLoggable(Level.FINE);
}

public static boolean isLoggableInfo() {
    return isLoggable(Level.INFO);
}

public static boolean isLoggableWarning() {
    return isLoggable(Level.WARNING);
}
public static boolean isLoggableSevere() {
    return isLoggable(Level.SEVERE);
}

private static boolean isLoggable(Level level) {
    return log(level, null);
}

}

score 0 · Answer 18 · answered Feb 03 '13 at 07:58

Take a look at Logger class from jcabi-log. It does exactly what you're looking for, providing a collection of static methods. You don't need to embed loggers into classes any more:

import com.jcabi.log.Logger;
class Foo {
  public void bar() {
    Logger.info(this, "doing something...");
  }
}

Logger sends all logs to SLF4J, which you can redirect to any other logging facility, in runtime.

score 0 · Answer 19 · answered Sep 17 '08 at 07:39

0

Why not?

public static Logger getLogger(Object o) {
  final Logger logger = Logger.getLogger(o.getClass());
  logger.setLevel(ResourceManager.LOGLEVEL);
  return logger;
}

And then when you need a logger for a class:

getLogger(this).debug("Some log message")

answered Sep 17 '08 at 07:39

Mario Ortegón

18,670
17
71
81

Because it is readable and predictable rather than magic of course! ;-) – Eelco Feb 02 '10 at 05:17
This would mean doing unnecessary amounts of work for log statements that are not usually being emitted >99% of the time. And it also prevents you from logging in static methods. – David Sep 01 '23 at 02:53

score 0 · Answer 20 · answered Sep 17 '08 at 09:35

This mechanism puts in a lot of extra effort at runtime.

If you use Eclipse as your IDE, consider using Log4e. This handy plugin will generate logger declarations for you using your favourite logging framework. A fraction more effort at coding time, but much less work at runtime.

score 0 · Answer 21 · answered Sep 17 '08 at 14:33

0

Unless you really need your Logger to be static, you could use

final Logger logger = LoggerFactory.getLogger(getClass());

answered Sep 17 '08 at 14:33

Asgeir S. Nilsen

1,137
9
13

what happens if getClass() is overrided ? even worse, what the if class is instantiated with inheritance ? – Abdelghani AINOUSS Jul 12 '18 at 12:11

Java logger that automatically determines caller's class name

21 Answers21

Linked