| /** |
| * Copyright (c) 2004-2011 QOS.ch |
| * All rights reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining |
| * a copy of this software and associated documentation files (the |
| * "Software"), to deal in the Software without restriction, including |
| * without limitation the rights to use, copy, modify, merge, publish, |
| * distribute, sublicense, and/or sell copies of the Software, and to |
| * permit persons to whom the Software is furnished to do so, subject to |
| * the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be |
| * included in all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE |
| * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION |
| * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
| * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| * |
| */ |
| package org.slf4j.helpers; |
| |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.util.Queue; |
| |
| import org.slf4j.Logger; |
| import org.slf4j.Marker; |
| import org.slf4j.event.EventRecordingLogger; |
| import org.slf4j.event.Level; |
| import org.slf4j.event.LoggingEvent; |
| import org.slf4j.event.SubstituteLoggingEvent; |
| import org.slf4j.spi.LoggingEventBuilder; |
| |
| /** |
| * A logger implementation which logs via a delegate logger. By default, the delegate is a |
| * {@link NOPLogger}. However, a different delegate can be set at any time. |
| * |
| * <p>See also the <a href="http://www.slf4j.org/codes.html#substituteLogger">relevant |
| * error code</a> documentation. |
| * |
| * @author Chetan Mehrotra |
| * @author Ceki Gulcu |
| */ |
| public class SubstituteLogger implements Logger { |
| |
| private final String name; |
| private volatile Logger _delegate; |
| private Boolean delegateEventAware; |
| private Method logMethodCache; |
| private EventRecordingLogger eventRecordingLogger; |
| private final Queue<SubstituteLoggingEvent> eventQueue; |
| |
| public final boolean createdPostInitialization; |
| |
| public SubstituteLogger(String name, Queue<SubstituteLoggingEvent> eventQueue, boolean createdPostInitialization) { |
| this.name = name; |
| this.eventQueue = eventQueue; |
| this.createdPostInitialization = createdPostInitialization; |
| } |
| |
| @Override |
| public String getName() { |
| return name; |
| } |
| |
| @Override |
| public LoggingEventBuilder makeLoggingEventBuilder(Level level) { |
| return delegate().makeLoggingEventBuilder(level); |
| } |
| |
| @Override |
| public LoggingEventBuilder atLevel(Level level) { |
| return delegate().atLevel(level); |
| } |
| |
| @Override |
| public boolean isEnabledForLevel(Level level) { |
| return delegate().isEnabledForLevel(level); |
| } |
| |
| @Override |
| public boolean isTraceEnabled() { |
| return delegate().isTraceEnabled(); |
| } |
| |
| @Override |
| public void trace(String msg) { |
| delegate().trace(msg); |
| } |
| |
| @Override |
| public void trace(String format, Object arg) { |
| delegate().trace(format, arg); |
| } |
| |
| @Override |
| public void trace(String format, Object arg1, Object arg2) { |
| delegate().trace(format, arg1, arg2); |
| } |
| |
| @Override |
| public void trace(String format, Object... arguments) { |
| delegate().trace(format, arguments); |
| } |
| |
| @Override |
| public void trace(String msg, Throwable t) { |
| delegate().trace(msg, t); |
| } |
| |
| @Override |
| public boolean isTraceEnabled(Marker marker) { |
| return delegate().isTraceEnabled(marker); |
| } |
| |
| @Override |
| public void trace(Marker marker, String msg) { |
| delegate().trace(marker, msg); |
| } |
| |
| @Override |
| public void trace(Marker marker, String format, Object arg) { |
| delegate().trace(marker, format, arg); |
| } |
| |
| @Override |
| public void trace(Marker marker, String format, Object arg1, Object arg2) { |
| delegate().trace(marker, format, arg1, arg2); |
| } |
| @Override |
| public void trace(Marker marker, String format, Object... arguments) { |
| delegate().trace(marker, format, arguments); |
| } |
| @Override |
| public void trace(Marker marker, String msg, Throwable t) { |
| delegate().trace(marker, msg, t); |
| } |
| |
| @Override |
| public LoggingEventBuilder atTrace() { |
| return delegate().atTrace(); |
| } |
| |
| @Override |
| public boolean isDebugEnabled() { |
| return delegate().isDebugEnabled(); |
| } |
| |
| @Override |
| public void debug(String msg) { |
| delegate().debug(msg); |
| } |
| |
| @Override |
| public void debug(String format, Object arg) { |
| delegate().debug(format, arg); |
| } |
| |
| @Override |
| public void debug(String format, Object arg1, Object arg2) { |
| delegate().debug(format, arg1, arg2); |
| } |
| |
| @Override |
| public void debug(String format, Object... arguments) { |
| delegate().debug(format, arguments); |
| } |
| |
| @Override |
| public void debug(String msg, Throwable t) { |
| delegate().debug(msg, t); |
| } |
| |
| @Override |
| public boolean isDebugEnabled(Marker marker) { |
| return delegate().isDebugEnabled(marker); |
| } |
| |
| @Override |
| public void debug(Marker marker, String msg) { |
| delegate().debug(marker, msg); |
| } |
| |
| @Override |
| public void debug(Marker marker, String format, Object arg) { |
| delegate().debug(marker, format, arg); |
| } |
| |
| @Override |
| public void debug(Marker marker, String format, Object arg1, Object arg2) { |
| delegate().debug(marker, format, arg1, arg2); |
| } |
| |
| @Override |
| public void debug(Marker marker, String format, Object... arguments) { |
| delegate().debug(marker, format, arguments); |
| } |
| |
| @Override |
| public void debug(Marker marker, String msg, Throwable t) { |
| delegate().debug(marker, msg, t); |
| } |
| |
| @Override |
| public LoggingEventBuilder atDebug() { |
| return delegate().atDebug(); |
| } |
| |
| @Override |
| public boolean isInfoEnabled() { |
| return delegate().isInfoEnabled(); |
| } |
| |
| |
| @Override |
| public void info(String msg) { |
| delegate().info(msg); |
| } |
| |
| @Override |
| public void info(String format, Object arg) { |
| delegate().info(format, arg); |
| } |
| |
| @Override |
| public void info(String format, Object arg1, Object arg2) { |
| delegate().info(format, arg1, arg2); |
| } |
| |
| @Override |
| public void info(String format, Object... arguments) { |
| delegate().info(format, arguments); |
| } |
| |
| @Override |
| public void info(String msg, Throwable t) { |
| delegate().info(msg, t); |
| } |
| |
| @Override |
| public boolean isInfoEnabled(Marker marker) { |
| return delegate().isInfoEnabled(marker); |
| } |
| |
| @Override |
| public void info(Marker marker, String msg) { |
| delegate().info(marker, msg); |
| } |
| |
| @Override |
| public void info(Marker marker, String format, Object arg) { |
| delegate().info(marker, format, arg); |
| } |
| |
| @Override |
| public void info(Marker marker, String format, Object arg1, Object arg2) { |
| delegate().info(marker, format, arg1, arg2); |
| } |
| |
| @Override |
| public void info(Marker marker, String format, Object... arguments) { |
| delegate().info(marker, format, arguments); |
| } |
| |
| @Override |
| public void info(Marker marker, String msg, Throwable t) { |
| delegate().info(marker, msg, t); |
| } |
| |
| @Override |
| public LoggingEventBuilder atInfo() { |
| return delegate().atInfo(); |
| } |
| |
| |
| @Override |
| public boolean isWarnEnabled() { |
| return delegate().isWarnEnabled(); |
| } |
| |
| @Override |
| public void warn(String msg) { |
| delegate().warn(msg); |
| } |
| |
| @Override |
| public void warn(String format, Object arg) { |
| delegate().warn(format, arg); |
| } |
| |
| @Override |
| public void warn(String format, Object arg1, Object arg2) { |
| delegate().warn(format, arg1, arg2); |
| } |
| |
| @Override |
| public void warn(String format, Object... arguments) { |
| delegate().warn(format, arguments); |
| } |
| |
| @Override |
| public void warn(String msg, Throwable t) { |
| delegate().warn(msg, t); |
| } |
| |
| public boolean isWarnEnabled(Marker marker) { |
| return delegate().isWarnEnabled(marker); |
| } |
| |
| @Override |
| public void warn(Marker marker, String msg) { |
| delegate().warn(marker, msg); |
| } |
| |
| @Override |
| public void warn(Marker marker, String format, Object arg) { |
| delegate().warn(marker, format, arg); |
| } |
| |
| @Override |
| public void warn(Marker marker, String format, Object arg1, Object arg2) { |
| delegate().warn(marker, format, arg1, arg2); |
| } |
| |
| @Override |
| public void warn(Marker marker, String format, Object... arguments) { |
| delegate().warn(marker, format, arguments); |
| } |
| |
| @Override |
| public void warn(Marker marker, String msg, Throwable t) { |
| delegate().warn(marker, msg, t); |
| } |
| |
| @Override |
| public LoggingEventBuilder atWarn() { |
| return delegate().atWarn(); |
| } |
| |
| |
| |
| @Override |
| public boolean isErrorEnabled() { |
| return delegate().isErrorEnabled(); |
| } |
| |
| @Override |
| public void error(String msg) { |
| delegate().error(msg); |
| } |
| |
| @Override |
| public void error(String format, Object arg) { |
| delegate().error(format, arg); |
| } |
| |
| @Override |
| public void error(String format, Object arg1, Object arg2) { |
| delegate().error(format, arg1, arg2); |
| } |
| |
| @Override |
| public void error(String format, Object... arguments) { |
| delegate().error(format, arguments); |
| } |
| |
| @Override |
| public void error(String msg, Throwable t) { |
| delegate().error(msg, t); |
| } |
| |
| @Override |
| public boolean isErrorEnabled(Marker marker) { |
| return delegate().isErrorEnabled(marker); |
| } |
| |
| @Override |
| public void error(Marker marker, String msg) { |
| delegate().error(marker, msg); |
| } |
| |
| @Override |
| public void error(Marker marker, String format, Object arg) { |
| delegate().error(marker, format, arg); |
| } |
| |
| @Override |
| public void error(Marker marker, String format, Object arg1, Object arg2) { |
| delegate().error(marker, format, arg1, arg2); |
| } |
| |
| @Override |
| public void error(Marker marker, String format, Object... arguments) { |
| delegate().error(marker, format, arguments); |
| } |
| |
| @Override |
| public void error(Marker marker, String msg, Throwable t) { |
| delegate().error(marker, msg, t); |
| } |
| |
| @Override |
| public LoggingEventBuilder atError() { |
| return delegate().atError(); |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| if (this == o) |
| return true; |
| if (o == null || getClass() != o.getClass()) |
| return false; |
| |
| SubstituteLogger that = (SubstituteLogger) o; |
| |
| if (!name.equals(that.name)) |
| return false; |
| |
| return true; |
| } |
| |
| @Override |
| public int hashCode() { |
| return name.hashCode(); |
| } |
| |
| /** |
| * Return the delegate logger instance if set. Otherwise, return a {@link NOPLogger} |
| * instance. |
| */ |
| public Logger delegate() { |
| if (_delegate != null) { |
| return _delegate; |
| } |
| if (createdPostInitialization) { |
| return NOPLogger.NOP_LOGGER; |
| } else { |
| return getEventRecordingLogger(); |
| } |
| } |
| |
| private Logger getEventRecordingLogger() { |
| if (eventRecordingLogger == null) { |
| eventRecordingLogger = new EventRecordingLogger(this, eventQueue); |
| } |
| return eventRecordingLogger; |
| } |
| |
| /** |
| * Typically called after the {@link org.slf4j.LoggerFactory} initialization phase is completed. |
| * @param delegate |
| */ |
| public void setDelegate(Logger delegate) { |
| this._delegate = delegate; |
| } |
| |
| public boolean isDelegateEventAware() { |
| if (delegateEventAware != null) |
| return delegateEventAware; |
| |
| try { |
| logMethodCache = _delegate.getClass().getMethod("log", LoggingEvent.class); |
| delegateEventAware = Boolean.TRUE; |
| } catch (NoSuchMethodException e) { |
| delegateEventAware = Boolean.FALSE; |
| } |
| return delegateEventAware; |
| } |
| |
| public void log(LoggingEvent event) { |
| if (isDelegateEventAware()) { |
| try { |
| logMethodCache.invoke(_delegate, event); |
| } catch (IllegalAccessException e) { |
| } catch (IllegalArgumentException e) { |
| } catch (InvocationTargetException e) { |
| } |
| } |
| } |
| |
| public boolean isDelegateNull() { |
| return _delegate == null; |
| } |
| |
| public boolean isDelegateNOP() { |
| return _delegate instanceof NOPLogger; |
| } |
| } |