View Javadoc

    1   /*
    2    * Licensed to the Apache Software Foundation (ASF) under one or more
    3    * contributor license agreements.  See the NOTICE file distributed with
    4    * this work for additional information regarding copyright ownership.
    5    * The ASF licenses this file to You under the Apache License, Version 2.0
    6    * (the "License"); you may not use this file except in compliance with
    7    * the License.  You may obtain a copy of the License at
    8    *
    9    *      http://www.apache.org/licenses/LICENSE-2.0
    10   *
    11   * Unless required by applicable law or agreed to in writing, software
    12   * distributed under the License is distributed on an "AS IS" BASIS,
    13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14   * See the License for the specific language governing permissions and
    15   * limitations under the License.
    16   */
    17
    18
    19  package org.apache.commons.logging.impl;
    20
    21
    22  import java.io.Serializable;
    23  import java.util.logging.Level;
    24  import java.util.logging.Logger;
    25  import java.util.logging.LogRecord;
    26  import java.util.StringTokenizer;
    27  import java.io.PrintWriter;
    28  import java.io.StringWriter;
    29
    30  import org.apache.commons.logging.Log;
    31
    32
    33  /**
    34   * <p>Implementation of the <code>org.apache.commons.logging.Log</code>
    35   * interface that wraps the standard JDK logging mechanisms that are
    36   * available in SourceForge's Lumberjack for JDKs prior to 1.4.</p>
    37   *
    38   * @author <a href="mailto:sanders@apache.org">Scott Sanders</a>
    39   * @author <a href="mailto:bloritsch@apache.org">Berin Loritsch</a>
    40   * @author <a href="mailto:donaldp@apache.org">Peter Donald</a>
    41   * @author <a href="mailto:vince256@comcast.net">Vince Eagen</a>
    42   * @version $Revision: 424107 $ $Date: 2006-07-21 01:15:42 +0200 (fr, 21 jul 2006) $
    43   * @since 1.1
    44   */
    45
    46  public class Jdk13LumberjackLogger implements Log, Serializable {
    47
    48
    49      // ----------------------------------------------------- Instance Variables
    50
    51
    52      /**
    53       * The underlying Logger implementation we are using.
    54       */
    55      protected transient Logger logger = null;
    56      protected String name = null;
    57      private String sourceClassName = "unknown";
    58      private String sourceMethodName = "unknown";
    59      private boolean classAndMethodFound = false;
    60
    61
    62      /**
    63       * This member variable simply ensures that any attempt to initialise
    64       * this class in a pre-1.4 JVM will result in an ExceptionInInitializerError.
    65       * It must not be private, as an optimising compiler could detect that it
    66       * is not used and optimise it away.
    67       */
    68      protected static final Level dummyLevel = Level.FINE;
    69
    70      // ----------------------------------------------------------- Constructors
    71
    72
    73      /**
    74       * Construct a named instance of this Logger.
    75       *
    76       * @param name Name of the logger to be constructed
    77       */
    78      public Jdk13LumberjackLogger(String name) {
    79
    80          this.name = name;
    81          logger = getLogger();
    82
    83      }
    84
    85
    86      // --------------------------------------------------------- Public Methods
    87
    88
    89      private void log( Level level, String msg, Throwable ex ) {
    90          if( getLogger().isLoggable(level) ) {
    91              LogRecord record = new LogRecord(level, msg);
    92              if( !classAndMethodFound ) {
    93                  getClassAndMethod();
    94              }
    95              record.setSourceClassName(sourceClassName);
    96              record.setSourceMethodName(sourceMethodName);
    97              if( ex != null ) {
    98                  record.setThrown(ex);
    99              }
    100             getLogger().log(record);
    101         }
    102     }
    103
    104     /**
    105      * <p>Gets the class and method by looking at the stack trace for the
    106      * first entry that is not this class.</p>
    107      */
    108     private void getClassAndMethod() {
    109         try {
    110             Throwable throwable = new Throwable();
    111             throwable.fillInStackTrace();
    112             StringWriter stringWriter = new StringWriter();
    113             PrintWriter printWriter = new PrintWriter( stringWriter );
    114             throwable.printStackTrace( printWriter );
    115             String traceString = stringWriter.getBuffer().toString();
    116             StringTokenizer tokenizer =
    117                 new StringTokenizer( traceString, "\n" );
    118             tokenizer.nextToken();
    119             String line = tokenizer.nextToken();
    120             while ( line.indexOf( this.getClass().getName() )  == -1 ) {
    121                 line = tokenizer.nextToken();
    122             }
    123             while ( line.indexOf( this.getClass().getName() ) >= 0 ) {
    124                 line = tokenizer.nextToken();
    125             }
    126             int start = line.indexOf( "at " ) + 3;
    127             int end = line.indexOf( '(' );
    128             String temp = line.substring( start, end );
    129             int lastPeriod = temp.lastIndexOf( '.' );
    130             sourceClassName = temp.substring( 0, lastPeriod );
    131             sourceMethodName = temp.substring( lastPeriod + 1 );
    132         } catch ( Exception ex ) {
    133             // ignore - leave class and methodname unknown
    134         }
    135         classAndMethodFound = true;
    136     }
    137
    138     /**
    139      * Logs a message with <code>java.util.logging.Level.FINE</code>.
    140      *
    141      * @param message to log
    142      * @see org.apache.commons.logging.Log#debug(Object)
    143      */
    144     public void debug(Object message) {
    145         log(Level.FINE, String.valueOf(message), null);
    146     }
    147
    148
    149     /**
    150      * Logs a message with <code>java.util.logging.Level.FINE</code>.
    151      *
    152      * @param message to log
    153      * @param exception log this cause
    154      * @see org.apache.commons.logging.Log#debug(Object, Throwable)
    155      */
    156     public void debug(Object message, Throwable exception) {
    157         log(Level.FINE, String.valueOf(message), exception);
    158     }
    159
    160
    161     /**
    162      * Logs a message with <code>java.util.logging.Level.SEVERE</code>.
    163      *
    164      * @param message to log
    165      * @see org.apache.commons.logging.Log#error(Object)
    166      */
    167     public void error(Object message) {
    168         log(Level.SEVERE, String.valueOf(message), null);
    169     }
    170
    171
    172     /**
    173      * Logs a message with <code>java.util.logging.Level.SEVERE</code>.
    174      *
    175      * @param message to log
    176      * @param exception log this cause
    177      * @see org.apache.commons.logging.Log#error(Object, Throwable)
    178      */
    179     public void error(Object message, Throwable exception) {
    180         log(Level.SEVERE, String.valueOf(message), exception);
    181     }
    182
    183
    184     /**
    185      * Logs a message with <code>java.util.logging.Level.SEVERE</code>.
    186      *
    187      * @param message to log
    188      * @see org.apache.commons.logging.Log#fatal(Object)
    189      */
    190     public void fatal(Object message) {
    191         log(Level.SEVERE, String.valueOf(message), null);
    192     }
    193
    194
    195     /**
    196      * Logs a message with <code>java.util.logging.Level.SEVERE</code>.
    197      *
    198      * @param message to log
    199      * @param exception log this cause
    200      * @see org.apache.commons.logging.Log#fatal(Object, Throwable)
    201      */
    202     public void fatal(Object message, Throwable exception) {
    203         log(Level.SEVERE, String.valueOf(message), exception);
    204     }
    205
    206
    207     /**
    208      * Return the native Logger instance we are using.
    209      */
    210     public Logger getLogger() {
    211         if (logger == null) {
    212             logger = Logger.getLogger(name);
    213         }
    214         return (logger);
    215     }
    216
    217
    218     /**
    219      * Logs a message with <code>java.util.logging.Level.INFO</code>.
    220      *
    221      * @param message to log
    222      * @see org.apache.commons.logging.Log#info(Object)
    223      */
    224     public void info(Object message) {
    225         log(Level.INFO, String.valueOf(message), null);
    226     }
    227
    228
    229     /**
    230      * Logs a message with <code>java.util.logging.Level.INFO</code>.
    231      *
    232      * @param message to log
    233      * @param exception log this cause
    234      * @see org.apache.commons.logging.Log#info(Object, Throwable)
    235      */
    236     public void info(Object message, Throwable exception) {
    237         log(Level.INFO, String.valueOf(message), exception);
    238     }
    239
    240
    241     /**
    242      * Is debug logging currently enabled?
    243      */
    244     public boolean isDebugEnabled() {
    245         return (getLogger().isLoggable(Level.FINE));
    246     }
    247
    248
    249     /**
    250      * Is error logging currently enabled?
    251      */
    252     public boolean isErrorEnabled() {
    253         return (getLogger().isLoggable(Level.SEVERE));
    254     }
    255
    256
    257     /**
    258      * Is fatal logging currently enabled?
    259      */
    260     public boolean isFatalEnabled() {
    261         return (getLogger().isLoggable(Level.SEVERE));
    262     }
    263
    264
    265     /**
    266      * Is info logging currently enabled?
    267      */
    268     public boolean isInfoEnabled() {
    269         return (getLogger().isLoggable(Level.INFO));
    270     }
    271
    272
    273     /**
    274      * Is trace logging currently enabled?
    275      */
    276     public boolean isTraceEnabled() {
    277         return (getLogger().isLoggable(Level.FINEST));
    278     }
    279
    280
    281     /**
    282      * Is warn logging currently enabled?
    283      */
    284     public boolean isWarnEnabled() {
    285         return (getLogger().isLoggable(Level.WARNING));
    286     }
    287
    288
    289     /**
    290      * Logs a message with <code>java.util.logging.Level.FINEST</code>.
    291      *
    292      * @param message to log
    293      * @see org.apache.commons.logging.Log#trace(Object)
    294      */
    295     public void trace(Object message) {
    296         log(Level.FINEST, String.valueOf(message), null);
    297     }
    298
    299
    300     /**
    301      * Logs a message with <code>java.util.logging.Level.FINEST</code>.
    302      *
    303      * @param message to log
    304      * @param exception log this cause
    305      * @see org.apache.commons.logging.Log#trace(Object, Throwable)
    306      */
    307     public void trace(Object message, Throwable exception) {
    308         log(Level.FINEST, String.valueOf(message), exception);
    309     }
    310
    311
    312     /**
    313      * Logs a message with <code>java.util.logging.Level.WARNING</code>.
    314      *
    315      * @param message to log
    316      * @see org.apache.commons.logging.Log#warn(Object)
    317      */
    318     public void warn(Object message) {
    319         log(Level.WARNING, String.valueOf(message), null);
    320     }
    321
    322
    323     /**
    324      * Logs a message with <code>java.util.logging.Level.WARNING</code>.
    325      *
    326      * @param message to log
    327      * @param exception log this cause
    328      * @see org.apache.commons.logging.Log#warn(Object, Throwable)
    329      */
    330     public void warn(Object message, Throwable exception) {
    331         log(Level.WARNING, String.valueOf(message), exception);
    332     }
    333
    334
    335 }