Logger.java
/**
* Logback: the reliable, generic, fast and flexible logging framework.
* Copyright (C) 1999-2015, QOS.ch. All rights reserved.
*
* This program and the accompanying materials are dual-licensed under
* either the terms of the Eclipse Public License v1.0 as published by
* the Eclipse Foundation
*
* or (per the licensee's choosing)
*
* under the terms of the GNU Lesser General Public License version 2.1
* as published by the Free Software Foundation.
*/
package ch.qos.logback.classic;
import java.io.ObjectStreamException;
import java.io.Serializable;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import org.slf4j.LoggerFactory;
import org.slf4j.Marker;
import org.slf4j.spi.DefaultLoggingEventBuilder;
import org.slf4j.spi.LocationAwareLogger;
import org.slf4j.spi.LoggingEventAware;
import org.slf4j.spi.LoggingEventBuilder;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.classic.spi.LoggingEvent;
import ch.qos.logback.classic.util.LoggerNameUtil;
import ch.qos.logback.core.Appender;
import ch.qos.logback.core.CoreConstants;
import ch.qos.logback.core.spi.AppenderAttachable;
import ch.qos.logback.core.spi.AppenderAttachableImpl;
import ch.qos.logback.core.spi.FilterReply;
public final class Logger
implements org.slf4j.Logger, LocationAwareLogger, LoggingEventAware, AppenderAttachable<ILoggingEvent>, Serializable {
private static final long serialVersionUID = 5454405123156820674L; // 8745934908040027998L;
/**
* The fully qualified name of this class. Used in gathering caller information.
*/
public static final String FQCN = ch.qos.logback.classic.Logger.class.getName();
/**
* The name of this logger
*/
private String name;
// The assigned levelInt of this logger. Can be null.
transient private Level level;
// The effective levelInt is the assigned levelInt and if null, a levelInt is
// inherited form a parent.
transient private int effectiveLevelInt;
/**
* The parent of this category. All categories have at least one ancestor which
* is the root category.
*/
transient private Logger parent;
/**
* The children of this logger. A logger may have zero or more children.
*/
transient private List<Logger> childrenList;
/**
* It is assumed that once the 'aai' variable is set to a non-null value, it
* will never be reset to null. it is further assumed that only place where the
* 'aai'ariable is set is within the addAppender method. This method is
* synchronized on 'this' (Logger) protecting against simultaneous
* re-configuration of this logger (a very unlikely scenario).
*
* <p>
* It is further assumed that the AppenderAttachableImpl is responsible for its
* internal synchronization and thread safety. Thus, we can get away with *not*
* synchronizing on the 'aai' (check null/ read) because
* <p>
* 1) the 'aai' variable is immutable once set to non-null
* <p>
* 2) 'aai' is getAndSet only within addAppender which is synchronized
* <p>
* 3) all the other methods check whether 'aai' is null
* <p>
* 4) AppenderAttachableImpl is thread safe
*/
transient private AppenderAttachableImpl<ILoggingEvent> aai;
/**
* Additivity is set to true by default, that is children inherit the appenders
* of their ancestors by default. If this variable is set to <code>false</code>
* then the appenders located in the ancestors of this logger will not be used.
* However, the children of this logger will inherit its appenders, unless the
* children have their additivity flag set to <code>false</code> too. See the
* user manual for more details.
*/
transient private boolean additive = true;
final transient LoggerContext loggerContext;
Logger(String name, Logger parent, LoggerContext loggerContext) {
this.name = name;
this.parent = parent;
this.loggerContext = loggerContext;
}
public Level getEffectiveLevel() {
return Level.toLevel(effectiveLevelInt);
}
int getEffectiveLevelInt() {
return effectiveLevelInt;
}
public Level getLevel() {
return level;
}
public String getName() {
return name;
}
private boolean isRootLogger() {
// only the root logger has a null parent
return parent == null;
}
Logger getChildByName(final String childName) {
if (childrenList == null) {
return null;
} else {
int len = this.childrenList.size();
for (int i = 0; i < len; i++) {
final Logger childLogger_i = (Logger) childrenList.get(i);
final String childName_i = childLogger_i.getName();
if (childName.equals(childName_i)) {
return childLogger_i;
}
}
// no child found
return null;
}
}
public synchronized void setLevel(Level newLevel) {
if (level == newLevel) {
// nothing to do;
return;
}
if (newLevel == null && isRootLogger()) {
throw new IllegalArgumentException("The level of the root logger cannot be set to null");
}
level = newLevel;
if (newLevel == null) {
effectiveLevelInt = parent.effectiveLevelInt;
newLevel = parent.getEffectiveLevel();
} else {
effectiveLevelInt = newLevel.levelInt;
}
if (childrenList != null) {
int len = childrenList.size();
for (int i = 0; i < len; i++) {
Logger child = (Logger) childrenList.get(i);
// tell child to handle parent levelInt change
child.handleParentLevelChange(effectiveLevelInt);
}
}
// inform listeners
loggerContext.fireOnLevelChange(this, newLevel);
}
/**
* This method is invoked by parent logger to let this logger know that the
* prent's levelInt changed.
*
* @param newParentLevelInt
*/
private synchronized void handleParentLevelChange(int newParentLevelInt) {
// changes in the parent levelInt affect children only if their levelInt is
// null
if (level == null) {
effectiveLevelInt = newParentLevelInt;
// propagate the parent levelInt change to this logger's children
if (childrenList != null) {
int len = childrenList.size();
for (int i = 0; i < len; i++) {
Logger child = (Logger) childrenList.get(i);
child.handleParentLevelChange(newParentLevelInt);
}
}
}
}
/**
* Remove all previously added appenders from this logger instance.
* <p/>
* This is useful when re-reading configuration information.
*/
public void detachAndStopAllAppenders() {
if (aai != null) {
aai.detachAndStopAllAppenders();
}
}
public boolean detachAppender(String name) {
if (aai == null) {
return false;
}
return aai.detachAppender(name);
}
// this method MUST be synchronized. See comments on 'aai' field for further
// details.
public synchronized void addAppender(Appender<ILoggingEvent> newAppender) {
if (aai == null) {
aai = new AppenderAttachableImpl<ILoggingEvent>();
}
aai.addAppender(newAppender);
}
public boolean isAttached(Appender<ILoggingEvent> appender) {
if (aai == null) {
return false;
}
return aai.isAttached(appender);
}
@SuppressWarnings("unchecked")
public Iterator<Appender<ILoggingEvent>> iteratorForAppenders() {
if (aai == null) {
return Collections.EMPTY_LIST.iterator();
}
return aai.iteratorForAppenders();
}
public Appender<ILoggingEvent> getAppender(String name) {
if (aai == null) {
return null;
}
return aai.getAppender(name);
}
/**
* Invoke all the appenders of this logger.
*
* @param event The event to log
*/
public void callAppenders(ILoggingEvent event) {
int writes = 0;
for (Logger l = this; l != null; l = l.parent) {
writes += l.appendLoopOnAppenders(event);
if (!l.additive) {
break;
}
}
// No appenders in hierarchy
if (writes == 0) {
loggerContext.noAppenderDefinedWarning(this);
}
}
private int appendLoopOnAppenders(ILoggingEvent event) {
if (aai != null) {
return aai.appendLoopOnAppenders(event);
} else {
return 0;
}
}
/**
* Remove the appender passed as parameter form the list of appenders.
*/
public boolean detachAppender(Appender<ILoggingEvent> appender) {
if (aai == null) {
return false;
}
return aai.detachAppender(appender);
}
/**
* Create a child of this logger by suffix, that is, the part of the name
* extending this logger. For example, if this logger is named "x.y" and the
* lastPart is "z", then the created child logger will be named "x.y.z".
*
* <p>
* IMPORTANT: Calls to this method must be within a synchronized block on this
* logger.
*
* @param lastPart the suffix (i.e. last part) of the child logger name. This
* parameter may not include dots, i.e. the logger separator
* character.
* @return
*/
Logger createChildByLastNamePart(final String lastPart) {
int i_index = LoggerNameUtil.getFirstSeparatorIndexOf(lastPart);
if (i_index != -1) {
throw new IllegalArgumentException(
"Child name [" + lastPart + " passed as parameter, may not include [" + CoreConstants.DOT + "]");
}
if (childrenList == null) {
childrenList = new CopyOnWriteArrayList<Logger>();
}
Logger childLogger;
if (this.isRootLogger()) {
childLogger = new Logger(lastPart, this, this.loggerContext);
} else {
childLogger = new Logger(name + CoreConstants.DOT + lastPart, this, this.loggerContext);
}
childrenList.add(childLogger);
childLogger.effectiveLevelInt = this.effectiveLevelInt;
return childLogger;
}
private void localLevelReset() {
effectiveLevelInt = Level.DEBUG_INT;
if (isRootLogger()) {
level = Level.DEBUG;
} else {
level = null;
}
}
void recursiveReset() {
detachAndStopAllAppenders();
localLevelReset();
additive = true;
if (childrenList == null) {
return;
}
for (Logger childLogger : childrenList) {
childLogger.recursiveReset();
}
}
/**
* The default size of child list arrays. The JDK 1.5 default is 10. We use a
* smaller value to save a little space.
*/
Logger createChildByName(final String childName) {
int i_index = LoggerNameUtil.getSeparatorIndexOf(childName, this.name.length() + 1);
if (i_index != -1) {
throw new IllegalArgumentException("For logger [" + this.name + "] child name [" + childName
+ " passed as parameter, may not include '.' after index" + (this.name.length() + 1));
}
if (childrenList == null) {
childrenList = new CopyOnWriteArrayList<Logger>();
}
Logger childLogger;
childLogger = new Logger(childName, this, this.loggerContext);
childrenList.add(childLogger);
childLogger.effectiveLevelInt = this.effectiveLevelInt;
return childLogger;
}
/**
* The next methods are not merged into one because of the time we gain by not
* creating a new Object[] with the params. This reduces the cost of not logging
* by about 20 nanoseconds.
*/
private void filterAndLog_0_Or3Plus(final String localFQCN, final Marker marker, final Level level,
final String msg, final Object[] params, final Throwable t) {
final FilterReply decision = loggerContext.getTurboFilterChainDecision_0_3OrMore(marker, this, level, msg,
params, t);
if (decision == FilterReply.NEUTRAL) {
if (effectiveLevelInt > level.levelInt) {
return;
}
} else if (decision == FilterReply.DENY) {
return;
}
buildLoggingEventAndAppend(localFQCN, marker, level, msg, params, t);
}
private void filterAndLog_1(final String localFQCN, final Marker marker, final Level level, final String msg,
final Object param, final Throwable t) {
final FilterReply decision = loggerContext.getTurboFilterChainDecision_1(marker, this, level, msg, param, t);
if (decision == FilterReply.NEUTRAL) {
if (effectiveLevelInt > level.levelInt) {
return;
}
} else if (decision == FilterReply.DENY) {
return;
}
buildLoggingEventAndAppend(localFQCN, marker, level, msg, new Object[] { param }, t);
}
private void filterAndLog_2(final String localFQCN, final Marker marker, final Level level, final String msg,
final Object param1, final Object param2, final Throwable t) {
final FilterReply decision = loggerContext.getTurboFilterChainDecision_2(marker, this, level, msg, param1,
param2, t);
if (decision == FilterReply.NEUTRAL) {
if (effectiveLevelInt > level.levelInt) {
return;
}
} else if (decision == FilterReply.DENY) {
return;
}
buildLoggingEventAndAppend(localFQCN, marker, level, msg, new Object[] { param1, param2 }, t);
}
private void buildLoggingEventAndAppend(final String localFQCN, final Marker marker, final Level level,
final String msg, final Object[] params, final Throwable t) {
LoggingEvent le = new LoggingEvent(localFQCN, this, level, msg, t, params);
le.addMarker(marker);
callAppenders(le);
}
public void trace(String msg) {
filterAndLog_0_Or3Plus(FQCN, null, Level.TRACE, msg, null, null);
}
public void trace(String format, Object arg) {
filterAndLog_1(FQCN, null, Level.TRACE, format, arg, null);
}
public void trace(String format, Object arg1, Object arg2) {
filterAndLog_2(FQCN, null, Level.TRACE, format, arg1, arg2, null);
}
public void trace(String format, Object... argArray) {
filterAndLog_0_Or3Plus(FQCN, null, Level.TRACE, format, argArray, null);
}
public void trace(String msg, Throwable t) {
filterAndLog_0_Or3Plus(FQCN, null, Level.TRACE, msg, null, t);
}
public void trace(Marker marker, String msg) {
filterAndLog_0_Or3Plus(FQCN, marker, Level.TRACE, msg, null, null);
}
public void trace(Marker marker, String format, Object arg) {
filterAndLog_1(FQCN, marker, Level.TRACE, format, arg, null);
}
public void trace(Marker marker, String format, Object arg1, Object arg2) {
filterAndLog_2(FQCN, marker, Level.TRACE, format, arg1, arg2, null);
}
public void trace(Marker marker, String format, Object... argArray) {
filterAndLog_0_Or3Plus(FQCN, marker, Level.TRACE, format, argArray, null);
}
public void trace(Marker marker, String msg, Throwable t) {
filterAndLog_0_Or3Plus(FQCN, marker, Level.TRACE, msg, null, t);
}
public boolean isDebugEnabled() {
return isDebugEnabled(null);
}
public boolean isDebugEnabled(Marker marker) {
final FilterReply decision = callTurboFilters(marker, Level.DEBUG);
if (decision == FilterReply.NEUTRAL) {
return effectiveLevelInt <= Level.DEBUG_INT;
} else if (decision == FilterReply.DENY) {
return false;
} else if (decision == FilterReply.ACCEPT) {
return true;
} else {
throw new IllegalStateException("Unknown FilterReply value: " + decision);
}
}
public void debug(String msg) {
filterAndLog_0_Or3Plus(FQCN, null, Level.DEBUG, msg, null, null);
}
public void debug(String format, Object arg) {
filterAndLog_1(FQCN, null, Level.DEBUG, format, arg, null);
}
public void debug(String format, Object arg1, Object arg2) {
filterAndLog_2(FQCN, null, Level.DEBUG, format, arg1, arg2, null);
}
public void debug(String format, Object... argArray) {
filterAndLog_0_Or3Plus(FQCN, null, Level.DEBUG, format, argArray, null);
}
public void debug(String msg, Throwable t) {
filterAndLog_0_Or3Plus(FQCN, null, Level.DEBUG, msg, null, t);
}
public void debug(Marker marker, String msg) {
filterAndLog_0_Or3Plus(FQCN, marker, Level.DEBUG, msg, null, null);
}
public void debug(Marker marker, String format, Object arg) {
filterAndLog_1(FQCN, marker, Level.DEBUG, format, arg, null);
}
public void debug(Marker marker, String format, Object arg1, Object arg2) {
filterAndLog_2(FQCN, marker, Level.DEBUG, format, arg1, arg2, null);
}
public void debug(Marker marker, String format, Object... argArray) {
filterAndLog_0_Or3Plus(FQCN, marker, Level.DEBUG, format, argArray, null);
}
public void debug(Marker marker, String msg, Throwable t) {
filterAndLog_0_Or3Plus(FQCN, marker, Level.DEBUG, msg, null, t);
}
public void error(String msg) {
filterAndLog_0_Or3Plus(FQCN, null, Level.ERROR, msg, null, null);
}
public void error(String format, Object arg) {
filterAndLog_1(FQCN, null, Level.ERROR, format, arg, null);
}
public void error(String format, Object arg1, Object arg2) {
filterAndLog_2(FQCN, null, Level.ERROR, format, arg1, arg2, null);
}
public void error(String format, Object... argArray) {
filterAndLog_0_Or3Plus(FQCN, null, Level.ERROR, format, argArray, null);
}
public void error(String msg, Throwable t) {
filterAndLog_0_Or3Plus(FQCN, null, Level.ERROR, msg, null, t);
}
public void error(Marker marker, String msg) {
filterAndLog_0_Or3Plus(FQCN, marker, Level.ERROR, msg, null, null);
}
public void error(Marker marker, String format, Object arg) {
filterAndLog_1(FQCN, marker, Level.ERROR, format, arg, null);
}
public void error(Marker marker, String format, Object arg1, Object arg2) {
filterAndLog_2(FQCN, marker, Level.ERROR, format, arg1, arg2, null);
}
public void error(Marker marker, String format, Object... argArray) {
filterAndLog_0_Or3Plus(FQCN, marker, Level.ERROR, format, argArray, null);
}
public void error(Marker marker, String msg, Throwable t) {
filterAndLog_0_Or3Plus(FQCN, marker, Level.ERROR, msg, null, t);
}
public boolean isInfoEnabled() {
return isInfoEnabled(null);
}
public boolean isInfoEnabled(Marker marker) {
FilterReply decision = callTurboFilters(marker, Level.INFO);
if (decision == FilterReply.NEUTRAL) {
return effectiveLevelInt <= Level.INFO_INT;
} else if (decision == FilterReply.DENY) {
return false;
} else if (decision == FilterReply.ACCEPT) {
return true;
} else {
throw new IllegalStateException("Unknown FilterReply value: " + decision);
}
}
public void info(String msg) {
filterAndLog_0_Or3Plus(FQCN, null, Level.INFO, msg, null, null);
}
public void info(String format, Object arg) {
filterAndLog_1(FQCN, null, Level.INFO, format, arg, null);
}
public void info(String format, Object arg1, Object arg2) {
filterAndLog_2(FQCN, null, Level.INFO, format, arg1, arg2, null);
}
public void info(String format, Object... argArray) {
filterAndLog_0_Or3Plus(FQCN, null, Level.INFO, format, argArray, null);
}
public void info(String msg, Throwable t) {
filterAndLog_0_Or3Plus(FQCN, null, Level.INFO, msg, null, t);
}
public void info(Marker marker, String msg) {
filterAndLog_0_Or3Plus(FQCN, marker, Level.INFO, msg, null, null);
}
public void info(Marker marker, String format, Object arg) {
filterAndLog_1(FQCN, marker, Level.INFO, format, arg, null);
}
public void info(Marker marker, String format, Object arg1, Object arg2) {
filterAndLog_2(FQCN, marker, Level.INFO, format, arg1, arg2, null);
}
public void info(Marker marker, String format, Object... argArray) {
filterAndLog_0_Or3Plus(FQCN, marker, Level.INFO, format, argArray, null);
}
public void info(Marker marker, String msg, Throwable t) {
filterAndLog_0_Or3Plus(FQCN, marker, Level.INFO, msg, null, t);
}
public boolean isTraceEnabled() {
return isTraceEnabled(null);
}
public boolean isTraceEnabled(Marker marker) {
final FilterReply decision = callTurboFilters(marker, Level.TRACE);
if (decision == FilterReply.NEUTRAL) {
return effectiveLevelInt <= Level.TRACE_INT;
} else if (decision == FilterReply.DENY) {
return false;
} else if (decision == FilterReply.ACCEPT) {
return true;
} else {
throw new IllegalStateException("Unknown FilterReply value: " + decision);
}
}
public boolean isErrorEnabled() {
return isErrorEnabled(null);
}
public boolean isErrorEnabled(Marker marker) {
FilterReply decision = callTurboFilters(marker, Level.ERROR);
if (decision == FilterReply.NEUTRAL) {
return effectiveLevelInt <= Level.ERROR_INT;
} else if (decision == FilterReply.DENY) {
return false;
} else if (decision == FilterReply.ACCEPT) {
return true;
} else {
throw new IllegalStateException("Unknown FilterReply value: " + decision);
}
}
public boolean isWarnEnabled() {
return isWarnEnabled(null);
}
public boolean isWarnEnabled(Marker marker) {
FilterReply decision = callTurboFilters(marker, Level.WARN);
if (decision == FilterReply.NEUTRAL) {
return effectiveLevelInt <= Level.WARN_INT;
} else if (decision == FilterReply.DENY) {
return false;
} else if (decision == FilterReply.ACCEPT) {
return true;
} else {
throw new IllegalStateException("Unknown FilterReply value: " + decision);
}
}
public boolean isEnabledFor(Marker marker, Level level) {
FilterReply decision = callTurboFilters(marker, level);
if (decision == FilterReply.NEUTRAL) {
return effectiveLevelInt <= level.levelInt;
} else if (decision == FilterReply.DENY) {
return false;
} else if (decision == FilterReply.ACCEPT) {
return true;
} else {
throw new IllegalStateException("Unknown FilterReply value: " + decision);
}
}
public boolean isEnabledFor(Level level) {
return isEnabledFor(null, level);
}
public void warn(String msg) {
filterAndLog_0_Or3Plus(FQCN, null, Level.WARN, msg, null, null);
}
public void warn(String msg, Throwable t) {
filterAndLog_0_Or3Plus(FQCN, null, Level.WARN, msg, null, t);
}
public void warn(String format, Object arg) {
filterAndLog_1(FQCN, null, Level.WARN, format, arg, null);
}
public void warn(String format, Object arg1, Object arg2) {
filterAndLog_2(FQCN, null, Level.WARN, format, arg1, arg2, null);
}
public void warn(String format, Object... argArray) {
filterAndLog_0_Or3Plus(FQCN, null, Level.WARN, format, argArray, null);
}
public void warn(Marker marker, String msg) {
filterAndLog_0_Or3Plus(FQCN, marker, Level.WARN, msg, null, null);
}
public void warn(Marker marker, String format, Object arg) {
filterAndLog_1(FQCN, marker, Level.WARN, format, arg, null);
}
public void warn(Marker marker, String format, Object... argArray) {
filterAndLog_0_Or3Plus(FQCN, marker, Level.WARN, format, argArray, null);
}
public void warn(Marker marker, String format, Object arg1, Object arg2) {
filterAndLog_2(FQCN, marker, Level.WARN, format, arg1, arg2, null);
}
public void warn(Marker marker, String msg, Throwable t) {
filterAndLog_0_Or3Plus(FQCN, marker, Level.WARN, msg, null, t);
}
public boolean isAdditive() {
return additive;
}
public void setAdditive(boolean additive) {
this.additive = additive;
}
public String toString() {
return "Logger[" + name + "]";
}
/**
* Method that calls the attached TurboFilter objects based on the logger and
* the level.
*
* It is used by isYYYEnabled() methods.
*
* It returns the typical FilterReply values: ACCEPT, NEUTRAL or DENY.
*
* @param level
* @return the reply given by the TurboFilters
*/
private FilterReply callTurboFilters(Marker marker, Level level) {
return loggerContext.getTurboFilterChainDecision_0_3OrMore(marker, this, level, null, null, null);
}
/**
* Return the context for this logger.
*
* @return the context
*/
public LoggerContext getLoggerContext() {
return loggerContext;
}
/**
* Creates a {@link LoggingEventBuilder} of type {@link DefaultLoggingEventBuilder}.
*
* @since 1.3
*/
@Override
public LoggingEventBuilder makeLoggingEventBuilder(org.slf4j.event.Level level) {
return new DefaultLoggingEventBuilder(this, level);
}
public void log(Marker marker, String fqcn, int levelInt, String message, Object[] argArray, Throwable t) {
Level level = Level.fromLocationAwareLoggerInteger(levelInt);
filterAndLog_0_Or3Plus(fqcn, marker, level, message, argArray, t);
}
/**
* Support SLF4J interception during initialization as introduced in SLF4J
* version 1.7.15
*
* @since 1.1.4
* @param slf4jEvent
*/
public void log(org.slf4j.event.LoggingEvent slf4jEvent) {
org.slf4j.event.Level slf4jLevel = slf4jEvent.getLevel();
Level logbackLevel = Level.convertAnSLF4JLevel(slf4jLevel);
// By default, assume this class was the caller. This happens during
// initialization.
// However, it is possible that the caller is some other library, e.g.
// slf4j-jdk-platform-logging
String callerBoundary = slf4jEvent.getCallerBoundary();
if (callerBoundary == null) {
callerBoundary = FQCN;
}
LoggingEvent lle = new LoggingEvent(callerBoundary, this, logbackLevel, slf4jEvent.getMessage(),
slf4jEvent.getThrowable(), slf4jEvent.getArgumentArray());
List<Marker> markers = slf4jEvent.getMarkers();
if (markers != null) {
markers.forEach(m -> lle.addMarker(m));
}
lle.setKeyValuePairs(slf4jEvent.getKeyValuePairs());
// Note that at this point, any calls made with a logger disabled
// for a given level, will be already filtered out/in. TurboFilters cannot
// act at this point in the process.
this.callAppenders(lle);
}
/**
* After serialization, the logger instance does not know its LoggerContext. The
* best we can do here, is to return a logger with the same name returned by
* org.slf4j.LoggerFactory.
*
* @return Logger instance with the same name
* @throws ObjectStreamException
*/
protected Object readResolve() throws ObjectStreamException {
return LoggerFactory.getLogger(getName());
}
}