diff --git a/build.xml b/build.xml index a0dc252..21ea0ff 100644 --- a/build.xml +++ b/build.xml @@ -3,7 +3,7 @@ @@ -227,6 +227,8 @@ deprecation="${compile.deprecation}" optimize="${compile.optimize}"> + . + * + */ + + +package org.apache.commons.logging.impl; + + +import java.io.Serializable; +import java.util.logging.Level; +import java.util.logging.Logger; +import java.util.logging.LogRecord; +import java.util.StringTokenizer; +import java.io.PrintWriter; +import java.io.StringWriter; + +import org.apache.commons.logging.Log; + + +/** + *

Implementation of the org.apache.commons.logging.Log + * interfaces that wraps the standard JDK logging mechanisms that are + * available in SourceForge's Lumberjack for JDKs prior to 1.4.

+ * + * @author Scott Sanders + * @author Berin Loritsch + * @author Peter Donald + * @author Vince Eagen + * @version $Revision: 1.1 $ $Date: 2003/08/16 22:35:16 $ + */ + +public final class Jdk13LumberjackLogger implements Log, Serializable { + + + // ----------------------------------------------------- Instance Variables + + + /** + * The underlying Logger implementation we are using. + */ + protected transient Logger logger = null; + protected String name = null; + private String sourceClassName = "unknown"; + private String sourceMethodName = "unknown"; + private boolean classAndMethodFound = false; + + + // ----------------------------------------------------------- Constructors + + + /** + * Construct a named instance of this Logger. + * + * @param name Name of the logger to be constructed + */ + public Jdk13LumberjackLogger(String name) { + + this.name = name; + logger = getLogger(); + + } + + + // --------------------------------------------------------- Public Methods + + + private void log( Level level, String msg, Throwable ex ) { + if( getLogger().isLoggable(level) ) { + LogRecord record = new LogRecord(level, msg); + if( !classAndMethodFound ) { + getClassAndMethod(); + } + record.setSourceClassName(sourceClassName); + record.setSourceMethodName(sourceMethodName); + if( ex != null ) { + record.setThrown(ex); + } + getLogger().log(record); + } + } + + /** + *

Gets the class and method by looking at the stack trace for the + * first entry that is not this class.

+ */ + private void getClassAndMethod() { + try { + Throwable throwable = new Throwable(); + throwable.fillInStackTrace(); + StringWriter stringWriter = new StringWriter(); + PrintWriter printWriter = new PrintWriter( stringWriter ); + throwable.printStackTrace( printWriter ); + String traceString = stringWriter.getBuffer().toString(); + StringTokenizer tokenizer = + new StringTokenizer( traceString, "\n" ); + tokenizer.nextToken(); + String line = tokenizer.nextToken(); + while ( line.indexOf( this.getClass().getName() ) == -1 ) { + line = tokenizer.nextToken(); + } + while ( line.indexOf( this.getClass().getName() ) >= 0 ) { + line = tokenizer.nextToken(); + } + int start = line.indexOf( "at " ) + 3; + int end = line.indexOf( '(' ); + String temp = line.substring( start, end ); + int lastPeriod = temp.lastIndexOf( '.' ); + sourceClassName = temp.substring( 0, lastPeriod ); + sourceMethodName = temp.substring( lastPeriod + 1 ); + } catch ( Exception ex ) { + // ignore - leave class and methodname unknown + } + classAndMethodFound = true; + } + + /** + * Log a message with debug log level. + */ + public void debug(Object message) { + log(Level.FINE, String.valueOf(message), null); + } + + + /** + * Log a message and exception with debug log level. + */ + public void debug(Object message, Throwable exception) { + log(Level.FINE, String.valueOf(message), exception); + } + + + /** + * Log a message with error log level. + */ + public void error(Object message) { + log(Level.SEVERE, String.valueOf(message), null); + } + + + /** + * Log a message and exception with error log level. + */ + public void error(Object message, Throwable exception) { + log(Level.SEVERE, String.valueOf(message), exception); + } + + + /** + * Log a message with fatal log level. + */ + public void fatal(Object message) { + log(Level.SEVERE, String.valueOf(message), null); + } + + + /** + * Log a message and exception with fatal log level. + */ + public void fatal(Object message, Throwable exception) { + log(Level.SEVERE, String.valueOf(message), exception); + } + + + /** + * Return the native Logger instance we are using. + */ + public Logger getLogger() { + if (logger == null) { + logger = Logger.getLogger(name); + } + return (logger); + } + + + /** + * Log a message with info log level. + */ + public void info(Object message) { + log(Level.INFO, String.valueOf(message), null); + } + + + /** + * Log a message and exception with info log level. + */ + public void info(Object message, Throwable exception) { + log(Level.INFO, String.valueOf(message), exception); + } + + + /** + * Is debug logging currently enabled? + */ + public boolean isDebugEnabled() { + return (getLogger().isLoggable(Level.FINE)); + } + + + /** + * Is error logging currently enabled? + */ + public boolean isErrorEnabled() { + return (getLogger().isLoggable(Level.SEVERE)); + } + + + /** + * Is fatal logging currently enabled? + */ + public boolean isFatalEnabled() { + return (getLogger().isLoggable(Level.SEVERE)); + } + + + /** + * Is info logging currently enabled? + */ + public boolean isInfoEnabled() { + return (getLogger().isLoggable(Level.INFO)); + } + + + /** + * Is tace logging currently enabled? + */ + public boolean isTraceEnabled() { + return (getLogger().isLoggable(Level.FINEST)); + } + + + /** + * Is warning logging currently enabled? + */ + public boolean isWarnEnabled() { + return (getLogger().isLoggable(Level.WARNING)); + } + + + /** + * Log a message with trace log level. + */ + public void trace(Object message) { + log(Level.FINEST, String.valueOf(message), null); + } + + + /** + * Log a message and exception with trace log level. + */ + public void trace(Object message, Throwable exception) { + log(Level.FINEST, String.valueOf(message), exception); + } + + + /** + * Log a message with warn log level. + */ + public void warn(Object message) { + log(Level.WARNING, String.valueOf(message), null); + } + + + /** + * Log a message and exception with warn log level. + */ + public void warn(Object message, Throwable exception) { + log(Level.WARNING, String.valueOf(message), exception); + } + + +} diff --git a/src/java/org/apache/commons/logging/impl/LogFactoryImpl.java b/src/java/org/apache/commons/logging/impl/LogFactoryImpl.java index c5e3a88..1fac4a8 100644 --- a/src/java/org/apache/commons/logging/impl/LogFactoryImpl.java +++ b/src/java/org/apache/commons/logging/impl/LogFactoryImpl.java @@ -1,7 +1,7 @@ /* - * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//logging/src/java/org/apache/commons/logging/impl/LogFactoryImpl.java,v 1.25 2003/04/02 01:53:04 craigmcc Exp $ - * $Revision: 1.25 $ - * $Date: 2003/04/02 01:53:04 $ + * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//logging/src/java/org/apache/commons/logging/impl/LogFactoryImpl.java,v 1.26 2003/08/16 22:35:16 craigmcc Exp $ + * $Revision: 1.26 $ + * $Date: 2003/08/16 22:35:16 $ * * ==================================================================== * @@ -107,7 +107,7 @@ import org.apache.commons.logging.LogFactory; * @author Rod Waldhoff * @author Craig R. McClanahan * @author Richard A. Sitze - * @version $Revision: 1.25 $ $Date: 2003/04/02 01:53:04 $ + * @version $Revision: 1.26 $ $Date: 2003/08/16 22:35:16 $ */ public class LogFactoryImpl extends LogFactory { @@ -369,6 +369,10 @@ public class LogFactoryImpl extends LogFactory { logClassName = "org.apache.commons.logging.impl.Jdk14Logger"; } + if ((logClassName == null) && isJdk13LumberjackAvailable()) { + logClassName = "org.apache.commons.logging.impl.Jdk13LumberjackLogger"; + } + if (logClassName == null) { logClassName = "org.apache.commons.logging.impl.SimpleLog"; } @@ -478,13 +482,35 @@ public class LogFactoryImpl extends LogFactory { /** - * Is JDK 1.4 or later logging available? + * Is JDK 1.3 with Lumberjack logging available? + */ + protected boolean isJdk13LumberjackAvailable() { + + try { + loadClass("java.util.logging.Logger"); + loadClass("org.apache.commons.logging.impl.Jdk13LumberjackLogger"); + return (true); + } catch (Throwable t) { + return (false); + } + + } + + + /** + * Is JDK 1.4 or later logging available? Also checks that + * the Throwable class supports getStackTrace(), which is + * required by Jdk14Logger. */ protected boolean isJdk14Available() { try { loadClass("java.util.logging.Logger"); loadClass("org.apache.commons.logging.impl.Jdk14Logger"); + Class throwable = loadClass("java.lang.Throwable"); + if (throwable.getDeclaredMethod("getStackTrace", null) == null) { + return (false); + } return (true); } catch (Throwable t) { return (false);