/*
* Copyright 2010-2012 Ning, Inc.
*
* Ning 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.killbill.billing.dbi;
import java.io.IOException;
import java.io.OutputStream;
import org.slf4j.Logger;
/**
* Adapted from http://www.mail-archive.com/user@slf4j.org/msg00674.html for slf4j.
* <p/>
* An OutputStream that flushes out to a Category.<p>
* <p/>
* Note that no data is written out to the Category until the stream is
* flushed or closed.<p>
* <p/>
* Example:<pre>
* // make sure everything sent to System.err is logged
* System.setErr(new PrintStream(new
* LoggingOutputStream(Logger.getRootCategory(),
* Level.WARN), true));
* <p/>
* // make sure everything sent to System.out is also logged
* System.setOut(new PrintStream(new
* LoggingOutputStream(Logger.getRootCategory(),
* Level.INFO), true));
* </pre>
*
* @author <a href="[EMAIL PROTECTED]">Jim Moore</a>
* @see {{http://www.mail-archive.com/user@slf4j.org/msg00674.html}}
*/
public class LoggingOutputStream extends OutputStream {
/**
* Used to maintain the contract of [EMAIL PROTECTED] #close()}.
*/
private boolean hasBeenClosed = false;
/**
* The internal buffer where data is stored.
*/
private byte[] buf;
/**
* The number of valid bytes in the buffer. This value is always
* in the range <tt>0</tt> through <tt>buf.length</tt>; elements
* <tt>buf[0]</tt> through <tt>buf[count-1]</tt> contain valid
* byte data.
*/
private int count;
/**
* Remembers the size of the buffer for speed.
*/
private int bufLength;
/**
* The default number of bytes in the buffer. =2048
*/
public static final int DEFAULT_BUFFER_LENGTH = 2048;
/**
* The category to write to.
*/
private final Logger logger;
/**
* Creates the LoggingOutputStream to flush to the given Category.
*
* @param log the Logger to write to
* @throws IllegalArgumentException if log == null
*/
public LoggingOutputStream(final Logger log) throws IllegalArgumentException {
if (log == null) {
throw new IllegalArgumentException("log == null");
}
logger = log;
bufLength = DEFAULT_BUFFER_LENGTH;
buf = new byte[DEFAULT_BUFFER_LENGTH];
count = 0;
}
/**
* Closes this output stream and releases any system resources
* associated with this stream. The general contract of
* <code>close</code>
* is that it closes the output stream. A closed stream cannot
* perform
* output operations and cannot be reopened.
*/
public void close() {
flush();
hasBeenClosed = true;
}
/**
* Writes the specified byte to this output stream. The general
* contract for <code>write</code> is that one byte is written
* to the output stream. The byte to be written is the eight
* low-order bits of the argument <code>b</code>. The 24
* high-order bits of <code>b</code> are ignored.
*
* @param b the <code>byte</code> to write
* @throws java.io.IOException if an I/O error occurs. In particular, an
* <code>IOException</code> may be
* thrown if the output stream has been closed.
*/
public void write(final int b) throws IOException {
if (hasBeenClosed) {
throw new IOException("The stream has been closed.");
}
if (((char) b) == '\r' || ((char) b) == '\n') {
return;
}
// would this be writing past the buffer?
if (count == bufLength) {
// grow the buffer
final int newBufLength = bufLength + DEFAULT_BUFFER_LENGTH;
final byte[] newBuf = new byte[newBufLength];
System.arraycopy(buf, 0, newBuf, 0, bufLength);
buf = newBuf;
bufLength = newBufLength;
}
buf[count] = (byte) b;
count++;
}
/**
* Flushes this output stream and forces any buffered output bytes
* to be written out. The general contract of <code>flush</code> is
* that calling it is an indication that, if any bytes previously
* written have been buffered by the implementation of the output
* stream, such bytes should immediately be written to their
* intended destination.
*/
public void flush() {
if (count == 0) {
return;
}
// don't print out blank lines; flushing from PrintStream puts
// For linux system
if (count == 1 && ((char) buf[0]) == '\n') {
reset();
return;
}
// For mac system
if (count == 1 && ((char) buf[0]) == '\r') {
reset();
return;
}
// On windows system
if (count == 2 && (char) buf[0] == '\r' && (char) buf[1] == '\n') {
reset();
return;
}
final byte[] theBytes = new byte[count];
System.arraycopy(buf, 0, theBytes, 0, count);
logger.debug(new String(theBytes));
reset();
}
private void reset() {
// not resetting the buffer -- assuming that if it grew then it will likely grow similarly again
count = 0;
}
}