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.core.rolling;
 
 import java.io.File;
 
 import static ch.qos.logback.core.CoreConstants.CODES_URL;
RollingFileAppender extends ch.qos.logback.core.FileAppender to backup the log files depending on RollingPolicy and TriggeringPolicy.

For more information about this appender, please refer to the online manual at http://logback.qos.ch/manual/appenders.html#RollingFileAppender

Author(s):
Heinz Richter
Ceki Gülcü
 
 public class RollingFileAppender<E> extends FileAppender<E> {
 
   public void start() {
     if ( == null) {
       addWarn("No TriggeringPolicy was set for the RollingFileAppender named "
           + getName());
       addWarn("For more information, please visit "++"#rfa_no_tp");
       return;
     }
 
     // we don't want to void existing log files
     if (!) {
       addWarn("Append mode is mandatory for RollingFileAppender");
        = true;
     }
 
     if ( == null) {
       addError("No RollingPolicy was set for the RollingFileAppender named "
           + getName());
       addError("For more information, please visit "++"rfa_no_rp");
       return;
     }
 
     if (isPrudent()) {
       if (rawFileProperty() != null) {
         addWarn("Setting \"File\" property to null on account of prudent mode");
         setFile(null);
       }
         addError("Compression is not supported in prudent mode. Aborting");
         return;
       }
     }
 
      = new File(getFile());
     addInfo("Active log file name: " + getFile());
     super.start();
   }
 
   @Override
   public void stop() {
     if( != null.stop();
     if( != null.stop();
     super.stop();
   }
 
   @Override
   public void setFile(String file) {
     // http://jira.qos.ch/browse/LBCORE-94
     // allow setting the file name to null if mandated by prudent mode
     if (file != null && (( != null) || ( != null))) {
       addError("File property must be set before any triggeringPolicy or rollingPolicy properties");
       addError("Visit "++"#rfa_file_after for more information");
     }
     super.setFile(file);
   }
 
   @Override
   public String getFile() {
     return .getActiveFileName();
   }

  
Implemented by delegating most of the rollover work to a rolling policy.
  public void rollover() {
    synchronized () {
      // Note: This method needs to be synchronized because it needs exclusive
      // access while it closes and then re-opens the target file.
      //
      // make sure to close the hereto active log file! Renaming under windows
      // does not work for open files.
      this.closeOutputStream();
      try {
        .rollover();
      } catch (RolloverFailure rf) {
        addWarn("RolloverFailure occurred. Deferring roll-over.");
        // we failed to roll-over, let us not truncate and risk data loss
        this. = true;
      }
      try {
        // update the currentlyActiveFile
        // http://jira.qos.ch/browse/LBCORE-90
        // This will also close the file. This is OK since multiple
        // close operations are safe.
      } catch (IOException e) {
        addError("setFile(" +  + ", false) call failed."e);
      }
    }
  }

  
This method differentiates RollingFileAppender from its super class.
  protected void subAppend(E event) {
    // The roll-over check must precede actual writing. This is the
    // only correct behavior for time driven triggers.
    // We need to synchronize on triggeringPolicy so that only one rollover
    // occurs at a time
    synchronized () {
        rollover();
      }
    }
    super.subAppend(event);
  }
    return ;
  }
    return ;
  }

  
Sets the rolling policy. In case the 'policy' argument also implements TriggeringPolicy, then the triggering policy for this appender is automatically set to be the policy argument.

Parameters:
policy
  @SuppressWarnings("unchecked")
  public void setRollingPolicy(RollingPolicy policy) {
     = policy;
    if ( instanceof TriggeringPolicy) {
       = (TriggeringPolicy<E>) policy;
    }
  }
  public void setTriggeringPolicy(TriggeringPolicy<E> policy) {
     = policy;
    if (policy instanceof RollingPolicy) {
       = (RollingPolicypolicy;
    }
  }
New to GrepCode? Check out our FAQ X