* The variable name is specified by the File option. This value should * follow the {@link PatternLayout} conventions. In particular, you * must escape literal text within a pair of single quotes. A formatted * version of the fileName pattern is used as the file name. * *
* For example, if the File option is set to
* /log/server[%c].log the file
* /foo/bar[com.foo.ClassName].log will be generated to
* com.foo.ClassName class and the file
* /foo/bar[com.foo.AnotherClassName].log will be generated to
* com.foo.AnotherClassName class.
*
*
* It is possible to specify any pattern available in the {@link PatternLayout} * class. * *
* If you specify a data parameter the VariableNameFileAppender will behave like * a RollingAppender creating a new file depending on the provided parameter *
* For example /foo/log[%d{dd-MMM-yyyy}].log will create a new file every day. * * *
* Is is possible to specify monthly, weekly, half-daily, daily, hourly, or * minutely rollover schedules. * * *
* 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 Eduardo Rodrigues
*/
public class ConfigurableFileNameAppender extends AppenderSkeleton {
private PatternLayout fileNamePatternLayout;
private Map
* The
* The
* This option is meaningful only if the FileAppender opens the file.
*/
protected boolean fileAppend = true;
/**
* Do we do bufferedIO?
*/
protected boolean bufferedIO = false;
/**
* Determines the size of IO buffer be. Default is 8K.
*/
protected int bufferSize = 8 * 1024;
private String fileName;
public ConfigurableFileNameAppender() {
super();
}
public ConfigurableFileNameAppender(Layout layout, String filename)
throws IOException {
super();
this.setFile(filename);
this.layout = layout;
}
public ConfigurableFileNameAppender(Layout layout, String filename,
boolean append) throws IOException {
this(layout, filename);
this.fileAppend = append;
}
public ConfigurableFileNameAppender(Layout layout, String filename,
boolean append, boolean bufferedIO, int bufferSize)
throws IOException {
this(layout, filename, append);
this.bufferedIO = bufferedIO;
this.bufferSize = bufferSize;
}
public void setFile(String file) {
this.fileName = file;
fileNamePatternLayout = new PatternLayout(fileName);
}
/**
* If the value of File is not
* Sets and opens the file where the log output will go. The
* specified file must be writable.
*
*
* If there was already an opened file, then the previous file is closed
* first.
*
*
* Do not use this method directly. To configure a FileAppender or one of
* its subclasses, set its properties one by one and then call
* activateOptions.
*
* @param fileName
* The path to the log file.
* @param append
* If true will append to fileName. Otherwise will truncate
* fileName.
*/
public synchronized QuietWriter createFile(String fileName, boolean append,
boolean bufferedIO, int bufferSize) throws IOException {
LogLog.debug("setFile called: " + fileName + ", " + append);
// It does not make sense to have immediate flush and bufferedIO.
if (bufferedIO) {
setImmediateFlush(false);
}
FileOutputStream ostream = null;
try {
//
// attempt to create file
//
ostream = new FileOutputStream(fileName, append);
} catch (FileNotFoundException ex) {
//
// if parent directory does not exist then
// attempt to create it and try to create file
// see bug 9150
//
String parentName = new File(fileName).getParent();
if (parentName != null) {
File parentDir = new File(parentName);
if (!parentDir.exists() && parentDir.mkdirs()) {
ostream = new FileOutputStream(fileName, append);
} else {
throw ex;
}
} else {
throw ex;
}
}
Writer fw = createWriter(ostream);
if (bufferedIO) {
fw = new BufferedWriter(fw, bufferSize);
}
QuietWriter qw = new QuietWriter(fw, errorHandler);
writeHeader(qw);
LogLog.debug("setFile ended");
return qw;
}
/**
* Returns an OutputStreamWriter when passed an OutputStream. The encoding
* used will depend on the value of the
* It checks whether there is a set output target and also if there is a set
* layout. If these checks fail, then the boolean value
* Avoiding the flush operation at the end of each append results in a
* performance gain of 10 to 20 percent. However, there is safety tradeoff
* involved in skipping flushing. Indeed, when flushing is skipped, then it
* is likely that the last few log events will not be recorded on disk when
* the application exits. This is a high price to pay even for a 20%
* performance gain.
*/
public void setImmediateFlush(boolean value) {
immediateFlush = value;
}
/**
* Returns value of the ImmediateFlush option.
*/
public boolean getImmediateFlush() {
return immediateFlush;
}
/**
* This method is called by the {@link AppenderSkeleton#doAppend} method.
*
*
* If the output stream exists and is writable then write a log statement to
* the output stream. Otherwise, write a single warning message to
*
* The format of the output will depend on this appender's layout.
*/
@Override
public void append(LoggingEvent event) {
// Reminder: the nesting of calls is:
//
// doAppend()
// - check threshold
// - filter
// - append();
// - checkEntryConditions();
// - subAppend();
if (!checkEntryConditions()) {
return;
}
subAppend(event);
}
/**
* Close this appender instance. The underlying stream or writer is also
* closed.
*
*
* Closed appenders cannot be reused.
*
* @see #setWriter
* @since 0.8.4
*/
@Override
public synchronized void close() {
if (this.closed)
return;
this.closed = true;
writeFooter();
reset();
}
@Override
public boolean requiresLayout() {
return false;
}
/**
* The Append option takes a boolean value. It is set to
*
* Note: Actual opening of the file is made when {@link #activateOptions} is
* called, not when the options are set.
*/
public void setAppend(boolean flag) {
fileAppend = flag;
}
/**
* Returns the value of the Append option.
*/
public boolean getAppend() {
return fileAppend;
}
}
immediateFlush is set to false, then there is a
* good chance that the last few logs events are not actually written to
* persistent media if and when the application crashes.
*
* immediateFlush variable is set to true by
* default.
*/
protected boolean immediateFlush = true;
/**
* The encoding to use when writing.
* encoding variable is set to null by
default which results in the utilization of the system's default
encoding.
*/
protected String encoding;
/**
* Controls file truncation. The default value for this variable is
* true, meaning that by default a FileAppender
* will append to an existing file and not truncate it.
*
* null, then
* {@link #setFile} is called with the values of File and
* Append properties.
*
* @since 0.8.1
*/
public void activateOptions() {
if (fileName == null) {
LogLog.warn("FileName not set for appender [" + name + "].");
}
}
/**
* this method can be overridden by the subclasses to improve the names
*
* @param event
* event to be logged.
*
* Returns the file name following the pattern provided.
*
* @since 0.1
*/
protected String generateFileName(LoggingEvent event) {
return fileNamePatternLayout.format(event);
}
protected void subAppend(LoggingEvent event) {
// overrides super behavior creative a file depending on the file
// pattern
String currentFileName = generateFileName(event);
QuietWriter qw = qwMap.get(currentFileName);
if (qw == null) {
try {
qw = createFile(currentFileName, fileAppend, bufferedIO,
bufferSize);
} catch (IOException e) {
errorHandler.error("createFile(" + currentFileName + ", "
+ fileAppend + ") call failed.");
}
qwMap.put(currentFileName, qw);
}
qw.write(this.layout.format(event));
if (layout.ignoresThrowable()) {
String[] s = event.getThrowableStrRep();
if (s != null) {
int len = s.length;
for (int i = 0; i < len; i++) {
qw.write(s[i]);
qw.write(Layout.LINE_SEP);
}
}
}
if (this.immediateFlush) {
qw.flush();
}
}
public synchronized void setFile(String fileName, boolean append,
boolean bufferedIO, int bufferSize) throws IOException {
}
/**
* encoding property. If
* the encoding value is specified incorrectly the writer will be opened
* using the default system encoding (an error message will be printed to
* the loglog.
*/
protected OutputStreamWriter createWriter(OutputStream os) {
OutputStreamWriter retval = null;
String enc = getEncoding();
if (enc != null) {
try {
retval = new OutputStreamWriter(os, enc);
} catch (IOException e) {
LogLog.warn("Error initializing output writer.");
LogLog.warn("Unsupported encoding?");
}
}
if (retval == null) {
retval = new OutputStreamWriter(os);
}
return retval;
}
public String getEncoding() {
return encoding;
}
public void setEncoding(String value) {
encoding = value;
}
/**
* Sets the quiet writer being used.
*
* This method is overriden by {@link RollingFileAppender}.
*/
protected void setQWForFiles(Writer writer) {
// this.qw = new QuietWriter(writer, errorHandler);
}
/**
* Clear internal references to the writer and other variables.
*
* Subclasses can override this method for an alternate closing behavior.
*/
protected void reset() {
closeWriter();
this.qwMap = new HashMapfalse
* is returned.
*/
protected boolean checkEntryConditions() {
if (this.closed) {
LogLog.warn("Not allowed to write to a closed appender.");
return false;
}
if (this.layout == null) {
errorHandler.error("No layout set for the appender named [" + name
+ "].");
return false;
}
return true;
}
/**
* If the ImmediateFlush option is set to true, the
* appender will flush at the end of each write. This is the default
* behavior. If the option is set to false, then the underlying
* stream can defer writing to physical medium to a later time.
*
* System.err.
*
* true by default. If true, then File will be
* opened in append mode by {@link #setFile setFile} (see above). Otherwise,
* {@link #setFile setFile} will open File in truncate mode.
*
*