For performance wise, some people suggest use the following method, e.g.
public class MyActivity extends Activity {
private static final String TAG = "MyApp";
private static final boolean D = true;
#Override public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if(D) Log.e(TAG, "MyActivity.onCreate debug message"); }
But this is non-senese when are working on a large project, because when you debug, you need to update many files for the debug flag, are there any better method?
You can check the DEBUG boolean in your BuildConfig:
if (BuildConfig.DEBUG) {
// Do what you need
}
Or else, you can have a debug variable, but instead or keeping it in every activity, declare it in you Application class, and check it's value whenever you need.
If your purpose of that variable is for logging, is a good practice to wrap your loggings into another class, which checks the DEBUG variable:
public class LogUtils {
public static void LOGD(final String tag, String message) {
if (BuildConfig.DEBUG) {
Log.d(tag, message);
}
}
public static void LOGV(final String tag, String message) {
if (BuildConfig.DEBUG) {
Log.v(tag, message);
}
}
public static void LOGI(final String tag, String message) {
if (BuildConfig.DEBUG) {
Log.i(tag, message);
}
}
public static void LOGW(final String tag, String message) {
if (BuildConfig.DEBUG) {
Log.w(tag, message);
}
}
public static void LOGE(final String tag, String message) {
if (BuildConfig.DEBUG) {
Log.e(tag, message);
}
}
}
Then, make log calls to this class:
LogUtils.LOGD(TAG, "MyActivity.onCreate debug message");
I strongly recommend what Google guys developed at their open source app iosched. Among other reasons it keeps in mind BuildConfig and checks to see whether or not a log for the specified tag is loggable at the specified level with isLoggable. It's a must for my projects.
/*
* Copyright 2012 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.android.apps.iosched.util;
import com.google.android.apps.iosched.BuildConfig;
import android.util.Log;
/**
* Helper methods that make logging more consistent throughout the app.
*/
public class LogUtils {
private static final String LOG_PREFIX = "iosched_";
private static final int LOG_PREFIX_LENGTH = LOG_PREFIX.length();
private static final int MAX_LOG_TAG_LENGTH = 23;
public static String makeLogTag(String str) {
if (str.length() > MAX_LOG_TAG_LENGTH - LOG_PREFIX_LENGTH) {
return LOG_PREFIX + str.substring(0, MAX_LOG_TAG_LENGTH - LOG_PREFIX_LENGTH - 1);
}
return LOG_PREFIX + str;
}
/**
* WARNING: Don't use this when obfuscating class names with Proguard!
*/
public static String makeLogTag(Class cls) {
return makeLogTag(cls.getSimpleName());
}
public static void LOGD(final String tag, String message) {
if (Log.isLoggable(tag, Log.DEBUG)) {
Log.d(tag, message);
}
}
public static void LOGD(final String tag, String message, Throwable cause) {
if (Log.isLoggable(tag, Log.DEBUG)) {
Log.d(tag, message, cause);
}
}
public static void LOGV(final String tag, String message) {
//noinspection PointlessBooleanExpression,ConstantConditions
if (BuildConfig.DEBUG && Log.isLoggable(tag, Log.VERBOSE)) {
Log.v(tag, message);
}
}
public static void LOGV(final String tag, String message, Throwable cause) {
//noinspection PointlessBooleanExpression,ConstantConditions
if (BuildConfig.DEBUG && Log.isLoggable(tag, Log.VERBOSE)) {
Log.v(tag, message, cause);
}
}
public static void LOGI(final String tag, String message) {
Log.i(tag, message);
}
public static void LOGI(final String tag, String message, Throwable cause) {
Log.i(tag, message, cause);
}
public static void LOGW(final String tag, String message) {
Log.w(tag, message);
}
public static void LOGW(final String tag, String message, Throwable cause) {
Log.w(tag, message, cause);
}
public static void LOGE(final String tag, String message) {
Log.e(tag, message);
}
public static void LOGE(final String tag, String message, Throwable cause) {
Log.e(tag, message, cause);
}
private LogUtils() {
}
}
Another solution is found in one of the answers to this somewhat related question. You can override the Log class like this:
public class Log {
static final boolean LOG = false;
public static void i(String tag, String string) {
if (LOG) android.util.Log.i(tag, string);
}
public static void e(String tag, String string) {
if (LOG) android.util.Log.e(tag, string);
}
public static void d(String tag, String string) {
if (LOG) android.util.Log.d(tag, string);
}
public static void v(String tag, String string) {
if (LOG) android.util.Log.v(tag, string);
}
public static void w(String tag, String string) {
if (LOG) android.util.Log.w(tag, string);
}
}
This way, you don't need the if statement every time you use log. Just change the boolean in your overridden Log class. When you're ready to publish, you can use a tool like ProGuard to strip all the references to Log for performance.
Strip out Log.v and Log.d messages using ProGuard
An alternative approach, with less code, is to have these stripped out for the final release app using ProGuard.
Basically, in the app\proguard-rules.pro file, define the methods of the android.util.Log class that you want stripped out. The following addition to the proguard-rules.pro file will cause the v (verbose) and d (debug) methods to be stripped out at build time:
# This tell Proguard to assume Log.v and Log.d have no side effects (even
# though they do since they write to the logs) and thus can be removed
# during optimization:
-assumenosideeffects class android.util.Log {
public static int v(...);
public static int d(...);
}
This avoids the need for if (BuildConfig.DEBUG)-style checks peppered throughout the code.
Also see: Disable LogCat Output COMPLETELY in release Android app?
I've written a LogWrapper class which is simple and looks something like this:
public class LogWrapper {
private static final String DEBUG_TAG = "some-tag"
private static boolean logsEnabled;
public static void e(String msg) {
if (logsEnabled) {
Log.e(DEBUG_TAG, msg);
}
}
// other Log methods
}
You can use it instead of Log class, modifying the boolean variable as you wish in one place. Hope this helps.
I had the same problem recently, and I don't think that stripping off the classes with Proguard is a good idea to disable logs. So I ended up writing a simple drop-in replacement for the standard Android Log class
https://github.com/zserge/log
It allows you to control the log levels. It also gives you a lot of "sugar" for logging multiple values, for log tags and even more, and it all comes with only 200 lines of code available on Maven Central/JCenter.
i am writing an application for android but i am planning to build this for the pc, too. So i want to reuse as much code as possible. But there are some cases where i have to use platform-specific functions. For example for logging-output and loading resources.
I am searching for an easy solution to abstract these features. My current solution is that i have written this class
public class LoggerAndroid{
public static void debug(String tag, String msg) {
Log.d(tag, msg);
}
public static void error(String tag, String msg) {
Log.e(tag, msg);
}
public static void info(String tag, String msg) {
Log.i(tag, msg);
}
public static void warn(String tag, String msg) {
Log.w(tag, msg);
}
}
and this one
public class Logger extends LoggerAndroid{
}
In my code i use expressions like
Logger.info("test", "HelloWorld");
and for writing the pc application i write another log class with the same methods and let Logger inherit from that one.
So there are very few changes to make and using the log-methods is still easy. But i think maintaining the code and be quite heavy-handed.
Are there better solutions for that?
I think an interface would operate better.
Take a look at this code:
public interface ILogger {
public void debug(String tag, String msg);
public void error(String tag, String msg);
public void info(String tag, String msg);
public void warn(String tag, String msg);
}
public class AndroidLogger implements ILogger {
#Override
public void debug(String tag, String msg) {
Log.d(tag, msg);
}
#Override
public void error(String tag, String msg) {
Log.e(tag, msg);
}
#Override
public void info(String tag, String msg) {
Log.i(tag, msg);
}
#Override
public void warn(String tag, String msg) {
Log.w(tag, msg);
}
}
Then, all you have to do is:
ILogger log = new AndroidLogger();
And in windows, that'd be:
ILogger log = new WindowsLogger();
This code makes it have no difference at all.
Is this what you meant in your question?
Favor Composition over Inheritance. Use Inversion of Control and the Strategy Pattern to hot swap out the Logger instance. For an illuminating example, see this on the related concept of toString().
I have multithreaded application and i want add some text information in every log message
I create factory and extend class, it works fine
...
protected Logger logger = Logger.getLogger("Test", new MyLog4JFactory());
...
import org.apache.log4j.Logger;
import org.apache.log4j.spi.LoggerFactory;
public class MyLog4JFactory implements LoggerFactory{
#Override
public Logger makeNewLoggerInstance(String arg0) {
return new MyLogger(arg0);
}
}
import org.apache.log4j.Logger;
public class MyLogger extends Logger{
protected MyLogger(String name) {
super(name);
}
private String getMessage(Object msg){
StringBuffer sb = new StringBuffer();
return sb.append(msg).append(" ").append("My text").toString();
}
#Override
public void debug(Object message) {
super.debug(getMessage(message));
}
#Override
public void error(Object message) {
super.error(getMessage(message));
}
#Override
public void fatal(Object message) {
super.fatal(getMessage(message));
}
#Override
public void info(Object message) {
super.info(getMessage(message));
}
#Override
public void warn(Object message) {
super.warn(getMessage(message));
}
}
but! in the logs I see the wrapper class
all logs print as
2011-09-08 10:45:49,359 DEBUG MyLogger (35) - Test1 My text
What should I do to the log file shows a classes (with line number) calls my logger?
I know this is an old question, but I would like to share a nice solution I found:
Add FQCN to your class,
call Logger.log method and pass it your FQCN
like so:
public class MyLogger extends Logger{
private static String FQCN = MyLogger.class.getName();
...
#Override
public void debug(Object message) {
super.log(FQCN, org.apache.log4j.Level.DEBUG,message, null);
}
#Override
public void debug(Object message,Throwable t) {
super.log(FQCN, org.apache.log4j.Level.DEBUG,message, t);
}
}
(same will work for creating a wrapper...)
In your log4j.properties file, remove the %l specifier from the line that looks something like this:
log4j.appender.A1.layout.ConversionPattern=<...>
ConversionPattern could be PatternLayout or something else. This will prevent the fully qualified calling class name and line number from being displayed.
More information on the specifiers can be found here.
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
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());
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.
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.
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.
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();
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?
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.
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
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.
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
I prefer creating a (static) Logger for each class (with it's explicit class name). I than use the logger as is.
You don't need to create a new Throwable object. You can just call
Thread.currentThread().getStackTrace()[1]
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.
Google Flogger logging API supports this e.g.
private static final FluentLogger logger = FluentLogger.forEnclosingClass();
See https://github.com/google/flogger for more details.
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()
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
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")
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.
Unless you really need your Logger to be static, you could use
final Logger logger = LoggerFactory.getLogger(getClass());
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);
}
}
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.