diff options
author | Jeremias Maerki <jeremias@apache.org> | 2004-09-11 18:56:20 +0000 |
---|---|---|
committer | Jeremias Maerki <jeremias@apache.org> | 2004-09-11 18:56:20 +0000 |
commit | f7d5393a79bc58683b3d63632bd235932b37d9d6 (patch) | |
tree | d4d1ddee2166cc6e6af85c64dad2a8e501a77030 /src/java/org/apache/fop/util | |
parent | 0aeb23b781bf11edf472d585f9eb40c317fb8801 (diff) | |
download | xmlgraphics-fop-f7d5393a79bc58683b3d63632bd235932b37d9d6.tar.gz xmlgraphics-fop-f7d5393a79bc58683b3d63632bd235932b37d9d6.zip |
Bugzilla patch 31162:
Better command-line logging without losing the possibility to fine-tune Commons Logging from outside.
Submitted by: Finn Bock <bckfnn.at.apache.org>
plus using the new CommandLineLogger for PFMReader and TTFReader, too.
git-svn-id: https://svn.apache.org/repos/asf/xmlgraphics/fop/trunk@197940 13f79535-47bb-0310-9956-ffa450edef68
Diffstat (limited to 'src/java/org/apache/fop/util')
-rw-r--r-- | src/java/org/apache/fop/util/CommandLineLogger.java | 261 |
1 files changed, 261 insertions, 0 deletions
diff --git a/src/java/org/apache/fop/util/CommandLineLogger.java b/src/java/org/apache/fop/util/CommandLineLogger.java new file mode 100644 index 000000000..20ba4e9f1 --- /dev/null +++ b/src/java/org/apache/fop/util/CommandLineLogger.java @@ -0,0 +1,261 @@ +/* Copyright 2004 The Apache Software Foundation. + * + * Licensed 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. + */ + +/* $Id$ */ + +package org.apache.fop.util; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +/** + * This is a commons-logging logger for command line use. + */ +public class CommandLineLogger implements Log { + /** "Trace" level logging. */ + public static final int LOG_LEVEL_TRACE = 1; + /** "Debug" level logging. */ + public static final int LOG_LEVEL_DEBUG = 2; + /** "Info" level logging. */ + public static final int LOG_LEVEL_INFO = 3; + /** "Warn" level logging. */ + public static final int LOG_LEVEL_WARN = 4; + /** "Error" level logging. */ + public static final int LOG_LEVEL_ERROR = 5; + /** "Fatal" level logging. */ + public static final int LOG_LEVEL_FATAL = 6; + + private int logLevel; + private String logName; + + /** + * Construct the logger with a default log level taken from the LogFactory + * attribute "level". + * @param logName the logger name. + */ + public CommandLineLogger(String logName) { + this.logName = logName; + setLogLevel((String) LogFactory.getFactory().getAttribute("level")); + } + + /** + * Set a log level for the logger. + * @param level the log level + */ + public void setLogLevel(String level) { + if ("fatal".equals(level)) { + logLevel = LOG_LEVEL_FATAL; + } else if ("error".equals(level)) { + logLevel = LOG_LEVEL_ERROR; + } else if ("warn".equals(level)) { + logLevel = LOG_LEVEL_WARN; + } else if ("info".equals(level)) { + logLevel = LOG_LEVEL_INFO; + } else if ("debug".equals(level)) { + logLevel = LOG_LEVEL_DEBUG; + } else if ("trace".equals(level)) { + logLevel = LOG_LEVEL_TRACE; + } else { + logLevel = LOG_LEVEL_INFO; + } + } + + /** + * @see org.apache.commons.logging.Log#isTraceEnabled() + */ + public final boolean isTraceEnabled() { + return logLevel <= LOG_LEVEL_TRACE; + } + + /** + * @see org.apache.commons.logging.Log#isDebugEnabled() + */ + public final boolean isDebugEnabled() { + return logLevel <= LOG_LEVEL_DEBUG; + } + + /** + * @see org.apache.commons.logging.Log#isInfoEnabled() + */ + public final boolean isInfoEnabled() { + return logLevel <= LOG_LEVEL_INFO; + } + + /** + * @see org.apache.commons.logging.Log#isWarnEnabled() + */ + public final boolean isWarnEnabled() { + return logLevel <= LOG_LEVEL_WARN; + } + + /** + * @see org.apache.commons.logging.Log#isErrorEnabled() + */ + public final boolean isErrorEnabled() { + return logLevel <= LOG_LEVEL_ERROR; + } + + /** + * @see org.apache.commons.logging.Log#isFatalEnabled() + */ + public final boolean isFatalEnabled() { + return logLevel <= LOG_LEVEL_FATAL; + } + + /** + * @see org.apache.commons.logging.Log#trace(java.lang.Object) + */ + public final void trace(Object message) { + if (isTraceEnabled()) { + log(LOG_LEVEL_TRACE, message, null); + } + } + + /** + * @see org.apache.commons.logging.Log#trace(java.lang.Object, java.lang.Throwable) + */ + public final void trace(Object message, Throwable t) { + if (isTraceEnabled()) { + log(LOG_LEVEL_TRACE, message, t); + } + } + + /** + * @see org.apache.commons.logging.Log#debug(java.lang.Object) + */ + public final void debug(Object message) { + if (isDebugEnabled()) { + log(LOG_LEVEL_DEBUG, message, null); + } + } + + /** + * @see org.apache.commons.logging.Log#debug(java.lang.Object, java.lang.Throwable) + */ + public final void debug(Object message, Throwable t) { + if (isDebugEnabled()) { + log(LOG_LEVEL_DEBUG, message, t); + } + } + + /** + * @see org.apache.commons.logging.Log#info(java.lang.Object) + */ + public final void info(Object message) { + if (isInfoEnabled()) { + log(LOG_LEVEL_INFO, message, null); + } + } + + /** + * @see org.apache.commons.logging.Log#info(java.lang.Object, java.lang.Throwable) + */ + public final void info(Object message, Throwable t) { + if (isInfoEnabled()) { + log(LOG_LEVEL_INFO, message, t); + } + } + + /** + * @see org.apache.commons.logging.Log#warn(java.lang.Object) + */ + public final void warn(Object message) { + if (isWarnEnabled()) { + log(LOG_LEVEL_WARN, message, null); + } + } + + /** + * @see org.apache.commons.logging.Log#warn(java.lang.Object, java.lang.Throwable) + */ + public final void warn(Object message, Throwable t) { + if (isWarnEnabled()) { + log(LOG_LEVEL_WARN, message, t); + } + } + + /** + * @see org.apache.commons.logging.Log#error(java.lang.Object) + */ + public final void error(Object message) { + if (isErrorEnabled()) { + log(LOG_LEVEL_ERROR, message, null); + } + } + + /** + * @see org.apache.commons.logging.Log#error(java.lang.Object, java.lang.Throwable) + */ + public final void error(Object message, Throwable t) { + if (isErrorEnabled()) { + log(LOG_LEVEL_ERROR, message, t); + } + } + + /** + * @see org.apache.commons.logging.Log#fatal(java.lang.Object) + */ + public final void fatal(Object message) { + if (isFatalEnabled()) { + log(LOG_LEVEL_FATAL, message, null); + } + } + + /** + * @see org.apache.commons.logging.Log#fatal(java.lang.Object, java.lang.Throwable) + */ + public final void fatal(Object message, Throwable t) { + if (isFatalEnabled()) { + log(LOG_LEVEL_FATAL, message, t); + } + } + + /** + * Do the actual logging. + * This method assembles the message and prints it to + * and then calls <code>write()</code> to cause it to be written.</p> + * + * @param type One of the LOG_LEVEL_XXX constants defining the log level + * @param message The message itself (typically a String) + * @param t The exception whose stack trace should be logged + */ + protected void log(int type, Object message, Throwable t) { + StringBuffer buf = new StringBuffer(); + // Append the message + buf.append(String.valueOf(message)); + if (t != null) { + buf.append("\n"); + // Append a stack trace or just the stack trace message. + if (!isDebugEnabled()) { + buf.append(t.toString()); + buf.append("\n"); + } else { + java.io.StringWriter sw = new java.io.StringWriter(1024); + java.io.PrintWriter pw = new java.io.PrintWriter(sw); + t.printStackTrace(pw); + pw.close(); + buf.append(sw.toString()); + } + } + + // Print to the appropriate destination + if (type >= LOG_LEVEL_WARN) { + System.err.println(buf); + } else { + System.out.println(buf); + } + + } +} |