To use CompositeRollingAppender to roll log files as they reach a certain size (like RollingFileAppender), set rollingStyle=1. To use CompositeRollingAppender to roll log files at certain time intervals (daily for example), set rollingStyle=2 and a datePattern. To have CompositeRollingAppender roll log files at a certain size AND rename those according to time intervals, set rollingStyle=3.
A of few additional optional features have been added:
-- Attach date pattern for current log file
-- Backup number increments for newer files
-- Infinite number of backups by file size
A few notes and warnings: For large or infinite number of backups countDirection > 0 is highly recommended, with staticLogFileName = false if time based rolling is also used -- this will reduce the number of file renaming to few or none. Changing staticLogFileName or countDirection without clearing the directory could have nasty side effects. If Date/Time based rolling
is enabled, CompositeRollingAppender will attempt to roll existing files in the directory without a date/time tag based on the last modified date of the base log files last modification.
To use the CompositeRollingAppender you have to add the log4j.jar file in the classpath and go through the following configurations for the log4j.properties file.
And create the following CompositeRollingAppender java and RollingCalendar.java files in your workspace and run your application you will find the log files are created based on the date and size. Just copy paste the following code into single Java file and name it as a CompositeRollingAppender .
package com.group.log;
import java.io.File;
import java.io.IOException;
import java.io.Writer;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import org.apache.log4j.Layout;
import org.apache.log4j.helpers.CountingQuietWriter;
import org.apache.log4j.helpers.LogLog;
import org.apache.log4j.helpers.OptionConverter;
import org.apache.log4j.spi.LoggingEvent;
/**
* @author Krishnat Pawar
*/
public class CompositeRollingAppender extends org.apache.log4j.FileAppender {
static final int BY_COMPOSITE = 3;
static final int BY_DATE = 2;
/** Style of rolling to use */
static final int BY_SIZE = 1;
static final int HALF_DAY = 2;
static final String S_BY_COMPOSITE = "Composite";
static final String S_BY_DATE = "Date";
//Not currently used
static final String S_BY_SIZE = "Size";
static final int TOP_OF_DAY = 3;
static final int TOP_OF_HOUR = 1;
static final int TOP_OF_MINUTE = 0;
static final int TOP_OF_MONTH = 5;
// The code assumes that the following 'time' constants are in a increasing
// sequence.
static final int TOP_OF_TROUBLE = -1;
static final int TOP_OF_WEEK = 4;
/** Delete's the specified file if it exists */
protected static void deleteFile(String fileName) {
File file = new File(fileName);
if (file.exists()) {
file.delete();
}
}
/** Renames file from to file to. It
* also checks for existence of target file and deletes if it does.
*/
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);
boolean result=file.renameTo(target);
if(result) {
LogLog.debug(from +" -> "+ to);
} else {
LogLog.error("Failed to rename ["+from+"] to ["+to+"].");
}
}
/** FileName provided in configuration. Used for rolling properly */
protected String baseFileName;
/** Current period for roll overs */
int checkPeriod = TOP_OF_TROUBLE;
/** By default newer files have lower numbers. (countDirection <> 0 does the opposite ie.
* log.1 is the first backup made, log.5 is the 5th backup made, etc.
* For infinite backups use countDirection > 0 to reduce rollOver costs.
*/
protected int countDirection = -1;
/** How many sized based backups have been made so far */
protected int curSizeRollBackups = 0;
protected int curTimeRollBackups = 0;
/**
The date pattern. By default, the pattern is set to
"'.'yyyy-MM-dd" meaning daily rollover.
*/
private String datePattern = "'.'yyyy-MM-dd";
/** The default maximum file size is 10MB. */
protected long maxFileSize = 10 * 1024 * 1024;
/** There is zero backup files by default. */
protected int maxSizeRollBackups = 0;
/** not yet implemented */
protected int maxTimeRollBackups = -1;
/** The timestamp when we shall next recompute the filename. */
private long nextCheck = System.currentTimeMillis() - 1;
/** Holds date of last roll over */
Date now = new Date();
/** Helper class to determine next rollover time */
RollingCalendar rc = new RollingCalendar();
protected boolean rollDate = true;
/** Style of rolling to Use. BY_SIZE (1), BY_DATE(2), BY COMPOSITE(3) */
protected int rollingStyle = BY_COMPOSITE;
protected boolean rollSize = true;
/** The actual formatted filename that is currently being written to
or will be the file transferred to on roll over
(based on staticLogFileName). */
private String scheduledFilename = null;
SimpleDateFormat sdf;
/** By default file.log is always the current file. Optionally
* file.log.yyyy-mm-dd for current formated datePattern can by the currently
* logging file (or file.log.curSizeRollBackup or even
* file.log.yyyy-mm-dd.curSizeRollBackup) This will make time based roll
* overs with a large number of backups much faster -- it won't have to
* rename all the backups!
*/
protected boolean staticLogFileName = true;
/** The default constructor does nothing. */
public CompositeRollingAppender() {
}
/**
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) throws IOException {
super(layout, filename);
}
/**
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, 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.
*/
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, String datePattern, boolean append) throws IOException {
super(layout, filename, append);
this.datePattern = datePattern;
activateOptions();
}
/**
* Sets initial conditions including date/time roll over information, first check,
* scheduledFilename, and calls existingInit to initialize
* the current # of backups.
*/
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);
}
//Taken verbatum from DailyRollingFileAppender
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... } /** * 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. */ protected void existingInit() { curSizeRollBackups = 0; curTimeRollBackups = 0; //part A starts here 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 < index =" files[i].lastIndexOf(" endlength =" files[i].length()" backup =" Integer.parseInt(files[i].substring(index"> " + 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
}
public int getCountDirection() {
return countDirection;
}
/** Returns the value of the DatePattern option. */
public String getDatePattern() {
return datePattern;
}
/**
Get the maximum size that the output file is allowed to reach
before being rolled over to backup files.
@since 1.1
*/
public long getMaximumFileSize() {
return maxFileSize;
}
/**
Returns the value of the maxSizeRollBackups option.
*/
public int getMaxSizeRollBackups() {
return maxSizeRollBackups;
}
public int getRollingStyle() {
return rollingStyle;
}
public boolean getStaticLogFileName() {
return staticLogFileName;
}
/**
Implements roll overs base on file size.
If the maximum number of size based backups is reached
(curSizeRollBackups == maxSizeRollBackups
If countDirection < 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) { /* Compute filename, but only if datePattern is specified */ if (datePattern == null) { errorHandler.error(" dateformat =" sdf.format(now);" cursizerollbackups ="=" i =" curSizeRollBackups;">= 1; i--) {
rollFile((fileName + dateFormat + "." + i), (fileName + dateFormat + '.' + (i + 1)));
}
curSizeRollBackups++;
// Rename fileName to fileName.1
rollFile(fileName, fileName + dateFormat + ".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 + dateFormat;
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 + dateFormat + '.' + oldestFileIndex);
}
if (staticLogFileName) {
curSizeRollBackups++;
rollFile(fileName, fileName + dateFormat + '.' + 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);
}
}
/**
Rollover the file(s) to date/time tagged file(s).
Opens the new file (through setFile) and resets curSizeRollBackups.
*/
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
for (int i = curSizeRollBackups; i >= 1; i--) {
rollFile((scheduledFilename + "." + i), (scheduledFilename + '.' + (i + 1)));
}
rollFile(fileName, scheduledFilename+ "." + 1);
}
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.");
}
}
public void setCountDirection(int direction) {
countDirection = direction;
}
/**
The DatePattern takes a string in the same format as
expected by {@link SimpleDateFormat}. This options determines the
rollover schedule.
*/
public void setDatePattern(String pattern) {
datePattern = pattern;
}
public void setFile(String file) {
baseFileName = file.trim();
fileName = file.trim();
}
/**
* Creates and opens the file for logging. If staticLogFileName
* is false then the fully qualified name is determined and used.
*/
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, this.bufferedIO, this.bufferSize);
if (append) {
File f = new File(fileName);
((CountingQuietWriter) qw).setCount(f.length());
}
}
/**
Set the maximum size that the output file is allowed to reach
before being rolled over to backup files.
This method is equivalent to {@link #setMaxFileSize} except
that it is required for differentiating the setter taking a
long argument from the setter taking a
String argument by the JavaBeans {@link
java.beans.Introspector Introspector}.
@see #setMaxFileSize(String)
*/
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.
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 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.
This method is equivalent to {@link #setMaxFileSize} except
that it is required for differentiating the setter taking a
long argument from the setter taking a
String argument by the JavaBeans {@link
java.beans.Introspector Introspector}.
@see #setMaxFileSize(String)
*/
public void setMaximumFileSize(long maxFileSize) {
this.maxFileSize = maxFileSize;
}
/**
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
{@link #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 setMaxSizeRollBackups(int maxBackups) {
maxSizeRollBackups = maxBackups;
}
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));
}
//Now for the new stuff
/**
* 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.
*/
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);
}
}
/**
* RollingCalendar is a helper class to DailyRollingFileAppender.
* Given a periodicity type and the current time, it computes the
* start of the next interval.
*/
class RollingCalendar extends GregorianCalendar {
static final int HALF_DAY = 2;
private static final long serialVersionUID = 1L;
static final int TOP_OF_DAY = 3;
static final int TOP_OF_HOUR = 1;
static final int TOP_OF_MINUTE = 0;
static final int TOP_OF_MONTH = 5;
static final int TOP_OF_TROUBLE = -1;
static final int TOP_OF_WEEK = 4;
int type = TOP_OF_TROUBLE;
public Date getNextCheckDate(Date now) {
this.setTime(now);
switch (type) {
case TOP_OF_MINUTE:
this.set(Calendar.SECOND, 0);
this.set(Calendar.MILLISECOND, 0);
this.add(Calendar.MINUTE, 1);
break;
case TOP_OF_HOUR:
this.set(Calendar.MINUTE, 0);
this.set(Calendar.SECOND, 0);
this.set(Calendar.MILLISECOND, 0);
this.add(Calendar.HOUR_OF_DAY, 1);
break;
case HALF_DAY:
this.set(Calendar.MINUTE, 0);
this.set(Calendar.SECOND, 0);
this.set(Calendar.MILLISECOND, 0);
int hour = get(Calendar.HOUR_OF_DAY);
if (hour < 12) {
this.set(Calendar.HOUR_OF_DAY, 12);
} else {
this.set(Calendar.HOUR_OF_DAY, 0);
this.add(Calendar.DAY_OF_MONTH, 1);
}
break;
case TOP_OF_DAY:
this.set(Calendar.HOUR_OF_DAY, 0);
this.set(Calendar.MINUTE, 0);
this.set(Calendar.SECOND, 0);
this.set(Calendar.MILLISECOND, 0);
this.add(Calendar.DATE, 1);
break;
case TOP_OF_WEEK:
this.set(Calendar.DAY_OF_WEEK, getFirstDayOfWeek());
this.set(Calendar.HOUR_OF_DAY, 0);
this.set(Calendar.SECOND, 0);
this.set(Calendar.MILLISECOND, 0);
this.add(Calendar.WEEK_OF_YEAR, 1);
break;
case TOP_OF_MONTH:
this.set(Calendar.DATE, 1);
this.set(Calendar.HOUR_OF_DAY, 0);
this.set(Calendar.SECOND, 0);
this.set(Calendar.MILLISECOND, 0);
this.add(Calendar.MONTH, 1);
break;
default:
throw new IllegalStateException("Unknown periodicity type.");
}
return getTime();
}
public long getNextCheckMillis(Date now) {
return getNextCheckDate(now).getTime();
}
void setType(int type) {
this.type = type;
}
}
This comment has been removed by the author.
ReplyDelete