/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF 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.apache.uima.util.impl;
import java.io.OutputStream;
import java.io.PrintStream;
import java.text.MessageFormat;
import org.apache.uima.internal.util.I18nUtil;
import org.apache.uima.resource.ResourceManager;
import org.apache.uima.util.Level;
import org.apache.uima.util.Logger;
/**
* UIMA Logging interface implementation for Log4j
*/
public class Log4jLogger_impl implements Logger {
private static final String EXCEPTION_MESSAGE = "Exception occurred";
/**
* logger object from the underlying Log4j logging framework
*/
private org.apache.log4j.Logger logger = null;
/**
* ResourceManager whose extension ClassLoader will be used to locate the
* message digests. Null will cause the ClassLoader to default to
* this.class.getClassLoader().
*/
private ResourceManager mResourceManager = null;
/**
* create a new LogWrapper class for the specified source class
*
* @param component
* specified source class
*/
private Log4jLogger_impl(Class<?> component) {
super();
if (component != null) {
logger = org.apache.log4j.Logger.getLogger(component);
} else {
logger = org.apache.log4j.Logger.getLogger("org.apache.uima");
}
}
/**
* create a new LogWrapper object with the default logger from the Log4j
* logging framework
*/
private Log4jLogger_impl() {
this(null);
}
/**
* Creates a new Log4jLogger instance for the specified source class
*
* @param component
* current source class
* @return Logger returns the JSR47Logger object for the specified class
*/
public static synchronized Logger getInstance(Class<?> component) {
return new Log4jLogger_impl(component);
}
/**
* Creates a new Log4jLogger instance with the default Log4j framework logger
*
* @return Logger returns the JSR47Logger object with the default Log4j
* framework logger
*/
public static synchronized Logger getInstance() {
return new Log4jLogger_impl();
}
/**
* Logs a message with level INFO.
*
* @deprecated use new function with log level
* @param aMessage
* the message to be logged
*/
@Deprecated
public void log(String aMessage) {
if (isLoggable(Level.INFO)) {
if (aMessage == null || aMessage.equals(""))
return;
String[] sourceInfo = getStackTraceInfo(new Throwable());
org.apache.log4j.Logger.getLogger(sourceInfo[0]).info(aMessage);
}
}
/**
* Logs a message with a message key and the level INFO
*
* @deprecated use new function with log level
* @see org.apache.uima.util.Logger#log(java.lang.String, java.lang.String,
* java.lang.Object[])
*/
@Deprecated
public void log(String aResourceBundleName, String aMessageKey,
Object[] aArguments) {
if (isLoggable(Level.INFO)) {
if (aMessageKey == null || aMessageKey.equals(""))
return;
String[] sourceInfo = getStackTraceInfo(new Throwable());
org.apache.log4j.Logger.getLogger(sourceInfo[0]).info(
I18nUtil.localizeMessage(aResourceBundleName, aMessageKey,
aArguments, getExtensionClassLoader()));
}
}
/**
* Logs an exception with level INFO
*
* @deprecated use new function with log level
* @param aException
* the exception to be logged
*/
@Deprecated
public void logException(Exception aException) {
if (isLoggable(Level.INFO)) {
if (aException == null)
return;
String[] sourceInfo = getStackTraceInfo(new Throwable());
// log exception
org.apache.log4j.Logger.getLogger(sourceInfo[0]).info(
EXCEPTION_MESSAGE, aException);
}
}
/**
* @see org.apache.uima.util.Logger#setOutputStream(java.io.OutputStream)
* @deprecated use external configuration possibility
*/
@Deprecated
public void setOutputStream(OutputStream out) {
throw new UnsupportedOperationException(
"Method setOutputStream(OutputStream out) not supported");
}
/**
* @see org.apache.uima.util.Logger#setOutputStream(java.io.PrintStream)
* @deprecated use external configuration possibility
*/
@Deprecated
public void setOutputStream(PrintStream out) {
throw new UnsupportedOperationException(
"Method setOutputStream(PrintStream out) not supported");
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.util.Logger#isLoggable(org.apache.uima.util.Level)
*/
public boolean isLoggable(Level level) {
org.apache.log4j.Level log4jLevel = getLog4jLevel(level);
return logger.isEnabledFor(log4jLevel);
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.util.Logger#setLevel(org.apache.uima.util.Level)
*/
public void setLevel(Level level) {
// get corresponding Log4j level
org.apache.log4j.Level log4jLevel = getLog4jLevel(level);
logger.setLevel(log4jLevel);
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.util.Logger#log(org.apache.uima.util.Level,
* java.lang.String)
*/
public void log(Level level, String aMessage) {
if (isLoggable(level)) {
if (aMessage == null || aMessage.equals(""))
return;
org.apache.log4j.Level log4jLevel = getLog4jLevel(level);
logger.log(log4jLevel, aMessage);
}
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.util.Logger#log(org.apache.uima.util.Level,
* java.lang.String, java.lang.Object)
*/
public void log(Level level, String aMessage, Object param1) {
if (isLoggable(level)) {
if (aMessage == null || aMessage.equals(""))
return;
org.apache.log4j.Level log4jLevel = getLog4jLevel(level);
logger.log(log4jLevel, MessageFormat.format(aMessage,
new Object[] { param1 }));
}
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.util.Logger#log(org.apache.uima.util.Level,
* java.lang.String, java.lang.Object[])
*/
public void log(Level level, String aMessage, Object[] params) {
if (isLoggable(level)) {
if (aMessage == null || aMessage.equals(""))
return;
// get corresponding Log4j level
org.apache.log4j.Level log4jLevel = getLog4jLevel(level);
logger.log(log4jLevel, MessageFormat.format(aMessage, params));
}
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.util.Logger#log(org.apache.uima.util.Level,
* java.lang.String, java.lang.Throwable)
*/
public void log(Level level, String aMessage, Throwable thrown) {
if (isLoggable(level)) {
org.apache.log4j.Level log4jLevel = getLog4jLevel(level);
if (aMessage != null && !aMessage.equals("")) {
// get corresponding Log4j level
logger.log(log4jLevel, aMessage, thrown);
}
if (thrown != null && (aMessage == null || aMessage.equals(""))) {
// get corresponding Log4j level
// log exception
logger.log(log4jLevel, EXCEPTION_MESSAGE, thrown);
}
}
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.util.Logger#logrb(org.apache.uima.util.Level,
* java.lang.String, java.lang.String, java.lang.String,
* java.lang.String, java.lang.Object)
*/
public void logrb(Level level, String sourceClass, String sourceMethod,
String bundleName, String msgKey, Object param1) {
if (isLoggable(level)) {
if (msgKey == null || msgKey.equals(""))
return;
if (sourceClass == null) {
sourceClass = "";
}
// get corresponding Log4j level
org.apache.log4j.Level log4jLevel = getLog4jLevel(level);
logger.log(log4jLevel, I18nUtil.localizeMessage(bundleName, msgKey,
new Object[] { param1 }, getExtensionClassLoader()));
}
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.util.Logger#logrb(org.apache.uima.util.Level,
* java.lang.String, java.lang.String, java.lang.String,
* java.lang.String, java.lang.Object[])
*/
public void logrb(Level level, String sourceClass, String sourceMethod,
String bundleName, String msgKey, Object[] params) {
if (isLoggable(level)) {
if (msgKey == null || msgKey.equals(""))
return;
if (sourceClass == null) {
sourceClass = "";
}
// get corresponding Log4j level
org.apache.log4j.Level log4jLevel = getLog4jLevel(level);
logger.log(log4jLevel, I18nUtil.localizeMessage(bundleName, msgKey,
params, getExtensionClassLoader()));
}
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.util.Logger#logrb(org.apache.uima.util.Level,
* java.lang.String, java.lang.String, java.lang.String,
* java.lang.String, java.lang.Throwable)
*/
public void logrb(Level level, String sourceClass, String sourceMethod,
String bundleName, String msgKey, Throwable thrown) {
if (isLoggable(level)) {
org.apache.log4j.Level log4jLevel = getLog4jLevel(level);
if (sourceClass == null) {
sourceClass = "";
}
if (msgKey != null && !msgKey.equals("")) {
// get corresponding Log4j level
org.apache.log4j.Logger.getLogger(sourceClass).log(
log4jLevel,
I18nUtil.localizeMessage(bundleName, msgKey, null,
getExtensionClassLoader()), thrown);
}
if (thrown != null && (msgKey == null || msgKey.equals(""))) {
// log exception
org.apache.log4j.Logger.getLogger(sourceClass).log(log4jLevel,
EXCEPTION_MESSAGE, thrown);
}
}
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.util.Logger#logrb(org.apache.uima.util.Level,
* java.lang.String, java.lang.String, java.lang.String,
* java.lang.String)
*/
public void logrb(Level level, String sourceClass, String sourceMethod,
String bundleName, String msgKey) {
if (isLoggable(level)) {
if (msgKey == null || msgKey.equals(""))
return;
if (sourceClass == null) {
sourceClass = "";
}
// get corresponding Log4j level
org.apache.log4j.Level log4jLevel = getLog4jLevel(level);
org.apache.log4j.Logger.getLogger(sourceClass).log(
log4jLevel,
I18nUtil.localizeMessage(bundleName, msgKey, null,
getExtensionClassLoader()));
// logger.log(log4jLevel, sourceClass + sourceMethod +
// I18nUtil.localizeMessage(bundleName, msgKey, null,
// getExtensionClassLoader()));
}
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.util.Logger#setResourceManager(org.apache.uima.resource.ResourceManager)
*/
public void setResourceManager(ResourceManager resourceManager) {
mResourceManager = resourceManager;
}
/**
* Gets the extension ClassLoader to used to locate the message digests. If
* this returns null, then message digests will be searched for using
* this.class.getClassLoader().
*/
private ClassLoader getExtensionClassLoader() {
if (mResourceManager == null)
return null;
else
return mResourceManager.getExtensionClassLoader();
}
/**
* log4j level mapping to UIMA level mapping. SEVERE (highest value) ->
* SEVERE WARNING -> WARNING INFO -> INFO CONFIG -> CONFIG FINE -> FINE FINER ->
* FINER FINEST (lowest value) -> FINEST OFF -> OFF ALL -> ALL
*
* @param level
* uima level
* @return Level - corresponding JSR47 level
*/
private org.apache.log4j.Level getLog4jLevel(Level level) {
switch (level.toInteger()) {
case org.apache.uima.util.Level.OFF_INT:
return org.apache.log4j.Level.OFF;
case org.apache.uima.util.Level.SEVERE_INT:
return org.apache.log4j.Level.ERROR;
case org.apache.uima.util.Level.WARNING_INT:
return org.apache.log4j.Level.WARN;
case org.apache.uima.util.Level.INFO_INT:
return org.apache.log4j.Level.INFO;
case org.apache.uima.util.Level.CONFIG_INT:
return org.apache.log4j.Level.INFO;
case org.apache.uima.util.Level.FINE_INT:
return org.apache.log4j.Level.DEBUG;
case org.apache.uima.util.Level.FINER_INT:
return org.apache.log4j.Level.ALL;
case org.apache.uima.util.Level.FINEST_INT:
return org.apache.log4j.Level.ALL;
default: // for all other cases return Level.ALL
return org.apache.log4j.Level.ALL;
}
}
/**
* returns the method name and the line number if available
*
* @param thrown
* the thrown
* @return String[] - fist element is the souce class, second element is the
* method name with linenumber if available
*/
private String[] getStackTraceInfo(Throwable thrown) {
StackTraceElement[] stackTraceElement = thrown.getStackTrace();
String sourceMethod = "";
String sourceClass = "";
int lineNumber = 0;
try {
lineNumber = stackTraceElement[1].getLineNumber();
sourceMethod = stackTraceElement[1].getMethodName();
sourceClass = stackTraceElement[1].getClassName();
} catch (Exception ex) {
// do nothing, use the initialized string members
}
if (lineNumber > 0) {
StringBuffer buffer = new StringBuffer(25);
buffer.append(sourceMethod);
buffer.append("(");
buffer.append(lineNumber);
buffer.append(")");
sourceMethod = buffer.toString();
}
return new String[] { sourceClass, sourceMethod };
}
}