[slf4j-dev] svn commit: r556 - slf4j/trunk/src/java/org/slf4j/impl

ceki at slf4j.org ceki at slf4j.org
Wed Mar 8 20:49:12 CET 2006


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 {@link java.util.logging.Logger
- * java.util.logging.Logger} in conformance with the {@link Logger}
- * interface. Note that the logging levels mentioned in this class
- * refer to those defined in the java.util.logging package.
+ * A wrapper over {@link java.util.logging.Logger java.util.logging.Logger} in
+ * conformity with the {@link 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());
+    }
+  }
 }



More information about the slf4j-dev mailing list