Author: ceki Date: Wed Mar 8 20:49:10 2006 New Revision: 556 Modified: slf4j/trunk/src/java/org/slf4j/impl/JDK14LoggerAdapter.java Log: Adding caller info to JDK14LoggerAdapter as suggested in bug report #13 [1].
[]1 http://bugzilla.slf4j.org/show_bug.cgi?id=13 Modified: slf4j/trunk/src/java/org/slf4j/impl/JDK14LoggerAdapter.java ============================================================================== --- slf4j/trunk/src/java/org/slf4j/impl/JDK14LoggerAdapter.java (original) +++ slf4j/trunk/src/java/org/slf4j/impl/JDK14LoggerAdapter.java Wed Mar 8 20:49:10 2006 @@ -33,36 +33,37 @@ package org.slf4j.impl; -import org.slf4j.Logger; import java.util.logging.Level; +import java.util.logging.LogRecord; +import org.slf4j.Logger; /** - * A wrapper over [EMAIL PROTECTED] java.util.logging.Logger - * java.util.logging.Logger} in conformance with the [EMAIL PROTECTED] Logger} - * interface. Note that the logging levels mentioned in this class - * refer to those defined in the java.util.logging package. + * A wrapper over [EMAIL PROTECTED] java.util.logging.Logger java.util.logging.Logger} in + * conformity with the [EMAIL PROTECTED] Logger} interface. Note that the logging levels + * mentioned in this class refer to those defined in the java.util.logging + * package. * * @author Ceki Gülcü + * @author Peter Royal */ public final class JDK14LoggerAdapter extends MarkerIgnoringBase { final java.util.logging.Logger logger; - // WARN: JDK14LoggerAdapter constructor should have only package access so that - // only JDK14LoggerFactory be able to create one. + // WARN: JDK14LoggerAdapter constructor should have only package access so + // that only JDK14LoggerFactory be able to create one. JDK14LoggerAdapter(java.util.logging.Logger logger) { this.logger = logger; } public String getName() { - return logger.getName(); + return logger.getName(); } - + /** * Is this logger instance enabled for the FINE level? - * - * @return True if this Logger is enabled for level FINE, false - * otherwise. + * + * @return True if this Logger is enabled for level FINE, false otherwise. */ public boolean isDebugEnabled() { return logger.isLoggable(Level.FINE); @@ -72,248 +73,288 @@ /** * Log a message object at level FINE. - * @param msg - the message object to be logged + * + * @param msg - + * the message object to be logged */ public void debug(String msg) { - logger.fine(msg); + log(Level.FINE, msg, null); } /** - * Log a message at level FINE according to the specified format and - * argument. - * - * <p>This form avoids superfluous object creation when the logger - * is disabled for level FINE. </p> - * - * @param format the format string - * @param arg the argument + * Log a message at level FINE according to the specified format and argument. + * + * <p> + * This form avoids superfluous object creation when the logger is disabled + * for level FINE. + * </p> + * + * @param format + * the format string + * @param arg + * the argument */ public void debug(String format, Object arg) { if (logger.isLoggable(Level.FINE)) { String msgStr = MessageFormatter.format(format, arg); - logger.fine(msgStr); + log(Level.FINE, msgStr, null); } } /** * Log a message at level FINE according to the specified format and * arguments. - * - * <p>This form avoids superfluous object creation when the logger - * is disabled for the FINE level. </p> - * - * @param format the format string - * @param arg1 the first argument - * @param arg2 the second argument + * + * <p> + * This form avoids superfluous object creation when the logger is disabled + * for the FINE level. + * </p> + * + * @param format + * the format string + * @param arg1 + * the first argument + * @param arg2 + * the second argument */ public void debug(String format, Object arg1, Object arg2) { if (logger.isLoggable(Level.FINE)) { String msgStr = MessageFormatter.format(format, arg1, arg2); - logger.fine(msgStr); + log(Level.FINE, msgStr, null); } } - /** * Log a message at level FINE according to the specified format and * arguments. - * - * <p>This form avoids superfluous object creation when the logger - * is disabled for the FINE level. </p> - * - * @param format the format string - * @param argArray an array of arguments + * + * <p> + * This form avoids superfluous object creation when the logger is disabled + * for the FINE level. + * </p> + * + * @param format + * the format string + * @param argArray + * an array of arguments */ public void debug(String format, Object[] argArray) { if (logger.isLoggable(Level.FINE)) { String msgStr = MessageFormatter.arrayFormat(format, argArray); - logger.fine(msgStr); + log(Level.FINE, msgStr, null); } } - - /** - * Log an exception (throwable) at level FINE with an - * accompanying message. - * - * @param msg the message accompanying the exception - * @param t the exception (throwable) to log + + /** + * Log an exception (throwable) at level FINE with an accompanying message. + * + * @param msg + * the message accompanying the exception + * @param t + * the exception (throwable) to log */ public void debug(String msg, Throwable t) { - logger.log(Level.FINE, msg, t); + log(Level.FINE, msg, t); } /** * Is this logger instance enabled for the INFO level? - * - * @return True if this Logger is enabled for the INFO level, false - * otherwise. + * + * @return True if this Logger is enabled for the INFO level, false otherwise. */ public boolean isInfoEnabled() { return logger.isLoggable(Level.INFO); } - /** * Log a message object at the INFO level. - * - * @param msg - the message object to be logged + * + * @param msg - + * the message object to be logged */ public void info(String msg) { logger.info(msg); } /** - * Log a message at level INFO according to the specified format and - * argument. - * - * <p>This form avoids superfluous object creation when the logger - * is disabled for the INFO level. </p> - * - * @param format the format string - * @param arg the argument + * Log a message at level INFO according to the specified format and argument. + * + * <p> + * This form avoids superfluous object creation when the logger is disabled + * for the INFO level. + * </p> + * + * @param format + * the format string + * @param arg + * the argument */ public void info(String format, Object arg) { if (logger.isLoggable(Level.INFO)) { String msgStr = MessageFormatter.format(format, arg); - logger.info(msgStr); + log(Level.INFO, msgStr, null); } } /** - * Log a message at the INFO level according to the specified format - * and arguments. - * - * <p>This form avoids superfluous object creation when the logger - * is disabled for the INFO level. </p> - * - * @param format the format string - * @param arg1 the first argument - * @param arg2 the second argument + * Log a message at the INFO level according to the specified format and + * arguments. + * + * <p> + * This form avoids superfluous object creation when the logger is disabled + * for the INFO level. + * </p> + * + * @param format + * the format string + * @param arg1 + * the first argument + * @param arg2 + * the second argument */ public void info(String format, Object arg1, Object arg2) { if (logger.isLoggable(Level.INFO)) { String msgStr = MessageFormatter.format(format, arg1, arg2); - logger.info(msgStr); + log(Level.INFO, msgStr, null); } } - + /** * Log a message at level INFO according to the specified format and * arguments. - * - * <p>This form avoids superfluous object creation when the logger - * is disabled for the INFO level. </p> - * - * @param format the format string - * @param argArray an array of arguments + * + * <p> + * This form avoids superfluous object creation when the logger is disabled + * for the INFO level. + * </p> + * + * @param format + * the format string + * @param argArray + * an array of arguments */ public void info(String format, Object[] argArray) { if (logger.isLoggable(Level.INFO)) { String msgStr = MessageFormatter.arrayFormat(format, argArray); - logger.info(msgStr); + log(Level.INFO, msgStr, null); } } - - /** - * Log an exception (throwable) at the INFO level with an - * accompanying message. - * - * @param msg the message accompanying the exception - * @param t the exception (throwable) to log + * Log an exception (throwable) at the INFO level with an accompanying + * message. + * + * @param msg + * the message accompanying the exception + * @param t + * the exception (throwable) to log */ public void info(String msg, Throwable t) { - logger.log(Level.INFO, msg, t); + log(Level.INFO, msg, t); } - + /** * Is this logger instance enabled for the WARNING level? - * - * @return True if this Logger is enabled for the WARNING level, - * false otherwise. + * + * @return True if this Logger is enabled for the WARNING level, false + * otherwise. */ public boolean isWarnEnabled() { return logger.isLoggable(Level.WARNING); } - + /** * Log a message object at the WARNING level. - * - * @param msg - the message object to be logged + * + * @param msg - + * the message object to be logged */ public void warn(String msg) { - logger.warning(msg); + log(Level.WARNING, msg, null); } /** - * Log a message at the WARNING level according to the specified - * format and argument. - * - * <p>This form avoids superfluous object creation when the logger - * is disabled for the WARNING level. </p> - * - * @param format the format string - * @param arg the argument + * Log a message at the WARNING level according to the specified format and + * argument. + * + * <p> + * This form avoids superfluous object creation when the logger is disabled + * for the WARNING level. + * </p> + * + * @param format + * the format string + * @param arg + * the argument */ public void warn(String format, Object arg) { if (logger.isLoggable(Level.WARNING)) { String msgStr = MessageFormatter.format(format, arg); - logger.warning(msgStr); + log(Level.WARNING, msgStr, null); } } /** - * Log a message at the WARNING level according to the specified - * format and arguments. - * - * <p>This form avoids superfluous object creation when the logger - * is disabled for the WARNING level. </p> - * - * @param format the format string - * @param arg1 the first argument - * @param arg2 the second argument + * Log a message at the WARNING level according to the specified format and + * arguments. + * + * <p> + * This form avoids superfluous object creation when the logger is disabled + * for the WARNING level. + * </p> + * + * @param format + * the format string + * @param arg1 + * the first argument + * @param arg2 + * the second argument */ public void warn(String format, Object arg1, Object arg2) { if (logger.isLoggable(Level.WARNING)) { String msgStr = MessageFormatter.format(format, arg1, arg2); - logger.warning(msgStr); + log(Level.WARNING, msgStr, null); } } /** * Log a message at level WARNING according to the specified format and * arguments. - * - * <p>This form avoids superfluous object creation when the logger - * is disabled for the WARNING level. </p> - * - * @param format the format string - * @param argArray an array of arguments + * + * <p> + * This form avoids superfluous object creation when the logger is disabled + * for the WARNING level. + * </p> + * + * @param format + * the format string + * @param argArray + * an array of arguments */ public void warn(String format, Object[] argArray) { if (logger.isLoggable(Level.WARNING)) { String msgStr = MessageFormatter.arrayFormat(format, argArray); - logger.warning(msgStr); + log(Level.WARNING, msgStr, null); } } - + /** - * Log an exception (throwable) at the WARNING level with an - * accompanying message. - * - * @param msg the message accompanying the exception - * @param t the exception (throwable) to log + * Log an exception (throwable) at the WARNING level with an accompanying + * message. + * + * @param msg + * the message accompanying the exception + * @param t + * the exception (throwable) to log */ public void warn(String msg, Throwable t) { - logger.log(Level.WARNING, msg, t); + log(Level.WARNING, msg, t); } /** * Is this logger instance enabled for level SEVERE? - * - * @return True if this Logger is enabled for level SEVERE, false - * otherwise. + * + * @return True if this Logger is enabled for level SEVERE, false otherwise. */ public boolean isErrorEnabled() { return logger.isLoggable(Level.SEVERE); @@ -321,75 +362,128 @@ /** * Log a message object at the SEVERE level. - * - * @param msg - the message object to be logged + * + * @param msg - + * the message object to be logged */ public void error(String msg) { - logger.severe(msg); + log(Level.SEVERE, msg, null); } /** - * Log a message at the SEVERE level according to the specified - * format and argument. - * - * <p>This form avoids superfluous object creation when the logger - * is disabled for the SEVERE level. </p> - * - * @param format the format string - * @param arg the argument + * Log a message at the SEVERE level according to the specified format and + * argument. + * + * <p> + * This form avoids superfluous object creation when the logger is disabled + * for the SEVERE level. + * </p> + * + * @param format + * the format string + * @param arg + * the argument */ public void error(String format, Object arg) { if (logger.isLoggable(Level.SEVERE)) { String msgStr = MessageFormatter.format(format, arg); - logger.severe(msgStr); + log(Level.SEVERE, msgStr, null); } } /** - * Log a message at the SEVERE level according to the specified - * format and arguments. - * - * <p>This form avoids superfluous object creation when the logger - * is disabled for the SEVERE level. </p> - * - * @param format the format string - * @param arg1 the first argument - * @param arg2 the second argument + * Log a message at the SEVERE level according to the specified format and + * arguments. + * + * <p> + * This form avoids superfluous object creation when the logger is disabled + * for the SEVERE level. + * </p> + * + * @param format + * the format string + * @param arg1 + * the first argument + * @param arg2 + * the second argument */ public void error(String format, Object arg1, Object arg2) { if (logger.isLoggable(Level.SEVERE)) { String msgStr = MessageFormatter.format(format, arg1, arg2); - logger.severe(msgStr); + log(Level.SEVERE, msgStr, null); } } - /** * Log a message at level INFO according to the specified format and * arguments. - * - * <p>This form avoids superfluous object creation when the logger - * is disabled for the INFO level. </p> - * - * @param format the format string - * @param argArray an array of arguments + * + * <p> + * This form avoids superfluous object creation when the logger is disabled + * for the INFO level. + * </p> + * + * @param format + * the format string + * @param argArray + * an array of arguments */ public void error(String format, Object[] argArray) { if (logger.isLoggable(Level.SEVERE)) { String msgStr = MessageFormatter.arrayFormat(format, argArray); - logger.severe(msgStr); + log(Level.SEVERE, msgStr, null); } } - + /** - * Log an exception (throwable) at the SEVERE level with an - * accompanying message. - * - * @param msg the message accompanying the exception - * @param t the exception (throwable) to log + * Log an exception (throwable) at the SEVERE level with an accompanying + * message. + * + * @param msg + * the message accompanying the exception + * @param t + * the exception (throwable) to log */ public void error(String msg, Throwable t) { - logger.log(Level.SEVERE, msg, t); + log(Level.SEVERE, msg, t); + } + + private void log(Level level, String msg, Throwable t) { + LogRecord record = new LogRecord(level, msg); + record.setThrown(t); + fillCallerData(record); + logger.log(record); + } + static String SELF = JDK14LoggerAdapter.class.getName(); + static String SUPER = MarkerIgnoringBase.class.getName(); + + private final void fillCallerData(LogRecord record) { + StackTraceElement[] steArray = new Throwable().getStackTrace(); + + int selfIndex = -1; + for (int i = 0; i < steArray.length; i++) { + final String className = steArray[i].getClassName(); + if (className.equals(SELF) || className.equals(SUPER)) { + selfIndex = i; + break; + } + } + + int found = -1; + for (int i = selfIndex + 1; i < steArray.length; i++) { + final String className = steArray[i].getClassName(); + if (!(className.equals(SELF) || className.equals(SUPER))) { + found = i; + break; + } + } + + if (found != -1) { + StackTraceElement ste = steArray[found]; + record.setSourceClassName(ste.getClassName()); + record.setSourceMethodName(ste.getMethodName()); + } + } } _______________________________________________ dev mailing list [email protected] http://slf4j.org/mailman/listinfo/dev
