--- /dev/null
+/*
+ * 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.IOException;
+import java.io.InterruptedIOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+
+import org.apache.log4j.helpers.LogLog;
+import org.apache.log4j.helpers.QuietWriter;
+import org.apache.log4j.spi.ErrorHandler;
+import org.apache.log4j.spi.LoggingEvent;
+
+// Contibutors: Jens Uwe Pipka <jens.pipka@gmx.de>
+// Ben Sandee
+
+/**
+ WriterAppender appends log events to a {@link java.io.Writer} or an
+ {@link java.io.OutputStream} depending on the user's choice.
+
+ @author Ceki Gülcü
+ @since 1.1 */
+public class WriterAppender extends AppenderSkeleton {
+
+
+ /**
+ Immediate flush means that the underlying writer or output stream
+ will be flushed at the end of each append operation unless shouldFlush()
+ is overridden. Immediate
+ flush is slower but ensures that each append request is actually
+ written. If <code>immediateFlush</code> is set to
+ <code>false</code>, 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.
+
+ <p>The <code>immediateFlush</code> variable is set to
+ <code>true</code> by default.
+
+ */
+ protected boolean immediateFlush = true;
+
+ /**
+ The encoding to use when writing. <p>The
+ <code>encoding</code> variable is set to <code>null</null> by
+ default which results in the utilization of the system's default
+ encoding. */
+ protected String encoding;
+
+ /**
+ This is the {@link QuietWriter quietWriter} where we will write
+ to.
+ */
+ protected QuietWriter qw;
+
+
+ /**
+ This default constructor does nothing. */
+ public
+ WriterAppender() {
+ }
+
+ /**
+ Instantiate a WriterAppender and set the output destination to a
+ new {@link OutputStreamWriter} initialized with <code>os</code>
+ as its {@link OutputStream}. */
+ public
+ WriterAppender(Layout layout, OutputStream os) {
+ this(layout, new OutputStreamWriter(os));
+ }
+
+ /**
+ Instantiate a WriterAppender and set the output destination to
+ <code>writer</code>.
+
+ <p>The <code>writer</code> must have been previously opened by
+ the user. */
+ public
+ WriterAppender(Layout layout, Writer writer) {
+ this.layout = layout;
+ this.setWriter(writer);
+ }
+
+ /**
+ If the <b>ImmediateFlush</b> option is set to
+ <code>true</code>, the appender will flush at the end of each
+ write. This is the default behavior. If the option is set to
+ <code>false</code>, then the underlying stream can defer writing
+ to physical medium to a later time.
+
+ <p>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 <b>ImmediateFlush</b> option.
+ */
+ public
+ boolean getImmediateFlush() {
+ return immediateFlush;
+ }
+
+ /**
+ Does nothing.
+ */
+ public
+ void activateOptions() {
+ }
+
+
+ /**
+ This method is called by the {@link AppenderSkeleton#doAppend}
+ method.
+
+ <p>If the output stream exists and is writable then write a log
+ statement to the output stream. Otherwise, write a single warning
+ message to <code>System.err</code>.
+
+ <p>The format of the output will depend on this appender's
+ layout.
+
+ */
+ public
+ void append(LoggingEvent event) {
+
+ // Reminder: the nesting of calls is:
+ //
+ // doAppend()
+ // - check threshold
+ // - filter
+ // - append();
+ // - checkEntryConditions();
+ // - subAppend();
+
+ if(!checkEntryConditions()) {
+ return;
+ }
+ subAppend(event);
+ }
+
+ /**
+ This method determines if there is a sense in attempting to append.
+
+ <p>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 <code>false</code> is returned. */
+ protected
+ boolean checkEntryConditions() {
+ if(this.closed) {
+ LogLog.warn("Not allowed to write to a closed appender.");
+ return false;
+ }
+
+ if(this.qw == null) {
+ errorHandler.error("No output stream or file set for the appender named ["+
+ name+"].");
+ return false;
+ }
+
+ if(this.layout == null) {
+ errorHandler.error("No layout set for the appender named ["+ name+"].");
+ return false;
+ }
+ return true;
+ }
+
+
+ /**
+ Close this appender instance. The underlying stream or writer is
+ also closed.
+
+ <p>Closed appenders cannot be reused.
+
+ @see #setWriter
+ @since 0.8.4 */
+ public
+ synchronized
+ void close() {
+ if(this.closed) {
+ return;
+ }
+ this.closed = true;
+ writeFooter();
+ reset();
+ }
+
+ /**
+ * Close the underlying {@link java.io.Writer}.
+ * */
+ protected void closeWriter() {
+ if(qw != null) {
+ try {
+ qw.close();
+ } catch(IOException e) {
+ if (e instanceof InterruptedIOException) {
+ Thread.currentThread().interrupt();
+ }
+ // There is do need to invoke an error handler at this late
+ // stage.
+ LogLog.error("Could not close " + qw, e);
+ }
+ }
+ }
+
+ /**
+ Returns an OutputStreamWriter when passed an OutputStream. The
+ encoding used will depend on the value of the
+ <code>encoding</code> 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) {
+ if (e instanceof InterruptedIOException) {
+ Thread.currentThread().interrupt();
+ }
+ 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;
+ }
+
+
+
+
+ /**
+ Set the {@link ErrorHandler} for this WriterAppender and also the
+ underlying {@link QuietWriter} if any. */
+ public synchronized void setErrorHandler(ErrorHandler eh) {
+ if(eh == null) {
+ LogLog.warn("You have tried to set a null error-handler.");
+ } else {
+ this.errorHandler = eh;
+ if(this.qw != null) {
+ this.qw.setErrorHandler(eh);
+ }
+ }
+ }
+
+ /**
+ <p>Sets the Writer where the log output will go. The
+ specified Writer must be opened by the user and be
+ writable.
+
+ <p>The <code>java.io.Writer</code> will be closed when the
+ appender instance is closed.
+
+
+ <p><b>WARNING:</b> Logging to an unopened Writer will fail.
+ <p>
+ @param writer An already opened Writer. */
+ public synchronized void setWriter(Writer writer) {
+ reset();
+ this.qw = new QuietWriter(writer, errorHandler);
+ //this.tp = new TracerPrintWriter(qw);
+ writeHeader();
+ }
+
+
+ /**
+ Actual writing occurs here.
+
+ <p>Most subclasses of <code>WriterAppender</code> will need to
+ override this method.
+
+ @since 0.9.0 */
+ protected
+ void subAppend(LoggingEvent event) {
+ this.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++) {
+ this.qw.write(s[i]);
+ this.qw.write(Layout.LINE_SEP);
+ }
+ }
+ }
+
+ if(shouldFlush(event)) {
+ this.qw.flush();
+ }
+ }
+
+
+
+ /**
+ The WriterAppender requires a layout. Hence, this method returns
+ <code>true</code>.
+ */
+ public
+ boolean requiresLayout() {
+ return true;
+ }
+
+ /**
+ Clear internal references to the writer and other variables.
+
+ Subclasses can override this method for an alternate closing
+ behavior. */
+ protected
+ void reset() {
+ closeWriter();
+ this.qw = null;
+ //this.tp = null;
+ }
+
+
+ /**
+ Write a footer as produced by the embedded layout's {@link
+ Layout#getFooter} method. */
+ protected
+ void writeFooter() {
+ if(layout != null) {
+ String f = layout.getFooter();
+ if(f != null && this.qw != null) {
+ this.qw.write(f);
+ this.qw.flush();
+ }
+ }
+ }
+
+ /**
+ Write a header as produced by the embedded layout's {@link
+ Layout#getHeader} method. */
+ protected
+ void writeHeader() {
+ if(layout != null) {
+ String h = layout.getHeader();
+ if(h != null && this.qw != null) {
+ this.qw.write(h);
+ }
+ }
+ }
+
+ /**
+ * Determines whether the writer should be flushed after
+ * this event is written.
+ *
+ * @since 1.2.16
+ */
+ protected boolean shouldFlush(final LoggingEvent event) {
+ return immediateFlush;
+ }
+}
git://source.jalview.org / jalview.git / blobdiff