View Javadoc

    1   /*
    2    * Copyright 2001-2004 The Apache Software Foundation.
    3    *
    4    * Licensed under the Apache License, Version 2.0 (the "License");
    5    * you may not use this file except in compliance with the License.
    6    * You may obtain a copy of the License at
    7    *
    8    *      http://www.apache.org/licenses/LICENSE-2.0
    9    *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS,
    12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   * See the License for the specific language governing permissions and
    14   * limitations under the License.
    15   */
    16
    17  package org.apache.log4j;
    18
    19  import org.apache.log4j.helpers.NullEnumeration;
    20  import org.slf4j.LoggerFactory;
    21  import org.slf4j.Marker;
    22  import org.slf4j.MarkerFactory;
    23  import org.slf4j.spi.LocationAwareLogger;
    24
    25  import java.util.Enumeration;
    26
    27  /**
    28   * <p>
    29   * This class is a minimal implementation of the original
    30   * <code>org.apache.log4j.Category</code> class (as found in log4j 1.2) by
    31   * delegation of all calls to a {@link org.slf4j.Logger} instance.
    32   * </p>
    33   *
    34   * <p>
    35   * Log4j's <code>trace</code>, <code>debug()</code>, <code>info()</code>,
    36   * <code>warn()</code>, <code>error()</code> printing methods are directly
    37   * mapped to their SLF4J equivalents. Log4j's <code>fatal()</code> printing
    38   * method is mapped to SLF4J's <code>error()</code> method with a FATAL marker.
    39   *
    40   * @author S&eacute;bastien Pennec
    41   * @author Ceki G&uuml;lc&uuml;
    42   */
    43  @SuppressWarnings("rawtypes")
    44  public class Category {
    45
    46      private static final String CATEGORY_FQCN = Category.class.getName();
    47
    48      private String name;
    49
    50      protected org.slf4j.Logger slf4jLogger;
    51      private org.slf4j.spi.LocationAwareLogger locationAwareLogger;
    52
    53      private static Marker FATAL_MARKER = MarkerFactory.getMarker("FATAL");
    54
    55      Category(String name) {
    56          this.name = name;
    57          slf4jLogger = LoggerFactory.getLogger(name);
    58          if (slf4jLogger instanceof LocationAwareLogger) {
    59              locationAwareLogger = (LocationAwareLogger) slf4jLogger;
    60          }
    61      }
    62
    63      public static Category getInstance(Class clazz) {
    64          return Log4jLoggerFactory.getLogger(clazz.getName());
    65      }
    66
    67      public static Category getInstance(String name) {
    68          return Log4jLoggerFactory.getLogger(name);
    69      }
    70
    71      public final Category getParent() {
    72          return null;
    73      }
    74
    75      /**
    76       * Returns the obvious.
    77       *
    78       * @return
    79       */
    80      public String getName() {
    81          return name;
    82      }
    83
    84      public Appender getAppender(String name) {
    85          return null;
    86      }
    87
    88      public Enumeration getAllAppenders() {
    89          return NullEnumeration.getInstance();
    90      }
    91
    92      /**
    93       * Return the level in effect for this category/logger.
    94       *
    95       * <p>
    96       * The result is computed by simulation.
    97       *
    98       * @return
    99       */
    100     public Level getEffectiveLevel() {
    101         if (slf4jLogger.isTraceEnabled()) {
    102             return Level.TRACE;
    103         }
    104         if (slf4jLogger.isDebugEnabled()) {
    105             return Level.DEBUG;
    106         }
    107         if (slf4jLogger.isInfoEnabled()) {
    108             return Level.INFO;
    109         }
    110         if (slf4jLogger.isWarnEnabled()) {
    111             return Level.WARN;
    112         }
    113         return Level.ERROR;
    114     }
    115
    116     /**
    117      * Returns the assigned {@link Level}, if any, for this Category. This
    118      * implementation always returns null.
    119      *
    120      * @return Level - the assigned Level, can be <code>null</code>.
    121      */
    122     final public Level getLevel() {
    123         return null;
    124     }
    125
    126     /**
    127      * @deprecated Please use {@link #getLevel} instead.
    128      */
    129     final public Level getPriority() {
    130         return null;
    131     }
    132
    133     /**
    134      * Delegates to {@link org.slf4j.Logger#isDebugEnabled} method in SLF4J
    135      */
    136     public boolean isDebugEnabled() {
    137         return slf4jLogger.isDebugEnabled();
    138     }
    139
    140     /**
    141      * Delegates to {@link org.slf4j.Logger#isInfoEnabled} method in SLF4J
    142      */
    143     public boolean isInfoEnabled() {
    144         return slf4jLogger.isInfoEnabled();
    145     }
    146
    147     /**
    148      * Delegates to {@link org.slf4j.Logger#isWarnEnabled} method in SLF4J
    149      */
    150     public boolean isWarnEnabled() {
    151         return slf4jLogger.isWarnEnabled();
    152     }
    153
    154     /**
    155      * Delegates to {@link org.slf4j.Logger#isErrorEnabled} method in SLF4J
    156      */
    157     public boolean isErrorEnabled() {
    158         return slf4jLogger.isErrorEnabled();
    159     }
    160
    161     /**
    162      * Determines whether the priority passed as parameter is enabled in the
    163      * underlying SLF4J logger. Each log4j priority is mapped directly to its
    164      * SLF4J equivalent, except for FATAL which is mapped as ERROR.
    165      *
    166      * @param p
    167      *          the priority to check against
    168      * @return true if this logger is enabled for the given level, false
    169      *         otherwise.
    170      */
    171     public boolean isEnabledFor(Priority p) {
    172         switch (p.level) {
    173         case Level.TRACE_INT:
    174             return slf4jLogger.isTraceEnabled();
    175         case Level.DEBUG_INT:
    176             return slf4jLogger.isDebugEnabled();
    177         case Level.INFO_INT:
    178             return slf4jLogger.isInfoEnabled();
    179         case Level.WARN_INT:
    180             return slf4jLogger.isWarnEnabled();
    181         case Level.ERROR_INT:
    182             return slf4jLogger.isErrorEnabled();
    183         case Priority.FATAL_INT:
    184             return slf4jLogger.isErrorEnabled();
    185         }
    186         return false;
    187     }
    188
    189     void differentiatedLog(Marker marker, String fqcn, int level, Object message, Throwable t) {
    190
    191         String m = convertToString(message);
    192         if (locationAwareLogger != null) {
    193             locationAwareLogger.log(marker, fqcn, level, m, null, t);
    194         } else {
    195             switch (level) {
    196             case LocationAwareLogger.TRACE_INT:
    197                 slf4jLogger.trace(marker, m);
    198                 break;
    199             case LocationAwareLogger.DEBUG_INT:
    200                 slf4jLogger.debug(marker, m);
    201                 break;
    202             case LocationAwareLogger.INFO_INT:
    203                 slf4jLogger.info(marker, m);
    204                 break;
    205             case LocationAwareLogger.WARN_INT:
    206                 slf4jLogger.warn(marker, m);
    207                 break;
    208             case LocationAwareLogger.ERROR_INT:
    209                 slf4jLogger.error(marker, m);
    210                 break;
    211             }
    212         }
    213     }
    214
    215     /**
    216      * Delegates to {@link org.slf4j.Logger#debug(String)} method of SLF4J.
    217      */
    218     public void debug(Object message) {
    219         differentiatedLog(null, CATEGORY_FQCN, LocationAwareLogger.DEBUG_INT, message, null);
    220     }
    221
    222     /**
    223      * Delegates to {@link org.slf4j.Logger#debug(String,Throwable)} method in
    224      * SLF4J.
    225      */
    226     public void debug(Object message, Throwable t) {
    227         differentiatedLog(null, CATEGORY_FQCN, LocationAwareLogger.DEBUG_INT, message, t);
    228     }
    229
    230     /**
    231      * Delegates to {@link org.slf4j.Logger#info(String)} method in SLF4J.
    232      */
    233     public void info(Object message) {
    234         differentiatedLog(null, CATEGORY_FQCN, LocationAwareLogger.INFO_INT, message, null);
    235     }
    236
    237     /**
    238      * Delegates to {@link org.slf4j.Logger#info(String,Throwable)} method in
    239      * SLF4J.
    240      */
    241     public void info(Object message, Throwable t) {
    242         differentiatedLog(null, CATEGORY_FQCN, LocationAwareLogger.INFO_INT, message, t);
    243     }
    244
    245     /**
    246      * Delegates to {@link org.slf4j.Logger#warn(String)} method in SLF4J.
    247      */
    248     public void warn(Object message) {
    249         differentiatedLog(null, CATEGORY_FQCN, LocationAwareLogger.WARN_INT, message, null);
    250     }
    251
    252     /**
    253      * Delegates to {@link org.slf4j.Logger#warn(String,Throwable)} method in
    254      * SLF4J.
    255      */
    256     public void warn(Object message, Throwable t) {
    257         differentiatedLog(null, CATEGORY_FQCN, LocationAwareLogger.WARN_INT, message, t);
    258     }
    259
    260     /**
    261      * Delegates to {@link org.slf4j.Logger#error(String)} method in SLF4J.
    262      */
    263     public void error(Object message) {
    264         differentiatedLog(null, CATEGORY_FQCN, LocationAwareLogger.ERROR_INT, message, null);
    265     }
    266
    267     /**
    268      * Delegates to {@link org.slf4j.Logger#error(String,Throwable)} method in
    269      * SLF4J.
    270      */
    271     public void error(Object message, Throwable t) {
    272         differentiatedLog(null, CATEGORY_FQCN, LocationAwareLogger.ERROR_INT, message, t);
    273     }
    274
    275     /**
    276      * Delegates to {@link org.slf4j.Logger#error(String)} method in SLF4J.
    277      */
    278     public void fatal(Object message) {
    279         differentiatedLog(FATAL_MARKER, CATEGORY_FQCN, LocationAwareLogger.ERROR_INT, message, null);
    280     }
    281
    282     /**
    283      * Delegates to {@link org.slf4j.Logger#error(String,Throwable)} method in
    284      * SLF4J. In addition, the call is marked with a marker named "FATAL".
    285      */
    286     public void fatal(Object message, Throwable t) {
    287         differentiatedLog(FATAL_MARKER, CATEGORY_FQCN, LocationAwareLogger.ERROR_INT, message, t);
    288     }
    289
    290     protected void forcedLog(String FQCN, Priority p, Object msg, Throwable t) {
    291         log(FQCN, p, msg, t);
    292     }
    293
    294     // See also http://jira.qos.ch/browse/SLF4J-159
    295     public void log(String FQCN, Priority p, Object msg, Throwable t) {
    296         int levelInt = priorityToLevelInt(p);
    297         differentiatedLog(null, FQCN, levelInt, msg, t);
    298     }
    299
    300     public void log(Priority p, Object message, Throwable t) {
    301         int levelInt = priorityToLevelInt(p);
    302         differentiatedLog(null, CATEGORY_FQCN, levelInt, message, t);
    303     }
    304
    305     public void log(Priority p, Object message) {
    306         int levelInt = priorityToLevelInt(p);
    307         differentiatedLog(null, CATEGORY_FQCN, levelInt, message, null);
    308     }
    309
    310     private int priorityToLevelInt(Priority p) {
    311         switch (p.level) {
    312         case Level.TRACE_INT:
    313         case Level.X_TRACE_INT:
    314             return LocationAwareLogger.TRACE_INT;
    315         case Priority.DEBUG_INT:
    316             return LocationAwareLogger.DEBUG_INT;
    317         case Priority.INFO_INT:
    318             return LocationAwareLogger.INFO_INT;
    319         case Priority.WARN_INT:
    320             return LocationAwareLogger.WARN_INT;
    321         case Priority.ERROR_INT:
    322             return LocationAwareLogger.ERROR_INT;
    323         case Priority.FATAL_INT:
    324             return LocationAwareLogger.ERROR_INT;
    325         default:
    326             throw new IllegalStateException("Unknown Priority " + p);
    327         }
    328     }
    329
    330     protected final String convertToString(Object message) {
    331         if (message == null) {
    332             return (String) message;
    333         } else {
    334             return message.toString();
    335         }
    336     }
    337
    338     public void setAdditivity(boolean additive) {
    339         // nothing to do
    340     }
    341
    342     public void addAppender(Appender newAppender) {
    343         // nothing to do
    344     }
    345
    346     public void setLevel(Level level) {
    347         // nothing to do
    348     }
    349
    350     public boolean getAdditivity() {
    351         return false;
    352     }
    353
    354     public void assertLog(boolean assertion, String msg) {
    355         if (!assertion)
    356             error(msg);
    357     }
    358
    359 }