at.spardat.xma.boot.logger.LogManager Maven / Gradle / Ivy
The newest version!
/*******************************************************************************
* Copyright (c) 2003, 2007 s IT Solutions AT Spardat GmbH .
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* s IT Solutions AT Spardat GmbH - initial API and implementation
*******************************************************************************/
/*
* Created on : 25.06.2003
* Created by : s3595
*/
package at.spardat.xma.boot.logger;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Properties;
import java.util.Vector;
import at.spardat.xma.boot.Statics;
/**
* LogManager
*
* @author s3595 (CGS)
* @version $Id: LogManager.java 5887 2010-06-07 09:58:14Z gub $
*
*/
public class LogManager {
/* The global LogManager object */
private static LogManager manager;
/* default and fallback loglevel */
private final static LogLevel defaultLevel = LogLevel.WARNING;
/* current active log level */
private LogLevel currentLogLevel;
/* Table of known loggers. Maps names to Loggers. */
private Hashtable loggers = new Hashtable();
/* configuration properties */
private Properties props;
/* default log handler */
private ILogHandler defaultHandler = new LogHandlerDefault();
/* log handlers */
private ArrayList handlers = new ArrayList(3);
static {
if (manager == null) {
manager = new LogManager();
}
}
/**
* It is intended that there only be one LogManager object, whose value is
* retrieved by calling Logmanager.getLogManager.
*/
protected LogManager() {
currentLogLevel = defaultLevel;
handlers.add(defaultHandler);
}
/** Return the global LogManager object. */
public static LogManager getLogManager() {
return manager;
}
/**
* Reinitialize the logging properties and reread the logging configuration.
*/
public void setConfiguration( Properties in ) {
props = in;
String strDebug = (String)props.get( Statics.CFG_PROP_LOGLEVEL ); //$NON-NLS-1$
LogLevel newlevel = LogLevel.getLogLevelNamed(strDebug);
if(newlevel != null){
currentLogLevel = newlevel;
}
String strHandlers = (String)props.get( Statics.CFG_PROP_LOGLHANDLERS ); //$NON-NLS-1$
if(strHandlers!=null) {
handlers = new ArrayList();
loadHandlers( strHandlers );
if( handlers.size()== 0 ) {
handlers.add(defaultHandler);
}
}
notifyLoggers(currentLogLevel, true );
}
public void notifyLoggers( LogLevel newlevel, boolean notifyHandlers ) {
for (Iterator iter = loggers.keySet().iterator(); iter.hasNext();) {
Logger element = (Logger)loggers.get((String)iter.next());
element.setLevel(newlevel);
element.setHandlers(handlers);
}
}
public synchronized boolean addLogger(Logger logger) {
String name = logger.getName();
if (name == null) {
throw new NullPointerException();
}
Logger old = (Logger) loggers.get(name);
if (old != null) {
// We already have a registered logger with the given name.
return false;
}
loggers.put(name, logger);
logger.setLevel( currentLogLevel );
logger.setHandlers( handlers );
return true;
}
/**
* Method to find a named logger.
*
* @param name name of the logger
* @return matching logger or null if none is found
*/
public synchronized Logger getLogger(String name) {
return (Logger) loggers.get(name);
}
private synchronized void loadHandlers(String strHandlers) {
if(strHandlers==null)
return;
String names[] = parseClassNames(strHandlers);
for (int i = 0; i < names.length; i++) {
String word = names[i];
try {
Class clz = this.getClass().getClassLoader().loadClass(word);
ILogHandler h = (ILogHandler) clz.newInstance();
h.setProperties(props);
handlers.add(h);
} catch (Exception ex) {
System.err.println("Can't load log handler \"" + word + "\"");
System.err.println("" + ex);
}
}
return;
}
// get a list of whitespace separated classnames from a property.
private String[] parseClassNames(String handlers) {
if (handlers == null) {
return new String[0];
}
handlers = handlers.trim();
int ix = 0;
Vector result = new Vector();
while (ix < handlers.length()) {
int end = ix;
while (end < handlers.length()) {
if (Character.isWhitespace(handlers.charAt(end))) {
break;
}
if (handlers.charAt(end) == ',') {
break;
}
end++;
}
String word = handlers.substring(ix, end);
ix = end+1;
word = word.trim();
if (word.length() == 0) {
continue;
}
result.add(word);
}
return (String[]) result.toArray(new String[result.size()]);
}
/**
* Get the fully quallified name of the used logfile.
* If no logfile is used, this method returns null.
* @since 1.6.0
*/
public String getLogFileName() {
for(Iterator it=handlers.iterator();it.hasNext();) {
Object handler = it.next();
if(handler instanceof LogHandlerFile) {
return ((LogHandlerFile)handler).getLogFileName();
}
}
return null;
}
}