Source code
Description: source: package: org.apache.commons.logging.impl, class: Jdk14Logger

    001/*
    002 * Licensed to the Apache Software Foundation (ASF) under one or more
    003 * contributor license agreements.  See the NOTICE file distributed with
    004 * this work for additional information regarding copyright ownership.
    005 * The ASF licenses this file to You under the Apache License, Version 2.0
    006 * (the "License"); you may not use this file except in compliance with
    007 * the License.  You may obtain a copy of the License at
    008 *
    009 *      https://www.apache.org/licenses/LICENSE-2.0
    010 *
    011 * Unless required by applicable law or agreed to in writing, software
    012 * distributed under the License is distributed on an "AS IS" BASIS,
    013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014 * See the License for the specific language governing permissions and
    015 * limitations under the License.
    016 */
    017
    018package org.apache.commons.logging.impl;
    019
    020import java.io.Serializable;
    021import java.util.logging.Level;
    022import java.util.logging.Logger;
    023
    024import org.apache.commons.logging.Log;
    025
    026/**
    027 * Implements the {@code org.apache.commons.logging.Log}
    028 * interface to wrap the standard JDK logging mechanisms that were
    029 * introduced in the Merlin release (JDK 1.4).
    030 */
    031public class Jdk14Logger implements Log, Serializable {
    032
    033    /** Serializable version identifier. */
    034    private static final long serialVersionUID = 4784713551416303804L;
    035
    036    /**
    037     * This member variable simply ensures that any attempt to initialize
    038     * this class in a pre-1.4 JVM will result in an ExceptionInInitializerError.
    039     * It must not be private, as an optimizing compiler could detect that it
    040     * is not used and optimize it away.
    041     */
    042    protected static final Level dummyLevel = Level.FINE;
    043
    044    /**
    045     * The underlying Logger implementation we are using.
    046     */
    047    protected transient Logger logger;
    048
    049    /**
    050     * The name of the logger we are wrapping.
    051     */
    052    protected String name;
    053
    054    /**
    055     * Constructs a named instance of this Logger.
    056     *
    057     * @param name Name of the logger to be constructed
    058     */
    059    public Jdk14Logger(final String name) {
    060        this.name = name;
    061        logger = getLogger();
    062    }
    063
    064    /**
    065     * Logs a message with {@link java.util.logging.Level#FINE}.
    066     *
    067     * @param message to log
    068     * @see org.apache.commons.logging.Log#debug(Object)
    069     */
    070    @Override
    071    public void debug(final Object message) {
    072        log(Level.FINE, String.valueOf(message), null);
    073    }
    074
    075    /**
    076     * Logs a message with {@link java.util.logging.Level#FINE}.
    077     *
    078     * @param message to log
    079     * @param exception log this cause
    080     * @see org.apache.commons.logging.Log#debug(Object, Throwable)
    081     */
    082    @Override
    083    public void debug(final Object message, final Throwable exception) {
    084        log(Level.FINE, String.valueOf(message), exception);
    085    }
    086
    087    /**
    088     * Logs a message with {@link java.util.logging.Level#SEVERE}.
    089     *
    090     * @param message to log
    091     * @see org.apache.commons.logging.Log#error(Object)
    092     */
    093    @Override
    094    public void error(final Object message) {
    095        log(Level.SEVERE, String.valueOf(message), null);
    096    }
    097
    098    /**
    099     * Logs a message with {@link java.util.logging.Level#SEVERE}.
    100     *
    101     * @param message to log
    102     * @param exception log this cause
    103     * @see org.apache.commons.logging.Log#error(Object, Throwable)
    104     */
    105    @Override
    106    public void error(final Object message, final Throwable exception) {
    107        log(Level.SEVERE, String.valueOf(message), exception);
    108    }
    109
    110    /**
    111     * Logs a message with {@link java.util.logging.Level#SEVERE}.
    112     *
    113     * @param message to log
    114     * @see org.apache.commons.logging.Log#fatal(Object)
    115     */
    116    @Override
    117    public void fatal(final Object message) {
    118        log(Level.SEVERE, String.valueOf(message), null);
    119    }
    120
    121    /**
    122     * Logs a message with {@link java.util.logging.Level#SEVERE}.
    123     *
    124     * @param message to log
    125     * @param exception log this cause
    126     * @see org.apache.commons.logging.Log#fatal(Object, Throwable)
    127     */
    128    @Override
    129    public void fatal(final Object message, final Throwable exception) {
    130        log(Level.SEVERE, String.valueOf(message), exception);
    131    }
    132
    133    /**
    134     * Gets the native Logger instance we are using.
    135     *
    136     * @return  the native Logger instance we are using.
    137     */
    138    public Logger getLogger() {
    139        if (logger == null) {
    140            logger = Logger.getLogger(name);
    141        }
    142        return logger;
    143    }
    144
    145    /**
    146     * Logs a message with {@link java.util.logging.Level#INFO}.
    147     *
    148     * @param message to log
    149     * @see org.apache.commons.logging.Log#info(Object)
    150     */
    151    @Override
    152    public void info(final Object message) {
    153        log(Level.INFO, String.valueOf(message), null);
    154    }
    155
    156    /**
    157     * Logs a message with {@link java.util.logging.Level#INFO}.
    158     *
    159     * @param message to log
    160     * @param exception log this cause
    161     * @see org.apache.commons.logging.Log#info(Object, Throwable)
    162     */
    163    @Override
    164    public void info(final Object message, final Throwable exception) {
    165        log(Level.INFO, String.valueOf(message), exception);
    166    }
    167
    168    /**
    169     * Is debug logging currently enabled?
    170     */
    171    @Override
    172    public boolean isDebugEnabled() {
    173        return getLogger().isLoggable(Level.FINE);
    174    }
    175
    176    /**
    177     * Is error logging currently enabled?
    178     */
    179    @Override
    180    public boolean isErrorEnabled() {
    181        return getLogger().isLoggable(Level.SEVERE);
    182    }
    183
    184    /**
    185     * Is fatal logging currently enabled?
    186     */
    187    @Override
    188    public boolean isFatalEnabled() {
    189        return getLogger().isLoggable(Level.SEVERE);
    190    }
    191
    192    /**
    193     * Is info logging currently enabled?
    194     */
    195    @Override
    196    public boolean isInfoEnabled() {
    197        return getLogger().isLoggable(Level.INFO);
    198    }
    199
    200    /**
    201     * Is trace logging currently enabled?
    202     */
    203    @Override
    204    public boolean isTraceEnabled() {
    205        return getLogger().isLoggable(Level.FINEST);
    206    }
    207
    208    /**
    209     * Is warn logging currently enabled?
    210     */
    211    @Override
    212    public boolean isWarnEnabled() {
    213        return getLogger().isLoggable(Level.WARNING);
    214    }
    215
    216    /**
    217     * Logs a message at the given level.
    218     *
    219     * @param level The level.
    220     * @param msg The message.
    221     * @param ex The exception.
    222     */
    223    protected void log(final Level level, final String msg, final Throwable ex) {
    224        final Logger logger = getLogger();
    225        if (logger.isLoggable(level)) {
    226            // Hack (?) to get the stack trace.
    227            final Throwable dummyException = new Throwable();
    228            final StackTraceElement[] locations = dummyException.getStackTrace();
    229            // LOGGING-132: use the provided logger name instead of the class name
    230            final String cname = name;
    231            String method = "unknown";
    232            // Caller will be the third element
    233            if (locations != null && locations.length > 2) {
    234                final StackTraceElement caller = locations[2];
    235                method = caller.getMethodName();
    236            }
    237            if (ex == null) {
    238                logger.logp(level, cname, method, msg);
    239            } else {
    240                logger.logp(level, cname, method, msg, ex);
    241            }
    242        }
    243    }
    244
    245    /**
    246     * Logs a message with {@link java.util.logging.Level#FINEST}.
    247     *
    248     * @param message to log
    249     * @see org.apache.commons.logging.Log#trace(Object)
    250     */
    251    @Override
    252    public void trace(final Object message) {
    253        log(Level.FINEST, String.valueOf(message), null);
    254    }
    255
    256    /**
    257     * Logs a message with {@link java.util.logging.Level#FINEST}.
    258     *
    259     * @param message to log
    260     * @param exception log this cause
    261     * @see org.apache.commons.logging.Log#trace(Object, Throwable)
    262     */
    263    @Override
    264    public void trace(final Object message, final Throwable exception) {
    265        log(Level.FINEST, String.valueOf(message), exception);
    266    }
    267
    268    /**
    269     * Logs a message with {@link java.util.logging.Level#WARNING}.
    270     *
    271     * @param message to log
    272     * @see org.apache.commons.logging.Log#warn(Object)
    273     */
    274    @Override
    275    public void warn(final Object message) {
    276        log(Level.WARNING, String.valueOf(message), null);
    277    }
    278
    279    /**
    280     * Logs a message with {@link java.util.logging.Level#WARNING}.
    281     *
    282     * @param message to log
    283     * @param exception log this cause
    284     * @see org.apache.commons.logging.Log#warn(Object, Throwable)
    285     */
    286    @Override
    287    public void warn(final Object message, final Throwable exception) {
    288        log(Level.WARNING, String.valueOf(message), exception);
    289    }
    290}