Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Logback: the reliable, generic, fast and flexible logging framework. Copyright (C) 1999-2011, 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.util.List;
 
 
 
 public final class Logger implements org.slf4j.LoggerLocationAwareLogger,
 
   private static final long serialVersionUID = 5454405123156820674L;

  
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.
   private Level level;
 
   // The effective levelInt is the assigned levelInt and if null, a levelInt is
   // inherited form a parent.
   private int effectiveLevelInt;

  
The parent of this category. All categories have at least one ancestor which is the root category.
 
   private Logger parent;

  
The children of this logger. A logger may have zero or more children.
 
   private List<LoggerchildrenList;

  
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).

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

1) the 'aai' variable is immutable once set to non-null

2) 'aai' is getAndSet only within addAppender which is synchronized

3) all the other methods check whether 'aai' is null

4) AppenderAttachableImpl is thread safe

 
   private transient AppenderAttachableImpl<ILoggingEventaai;
  
Additivity is set to true by default, that is children inherit the appenders of their ancestors by default. If this variable is set to false 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 false too. See the user manual for more details.
  private boolean additive = true;
  final transient LoggerContext loggerContext;
  // loggerRemoteView cannot be final because it may change as a consequence
  // of changes in LoggerContext
  Logger(String nameLogger parentLoggerContext loggerContext) {
    this. = name;
    this. = parent;
    this. = loggerContext;
  }
  public Level getEffectiveLevel() {
    return Level.toLevel();
  }
    return ;
  }
  public Level getLevel() {
    return ;
  }
  public String getName() {
    return ;
  }
  private boolean isRootLogger() {
    // only the root logger has a null parent
    return  == null;
  }
  Logger getChildByName(final String childName) {
    if ( == null) {
      return null;
    } else {
      int len = this..size();
      for (int i = 0; i < leni++) {
        final Logger childLogger_i = (Logger.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 ( == newLevel) {
      // nothing to do;
      return;
    }
    if (newLevel == null && isRootLogger()) {
      throw new IllegalArgumentException(
          "The level of the root logger cannot be set to null");
    }
     = newLevel;
    if (newLevel == null) {
    } else {
       = newLevel.levelInt;
    }
    if ( != null) {
      int len = .size();
      for (int i = 0; i < leni++) {
        Logger child = (Logger.get(i);
        // tell child to handle parent levelInt change
      }
    }
    // inform listeners
    .fireOnLevelChange(thisnewLevel);
  }

  
This method is invoked by parent logger to let this logger know that the prent's levelInt changed.

Parameters:
newParentLevelInt
  private synchronized void handleParentLevelChange(int newParentLevelInt) {
    // changes in the parent levelInt affect children only if their levelInt is
    // null
    if ( == null) {
       = newParentLevelInt;
      // propagate the parent levelInt change to this logger's children
      if ( != null) {
        int len = .size();
        for (int i = 0; i < leni++) {
          Logger child = (Logger.get(i);
          child.handleParentLevelChange(newParentLevelInt);
        }
      }
    }
  }

  
Remove all previously added appenders from this logger instance.

This is useful when re-reading configuration information.

  public void detachAndStopAllAppenders() {
    if ( != null) {
    }
  }
  public boolean detachAppender(String name) {
    if ( == null) {
      return false;
    }
    return .detachAppender(name);
  }
  // this method MUST be synchronized. See comments on 'aai' field for further
  // details.
  public synchronized void addAppender(Appender<ILoggingEventnewAppender) {
    if ( == null) {
    }
    .addAppender(newAppender);
  }
  public boolean isAttached(Appender<ILoggingEventappender) {
    if ( == null) {
      return false;
    }
    return .isAttached(appender);
  }
  @SuppressWarnings("unchecked")
    if ( == null) {
      return ..iterator();
    }
    return .iteratorForAppenders();
  }
    if ( == null) {
      return null;
    }
    return .getAppender(name);
  }

  
Invoke all the appenders of this logger.

Parameters:
event The event to log
  public void callAppenders(ILoggingEvent event) {
    int writes = 0;
    for (Logger l = thisl != nulll = l.parent) {
      writes += l.appendLoopOnAppenders(event);
      if (!l.additive) {
        break;
      }
    }
    // No appenders in hierarchy
    if (writes == 0) {
    }
  }
  private int appendLoopOnAppenders(ILoggingEvent event) {
    if ( != null) {
      return .appendLoopOnAppenders(event);
    } else {
      return 0;
    }
  }

  
Remove the appender passed as parameter form the list of appenders.
  public boolean detachAppender(Appender<ILoggingEventappender) {
    if ( == null) {
      return false;
    }
    return .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".

IMPORTANT: Calls to this method must be within a synchronized block on this logger.

Parameters:
lastPart the suffix (i.e. last part) of the child logger name. This parameter may not include dots, i.e. the logger separator character.
Returns:
  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 [" + . + "]");
    }
    if ( == null) {
       = new ArrayList<Logger>();
    }
    Logger childLogger;
    if (this.isRootLogger()) {
      childLogger = new Logger(lastPartthisthis.);
    } else {
      childLogger = new Logger( + . + lastPartthis,
          this.);
    }
    .add(childLogger);
    childLogger.effectiveLevelInt = this.;
    return childLogger;
  }
  private void localLevelReset() {
    if (isRootLogger()) {
       = .;
    } else {
       = null;
    }
  }
  void recursiveReset() {
     = true;
    if ( == null) {
      return;
    }
    for (Logger childLogger : ) {
      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.
  private static final int DEFAULT_CHILD_ARRAY_SIZE = 5;
  Logger createChildByName(final String childName) {
    int i_index = LoggerNameUtil.getSeparatorIndexOf(childNamethis..length() + 1);
    if (i_index != -1) {
      throw new IllegalArgumentException("For logger [" + this.
          + "] child name [" + childName
          + " passed as parameter, may not include '.' after index"
          + (this..length() + 1));
    }
    if ( == null) {
    }
    Logger childLogger;
    childLogger = new Logger(childNamethisthis.);
    .add(childLogger);
    childLogger.effectiveLevelInt = this.;
    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 markerfinal Level levelfinal String msg,
      final Object[] paramsfinal Throwable t) {
    final FilterReply decision = 
        .getTurboFilterChainDecision_0_3OrMore(markerthislevelmsg,
            paramst);
    if (decision == .) {
      if ( > level.levelInt) {
        return;
      }
    } else if (decision == .) {
      return;
    }
    buildLoggingEventAndAppend(localFQCNmarkerlevelmsgparamst);
  }
  private void filterAndLog_1(final String localFQCN,
      final Marker markerfinal Level levelfinal String msg,
      final Object paramfinal Throwable t) {
        markerthislevelmsgparamt);
    if (decision == .) {
      if ( > level.levelInt) {
        return;
      }
    } else if (decision == .) {
      return;
    }
    buildLoggingEventAndAppend(localFQCNmarkerlevelmsg,
        new Object[] { param }, t);
  }
  private void filterAndLog_2(final String localFQCN,
      final Marker markerfinal Level levelfinal String msg,
      final Object param1final Object param2final Throwable t) {
        markerthislevelmsgparam1param2t);
    if (decision == .) {
      if ( > level.levelInt) {
        return;
      }
    } else if (decision == .) {
      return;
    }
    buildLoggingEventAndAppend(localFQCNmarkerlevelmsgnew Object[] {
        param1param2 }, t);
  }
  private void buildLoggingEventAndAppend(final String localFQCN,
      final Marker markerfinal Level levelfinal String msg,
      final Object[] paramsfinal Throwable t) {
    LoggingEvent le = new LoggingEvent(localFQCNthislevelmsgtparams);
    le.setMarker(marker);
    callAppenders(le);
  }
  public void trace(String msg) {
    filterAndLog_0_Or3Plus(null.msgnullnull);
  }
  public void trace(String formatObject arg) {
    filterAndLog_1(null.formatargnull);
  }
  public void trace(String formatObject arg1Object arg2) {
    filterAndLog_2(null.formatarg1arg2null);
  }
  public void trace(String formatObject[] argArray) {
    filterAndLog_0_Or3Plus(null.formatargArraynull);
  }
  public void trace(String msgThrowable t) {
    filterAndLog_0_Or3Plus(null.msgnullt);
  }
  public void trace(Marker markerString msg) {
    filterAndLog_0_Or3Plus(marker.msgnullnull);
  }
  public void trace(Marker markerString formatObject arg) {
    filterAndLog_1(marker.formatargnull);
  }
  public void trace(Marker markerString formatObject arg1Object arg2) {
    filterAndLog_2(marker.formatarg1arg2null);
  }
  public void trace(Marker markerString formatObject[] argArray) {
    filterAndLog_0_Or3Plus(marker.formatargArraynull);
  }
  public void trace(Marker markerString msgThrowable t) {
    filterAndLog_0_Or3Plus(marker.msgnullt);
  }
  public boolean isDebugEnabled() {
    return isDebugEnabled(null);
  }
  public boolean isDebugEnabled(Marker marker) {
    final FilterReply decision = callTurboFilters(marker.);
    if (decision == .) {
      return  <= .;
    } else if (decision == .) {
      return false;
    } else if (decision == .) {
      return true;
    } else {
      throw new IllegalStateException("Unknown FilterReply value: " + decision);
    }
  }
  public void debug(String msg) {
    filterAndLog_0_Or3Plus(null.msgnullnull);
  }
  public void debug(String formatObject arg) {
    filterAndLog_1(null.formatargnull);
  }
  public void debug(String formatObject arg1Object arg2) {
    filterAndLog_2(null.formatarg1arg2null);
  }
  public void debug(String formatObject[] argArray) {
    filterAndLog_0_Or3Plus(null.formatargArraynull);
  }
  public void debug(String msgThrowable t) {
    filterAndLog_0_Or3Plus(null.msgnullt);
  }
  public void debug(Marker markerString msg) {
    filterAndLog_0_Or3Plus(marker.msgnullnull);
  }
  public void debug(Marker markerString formatObject arg) {
    filterAndLog_1(marker.formatargnull);
  }
  public void debug(Marker markerString formatObject arg1Object arg2) {
    filterAndLog_2(marker.formatarg1arg2null);
  }
  public void debug(Marker markerString formatObject[] argArray) {
    filterAndLog_0_Or3Plus(marker.formatargArraynull);
  }
  public void debug(Marker markerString msgThrowable t) {
    filterAndLog_0_Or3Plus(marker.msgnullt);
  }
  public void error(String msg) {
    filterAndLog_0_Or3Plus(null.msgnullnull);
  }
  public void error(String formatObject arg) {
    filterAndLog_1(null.formatargnull);
  }
  public void error(String formatObject arg1Object arg2) {
    filterAndLog_2(null.formatarg1arg2null);
  }
  public void error(String formatObject[] argArray) {
    filterAndLog_0_Or3Plus(null.formatargArraynull);
  }
  public void error(String msgThrowable t) {
    filterAndLog_0_Or3Plus(null.msgnullt);
  }
  public void error(Marker markerString msg) {
    filterAndLog_0_Or3Plus(marker.msgnullnull);
  }
  public void error(Marker markerString formatObject arg) {
    filterAndLog_1(marker.formatargnull);
  }
  public void error(Marker markerString formatObject arg1Object arg2) {
    filterAndLog_2(marker.formatarg1arg2null);
  }
  public void error(Marker markerString formatObject[] argArray) {
    filterAndLog_0_Or3Plus(marker.formatargArraynull);
  }
  public void error(Marker markerString msgThrowable t) {
    filterAndLog_0_Or3Plus(marker.msgnullt);
  }
  public boolean isInfoEnabled() {
    return isInfoEnabled(null);
  }
  public boolean isInfoEnabled(Marker marker) {
    FilterReply decision = callTurboFilters(marker.);
    if (decision == .) {
      return  <= .;
    } else if (decision == .) {
      return false;
    } else if (decision == .) {
      return true;
    } else {
      throw new IllegalStateException("Unknown FilterReply value: " + decision);
    }
  }
  public void info(String msg) {
    filterAndLog_0_Or3Plus(null.msgnullnull);
  }
  public void info(String formatObject arg) {
    filterAndLog_1(null.formatargnull);
  }
  public void info(String formatObject arg1Object arg2) {
    filterAndLog_2(null.formatarg1arg2null);
  }
  public void info(String formatObject[] argArray) {
    filterAndLog_0_Or3Plus(null.formatargArraynull);
  }
  public void info(String msgThrowable t) {
    filterAndLog_0_Or3Plus(null.msgnullt);
  }
  public void info(Marker markerString msg) {
    filterAndLog_0_Or3Plus(marker.msgnullnull);
  }
  public void info(Marker markerString formatObject arg) {
    filterAndLog_1(marker.formatargnull);
  }
  public void info(Marker markerString formatObject arg1Object arg2) {
    filterAndLog_2(marker.formatarg1arg2null);
  }
  public void info(Marker markerString formatObject[] argArray) {
    filterAndLog_0_Or3Plus(marker.formatargArraynull);
  }
  public void info(Marker markerString msgThrowable t) {
    filterAndLog_0_Or3Plus(marker.msgnullt);
  }
  public boolean isTraceEnabled() {
    return isTraceEnabled(null);
  }
  public boolean isTraceEnabled(Marker marker) {
    final FilterReply decision = callTurboFilters(marker.);
    if (decision == .) {
      return  <= .;
    } else if (decision == .) {
      return false;
    } else if (decision == .) {
      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.);
    if (decision == .) {
      return  <= .;
    } else if (decision == .) {
      return false;
    } else if (decision == .) {
      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.);
    if (decision == .) {
      return  <= .;
    } else if (decision == .) {
      return false;
    } else if (decision == .) {
      return true;
    } else {
      throw new IllegalStateException("Unknown FilterReply value: " + decision);
    }
  }
  public boolean isEnabledFor(Marker markerLevel level) {
    FilterReply decision = callTurboFilters(markerlevel);
    if (decision == .) {
      return  <= level.levelInt;
    } else if (decision == .) {
      return false;
    } else if (decision == .) {
      return true;
    } else {
      throw new IllegalStateException("Unknown FilterReply value: " + decision);
    }
  }
  public boolean isEnabledFor(Level level) {
    return isEnabledFor(nulllevel);
  }
  public void warn(String msg) {
    filterAndLog_0_Or3Plus(null.msgnullnull);
  }
  public void warn(String msgThrowable t) {
    filterAndLog_0_Or3Plus(null.msgnullt);
  }
  public void warn(String formatObject arg) {
    filterAndLog_1(null.formatargnull);
  }
  public void warn(String formatObject arg1Object arg2) {
    filterAndLog_2(null.formatarg1arg2null);
  }
  public void warn(String formatObject[] argArray) {
    filterAndLog_0_Or3Plus(null.formatargArraynull);
  }
  public void warn(Marker markerString msg) {
    filterAndLog_0_Or3Plus(marker.msgnullnull);
  }
  public void warn(Marker markerString formatObject arg) {
    filterAndLog_1(marker.formatargnull);
  }
  public void warn(Marker markerString formatObject[] argArray) {
    filterAndLog_0_Or3Plus(marker.formatargArraynull);
  }
  public void warn(Marker markerString formatObject arg1Object arg2) {
    filterAndLog_2(marker.formatarg1arg2null);
  }
  public void warn(Marker markerString msgThrowable t) {
    filterAndLog_0_Or3Plus(marker.msgnullt);
  }
  public boolean isAdditive() {
    return ;
  }
  public void setAdditive(boolean additive) {
    this. = additive;
  }
  public String toString() {
    return "Logger[" +  + "]";
  }

  
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.

Parameters:
level
Returns:
the reply given by the TurboFilters
  private FilterReply callTurboFilters(Marker markerLevel level) {
        levelnullnullnull);
  }

  
Return the context for this logger.

Returns:
the context
    return ;
  }
    return ;
  }
  void buildRemoteView() {
  }
  public void log(Marker markerString fqcnint levelIntString message,
      Object[] argArrayThrowable t) {
    Level level = Level.fromLocationAwareLoggerInteger(levelInt);
    filterAndLog_0_Or3Plus(fqcnmarkerlevelmessageargArrayt);
  }

  
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 as generated by LoggerFactory.

Returns:
Logger instance with the same name
Throws:
java.io.ObjectStreamException
  protected Object readResolve() throws ObjectStreamException {
    return LoggerFactory.getLogger(getName());
  }
New to GrepCode? Check out our FAQ X