public CompositeRollingAppender() 
{

}

The default constructor does nothing.

 public CompositeRollingAppender(Layout layout,
    String filename) throws IOException 
{
	    super(layout, filename);
}

Instantiate a CompositeRollingAppender and open the file designated by filename. The opened filename will become the output destination for this appender.

The file will be appended to. DatePattern is default.

 public CompositeRollingAppender(Layout layout,
    String filename,
    String datePattern) throws IOException 
{
	    this(layout, filename, datePattern, true);
}

Instantiate a CompositeRollingAppender and open the file designated by filename. The opened filename will become the ouput destination for this appender.

 public CompositeRollingAppender(Layout layout,
    String filename,
    boolean append) throws IOException 
{
	    super(layout, filename, append);
}

Instantiate a CompositeRollingAppender and open the file designated by filename. The opened filename will become the ouput destination for this appender.

If the append parameter is true, the file will be appended to. Otherwise, the file desginated by filename will be truncated before being opened.

 public CompositeRollingAppender(Layout layout,
    String filename,
    String datePattern,
    boolean append) throws IOException 
{
	    super(layout, filename, append);
	    this.datePattern = datePattern;
		activateOptions();
}

Instantiate a CompositeRollingAppender and open the file designated by filename. The opened filename will become the ouput destination for this appender.

 public  void activateOptions() 
{
	    //REMOVE removed rollDate from boolean to enable Alex's change
		if(datePattern != null) {
			now.setTime(System.currentTimeMillis());
			sdf = new SimpleDateFormat(datePattern);
			int type = computeCheckPeriod();
			//printPeriodicity(type);
			rc.setType(type);
			//next line added as this removes the name check in rollOver
			nextCheck = rc.getNextCheckMillis(now);
		} else {
			if (rollDate)
			    LogLog.error("Either DatePattern or rollingStyle options are not set for ["+
			      name+"].");
		}
		existingInit();
		super.activateOptions();
		if (rollDate && fileName != null && scheduledFilename == null)
			scheduledFilename = fileName + sdf.format(now);
}

Sets initial conditions including date/time roll over information, first check, scheduledFilename, and calls existingInit to initialize the current # of backups.

 int computeCheckPeriod() 
{
		RollingCalendar c = new RollingCalendar();
		// set sate to 1970-01-01 00:00:00 GMT
		Date epoch = new Date(0);
		if(datePattern != null) {
			for(int i = TOP_OF_MINUTE; i < = TOP_OF_MONTH; i++) {
				String r0 = sdf.format(epoch);
				c.setType(i);
				Date next = new Date(c.getNextCheckMillis(epoch));
				String r1 = sdf.format(next);
				//LogLog.debug("Type = "+i+", r0 = "+r0+", r1 = "+r1);
				if(r0 != null && r1 != null && !r0.equals(r1)) {
					return i;
				}
			}
		}
		return TOP_OF_TROUBLE; // Deliberately head for trouble...
}

 protected static  void deleteFile(String fileName) 
{
		File file = new File(fileName);
		if (file.exists()) {
		   file.delete();
		}
}

Delete's the specified file if it exists

 protected  void existingInit() 
{
		curSizeRollBackups = 0;
		curTimeRollBackups = 0;
		//part A starts here
		String filter;
		if (staticLogFileName || !rollDate) {
			filter = baseFileName + ".*";
		}
		else {
			filter = scheduledFilename + ".*";
		}
		File f = new File(baseFileName);
		f = f.getParentFile();
		if (f == null)
		   f = new File(".");
		LogLog.debug("Searching for existing files in: " + f);
		String[] files = f.list();
		if (files != null) {
			for (int i = 0; i <  files.length; i++) {
				if (!files[i].startsWith(baseFileName))
				   continue;
				int index = files[i].lastIndexOf(".");
				if (staticLogFileName) {
				   int endLength = files[i].length() - index;
				   if (baseFileName.length() + endLength != files[i].length()) {
					   //file is probably scheduledFilename + .x so I don't care
					   continue;
				   }
				}
				try {
					int backup = Integer.parseInt(files[i].substring(index + 1, files[i].length()));
					LogLog.debug("From file: " + files[i] + " - > " + backup);
					if (backup  > curSizeRollBackups)
					   curSizeRollBackups = backup;
				}
				catch (Exception e) {
					//this happens when file.log - > file.log.yyyy-mm-dd which is normal
					//when staticLogFileName == false
					LogLog.debug("Encountered a backup file not ending in .x " + files[i]);
				}
			}
		}
		LogLog.debug("curSizeRollBackups starts at: " + curSizeRollBackups);
		//part A ends here
		//part B not yet implemented
		//part C
		if (staticLogFileName && rollDate) {
			File old = new File(baseFileName);
			if (old.exists()) {
				Date last = new Date(old.lastModified());
				if (!(sdf.format(last).equals(sdf.format(now)))) {
					scheduledFilename = baseFileName + sdf.format(last);
					LogLog.debug("Initial roll over to: " + scheduledFilename);
					rollOverTime();
				}
			}
		}
		LogLog.debug("curSizeRollBackups after rollOver at: " + curSizeRollBackups);
		//part C ends here
}

Initializes based on exisiting conditions at time of activateOptions. The following is done:

A) determine curSizeRollBackups
B) determine curTimeRollBackups (not implemented)
C) initiates a roll over if needed for crossing a date boundary since the last run.

 public int getCountDirection() 
{
		return countDirection;
}

 public String getDatePattern() 
{
	    return datePattern;
}

Returns the value of the DatePattern option.

 public int getMaxSizeRollBackups() 
{
	    return maxSizeRollBackups;
}

Returns the value of the maxSizeRollBackups option.

 public long getMaximumFileSize() 
{
		return maxFileSize;
}

Get the maximum size that the output file is allowed to reach before being rolled over to backup files.

 public int getRollingStyle() 
{
        return rollingStyle;
}

 public boolean getStaticLogFileName() 
{
	    return staticLogFileName;
}

 protected static  void rollFile(String from,
    String to) 
{
		File target = new File(to);
		if (target.exists()) {
			LogLog.debug("deleting existing target file: " + target);
			target.delete();
		}
		File file = new File(from);
		file.renameTo(target);
		LogLog.debug(from +" - > "+ to);
}

Renames file from to file to. It also checks for existence of target file and deletes if it does.

 protected  void rollOverSize() 
{
		File file;
		this.closeFile(); // keep windows happy.
		LogLog.debug("rolling over count=" + ((CountingQuietWriter) qw).getCount());
		LogLog.debug("maxSizeRollBackups = " + maxSizeRollBackups);
		LogLog.debug("curSizeRollBackups = " + curSizeRollBackups);
		LogLog.debug("countDirection = " + countDirection);
		// If maxBackups < = 0, then there is no file renaming to be done.
		if (maxSizeRollBackups != 0) {
			if (countDirection <  0) {
				// Delete the oldest file, to keep Windows happy.
				if (curSizeRollBackups == maxSizeRollBackups) {
				    deleteFile(fileName + '." + maxSizeRollBackups);
					curSizeRollBackups--;
				}
				// Map {(maxBackupIndex - 1), ..., 2, 1} to {maxBackupIndex, ..., 3, 2}
				for (int i = curSizeRollBackups; i  >= 1; i--) {
					rollFile((fileName + "." + i), (fileName + '." + (i + 1)));
				}
				curSizeRollBackups++;
				// Rename fileName to fileName.1
				rollFile(fileName, fileName + ".1");
			} //REMOVE This code branching for Alexander Cerna's request
			else if (countDirection == 0) {
				//rollFile based on date pattern
				curSizeRollBackups++;
				now.setTime(System.currentTimeMillis());
				scheduledFilename = fileName + sdf.format(now);
				rollFile(fileName, scheduledFilename);
			}
			else { //countDirection  > 0
				if (curSizeRollBackups  >= maxSizeRollBackups && maxSizeRollBackups  > 0) {
					//delete the first and keep counting up.
					int oldestFileIndex = curSizeRollBackups - maxSizeRollBackups + 1;
					deleteFile(fileName + '." + oldestFileIndex);
				}
				if (staticLogFileName) {
					curSizeRollBackups++;
					rollFile(fileName, fileName + '." + curSizeRollBackups);
				}
			}
		}
		try {
			// This will also close the file. This is OK since multiple
			// close operations are safe.
			this.setFile(baseFileName, false);
		}
		catch(IOException e) {
			LogLog.error("setFile("+fileName+", false) call failed.", e);
		}
}

Implements roll overs base on file size.

If the maximum number of size based backups is reached (curSizeRollBackups == maxSizeRollBackups If countDirection < 0, then files {File.1, ..., File.curSizeRollBackups -1} are renamed to {File.2, ..., File.curSizeRollBackups}. Moreover, File is renamed File.1 and closed.
A new file is created to receive further log output.

If maxSizeRollBackups is equal to zero, then the File is truncated with no backup files created.

If maxSizeRollBackups < 0, then File is renamed if needed and no files are deleted.

 protected  void rollOverTime() 
{
	    curTimeRollBackups++;
		//delete the old stuff here
		if (staticLogFileName) {
			/* Compute filename, but only if datePattern is specified */
			if (datePattern == null) {
				errorHandler.error("Missing DatePattern option in rollOver().");
				return;
			}
			//is the new file name equivalent to the 'current' one
			//something has gone wrong if we hit this -- we should only
			//roll over if the new file will be different from the old
			String dateFormat = sdf.format(now);
			if (scheduledFilename.equals(fileName + dateFormat)) {
				errorHandler.error("Compare " + scheduledFilename + " : " + fileName + dateFormat);
				return;
			}
			// close current file, and rename it to datedFilename
			this.closeFile();
			//we may have to roll over a large number of backups here
	        String from, to;
			for (int i = 1; i < = curSizeRollBackups; i++) {
				from = fileName + '." + i;
				to = scheduledFilename + '." + i;
				rollFile(from, to);
	        }
			rollFile(fileName, scheduledFilename);
		}
		try {
			// This will also close the file. This is OK since multiple
			// close operations are safe.
			curSizeRollBackups = 0; //We're cleared out the old date and are ready for the new
			//new scheduled name
			scheduledFilename = fileName + sdf.format(now);
			this.setFile(baseFileName, false);
		}
		catch(IOException e) {
			errorHandler.error("setFile("+fileName+", false) call failed.");
		}
}

Rollover the file(s) to date/time tagged file(s). Opens the new file (through setFile) and resets curSizeRollBackups.

 public  void setCountDirection(int direction) 
{
		countDirection = direction;
}

 public  void setDatePattern(String pattern) 
{
	    datePattern = pattern;
}

The DatePattern takes a string in the same format as expected by SimpleDateFormat . This options determines the rollover schedule.

 public  void setFile(String file) 
{
		baseFileName = file.trim();
		fileName = file.trim();
}

 public synchronized  void setFile(String fileName,
    boolean append) throws IOException 
{
		if (!staticLogFileName) {
		    scheduledFilename = fileName = fileName.trim() + sdf.format(now);
			if (countDirection  > 0) {
				scheduledFilename = fileName = fileName + '." + (++curSizeRollBackups);
			}
		}
		super.setFile(fileName, append);
		if(append) {
		  File f = new File(fileName);
		  ((CountingQuietWriter) qw).setCount(f.length());
		}
}

Creates and opens the file for logging. If staticLogFileName is false then the fully qualified name is determined and used.

 public  void setMaxFileSize(long maxFileSize) 
{
	   this.maxFileSize = maxFileSize;
}

Set the maximum size that the output file is allowed to reach before being rolled over to backup files.

This method is equivalent to #setMaxFileSize except that it is required for differentiating the setter taking a long argument from the setter taking a String argument by the JavaBeans Introspector .

 public  void setMaxFileSize(String value) 
{
	    maxFileSize = OptionConverter.toFileSize(value, maxFileSize + 1);
}

Set the maximum size that the output file is allowed to reach before being rolled over to backup files.

In configuration files, the MaxFileSize option takes an long integer in the range 0 - 2^63. You can specify the value with the suffixes "KB", "MB" or "GB" so that the integer is interpreted being expressed respectively in kilobytes, megabytes or gigabytes. For example, the value "10KB" will be interpreted as 10240.

 public  void setMaxSizeRollBackups(int maxBackups) 
{
	    maxSizeRollBackups = maxBackups;
}

Set the maximum number of backup files to keep around based on file size.

The MaxSizeRollBackups option determines how many backup files are kept before the oldest is erased. This option takes an integer value. If set to zero, then there will be no backup files and the log file will be truncated when it reaches MaxFileSize. If a negative number is supplied then no deletions will be made. Note that this could result in very slow performance as a large number of files are rolled over unless #setCountDirection up is used.

The maximum applys to -each- time based group of files and -not- the total. Using a daily roll the maximum total files would be (#days run) * (maxSizeRollBackups)

 public  void setMaximumFileSize(long maxFileSize) 
{
		this.maxFileSize = maxFileSize;
}

Set the maximum size that the output file is allowed to reach before being rolled over to backup files.

This method is equivalent to #setMaxFileSize except that it is required for differentiating the setter taking a long argument from the setter taking a String argument by the JavaBeans Introspector .

 protected  void setQWForFiles(Writer writer) 
{
	    qw = new CountingQuietWriter(writer, errorHandler);
}

 public  void setRollingStyle(int style) 
{
	    rollingStyle = style;
		switch (rollingStyle) {
			case BY_SIZE:
				 rollDate = false;
				 rollSize = true;
				 break;
			case BY_DATE:
				 rollDate = true;
				 rollSize = false;
				 break;
			case BY_COMPOSITE:
				 rollDate = true;
				 rollSize = true;
				 break;
			default:
				errorHandler.error("Invalid rolling Style, use 1 (by size only), 2 (by date only) or 3 (both)");
		}
}

 public  void setStaticLogFileName(boolean s) 
{
		staticLogFileName = s;
}

 public  void setStaticLogFileName(String value) 
{
		setStaticLogFileName(OptionConverter.toBoolean(value, true));
}

 protected  void subAppend(LoggingEvent event) 
{
		if (rollDate) {
			long n = System.currentTimeMillis();
			if (n  >= nextCheck) {
				now.setTime(n);
				nextCheck = rc.getNextCheckMillis(now);
				rollOverTime();
			}
		}
		if (rollSize) {
			if ((fileName != null) && ((CountingQuietWriter) qw).getCount()  >= maxFileSize) {
			    rollOverSize();
			}
		}
		super.subAppend(event);
}

Handles append time behavior for CompositeRollingAppender. This checks if a roll over either by date (checked first) or time (checked second) is need and then appends to the file last.