mosgi/jmx.agent/src/main/java/org/apache/felix/mosgi/jmx/agent/mx4j/log/Log.java

/* 
 * 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.felix.mosgi.jmx.agent.mx4j.log;

import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Map;
import java.util.HashMap;

import javax.management.RuntimeOperationsException;

import org.apache.felix.mosgi.jmx.agent.mx4j.MX4JSystemKeys;

/**
 * Main class for the log service. <p>
 * The system property 'mx4j.log.priority' controls the priority of the standard logging, and defaults to 'warn'.
 * Possible values are, from least to greatest priority, the following (case insensitive):
 * <ul>
 * <li>trace
 * <li>debug
 * <li>info
 * <li>warn
 * <li>error
 * <li>fatal
 * </ul>
 *
 * @author <a href="mailto:biorn_steedom@users.sourceforge.net">Simone Bordet</a>
 * @version $Revision: 1.1.1.1 $
 */
public class Log
{
	private static Logger m_prototype;
	private static Map m_prototypeMap = new HashMap();
	private static Map m_loggerCache = new HashMap();
	private static int m_defaultPriority;

	static
	{
		// Do not require callers up in the stack to have this permission
		String priority = (String)AccessController.doPrivileged(new PrivilegedAction()
		{
			public Object run()
			{
				 return System.getProperty(MX4JSystemKeys.MX4J_LOG_PRIORITY);
			}
		});
		if ("trace".equalsIgnoreCase(priority)) {m_defaultPriority = Logger.TRACE;}
		else if ("debug".equalsIgnoreCase(priority)) {m_defaultPriority = Logger.DEBUG;}
		else if ("info".equalsIgnoreCase(priority)) {m_defaultPriority = Logger.INFO;}
		else if ("warn".equalsIgnoreCase(priority)) {m_defaultPriority = Logger.WARN;}
		else if ("error".equalsIgnoreCase(priority)) {m_defaultPriority = Logger.ERROR;}
		else if ("fatal".equalsIgnoreCase(priority)) {m_defaultPriority = Logger.FATAL;}
		else {m_defaultPriority = Logger.INFO;}

		String prototype = (String)AccessController.doPrivileged(new PrivilegedAction()
		{
			public Object run()
			{
				 return System.getProperty(MX4JSystemKeys.MX4J_LOG_PROTOTYPE);
			}
		});
		if (prototype != null && prototype.trim().length() > 0)
		{
			try
			{
				ClassLoader cl = Thread.currentThread().getContextClassLoader();
				Class cls = cl.loadClass(prototype);
				redirectTo((Logger)cls.newInstance());
			}
			catch (Exception x)
			{
				x.printStackTrace();
				// Do nothing else: the user will see the exception trace
				// and understand that the property was wrong
			}
		}
	}

	private Log() {}

	/**
	 * Sets the default priority for all loggers.
	 * @see #setDefaultPriority
	 */
	public static void setDefaultPriority(int priority)
	{
		switch (priority)
		{
			case Logger.TRACE: m_defaultPriority = Logger.TRACE; break;
			case Logger.DEBUG: m_defaultPriority = Logger.DEBUG; break;
			case Logger.INFO: m_defaultPriority = Logger.INFO; break;
			case Logger.WARN: m_defaultPriority = Logger.WARN; break;
			case Logger.ERROR: m_defaultPriority = Logger.ERROR; break;
			case Logger.FATAL: m_defaultPriority = Logger.FATAL; break;
			default: m_defaultPriority = Logger.WARN; break;
		}
	}

	/**
	 * Returns the default priority.
	 * @see #setDefaultPriority
	 */
	public static int getDefaultPriority()
	{
		return m_defaultPriority;
	}

	/**
	 * Returns a new instance of a Logger associated with the given <code>category</code>;
	 * if {@link #redirectTo} has been called then a new instance of the prototype Logger, associated with the given
	 * <code>category<code>, is returned. This requires the prototype Logger class to have a public parameterless
	 * constructor.
	 */
	public static Logger getLogger(String category)
	{
		if (category == null) {throw new RuntimeOperationsException(new IllegalArgumentException("Category cannot be null"));}

		synchronized (m_loggerCache)
		{
			Logger logger = (Logger)m_loggerCache.get(category);
			if (logger == null)
			{
				// Try to see if a delegate for this category overrides other settings
				Logger prototype = null;
				synchronized (m_prototypeMap)
				{
					prototype = (Logger)m_prototypeMap.get(category);
				}
				if (prototype == null)
				{
					// Try to see if a prototype for all categories has been set
					if (m_prototype != null)
					{
						logger = createLogger(m_prototype, category);
					}
					else
					{
						logger = createLogger(null, category);
					}
				}
				else
				{
					logger = createLogger(prototype, category);
				}

				// cache it
				m_loggerCache.put(category, logger);
			}
			return logger;
		}
	}

	private static Logger createLogger(Logger prototype, String category)
	{
		Logger logger = null;
		try
		{
			logger = prototype == null ? new Logger() : (Logger)prototype.getClass().newInstance();
		}
		catch (Exception x)
		{
			x.printStackTrace();
			logger = new Logger();
		}
		logger.setCategory(category);
		logger.setPriority(m_defaultPriority);
		return logger;
	}

	/**
	 * Tells to the log service to use the given <code>delegate</code> Logger to perform logging. <br>
	 * Use a null delegate to remove redirection.
	 * @see #getLogger
	 */
	public static void redirectTo(Logger prototype)
	{
		m_prototype = prototype;

		// Clear the cache, as we want requests for new loggers to be generated again.
		synchronized (m_loggerCache)
		{
			m_loggerCache.clear();
		}
	}

	/**
	 * Tells to the log service to use the given <code>delegate</code> Logger to perform logging for the given
	 * category (that cannot be null). <br>
	 * Settings made using this method overrides the ones made with {@link #redirectTo(Logger) redirectTo}, meaning
	 * that it is possible to redirect all the log to a certain delegate but certain categories.
	 * Use a null delegate to remove redirection for the specified category.
	 * @see #getLogger
	 */
	public static void redirectTo(Logger prototype, String category)
	{
		if (category == null) {throw new RuntimeOperationsException(new IllegalArgumentException("Category cannot be null"));}

		if (prototype == null)
		{
			// Remove the redirection
			synchronized (m_prototypeMap)
			{
				m_prototypeMap.remove(category);
			}

			// Clear the cache for this category
			synchronized (m_loggerCache)
			{
				m_loggerCache.remove(category);
			}
		}
		else
		{
			// Put or replace
			synchronized (m_prototypeMap)
			{
				m_prototypeMap.put(category, prototype);
			}

			// Clear the cache for this category
			synchronized (m_loggerCache)
			{
				m_loggerCache.remove(category);
			}
		}
	}
}