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
    26  import org.apache.commons.logging.Log;
    27
    28
    29  /**
    30   * <p>Implementation of the <code>org.apache.commons.logging.Log</code>
    31   * interface that wraps the standard JDK logging mechanisms that were
    32   * introduced in the Merlin release (JDK 1.4).</p>
    33   *
    34   * @author <a href="mailto:sanders@apache.org">Scott Sanders</a>
    35   * @author <a href="mailto:bloritsch@apache.org">Berin Loritsch</a>
    36   * @author <a href="mailto:donaldp@apache.org">Peter Donald</a>
    37   * @version $Revision: 424107 $ $Date: 2006-07-21 01:15:42 +0200 (fr, 21 jul 2006) $
    38   */
    39
    40  public class Jdk14Logger implements Log, Serializable {
    41
    42      /**
    43       * This member variable simply ensures that any attempt to initialise
    44       * this class in a pre-1.4 JVM will result in an ExceptionInInitializerError.
    45       * It must not be private, as an optimising compiler could detect that it
    46       * is not used and optimise it away.
    47       */
    48      protected static final Level dummyLevel = Level.FINE;
    49
    50      // ----------------------------------------------------------- Constructors
    51
    52
    53      /**
    54       * Construct a named instance of this Logger.
    55       *
    56       * @param name Name of the logger to be constructed
    57       */
    58      public Jdk14Logger(String name) {
    59
    60          this.name = name;
    61          logger = getLogger();
    62
    63      }
    64
    65
    66      // ----------------------------------------------------- Instance Variables
    67
    68
    69      /**
    70       * The underlying Logger implementation we are using.
    71       */
    72      protected transient Logger logger = null;
    73
    74
    75      /**
    76       * The name of the logger we are wrapping.
    77       */
    78      protected String name = null;
    79
    80
    81      // --------------------------------------------------------- Public Methods
    82
    83      private void log( Level level, String msg, Throwable ex ) {
    84
    85          Logger logger = getLogger();
    86          if (logger.isLoggable(level)) {
    87              // Hack (?) to get the stack trace.
    88              Throwable dummyException=new Throwable();
    89              StackTraceElement locations[]=dummyException.getStackTrace();
    90              // Caller will be the third element
    91              String cname="unknown";
    92              String method="unknown";
    93              if( locations!=null && locations.length >2 ) {
    94                  StackTraceElement caller=locations[2];
    95                  cname=caller.getClassName();
    96                  method=caller.getMethodName();
    97              }
    98              if( ex==null ) {
    99                  logger.logp( level, cname, method, msg );
    100             } else {
    101                 logger.logp( level, cname, method, msg, ex );
    102             }
    103         }
    104
    105     }
    106
    107     /**
    108      * Logs a message with <code>java.util.logging.Level.FINE</code>.
    109      *
    110      * @param message to log
    111      * @see org.apache.commons.logging.Log#debug(Object)
    112      */
    113     public void debug(Object message) {
    114         log(Level.FINE, String.valueOf(message), null);
    115     }
    116
    117
    118     /**
    119      * Logs a message with <code>java.util.logging.Level.FINE</code>.
    120      *
    121      * @param message to log
    122      * @param exception log this cause
    123      * @see org.apache.commons.logging.Log#debug(Object, Throwable)
    124      */
    125     public void debug(Object message, Throwable exception) {
    126         log(Level.FINE, String.valueOf(message), exception);
    127     }
    128
    129
    130     /**
    131      * Logs a message with <code>java.util.logging.Level.SEVERE</code>.
    132      *
    133      * @param message to log
    134      * @see org.apache.commons.logging.Log#error(Object)
    135      */
    136     public void error(Object message) {
    137         log(Level.SEVERE, String.valueOf(message), null);
    138     }
    139
    140
    141     /**
    142      * Logs a message with <code>java.util.logging.Level.SEVERE</code>.
    143      *
    144      * @param message to log
    145      * @param exception log this cause
    146      * @see org.apache.commons.logging.Log#error(Object, Throwable)
    147      */
    148     public void error(Object message, Throwable exception) {
    149         log(Level.SEVERE, String.valueOf(message), exception);
    150     }
    151
    152
    153     /**
    154      * Logs a message with <code>java.util.logging.Level.SEVERE</code>.
    155      *
    156      * @param message to log
    157      * @see org.apache.commons.logging.Log#fatal(Object)
    158      */
    159     public void fatal(Object message) {
    160         log(Level.SEVERE, String.valueOf(message), null);
    161     }
    162
    163
    164     /**
    165      * Logs a message with <code>java.util.logging.Level.SEVERE</code>.
    166      *
    167      * @param message to log
    168      * @param exception log this cause
    169      * @see org.apache.commons.logging.Log#fatal(Object, Throwable)
    170      */
    171     public void fatal(Object message, Throwable exception) {
    172         log(Level.SEVERE, String.valueOf(message), exception);
    173     }
    174
    175
    176     /**
    177      * Return the native Logger instance we are using.
    178      */
    179     public Logger getLogger() {
    180         if (logger == null) {
    181             logger = Logger.getLogger(name);
    182         }
    183         return (logger);
    184     }
    185
    186
    187     /**
    188      * Logs a message with <code>java.util.logging.Level.INFO</code>.
    189      *
    190      * @param message to log
    191      * @see org.apache.commons.logging.Log#info(Object)
    192      */
    193     public void info(Object message) {
    194         log(Level.INFO, String.valueOf(message), null);
    195     }
    196
    197
    198     /**
    199      * Logs a message with <code>java.util.logging.Level.INFO</code>.
    200      *
    201      * @param message to log
    202      * @param exception log this cause
    203      * @see org.apache.commons.logging.Log#info(Object, Throwable)
    204      */
    205     public void info(Object message, Throwable exception) {
    206         log(Level.INFO, String.valueOf(message), exception);
    207     }
    208
    209
    210     /**
    211      * Is debug logging currently enabled?
    212      */
    213     public boolean isDebugEnabled() {
    214         return (getLogger().isLoggable(Level.FINE));
    215     }
    216
    217
    218     /**
    219      * Is error logging currently enabled?
    220      */
    221     public boolean isErrorEnabled() {
    222         return (getLogger().isLoggable(Level.SEVERE));
    223     }
    224
    225
    226     /**
    227      * Is fatal logging currently enabled?
    228      */
    229     public boolean isFatalEnabled() {
    230         return (getLogger().isLoggable(Level.SEVERE));
    231     }
    232
    233
    234     /**
    235      * Is info logging currently enabled?
    236      */
    237     public boolean isInfoEnabled() {
    238         return (getLogger().isLoggable(Level.INFO));
    239     }
    240
    241
    242     /**
    243      * Is trace logging currently enabled?
    244      */
    245     public boolean isTraceEnabled() {
    246         return (getLogger().isLoggable(Level.FINEST));
    247     }
    248
    249
    250     /**
    251      * Is warn logging currently enabled?
    252      */
    253     public boolean isWarnEnabled() {
    254         return (getLogger().isLoggable(Level.WARNING));
    255     }
    256
    257
    258     /**
    259      * Logs a message with <code>java.util.logging.Level.FINEST</code>.
    260      *
    261      * @param message to log
    262      * @see org.apache.commons.logging.Log#trace(Object)
    263      */
    264     public void trace(Object message) {
    265         log(Level.FINEST, String.valueOf(message), null);
    266     }
    267
    268
    269     /**
    270      * Logs a message with <code>java.util.logging.Level.FINEST</code>.
    271      *
    272      * @param message to log
    273      * @param exception log this cause
    274      * @see org.apache.commons.logging.Log#trace(Object, Throwable)
    275      */
    276     public void trace(Object message, Throwable exception) {
    277         log(Level.FINEST, String.valueOf(message), exception);
    278     }
    279
    280
    281     /**
    282      * Logs a message with <code>java.util.logging.Level.WARNING</code>.
    283      *
    284      * @param message to log
    285      * @see org.apache.commons.logging.Log#warn(Object)
    286      */
    287     public void warn(Object message) {
    288         log(Level.WARNING, String.valueOf(message), null);
    289     }
    290
    291
    292     /**
    293      * Logs a message with <code>java.util.logging.Level.WARNING</code>.
    294      *
    295      * @param message to log
    296      * @param exception log this cause
    297      * @see org.apache.commons.logging.Log#warn(Object, Throwable)
    298      */
    299     public void warn(Object message, Throwable exception) {
    300         log(Level.WARNING, String.valueOf(message), exception);
    301     }
    302
    303
    304 }