org.apache.log4j.DailyZipRollingFileAppender Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of pax-logging-log4j1 Show documentation
Show all versions of pax-logging-log4j1 Show documentation
Pax Logging backend implementation based on Apache Log4J. It provides Log4J specific implementation
of PaxLoggingService interface and Log4J specific configuration methods.
Users may customize Log4J behaviour (appenders, layouts) by creating fragment attached to this bundle.
The newest version!
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.log4j;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InterruptedIOException;
import java.io.Serializable;
import java.net.URI;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.TimeZone;
import java.util.zip.GZIPOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
import org.apache.log4j.helpers.LogLog;
import org.apache.log4j.spi.LoggingEvent;
/**
* DailyZipRollingFileAppender extends {@link FileAppender} so that the
* underlying file is rolled over at a user chosen frequency.
*
* The rolling schedule is specified by the DatePattern option. This
* pattern should follow the {@link SimpleDateFormat} conventions. In
* particular, you must escape literal text within a pair of single
* quotes. A formatted version of the date pattern is used as the suffix for the
* rolled file name.
*
* For example, if the File option is set to /foo/bar.log
* and the DatePattern set to '.'yyyy-MM-dd, on 2001-02-16
* at midnight, the logging file /foo/bar.log will be copied to
* /foo/bar.log.2001-02-16 and logging for 2001-02-17 will continue
* in /foo/bar.log until it rolls over the next day.
*
* Is is possible to specify monthly, weekly, half-daily, daily, hourly, or
* minutely rollover schedules.
*
*
*
* DatePattern
* Rollover schedule
* Example
*
*
* '.'yyyy-MMRollover at the beginning of each month
*
* At midnight of May 31st, 2002 /foo/bar.log will be copied to
* /foo/bar.log.2002-05. Logging for the month of June will be
* output to /foo/bar.log until it is also rolled over the next
* month.
*
*
* '.'yyyy-wwRollover at the first day of each week. The first day of the week depends
* on the locale.
*
* Assuming the first day of the week is Sunday, on Saturday midnight, June
* 9th 2002, the file /foo/bar.log will be copied to
* /foo/bar.log.2002-23. Logging for the 24th week of 2002 will be output
* to /foo/bar.log until it is rolled over the next week.
*
*
*
* '.'yyyy-MM-ddRollover at midnight each day.
*
* At midnight, on March 8th, 2002, /foo/bar.log will be copied
* to /foo/bar.log.2002-03-08. Logging for the 9th day of March
* will be output to /foo/bar.log until it is rolled over the next
* day.
*
*
*
* '.'yyyy-MM-dd-aRollover at midnight and midday of each day.
*
* At noon, on March 9th, 2002, /foo/bar.log will be copied to
* /foo/bar.log.2002-03-09-AM. Logging for the afternoon of the 9th
* will be output to /foo/bar.log until it is rolled over at
* midnight.
*
*
*
* '.'yyyy-MM-dd-HHRollover at the top of every hour.
*
* At approximately 11:00.000 o'clock on March 9th, 2002,
* /foo/bar.log will be copied to
* /foo/bar.log.2002-03-09-10. Logging for the 11th hour of the 9th
* of March will be output to /foo/bar.log until it is rolled over
* at the beginning of the next hour.
*
*
*
* '.'yyyy-MM-dd-HH-mmRollover at the beginning of every minute.
*
* At approximately 11:23,000, on March 9th, 2001, /foo/bar.log
* will be copied to /foo/bar.log.2001-03-09-10-22. Logging for the
* minute of 11:23 (9th of March) will be output to /foo/bar.log
* until it is rolled over the next minute.
*
*
*
* Do not use the colon ":" character in anywhere in the DatePattern
* option. The text before the colon is interpreted as the protocol specification
* of a URL which is probably not what you want.
*
* @author Giuseppe Gerla
*/
public class DailyZipRollingFileAppender extends FileAppender {
class ModifiedTimeSortableFile extends File implements Serializable,
Comparable {
private static final long serialVersionUID = 1373373728209668895L;
public ModifiedTimeSortableFile(String parent, String child) {
super(parent, child);
}
public ModifiedTimeSortableFile(URI uri) {
super(uri);
}
public ModifiedTimeSortableFile(File parent, String child) {
super(parent, child);
}
public ModifiedTimeSortableFile(String string) {
super(string);
}
public int compareTo(File anotherPathName) {
long thisVal = this.lastModified();
long anotherVal = anotherPathName.lastModified();
return (thisVal < anotherVal ? -1 : (thisVal == anotherVal ? 0 : 1));
}
}
class CleanUpThread implements Runnable {
private Map> getAllFiles(String perentDirectory) {
Map> groupedFiles = null;
try {
// Files grouped by bundle, if using Sift appender.
// Otherwise, a single group containing the karaf.log (and backups).
groupedFiles = new HashMap>();
List files = null;
File dir = new File(perentDirectory);
String[] names = dir.list();
String uniquePartOfName;
for (int i = 0; i < names.length; i++) {
int truncateToLength = names[i].length() - datePattern.length();
if (names[i].endsWith(typeOfCompression)) {
truncateToLength = truncateToLength - (typeOfCompression.length() + 1);
}
uniquePartOfName = names[i].substring(0, truncateToLength);
if (groupedFiles.containsKey(uniquePartOfName)) {
files = groupedFiles.get(uniquePartOfName);
} else {
files = new ArrayList();
}
files.add(new ModifiedTimeSortableFile(dir + System.getProperty("file.separator") + names[i]));
groupedFiles.put(uniquePartOfName, files);
}
} catch (Exception e) {
LogLog.error("LogLog Error during retrieving all files of parent folder. ", e);
}
return groupedFiles;
}
public void run() {
Map> groupedFiles = getAllFiles(perentDirectory);
Iterator iterator = groupedFiles.entrySet().iterator();
List files = null;
// For each group of files, delete the backups that exceed the maxBackupIndex.
// Note: there will only be single group if Sift appender is not used.
while(iterator.hasNext()) {
Map.Entry> pair = (Map.Entry) iterator.next();
files = pair.getValue();
if (files.size() > (maxBackupIndex + 1)) {
Collections.sort(files);
int index = 0;
int diff = files.size() - (maxBackupIndex + 1);
for (ModifiedTimeSortableFile file : files) {
if (index >= diff)
break;
file.delete();
index++;
}
}
}
}
}
/**
* Compresses the passed file to a .zip file, stores the .zip in the same
* directory as the passed file, and then deletes the original, leaving only
* the .zipped archive.
*
* @param file
*/
class CompressFile implements Runnable {
File file;
public CompressFile(File file) {
this.file = file;
}
public void run() {
try {
if (!file.getName().endsWith("." + typeOfCompression)) {
if ("zip".equals(typeOfCompression)) {
File zipFile = new File(file.getParent(),
file.getName() + ".zip");
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(zipFile);
ZipOutputStream zos = new ZipOutputStream(fos);
ZipEntry zipEntry = new ZipEntry(file.getName());
zos.putNextEntry(zipEntry);
byte[] buffer = new byte[4096];
while (true) {
int bytesRead = fis.read(buffer);
if (bytesRead == -1)
break;
else {
zos.write(buffer, 0, bytesRead);
}
}
zos.closeEntry();
fis.close();
zos.close();
file.delete();
} else if ("gz".equals(typeOfCompression)) {
File zipFile = new File(file.getParent(),
file.getName() + ".gz");
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(zipFile);
GZIPOutputStream zos = new GZIPOutputStream(fos);
byte[] buffer = new byte[4096];
while (true) {
int bytesRead = fis.read(buffer);
if (bytesRead == -1)
break;
else {
zos.write(buffer, 0, bytesRead);
}
}
fis.close();
zos.close();
file.delete();
}
}
} catch (IOException e) {
LogLog.error("Error during compression of file " + fileName
+ ".", e);
}
}
}
// The code assumes that the following constants are in a increasing
// sequence.
static final int TOP_OF_TROUBLE = -1;
static final int TOP_OF_MINUTE = 0;
static final int TOP_OF_HOUR = 1;
static final int HALF_DAY = 2;
static final int TOP_OF_DAY = 3;
static final int TOP_OF_WEEK = 4;
static final int TOP_OF_MONTH = 5;
/**
* The date pattern. By default, the pattern is set to "'.'yyyy-MM-dd"
* meaning daily rollover.
*/
private String datePattern = "'.'yyyy-MM-dd";
/**
* The log file will be renamed to the value of the scheduledFilename
* variable when the next interval is entered. For example, if the rollover
* period is one hour, the log file will be renamed to the value of
* "scheduledFilename" at the beginning of the next hour.
*
* The precise time when a rollover occurs depends on logging activity.
*/
private String scheduledFilename;
/**
* The next time we estimate a rollover should occur.
*/
private long nextCheck = System.currentTimeMillis() - 1;
Date now = null;
SimpleDateFormat sdf;
RollingCalendar rc = new RollingCalendar();
int checkPeriod = TOP_OF_TROUBLE;
protected int maxBackupIndex = 1;
private String compressBackups = "false";
private String typeOfCompression = "gz";
private String baseFileName;
private String perentDirectory;
// The gmtTimeZone is used only in computeCheckPeriod() method.
static final TimeZone gmtTimeZone = TimeZone.getTimeZone("GMT");
/**
* The default constructor does nothing.
*/
public DailyZipRollingFileAppender() {
}
/**
* Instantiate a DailyRollingFileAppender and open the file
* designated by filename. The opened filename will become the
* ouput destination for this appender.
*/
public DailyZipRollingFileAppender(Layout layout, String filename,
String datePattern) throws IOException {
super(layout, filename, true);
this.datePattern = datePattern;
activateOptions();
}
/**
* 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;
}
/** Returns the value of the DatePattern option. */
public String getDatePattern() {
return datePattern;
}
public int getMaxBackupIndex() {
return maxBackupIndex;
}
public void setMaxBackupIndex(int maxBackups) {
this.maxBackupIndex = maxBackups;
}
public String getCompressBackups() {
return compressBackups;
}
public void setCompressBackups(String compressBackups) {
this.compressBackups = compressBackups;
}
public String getTypeOfCompression() {
return typeOfCompression;
}
public void setTypeOfCompression(String typeOfCompression) {
this.typeOfCompression = typeOfCompression;
}
public void activateOptions() {
if (datePattern != null && fileName != null) {
if(now==null) {
now = new Date();
now.setTime(System.currentTimeMillis());
}
sdf = new SimpleDateFormat(datePattern);
int type = computeCheckPeriod();
printPeriodicity(type);
rc.setType(type);
nextCheck = rc.getNextCheckMillis(now);
if (this.baseFileName == null)
this.baseFileName = fileName;
scheduledFilename = baseFileName + sdf.format(now);
fileName = scheduledFilename;
if (perentDirectory == null) {
File file = new File(fileName);
if (file != null) {
perentDirectory = file.getParent();
if (file.exists()) {
if (file.getParent() == null) {
String absolutePath = file.getAbsolutePath();
perentDirectory = absolutePath.substring(0,
absolutePath.lastIndexOf(fileName));
}
}
}
}
} else {
LogLog.error("Either File or DatePattern options are not set for appender ["
+ name + "].");
}
super.activateOptions();
}
void printPeriodicity(int type) {
switch (type) {
case TOP_OF_MINUTE:
LogLog.debug("Appender [" + name + "] to be rolled every minute.");
break;
case TOP_OF_HOUR:
LogLog.debug("Appender [" + name
+ "] to be rolled on top of every hour.");
break;
case HALF_DAY:
LogLog.debug("Appender [" + name
+ "] to be rolled at midday and midnight.");
break;
case TOP_OF_DAY:
LogLog.debug("Appender [" + name + "] to be rolled at midnight.");
break;
case TOP_OF_WEEK:
LogLog.debug("Appender [" + name
+ "] to be rolled at start of week.");
break;
case TOP_OF_MONTH:
LogLog.debug("Appender [" + name
+ "] to be rolled at start of every month.");
break;
default:
LogLog.warn("Unknown periodicity for appender [" + name + "].");
}
}
int computeCheckPeriod() {
RollingCalendar rollingCalendar = new RollingCalendar(gmtTimeZone,
Locale.getDefault());
// 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++) {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(
datePattern);
simpleDateFormat.setTimeZone(gmtTimeZone); // do all date
// formatting in GMT
String r0 = simpleDateFormat.format(epoch);
rollingCalendar.setType(i);
Date next = new Date(rollingCalendar.getNextCheckMillis(epoch));
String r1 = simpleDateFormat.format(next);
// System.out.println("Type = "+i+", r0 = "+r0+", r1 = "+r1);
if (r0 != null && r1 != null && !r0.equals(r1)) {
return i;
}
}
}
return TOP_OF_TROUBLE; // Deliberately head for trouble...
}
/**
* Rollover the current file to a new file.
*/
void rollOver() throws IOException {
// If compression is enabled we start a separated thread
if (getCompressBackups().equalsIgnoreCase("YES")
|| getCompressBackups().equalsIgnoreCase("TRUE")) {
File file = new File(fileName);
Thread fileCompressor = new Thread(new CompressFile(file));
fileCompressor.start();
}
/* Compute filename, but only if datePattern is specified */
if (datePattern == null) {
errorHandler.error("Missing DatePattern option in rollOver().");
return;
}
String datedFilename = baseFileName + sdf.format(now);
// It is too early to roll over because we are still within the
// bounds of the current interval. Rollover will occur once the
// next interval is reached.
if (scheduledFilename.equals(datedFilename)) {
return;
}
activateOptions();
}
/*
* This method checks to see if we're exceeding the number of log backups
* that we are supposed to keep, and if so, deletes the offending files. It
* then delegates to the rollover method to rollover to a new file if
* required.
*/
protected void cleanupAndRollOver() throws IOException {
// Since the deletion of older files can be slow, it will launch a
// separate
// thread
Thread clth = new Thread(new CleanUpThread());
clth.start();
rollOver();
}
/**
* This method differentiates DailyRollingFileAppender from its super class.
*
*
* Before actually logging, this method will check whether it is time to do
* a rollover. If it is, it will schedule the next rollover time and then
* rollover.
* */
protected void subAppend(LoggingEvent event) {
long n = event.timeStamp;
if (n >= nextCheck) {
try {
now.setTime(n);
cleanupAndRollOver();
} catch (IOException ioe) {
if (ioe instanceof InterruptedIOException) {
Thread.currentThread().interrupt();
}
LogLog.error("rollOver() failed.", ioe);
}
}
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 {
private static final long serialVersionUID = -3560331770601814177L;
int type = DailyZipRollingFileAppender.TOP_OF_TROUBLE;
RollingCalendar() {
super();
}
RollingCalendar(TimeZone tz, Locale locale) {
super(tz, locale);
}
void setType(int type) {
this.type = type;
}
public long getNextCheckMillis(Date now) {
return getNextCheckDate(now).getTime();
}
public Date getNextCheckDate(Date now) {
this.setTime(now);
switch (type) {
case DailyZipRollingFileAppender.TOP_OF_MINUTE:
this.set(Calendar.SECOND, 0);
this.set(Calendar.MILLISECOND, 0);
this.add(Calendar.MINUTE, 1);
break;
case DailyZipRollingFileAppender.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 DailyZipRollingFileAppender.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 DailyZipRollingFileAppender.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 DailyZipRollingFileAppender.TOP_OF_WEEK:
this.set(Calendar.DAY_OF_WEEK, getFirstDayOfWeek());
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.WEEK_OF_YEAR, 1);
break;
case DailyZipRollingFileAppender.TOP_OF_MONTH:
this.set(Calendar.DATE, 1);
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.MONTH, 1);
break;
default:
throw new IllegalStateException("Unknown periodicity type.");
}
return getTime();
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy