Source code

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.util.Objects;
021
022import org.apache.avalon.framework.logger.Logger;
023import org.apache.commons.logging.Log;
024
025/**
026 * Implements Commons Logging's Log interface to delegate 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 <em>was</em> 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} 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, "defaultLogger");
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     *
214     * @see org.apache.commons.logging.Log#isDebugEnabled()
215     */
216    @Override
217    public boolean isDebugEnabled() {
218        return getLogger().isDebugEnabled();
219    }
220
221    /**
222     * Is logging to {@code org.apache.avalon.framework.logger.Logger.error} enabled?
223     *
224     * @see org.apache.commons.logging.Log#isErrorEnabled()
225     */
226    @Override
227    public boolean isErrorEnabled() {
228        return getLogger().isErrorEnabled();
229    }
230
231    /**
232     * Is logging to {@code org.apache.avalon.framework.logger.Logger.fatalError} enabled?
233     *
234     * @see org.apache.commons.logging.Log#isFatalEnabled()
235     */
236    @Override
237    public boolean isFatalEnabled() {
238        return getLogger().isFatalErrorEnabled();
239    }
240
241    /**
242     * Is logging to {@code org.apache.avalon.framework.logger.Logger.info} enabled?
243     *
244     * @see org.apache.commons.logging.Log#isInfoEnabled()
245     */
246    @Override
247    public boolean isInfoEnabled() {
248        return getLogger().isInfoEnabled();
249    }
250
251    /**
252     * Is logging to {@code org.apache.avalon.framework.logger.Logger.debug} enabled?
253     *
254     * @see org.apache.commons.logging.Log#isTraceEnabled()
255     */
256    @Override
257    public boolean isTraceEnabled() {
258        return getLogger().isDebugEnabled();
259    }
260
261    /**
262     * Is logging to {@code org.apache.avalon.framework.logger.Logger.warn} enabled?
263     *
264     * @see org.apache.commons.logging.Log#isWarnEnabled()
265     */
266    @Override
267    public boolean isWarnEnabled() {
268        return getLogger().isWarnEnabled();
269    }
270
271    /**
272     * Logs a message with {@code org.apache.avalon.framework.logger.Logger.debug}.
273     *
274     * @param message to log
275     * @see org.apache.commons.logging.Log#trace(Object)
276     */
277    @Override
278    public void trace(final Object message) {
279        if (getLogger().isDebugEnabled()) {
280            getLogger().debug(String.valueOf(message));
281        }
282    }
283
284    /**
285     * Logs a message with {@code org.apache.avalon.framework.logger.Logger.debug}.
286     *
287     * @param message to log.
288     * @param t log this cause.
289     * @see org.apache.commons.logging.Log#trace(Object, Throwable)
290     */
291    @Override
292    public void trace(final Object message, final Throwable t) {
293        if (getLogger().isDebugEnabled()) {
294            getLogger().debug(String.valueOf(message), t);
295        }
296    }
297
298    /**
299     * Logs a message with {@code org.apache.avalon.framework.logger.Logger.warn}.
300     *
301     * @param message to log
302     * @see org.apache.commons.logging.Log#warn(Object)
303     */
304    @Override
305    public void warn(final Object message) {
306        if (getLogger().isWarnEnabled()) {
307            getLogger().warn(String.valueOf(message));
308        }
309    }
310
311    /**
312     * Logs a message with {@code org.apache.avalon.framework.logger.Logger.warn}.
313     *
314     * @param message to log
315     * @param t log this cause
316     * @see org.apache.commons.logging.Log#warn(Object, Throwable)
317     */
318    @Override
319    public void warn(final Object message, final Throwable t) {
320        if (getLogger().isWarnEnabled()) {
321            getLogger().warn(String.valueOf(message), t);
322        }
323    }
324}