/* Copyright (C) 2003 Vladimir Roubtsov. All rights reserved.
*
* This program and the accompanying materials are made available under
* the terms of the Common Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/cpl-v10.html
*
* $Id: Logger.java,v 1.1.1.1.2.2 2004/07/16 23:32:29 vlad_r Exp $
*/
package com.vladium.logging;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.NoSuchElementException;
import java.util.Properties;
import java.util.Set;
import java.util.StringTokenizer;
import com.vladium.emma.AppLoggers;
import com.vladium.emma.IAppConstants;
import com.vladium.util.ClassLoaderResolver;
import com.vladium.util.Property;
import com.vladium.util.Strings;
// ----------------------------------------------------------------------------
/**
* A simple Java version-independent logging framework. Each Logger is also
* an immutable context that encapsulates configuration elements like the
* logging verbosity level etc. In general, a Logger is looked up as an
* inheritable thread-local piece of data. This decouples classes and
* logging configurations in a way that seems difficult with log4j.<P>
*
* Note that a given class is free to cache its context in an instance field
* if the class is instantiated and used only on a single thread (or a set of
* threads that are guaranteed to share the same logging context). [This is
* different from the usual log4j pattern of caching a logger in a class static
* field]. In other cases (e.g., the instrumentation runtime), it makes more
* sense to scope a context to a single method invocation.<P>
*
* Every log message is structured as follows:
* <OL>
* <LI> message is prefixed with the prefix string set in the Logger if that is
* not null;
* <LI> if the calling class could be identified and it supplied the calling
* method name, the calling method is identified with all name components that
* are not null;
* <LI> caller-supplied message is logged, if not null;
* <LI> caller-supplied Throwable is dumped starting with a new line, if not null.
* </OL>
*
* MT-safety: a given Logger instance will not get corrupted by concurrent
* usage from multiple threads and guarantees that data written to the underlying
* PrintWriter in a single log call will be done in one atomic print() step.
*
* @see ILogLevels
*
* @author (C) 2001, Vlad Roubtsov
*/
public
final class Logger implements ILogLevels
{
// public: ................................................................
// TODO: update javadoc for 'logCaller'
// TODO: need isLoggable (Class)
public static Logger create (final int level, final PrintWriter out, final String prefix, final Set classMask)
{
if ((level < NONE) || (level > ALL))
throw new IllegalArgumentException ("invalid log level: " + level);
if ((out == null) || out.checkError ())
throw new IllegalArgumentException ("null or corrupt input: out");
return new Logger (level, out, prefix, classMask);
}
/**
* This works as a cloning creator of sorts.
*
* @param level
* @param out
* @param prefix
* @param classMask
* @param base
* @return
*/
public static Logger create (final int level, final PrintWriter out, final String prefix, final Set classMask,
final Logger base)
{
if (base == null)
{
return create (level, out, prefix, classMask);
}
else
{
final int _level = level >= NONE
? level
: base.m_level;
final PrintWriter _out = (out != null) && ! out.checkError ()
? out
: base.m_out;
// TODO: do a better job of logger cloning
final String _prefix = prefix;
// final String _prefix = prefix != null
// ? prefix
// : base.m_prefix;
final Set _classMask = classMask != null
? classMask
: base.m_classMask;
return new Logger (_level, _out, _prefix, _classMask);
}
}
/**
* A quick method to determine if logging is enabled at a given level.
* This method acquires no monitors and should be used when calling one of
* log() or convenience logging methods directly incurs significant
* parameter construction overhead.
*
* @see ILogLevels
*/
public final boolean isLoggable (final int level)
{
return (level <= m_level);
}
/**
* A convenience method equivalent to isLoggable(INFO).
*/
public final boolean atINFO ()
{
return (INFO <= m_level);
}
/**
* A convenience method equivalent to isLoggable(VERBOSE).
*/
public final boolean atVERBOSE ()
{
return (VERBOSE <= m_level);
}
/**
* A convenience method equivalent to isLoggable(TRACE1).
*/
public final boolean atTRACE1 ()
{
return (TRACE1 <= m_level);
}
/**
* A convenience method equivalent to isLoggable(TRACE2).
*/
public final boolean atTRACE2 ()
{
return (TRACE2 <= m_level);
}
/**
* A convenience method equivalent to isLoggable(TRACE3).
*/
public final boolean atTRACE3 ()
{
return (TRACE3 <= m_level);
}
/**
* A convenience method to log 'msg' from an anonymous calling method
* at WARNING level.
*
* @param msg log message [ignored if null]
*/
public final void warning (final String msg)
{
_log (WARNING, null, msg, false);
}
/**
* A convenience method to log 'msg' from an anonymous calling method
* at INFO level.
*
* @param msg log message [ignored if null]
*/
public final void info (final String msg)
{
_log (INFO, null, msg, false);
}
/**
* A convenience method to log 'msg' from an anonymous calling method
* at VERBOSE level.
*
* @param msg log message [ignored if null]
*/
public final void verbose (final String msg)
{
_log (VERBOSE, null, msg, false);
}
/**
* A convenience method equivalent to log(TRACE1, method, msg).
*
* @param method calling method name [ignored if null]
* @param msg log message [ignored if null]
*/
public final void trace1 (final String method, final String msg)
{
_log (TRACE1, method, msg, true);
}
/**
* A convenience method equivalent to log(TRACE2, method, msg).
*
* @param method calling method name [ignored if null]
* @param msg log message [ignored if null]
*/
public final void trace2 (final String method, final String msg)
{
_log (TRACE2, method, msg, true);
}
/**
* A convenience method equivalent to log(TRACE3, method, msg).
*
* @param method calling method name [ignored if null]
* @param msg log message [ignored if null]
*/
public final void trace3 (final String method, final String msg)
{
_log (TRACE3, method, msg, true);
}
/**
* Logs 'msg' from an unnamed calling method.
*
* @param level level to log at [the method does nothing if this is less
* than the set level].
* @param msg log message [ignored if null]
*/
public final void log (final int level, final String msg, final boolean logCaller)
{
_log (level, null, msg, logCaller);
}
/**
* Logs 'msg' from a given calling method.
*
* @param level level to log at [the method does nothing if this is less
* than the set level].
* @param method calling method name [ignored if null]
* @param msg log message [ignored if null]
*/
public final void log (final int level, final String method, final String msg, final boolean logCaller)
{
_log (level, method, msg, logCaller);
}
/**
* Logs 'msg' from an unnamed calling method followed by the 'throwable' stack
* trace dump.
*
* @param level level to log at [the method does nothing if this is less
* than the set level].
* @param msg log message [ignored if null]
* @param throwable to dump after message [ignored if null]
*/
public final void log (final int level, final String msg, final Throwable throwable)
{
_log (level, null, msg, throwable);
}
/**
* Logs 'msg' from a given calling method followed by the 'throwable' stack
* trace dump.
*
* @param level level to log at [the method does nothing if this is less
* than the set level].
* @param method calling method name [ignored if null]
* @param msg log message [ignored if null]
* @param throwable to dump after message [ignored if null]
*/
public final void log (final int level, final String method, final String msg, final Throwable throwable)
{
_log (level, method, msg, throwable);
}
/**
* Provides direct access to the PrintWriter used by this Logger.
*
* @return print writer used by this logger [never null]
*/
public PrintWriter getWriter ()
{
return m_out;
}
/**
* Returns the current top of the thread-local logger stack or the static
* Logger instance scoped to Logger.class if the stack is empty.
*
* @return current logger [never null]
*/
public static Logger getLogger ()
{
final LinkedList stack = (LinkedList) THREAD_LOCAL_STACK.get ();
// [assertion: stack != null]
if (stack.isEmpty ())
{
return STATIC_LOGGER;
}
else
{
return (Logger) stack.getLast ();
}
}
/**
*
* @param ctx [may not be null]
*/
public static void push (final Logger ctx)
{
if (ctx == null)
throw new IllegalArgumentException ("null input: ctx");
final LinkedList stack = (LinkedList) THREAD_LOCAL_STACK.get ();
stack.addLast (ctx);
}
/**
* Requiring a context parameter here helps enforce correct push/pop
* nesting in the caller code.
*
* @param ctx [may not be null]
*/
public static void pop (final Logger ctx)
{
// TODO: add guards for making sure only the pushing thread is allowed to
// execute this
final LinkedList stack = (LinkedList) THREAD_LOCAL_STACK.get ();
try
{
final Logger current = (Logger) stack.getLast ();
if (current != ctx)
throw new IllegalStateException ("invalid context being popped: " + ctx);
stack.removeLast ();
current.cleanup ();
}
catch (NoSuchElementException nsee)
{
throw new IllegalStateException ("empty logger context stack on thread [" + Thread.currentThread () + "]: " + nsee);
}
}
public static int stringToLevel (final String level)
{
if (ILogLevels.SEVERE_STRING.equalsIgnoreCase (level) || ILogLevels.SILENT_STRING.equalsIgnoreCase (level))
return ILogLevels.SEVERE;
else if (ILogLevels.WARNING_STRING.equalsIgnoreCase (level) || ILogLevels.QUIET_STRING.equalsIgnoreCase (level))
return ILogLevels.WARNING;
else if (ILogLevels.INFO_STRING.equalsIgnoreCase (level))
return ILogLevels.INFO;
else if (ILogLevels.VERBOSE_STRING.equalsIgnoreCase (level))
return ILogLevels.VERBOSE;
else if (ILogLevels.TRACE1_STRING.equalsIgnoreCase (level))
return ILogLevels.TRACE1;
else if (ILogLevels.TRACE2_STRING.equalsIgnoreCase (level))
return ILogLevels.TRACE2;
else if (ILogLevels.TRACE3_STRING.equalsIgnoreCase (level))
return ILogLevels.TRACE3;
else if (ILogLevels.NONE_STRING.equalsIgnoreCase (level))
return ILogLevels.NONE;
else if (ILogLevels.ALL_STRING.equalsIgnoreCase (level))
return ILogLevels.ALL;
else
{
int _level = Integer.MIN_VALUE;
try
{
_level = Integer.parseInt (level);
}
catch (Exception ignore) {}
if ((_level >= ILogLevels.NONE) && (_level <= ILogLevels.ALL))
return _level;
else
return ILogLevels.INFO; // default to something middle of the ground
}
}
// protected: .............................................................
// package: ...............................................................
// private: ...............................................................
private static final class ThreadLocalStack extends InheritableThreadLocal
{
protected Object initialValue ()
{
return new LinkedList ();
}
} // end of nested class
private Logger (final int level, final PrintWriter out, final String prefix, final Set classMask)
{
m_level = level;
m_out = out;
m_prefix = prefix;
m_classMask = classMask; // no defensive clone
}
private void cleanup ()
{
m_out.flush ();
}
private void _log (final int level, final String method,
final String msg, final boolean logCaller)
{
if ((level <= m_level) && (level >= SEVERE))
{
final Class caller = logCaller ? ClassLoaderResolver.getCallerClass (2) : null;
final StringBuffer buf = new StringBuffer (m_prefix != null ? m_prefix + ": " : "");
if ((caller != null) || (method != null))
{
buf.append ("[");
if (caller != null) // if the caller could not be determined, s_classMask is ignored
{
String callerName = caller.getName ();
if (callerName.startsWith (PREFIX_TO_STRIP))
callerName = callerName.substring (PREFIX_TO_STRIP_LENGTH);
String parentName = callerName;
final int firstDollar = callerName.indexOf ('$');
if (firstDollar > 0) parentName = callerName.substring (0, firstDollar);
if ((m_classMask == null) || m_classMask.contains (parentName))
buf.append (callerName);
else
return;
}
if (method != null)
{
buf.append ("::");
buf.append (method);
}
buf.append ("] ");
}
final PrintWriter out = m_out;
if (msg != null) buf.append (msg);
out.println (buf);
if (FLUSH_LOG) out.flush ();
}
}
private void _log (final int level, final String method,
final String msg, final Throwable throwable)
{
if ((level <= m_level) && (level >= SEVERE))
{
final Class caller = ClassLoaderResolver.getCallerClass (2);
final StringBuffer buf = new StringBuffer (m_prefix != null ? m_prefix + ": " : "");
if ((caller != null) || (method != null))
{
buf.append ("[");
if (caller != null) // if the caller could not be determined, s_classMask is ignored
{
String callerName = caller.getName ();
if (callerName.startsWith (PREFIX_TO_STRIP))
callerName = callerName.substring (PREFIX_TO_STRIP_LENGTH);
String parentName = callerName;
final int firstDollar = callerName.indexOf ('$');
if (firstDollar > 0) parentName = callerName.substring (0, firstDollar);
if ((m_classMask == null) || m_classMask.contains (parentName))
buf.append (callerName);
else
return;
}
if (method != null)
{
buf.append ("::");
buf.append (method);
}
buf.append ("] ");
}
final PrintWriter out = m_out;
if (msg != null) buf.append (msg);
if (throwable != null)
{
final StringWriter sw = new StringWriter ();
final PrintWriter pw = new PrintWriter (sw);
throwable.printStackTrace (pw);
pw.flush ();
buf.append (sw.toString ());
}
out.println (buf);
if (FLUSH_LOG) out.flush ();
}
}
private final int m_level; // always in [NONE, ALL] range
private final PrintWriter m_out; // never null
private final String m_prefix; // null is equivalent to no prefix
private final Set /* String */ m_classMask; // null is equivalent to no class filtering
private static final String PREFIX_TO_STRIP = "com.vladium."; // TODO: can this be set programmatically ?
private static final int PREFIX_TO_STRIP_LENGTH = PREFIX_TO_STRIP.length ();
private static final boolean FLUSH_LOG = true;
private static final String COMMA_DELIMITERS = "," + Strings.WHITE_SPACE;
private static final Logger STATIC_LOGGER; // set in <clinit>
private static final ThreadLocalStack THREAD_LOCAL_STACK; // set in <clinit>
static
{
THREAD_LOCAL_STACK = new ThreadLocalStack ();
// TODO: unfortunately, this init code makes Logger coupled to the app classes
// (via the app namespace string constants)
// I don't quite see an elegant solution to this design problem yet
final Properties properties = Property.getAppProperties (IAppConstants.APP_NAME_LC, Logger.class.getClassLoader ());
// verbosity level:
final int level;
{
final String _level = properties.getProperty (AppLoggers.PROPERTY_VERBOSITY_LEVEL,
AppLoggers.DEFAULT_VERBOSITY_LEVEL);
level = stringToLevel (_level);
}
// verbosity filter:
final Set filter;
{
final String _filter = properties.getProperty (AppLoggers.PROPERTY_VERBOSITY_FILTER);
Set temp = null;
if (_filter != null)
{
final StringTokenizer tokenizer = new StringTokenizer (_filter, COMMA_DELIMITERS);
if (tokenizer.countTokens () > 0)
{
temp = new HashSet (tokenizer.countTokens ());
while (tokenizer.hasMoreTokens ())
{
temp.add (tokenizer.nextToken ());
}
}
}
filter = temp;
}
STATIC_LOGGER = create (level,
new PrintWriter (System.out, false),
IAppConstants.APP_NAME,
filter);
}
} // end of class
// ---------------------------------------------------------------------------- |
