/*
*
* 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.qpid.server.logging.log4j;
import org.apache.log4j.Level;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.apache.log4j.xml.DOMConfigurator;
import org.apache.log4j.xml.Log4jEntityResolver;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
/**
* A facade over log4j that allows both the control of the runtime logging behaviour (that is, the ability to
* turn {@link Logger} on, off and control their {@link Level}, and the manipulation and reload
* of the log4j configuration file.
*/
public class LoggingFacade
{
private static Logger LOGGER;
private static transient LoggingFacade _instance;
private final String _filename;
private final int _delay;
public static LoggingFacade configure(String filename) throws LoggingFacadeException
{
_instance = new LoggingFacade(filename);
return _instance;
}
public static LoggingFacade configureAndWatch(String filename, int delay) throws LoggingFacadeException
{
_instance = new LoggingFacade(filename, delay);
return _instance;
}
public static LoggingFacade getCurrentInstance()
{
return _instance;
}
private LoggingFacade(String filename)
{
DOMConfigurator.configure(filename);
if(LOGGER == null)
{
LOGGER = Logger.getLogger(LoggingFacade.class);
}
_filename = filename;
_delay = 0;
}
private LoggingFacade(String filename, int delay)
{
DOMConfigurator.configureAndWatch(filename, delay);
if(LOGGER == null)
{
LOGGER = Logger.getLogger(LoggingFacade.class);
}
_filename = filename;
_delay = delay;
}
public int getLog4jLogWatchInterval()
{
return _delay;
}
public synchronized void reload() throws LoggingFacadeException
{
DOMConfigurator.configure(_filename);
}
/** The log4j XML configuration file DTD defines three possible element
* combinations for specifying optional logger+level settings.
* Must account for the following:
*
* <category name="x"> <priority value="y"/> </category> OR
* <category name="x"> <level value="y"/> </category> OR
* <logger name="x"> <level value="y"/> </logger>
*
* Noting also that the level/priority child element is optional too,
* and not the only possible child element.
*/
public synchronized Map<String,String> retrieveConfigFileLoggersLevels() throws LoggingFacadeException
{
try
{
Map<String,String> loggerLevelList = new HashMap<String,String>();
LOGGER.info("Getting logger levels from log4j configuration file");
Document doc = parseConfigFile(_filename);
List<Element> categoryOrLoggerElements = buildListOfCategoryOrLoggerElements(doc);
for (Element categoryOrLogger : categoryOrLoggerElements)
{
Element priorityOrLevelElement;
try
{
priorityOrLevelElement = getPriorityOrLevelElement(categoryOrLogger);
}
catch (LoggingFacadeException lfe)
{
//there is no exiting priority or level to view, move onto next category/logger
continue;
}
String categoryName = categoryOrLogger.getAttribute("name");
String priorityOrLevelValue = priorityOrLevelElement.getAttribute("value");
loggerLevelList.put(categoryName, priorityOrLevelValue);
}
return loggerLevelList;
}
catch (IOException e)
{
throw new LoggingFacadeException(e);
}
}
/**
* The log4j XML configuration file DTD defines 2 possible element
* combinations for specifying the optional root logger level settings
* Must account for the following:
*
* <root> <priority value="y"/> </root> OR
* <root> <level value="y"/> </root>
*
* Noting also that the level/priority child element is optional too,
* and not the only possible child element.
*/
public synchronized String retrieveConfigFileRootLoggerLevel() throws LoggingFacadeException
{
try
{
Document doc = parseConfigFile(_filename);
//retrieve the optional 'root' element node
NodeList rootElements = doc.getElementsByTagName("root");
if (rootElements.getLength() == 0)
{
//there is no root logger definition
return "N/A";
}
Element rootElement = (Element) rootElements.item(0);
Element levelElement = getPriorityOrLevelElement(rootElement);
if(levelElement != null)
{
return levelElement.getAttribute("value");
}
else
{
return "N/A";
}
}
catch (IOException e)
{
throw new LoggingFacadeException(e);
}
}
public synchronized void setConfigFileLoggerLevel(String logger, String level) throws LoggingFacadeException
{
LOGGER.info("Setting level to " + level + " for logger '" + logger
+ "' in log4j xml configuration file: " + _filename);
try
{
Document doc = parseConfigFile(_filename);
List<Element> logElements = buildListOfCategoryOrLoggerElements(doc);
//try to locate the specified logger/category in the elements retrieved
Element logElement = null;
for (Element e : logElements)
{
if (e.getAttribute("name").equals(logger))
{
logElement = e;
break;
}
}
if (logElement == null)
{
throw new LoggingFacadeException("Can't find logger " + logger);
}
Element levelElement = getPriorityOrLevelElement(logElement);
//update the element with the new level/priority
levelElement.setAttribute("value", level);
//output the new file
writeUpdatedConfigFile(_filename, doc);
}
catch (IOException ioe)
{
throw new LoggingFacadeException(ioe);
}
catch (TransformerConfigurationException e)
{
throw new LoggingFacadeException(e);
}
}
public synchronized void setConfigFileRootLoggerLevel(String level) throws LoggingFacadeException
{
try
{
LOGGER.info("Setting level to " + level + " for the Root logger in " +
"log4j xml configuration file: " + _filename);
Document doc = parseConfigFile(_filename);
//retrieve the optional 'root' element node
NodeList rootElements = doc.getElementsByTagName("root");
if (rootElements.getLength() == 0)
{
throw new LoggingFacadeException("Configuration contains no root element");
}
Element rootElement = (Element) rootElements.item(0);
Element levelElement = getPriorityOrLevelElement(rootElement);
//update the element with the new level/priority
levelElement.setAttribute("value", level);
//output the new file
writeUpdatedConfigFile(_filename, doc);
}
catch (IOException e)
{
throw new LoggingFacadeException(e);
}
catch (TransformerConfigurationException e)
{
throw new LoggingFacadeException(e);
}
}
public List<String> getAvailableLoggerLevels()
{
return new ArrayList<String>()
{{
add(Level.ALL.toString());
add(Level.TRACE.toString());
add(Level.DEBUG.toString());
add(Level.INFO.toString());
add(Level.WARN.toString());
add(Level.ERROR.toString());
add(Level.FATAL.toString());
add(Level.OFF.toString());
}};
}
public String retrieveRuntimeRootLoggerLevel()
{
Logger rootLogger = Logger.getRootLogger();
return rootLogger.getLevel().toString();
}
public void setRuntimeRootLoggerLevel(String level)
{
Level newLevel = Level.toLevel(level);
LOGGER.info("Setting RootLogger level to " + level);
Logger log = Logger.getRootLogger();
log.setLevel(newLevel);
}
public void setRuntimeLoggerLevel(String loggerName, String level) throws LoggingFacadeException
{
Level newLevel = level == null ? null : Level.toLevel(level);
Logger targetLogger = findRuntimeLogger(loggerName);
if(targetLogger == null)
{
throw new LoggingFacadeException("Can't find logger " + loggerName);
}
LOGGER.info("Setting level to " + newLevel + " for logger '" + targetLogger.getName() + "'");
targetLogger.setLevel(newLevel);
}
public Map<String,String> retrieveRuntimeLoggersLevels()
{
LOGGER.info("Getting levels for currently active log4j loggers");
Map<String, String> levels = new HashMap<String, String>();
@SuppressWarnings("unchecked")
Enumeration<Logger> loggers = LogManager.getCurrentLoggers();
while (loggers.hasMoreElements())
{
Logger logger = loggers.nextElement();
levels.put(logger.getName(), logger.getEffectiveLevel().toString());
}
return levels;
}
private void writeUpdatedConfigFile(String log4jConfigFileName, Document doc) throws IOException, TransformerConfigurationException
{
File log4jConfigFile = new File(log4jConfigFileName);
if (!log4jConfigFile.canWrite())
{
LOGGER.warn("Specified log4j XML configuration file is not writable: " + log4jConfigFile);
throw new IOException("Specified log4j XML configuration file is not writable");
}
Transformer transformer = null;
transformer = TransformerFactory.newInstance().newTransformer();
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, "log4j.dtd");
DOMSource source = new DOMSource(doc);
File tmp;
Random r = new Random();
do
{
tmp = new File(log4jConfigFile.getAbsolutePath() + r.nextInt() + ".tmp");
}
while(tmp.exists());
tmp.deleteOnExit();
try
{
StreamResult result = new StreamResult(new FileOutputStream(tmp));
transformer.transform(source, result);
}
catch (TransformerException e)
{
LOGGER.warn("Could not transform the XML into new file: ", e);
throw new IOException("Could not transform the XML into new file: ", e);
}
// Swap temp file in to replace existing configuration file.
File old = new File(log4jConfigFile.getAbsoluteFile() + ".old");
if (old.exists())
{
old.delete();
}
if(!log4jConfigFile.renameTo(old))
{
//unable to rename the existing file to the backup name
LOGGER.error("Could not backup the existing log4j XML file");
throw new IOException("Could not backup the existing log4j XML file");
}
if(!tmp.renameTo(log4jConfigFile))
{
//failed to rename the new file to the required filename
if(!old.renameTo(log4jConfigFile))
{
//unable to return the backup to required filename
LOGGER.error("Could not rename the new log4j configuration file into place, and unable to restore original file");
throw new IOException("Could not rename the new log4j configuration file into place, and unable to restore original file");
}
LOGGER.error("Could not rename the new log4j configuration file into place");
throw new IOException("Could not rename the new log4j configuration file into place");
}
}
//method to parse the XML configuration file, validating it in the process, and returning a DOM Document of the content.
private static Document parseConfigFile(String fileName) throws IOException
{
//check file was specified, exists, and is readable
if(fileName == null)
{
LOGGER.warn("Provided log4j XML configuration filename is null");
throw new IOException("Provided log4j XML configuration filename is null");
}
File configFile = new File(fileName);
if (!configFile.exists())
{
LOGGER.warn("The log4j XML configuration file could not be found: " + fileName);
throw new IOException("The log4j XML configuration file could not be found");
}
else if (!configFile.canRead())
{
LOGGER.warn("The log4j XML configuration file is not readable: " + fileName);
throw new IOException("The log4j XML configuration file is not readable");
}
//parse it
DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder docBuilder;
Document doc;
ErrorHandler errHandler = new QpidLog4JSaxErrorHandler();
try
{
docFactory.setValidating(true);
docBuilder = docFactory.newDocumentBuilder();
docBuilder.setErrorHandler(errHandler);
docBuilder.setEntityResolver(new Log4jEntityResolver());
doc = docBuilder.parse(fileName);
}
catch (ParserConfigurationException e)
{
LOGGER.warn("Unable to parse the log4j XML file due to possible configuration error: ", e);
throw new IOException("Unable to parse the log4j XML file due to possible configuration error: ", e);
}
catch (SAXException e)
{
LOGGER.warn("The specified log4j XML file is invalid: ", e);
throw new IOException("The specified log4j XML file is invalid: ", e);
}
catch (IOException e)
{
LOGGER.warn("Unable to parse the specified log4j XML file", e);
throw new IOException("Unable to parse the specified log4j XML file: ", e);
}
return doc;
}
private Logger findRuntimeLogger(String loggerName)
{
Logger targetLogger = null;
@SuppressWarnings("unchecked")
Enumeration<Logger> loggers = LogManager.getCurrentLoggers();
while(loggers.hasMoreElements())
{
targetLogger = loggers.nextElement();
if (targetLogger.getName().equals(loggerName))
{
return targetLogger;
}
}
return null;
}
private List<Element> buildListOfCategoryOrLoggerElements(Document doc)
{
//retrieve the 'category' and 'logger' element nodes
NodeList categoryElements = doc.getElementsByTagName("category");
NodeList loggerElements = doc.getElementsByTagName("logger");
//collect them into a single elements list
List<Element> logElements = new ArrayList<Element>();
for (int i = 0; i < categoryElements.getLength(); i++)
{
logElements.add((Element) categoryElements.item(i));
}
for (int i = 0; i < loggerElements.getLength(); i++)
{
logElements.add((Element) loggerElements.item(i));
}
return logElements;
}
private Element getPriorityOrLevelElement(Element categoryOrLogger) throws LoggingFacadeException
{
//retrieve the optional 'priority' or 'level' sub-element value.
//It may not be the only child node, so request by tag name.
NodeList priorityElements = categoryOrLogger.getElementsByTagName("priority");
NodeList levelElements = categoryOrLogger.getElementsByTagName("level");
Element levelElement = null;
if (priorityElements.getLength() != 0)
{
levelElement = (Element) priorityElements.item(0);
}
else if (levelElements.getLength() != 0)
{
levelElement = (Element) levelElements.item(0);
}
else
{
throw new LoggingFacadeException("Configuration " + categoryOrLogger.getNodeName()
+ " element contains neither priority nor level child");
}
return levelElement;
}
private static class QpidLog4JSaxErrorHandler implements ErrorHandler
{
public void error(SAXParseException e) throws SAXException
{
if(LOGGER != null)
{
LOGGER.warn(constructMessage("Error parsing XML file", e));
}
else
{
System.err.println(constructMessage("Error parsing XML file", e));
}
}
public void fatalError(SAXParseException e) throws SAXException
{
throw new SAXException(constructMessage("Fatal error parsing XML file", e));
}
public void warning(SAXParseException e) throws SAXException
{
if(LOGGER != null)
{
LOGGER.warn(constructMessage("Warning parsing XML file", e));
}
else
{
System.err.println(constructMessage("Warning parsing XML file", e));
}
}
private static String constructMessage(final String msg, final SAXParseException ex)
{
return msg + ": Line " + ex.getLineNumber()+" column " +ex.getColumnNumber() + ": " + ex.getMessage();
}
}
}