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 *      http://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.util.Objects;
021
022import org.apache.avalon.framework.logger.Logger;
023import org.apache.commons.logging.Log;
024
025/**
026 * Implementation of commons-logging Log interface that delegates all
027 * logging calls to the Avalon logging abstraction: the Logger interface.
028 * <p>
029 * There are two ways in which this class can be used:
030 * <ul>
031 * <li>the instance can be constructed with an Avalon logger
032 * (by calling {@link #AvalonLogger(Logger)}). In this case, it acts
033 * as a simple thin wrapping implementation over the logger. This is
034 * particularly useful when using a property setter.
035 * </li>
036 * <li>the {@link #setDefaultLogger} class property can be called which
037 * sets the ancestral Avalon logger for this class. Any {@code AvalonLogger}
038 * instances created through the {@code LogFactory} mechanisms will output
039 * to child loggers of this {@code Logger}.
040 * </li>
041 * </ul>
042 * <p>
043 * <strong>Note:</strong> {@code AvalonLogger} does not implement Serializable
044 * because the constructors available for it make this impossible to achieve in all
045 * circumstances; there is no way to "reconnect" to an underlying Logger object on
046 * deserialization if one was just passed in to the constructor of the original
047 * object. This class <i>was</i> marked Serializable in the 1.0.4 release of
048 * commons-logging, but this never actually worked (a NullPointerException would
049 * be thrown as soon as the deserialized object was used), so removing this marker
050 * is not considered to be an incompatible change.
051 *
052 * @deprecated Scheduled for removal because the Apache Avalon Project has been discontinued.
053 */
054@Deprecated
055public class AvalonLogger implements Log {
056
057    /** Ancestral Avalon logger. */
058    private static volatile Logger defaultLogger;
059
060    /**
061     * Sets the ancestral Avalon logger from which the delegating loggers will descend.
062     *
063     * @param logger the default avalon logger,
064     * in case there is no logger instance supplied in constructor
065     */
066    public static void setDefaultLogger(final Logger logger) {
067        defaultLogger = logger;
068    }
069
070    /** Avalon logger used to perform log. */
071    private final transient Logger logger;
072
073    /**
074     * Constructs an {@code AvalonLogger} that outputs to the given
075     * {@code Logger} instance.
076     *
077     * @param logger the Avalon logger implementation to delegate to
078     */
079    public AvalonLogger(final Logger logger) {
080        this.logger = logger;
081    }
082
083    /**
084     * Constructs an {@code AvalonLogger} that will log to a child
085     * of the <code>Logger</code> set by calling {@link #setDefaultLogger}.
086     *
087     * @param name the name of the avalon logger implementation to delegate to
088     */
089    public AvalonLogger(final String name) {
090        Objects.requireNonNull(defaultLogger, "default logger has to be specified if this constructor is used!");
091        this.logger = defaultLogger.getChildLogger(name);
092    }
093
094    /**
095     * Logs a message with {@code org.apache.avalon.framework.logger.Logger.debug}.
096     *
097     * @param message to log.
098     * @see org.apache.commons.logging.Log#debug(Object)
099     */
100    @Override
101    public void debug(final Object message) {
102        if (getLogger().isDebugEnabled()) {
103            getLogger().debug(String.valueOf(message));
104        }
105    }
106
107    /**
108    * Logs a message with {@code org.apache.avalon.framework.logger.Logger.debug}.
109    *
110    * @param message to log
111    * @param t log this cause
112    * @see org.apache.commons.logging.Log#debug(Object, Throwable)
113     */
114    @Override
115    public void debug(final Object message, final Throwable t) {
116        if (getLogger().isDebugEnabled()) {
117            getLogger().debug(String.valueOf(message), t);
118        }
119    }
120
121    /**
122     * Logs a message with {@code org.apache.avalon.framework.logger.Logger.error}.
123     *
124     * @param message to log
125     * @see org.apache.commons.logging.Log#error(Object)
126     */
127    @Override
128    public void error(final Object message) {
129        if (getLogger().isErrorEnabled()) {
130            getLogger().error(String.valueOf(message));
131        }
132    }
133
134    /**
135     * Logs a message with {@code org.apache.avalon.framework.logger.Logger.error}.
136     *
137     * @param message to log
138     * @param t log this cause
139     * @see org.apache.commons.logging.Log#error(Object, Throwable)
140     */
141    @Override
142    public void error(final Object message, final Throwable t) {
143        if (getLogger().isErrorEnabled()) {
144            getLogger().error(String.valueOf(message), t);
145        }
146    }
147
148    /**
149     * Logs a message with {@code org.apache.avalon.framework.logger.Logger.fatalError}.
150     *
151     * @param message to log
152     * @see org.apache.commons.logging.Log#fatal(Object)
153     */
154    @Override
155    public void fatal(final Object message) {
156        if (getLogger().isFatalErrorEnabled()) {
157            getLogger().fatalError(String.valueOf(message));
158        }
159    }
160
161    /**
162     * Logs a message with {@code org.apache.avalon.framework.logger.Logger.fatalError}.
163     *
164     * @param message to log.
165     * @param t log this cause.
166     * @see org.apache.commons.logging.Log#fatal(Object, Throwable)
167     */
168    @Override
169    public void fatal(final Object message, final Throwable t) {
170        if (getLogger().isFatalErrorEnabled()) {
171            getLogger().fatalError(String.valueOf(message), t);
172        }
173    }
174
175    /**
176     * Gets the Avalon logger implementation used to perform logging.
177     *
178     * @return avalon logger implementation
179     */
180    public Logger getLogger() {
181        return logger;
182    }
183
184    /**
185     * Logs a message with {@code org.apache.avalon.framework.logger.Logger.info}.
186     *
187     * @param message to log
188     * @see org.apache.commons.logging.Log#info(Object)
189     */
190    @Override
191    public void info(final Object message) {
192        if (getLogger().isInfoEnabled()) {
193            getLogger().info(String.valueOf(message));
194        }
195    }
196
197    /**
198     * Logs a message with {@code org.apache.avalon.framework.logger.Logger.info}.
199     *
200     * @param message to log
201     * @param t log this cause
202     * @see org.apache.commons.logging.Log#info(Object, Throwable)
203     */
204    @Override
205    public void info(final Object message, final Throwable t) {
206        if (getLogger().isInfoEnabled()) {
207            getLogger().info(String.valueOf(message), t);
208        }
209    }
210
211    /**
212     * Is logging to {@code org.apache.avalon.framework.logger.Logger.debug} enabled?
213     * @see org.apache.commons.logging.Log#isDebugEnabled()
214     */
215    @Override
216    public boolean isDebugEnabled() {
217        return getLogger().isDebugEnabled();
218    }
219
220    /**
221     * Is logging to {@code org.apache.avalon.framework.logger.Logger.error} enabled?
222     * @see org.apache.commons.logging.Log#isErrorEnabled()
223     */
224    @Override
225    public boolean isErrorEnabled() {
226        return getLogger().isErrorEnabled();
227    }
228
229    /**
230     * Is logging to {@code org.apache.avalon.framework.logger.Logger.fatalError} enabled?
231     * @see org.apache.commons.logging.Log#isFatalEnabled()
232     */
233    @Override
234    public boolean isFatalEnabled() {
235        return getLogger().isFatalErrorEnabled();
236    }
237
238    /**
239     * Is logging to {@code org.apache.avalon.framework.logger.Logger.info} enabled?
240     * @see org.apache.commons.logging.Log#isInfoEnabled()
241     */
242    @Override
243    public boolean isInfoEnabled() {
244        return getLogger().isInfoEnabled();
245    }
246
247    /**
248     * Is logging to {@code org.apache.avalon.framework.logger.Logger.debug} enabled?
249     * @see org.apache.commons.logging.Log#isTraceEnabled()
250     */
251    @Override
252    public boolean isTraceEnabled() {
253        return getLogger().isDebugEnabled();
254    }
255
256    /**
257     * Is logging to {@code org.apache.avalon.framework.logger.Logger.warn} enabled?
258     * @see org.apache.commons.logging.Log#isWarnEnabled()
259     */
260    @Override
261    public boolean isWarnEnabled() {
262        return getLogger().isWarnEnabled();
263    }
264
265    /**
266     * Logs a message with {@code org.apache.avalon.framework.logger.Logger.debug}.
267     *
268     * @param message to log
269     * @see org.apache.commons.logging.Log#trace(Object)
270     */
271    @Override
272    public void trace(final Object message) {
273        if (getLogger().isDebugEnabled()) {
274            getLogger().debug(String.valueOf(message));
275        }
276    }
277
278    /**
279     * Logs a message with {@code org.apache.avalon.framework.logger.Logger.debug}.
280     *
281     * @param message to log.
282     * @param t log this cause.
283     * @see org.apache.commons.logging.Log#trace(Object, Throwable)
284     */
285    @Override
286    public void trace(final Object message, final Throwable t) {
287        if (getLogger().isDebugEnabled()) {
288            getLogger().debug(String.valueOf(message), t);
289        }
290    }
291
292    /**
293     * Logs a message with {@code org.apache.avalon.framework.logger.Logger.warn}.
294     *
295     * @param message to log
296     * @see org.apache.commons.logging.Log#warn(Object)
297     */
298    @Override
299    public void warn(final Object message) {
300        if (getLogger().isWarnEnabled()) {
301            getLogger().warn(String.valueOf(message));
302        }
303    }
304
305    /**
306     * Logs a message with {@code org.apache.avalon.framework.logger.Logger.warn}.
307     *
308     * @param message to log
309     * @param t log this cause
310     * @see org.apache.commons.logging.Log#warn(Object, Throwable)
311     */
312    @Override
313    public void warn(final Object message, final Throwable t) {
314        if (getLogger().isWarnEnabled()) {
315            getLogger().warn(String.valueOf(message), t);
316        }
317    }
318}