/*
* Log.java
*
* Created on April 18, 2002, 5:24 PM
*/
package org.ninjasoft.util;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Level;
import java.io.PrintStream;
import java.io.ByteArrayOutputStream;
import org.apache.log4j.MDC;
/**
* Wrapper for log4j configuration and logging. Log4j will look for the
* file log4j.properties in your classpath.
*/
public class Log
{
/** Whether the log4j system has been properly initialize */
private static boolean initialized = false;
public static final String MDC_EXCEPTION = "exception";
/** Cannot instantiate */
private Log() {}
/** Initialize the log4j system */
private static void initialize()
{
try{
// This will search for the log4j configutation file
new PropertyConfigurator();
// Check that root logger has been configured, if not set a default config
Logger root = Logger.getRootLogger();
if (!root.getAllAppenders().hasMoreElements())
{
BasicConfigurator.configure();
root.setLevel(Level.INFO);
root.info("log4j.properties not found, using default configuration");
root.setLevel(Level.ERROR);
}
}catch(VerifyError e){
System.err.println();
System.err.println("log4j not installed or too old. Be sure log4j 1.2 or greater is installed.");
System.err.println("http://jakarta.apache.org/log4j/");
System.err.println();
throw e;
}
initialized = true;
}
/**
* Log a debug message
*@parm obj use this object's class name as the category name, or the literal name if a String object
*@param message message to log
*/
public static void debug(Object obj, String message)
{
log(obj, Level.DEBUG, message);
}
/**
* Log a debug message, with binary data
* @param obj use this object's class name as the category name, or the literal name if a String object
* @param message message to log
* @param data binary data to log
*/
public static void debug(Object obj, String message, byte[] data)
{
log(obj, Level.DEBUG, message + "\n" + encode(data));
}
/**
* Log an error message
*@parm obj use this object's class name as the category name, or the literal name if a String object
*@param message message to log
*/
public static void error(Object obj, String message)
{
log(obj, Level.ERROR, message);
}
/**
* Log an error message, with binary data
* @param obj use this object's class name as the category name, or the literal name if a String object
* @param message message to log
* @param data binary data to log
*/
public static void error(Object obj, String message, byte[] data)
{
log(obj, Level.ERROR, message + "\n" + encode(data));
}
/**
* Log an info message
*@parm obj use this object's class name as the category name, or the literal name if a String object
*@param message message to log
*/
public static void info(Object obj, String message)
{
log(obj, Level.INFO, message);
}
/**
* Log an info message, with binary data
* @param obj use this object's class name as the category name, or the literal name if a String object
* @param message message to log
* @param data binary data to log
*/
public static void info(Object obj, String message, byte[] data)
{
log(obj, Level.INFO, message + "\n" + encode(data));
}
/**
* Log a warning message
*@parm obj use this object's class name as the category name, or the literal name if a String object
*@param message message to log
*/
public static void warn(Object obj, String message)
{
log(obj, Level.WARN, message);
}
/**
* Log a warning message, with binary data
* @param obj use this object's class name as the category name, or the literal name if a String object
* @param message message to log
* @param data binary data to log
*/
public static void warn(Object obj, String message, byte[] data)
{
log(obj, Level.WARN, message + "\n" + encode(data));
}
/**
* Log a fatal message
*@parm obj use this object's class name as the category name, or the literal name if a String object
*@param message message to log
*/
public static void fatal(Object obj, String message)
{
log(obj, Level.FATAL, message);
}
/**
* Log a fatal message, with binary data
* @param obj use this object's class name as the category name, or the literal name if a String object
* @param message message to log
* @param data binary data to log
*/
public static void fatal(Object obj, String message, byte[] data)
{
log(obj, Level.FATAL, message + "\n" + encode(data));
}
/**
* Log a debug message, tied to a Throwable object
*@parm obj use this object's class name as the category name, or the literal name if a String object
*@param message message to log
*/
public static void debug(Object obj, String message, Throwable throwable)
{
log(obj, Level.DEBUG, message, throwable);
flagException (throwable );
}
/**
* Log an error message, tied to a Throwable object
*@parm obj use this object's class name as the category name, or the literal name if a String object
*@param message message to log
*/
public static void error(Object obj, String message, Throwable throwable)
{
log(obj, Level.ERROR, message, throwable);
flagException (throwable );
}
/**
* Log an info message, tied to a Throwable object
*@parm obj use this object's class name as the category name, or the literal name if a String object
*@param message message to log
*/
public static void info(Object obj, String message, Throwable throwable)
{
log(obj, Level.INFO, message, throwable);
flagException (throwable );
}
/**
* Log a warn message, tied to a Throwable object
*@parm obj use this object's class name as the category name, or the literal name if a String object
*@param message message to log
*/
public static void warn(Object obj, String message, Throwable throwable)
{
log(obj, Level.WARN, message, throwable);
flagException (throwable );
}
/**
* Log a fatal message, tied to a Throwable object
*@parm obj use this object's class name as the category name, or the literal name if a String object
*@param message message to log
*/
public static void fatal(Object obj, String message, Throwable throwable)
{
log(obj, Level.FATAL, message, throwable);
flagException (throwable );
}
/**
* Log a message in the log4j system
*@param obj use this object's class name as the category name, of the literal name if a String
*@param level log level to use
*@param message the message to log
*@param throwable the Throwable object to log with the message
*/
private static void log(Object obj, Level level, String message)
{
if (!initialized) initialize();
if (obj instanceof String)
Logger.getLogger((String)obj).log(level, message);
else
Logger.getLogger(obj.getClass()).log(level, message);
}
/**
* Log a message tied to a Throwable object in the log4j system
*@param obj use this object's class name as the category name, of the literal name if a String
*@param level log level to use
*@param message the message to log
*@param throwable the Throwable object to log with the message
*/
private static void log(Object obj, Level level, String message, Throwable throwable)
{
if (!initialized) initialize();
if (obj instanceof String)
Logger.getLogger((String)obj).log(level, message, throwable);
else
Logger.getLogger(obj.getClass()).log(level, message, throwable);
flagException (throwable );
}
public static void main(String[] argv)
{
Log.error(new java.util.Hashtable(), "Logger test1");
Log.error(new java.util.Hashtable(), "Logger test2", new RuntimeException("My Exception1"));
Log.error("com.certivo.test.of.logger", "Logger test3");
Log.error("com.certivo.test.of.logger", "Logger test4", new RuntimeException("My Exception2"));
Log.debug("com.certivo.debug", "Logger test5, this may be ignored");
}
/**
* returns true if debug is enabled for this object
*
* @returns true/false
*/
public static boolean isDebugEnabled(Object obj){
Logger theLogger = null;
if (obj instanceof String){
theLogger = Logger.getLogger((String)obj);
}
else{
theLogger = Logger.getLogger(obj.getClass());
}
return theLogger.isDebugEnabled();
}
public static void flagException ( Throwable t )
{
// add throwable to MDC context
if ( t != null )
{
MDC.put(MDC_EXCEPTION,t);
}
}
/**
* Perform a basic HTTP URL-Encoded encoding. This allows us to escape the binary
* characters, yet still be able to see any embedded ASCII characters.
* @param b the binary block to encode
* @return the encoded/escaped binary data as a string
*/
private static String encode(byte[] b) {
StringBuffer result = new StringBuffer();
int pos = 1;
boolean needsEncoding = false;
// First, check if it even NEEDS encoding. If it consists of
// strictly printable characters, we can just dump those
// verbatim (and this will increase readibility in the
// logs because the CRLF's are not going to be escaped).
for (int i=0; i<b.length; i++) {
int binaryCharacter = (int) b[i];
if (binaryCharacter < 0)
binaryCharacter += 255;
if (((binaryCharacter < 0x20) || (binaryCharacter > 0x7e))
&& (binaryCharacter != 0x0a) && (binaryCharacter != 0x0d)) {
needsEncoding = true;
break;
}
result.append((char) binaryCharacter);
}
if (!needsEncoding)
return "%TEXTBEGIN%\n" + result.toString() + "\n%TEXTEND%";
result = new StringBuffer();
// It looks like there are characters needing encoding. The encoding
// is done below...
for (int i=0; i<b.length; i++) {
int binaryCharacter = (int) b[i];
if (binaryCharacter < 0)
binaryCharacter += 256;
if ((binaryCharacter >= 0x20) && (binaryCharacter <= 0x7e) && (binaryCharacter != 0x25)) {
result.append((char) binaryCharacter);
pos++;
}else{
result.append("%");
String hex = Integer.toString(binaryCharacter, 16);
if (hex.length() == 1)
hex = "0" + hex;
result.append(hex);
pos += 3;
}
if (pos >= 80) {
result.append("\n");
pos = 1;
}
}
return "%BINARYBEGIN%\n" + result.toString() + "\n%BINARYEND%";
}
}
