| /* |
| * 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.log4j.xml; |
| |
| import org.apache.log4j.Appender; |
| import org.apache.log4j.Layout; |
| import org.apache.log4j.Level; |
| import org.apache.log4j.bridge.AppenderAdapter; |
| import org.apache.log4j.bridge.AppenderWrapper; |
| import org.apache.log4j.config.Log4j1Configuration; |
| import org.apache.log4j.config.PropertySetter; |
| import org.apache.log4j.helpers.OptionConverter; |
| import org.apache.log4j.rewrite.RewritePolicy; |
| import org.apache.log4j.spi.AppenderAttachable; |
| import org.apache.log4j.spi.ErrorHandler; |
| import org.apache.log4j.spi.Filter; |
| import org.apache.logging.log4j.core.LoggerContext; |
| import org.apache.logging.log4j.core.config.ConfigurationSource; |
| import org.apache.logging.log4j.core.config.LoggerConfig; |
| import org.apache.logging.log4j.core.config.status.StatusConfiguration; |
| import org.apache.logging.log4j.status.StatusLogger; |
| import org.apache.logging.log4j.util.LoaderUtil; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.NamedNodeMap; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| import org.xml.sax.InputSource; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.SAXParseException; |
| |
| import javax.xml.parsers.DocumentBuilder; |
| import javax.xml.parsers.DocumentBuilderFactory; |
| import javax.xml.parsers.FactoryConfigurationError; |
| import java.io.IOException; |
| import java.io.InterruptedIOException; |
| import java.lang.reflect.Method; |
| import java.util.HashMap; |
| import java.util.Map; |
| import java.util.Properties; |
| import java.util.function.Consumer; |
| |
| /** |
| * Class Description goes here. |
| */ |
| public class XmlConfiguration extends Log4j1Configuration { |
| |
| private static final org.apache.logging.log4j.Logger LOGGER = StatusLogger.getLogger(); |
| |
| private static final String CONFIGURATION_TAG = "log4j:configuration"; |
| private static final String OLD_CONFIGURATION_TAG = "configuration"; |
| private static final String RENDERER_TAG = "renderer"; |
| private static final String APPENDER_TAG = "appender"; |
| public static final String PARAM_TAG = "param"; |
| public static final String LAYOUT_TAG = "layout"; |
| private static final String CATEGORY = "category"; |
| private static final String LOGGER_ELEMENT = "logger"; |
| private static final String CATEGORY_FACTORY_TAG = "categoryFactory"; |
| private static final String LOGGER_FACTORY_TAG = "loggerFactory"; |
| public static final String NAME_ATTR = "name"; |
| private static final String CLASS_ATTR = "class"; |
| public static final String VALUE_ATTR = "value"; |
| private static final String ROOT_TAG = "root"; |
| private static final String LEVEL_TAG = "level"; |
| private static final String PRIORITY_TAG = "priority"; |
| public static final String FILTER_TAG = "filter"; |
| private static final String ERROR_HANDLER_TAG = "errorHandler"; |
| public static final String REF_ATTR = "ref"; |
| private static final String ADDITIVITY_ATTR = "additivity"; |
| private static final String CONFIG_DEBUG_ATTR = "configDebug"; |
| private static final String INTERNAL_DEBUG_ATTR = "debug"; |
| private static final String EMPTY_STR = ""; |
| private static final Class[] ONE_STRING_PARAM = new Class[]{String.class}; |
| private static final String dbfKey = "javax.xml.parsers.DocumentBuilderFactory"; |
| private static final String THROWABLE_RENDERER_TAG = "throwableRenderer"; |
| |
| public static final long DEFAULT_DELAY = 60000; |
| /** |
| * File name prefix for test configurations. |
| */ |
| protected static final String TEST_PREFIX = "log4j-test"; |
| |
| /** |
| * File name prefix for standard configurations. |
| */ |
| protected static final String DEFAULT_PREFIX = "log4j"; |
| |
| // key: appenderName, value: appender |
| private Map<String, Appender> appenderMap; |
| |
| private Properties props = null; |
| |
| public XmlConfiguration(final LoggerContext loggerContext, final ConfigurationSource source, |
| int monitorIntervalSeconds) { |
| super(loggerContext, source, monitorIntervalSeconds); |
| appenderMap = new HashMap<>(); |
| } |
| |
| public void addAppenderIfAbsent(Appender appender) { |
| appenderMap.putIfAbsent(appender.getName(), appender); |
| } |
| |
| /** |
| * Configure log4j by reading in a log4j.dtd compliant XML |
| * configuration file. |
| */ |
| @Override |
| public void doConfigure() throws FactoryConfigurationError { |
| ConfigurationSource source = getConfigurationSource(); |
| ParseAction action = new ParseAction() { |
| public Document parse(final DocumentBuilder parser) throws SAXException, IOException { |
| InputSource inputSource = new InputSource(source.getInputStream()); |
| inputSource.setSystemId("dummy://log4j.dtd"); |
| return parser.parse(inputSource); |
| } |
| |
| public String toString() { |
| return getConfigurationSource().getLocation(); |
| } |
| }; |
| doConfigure(action); |
| } |
| |
| private void doConfigure(final ParseAction action) throws FactoryConfigurationError { |
| DocumentBuilderFactory dbf; |
| try { |
| LOGGER.debug("System property is : {}", OptionConverter.getSystemProperty(dbfKey, null)); |
| dbf = DocumentBuilderFactory.newInstance(); |
| LOGGER.debug("Standard DocumentBuilderFactory search succeded."); |
| LOGGER.debug("DocumentBuilderFactory is: " + dbf.getClass().getName()); |
| } catch (FactoryConfigurationError fce) { |
| Exception e = fce.getException(); |
| LOGGER.debug("Could not instantiate a DocumentBuilderFactory.", e); |
| throw fce; |
| } |
| |
| try { |
| dbf.setValidating(true); |
| |
| DocumentBuilder docBuilder = dbf.newDocumentBuilder(); |
| |
| docBuilder.setErrorHandler(new SAXErrorHandler()); |
| docBuilder.setEntityResolver(new Log4jEntityResolver()); |
| |
| Document doc = action.parse(docBuilder); |
| parse(doc.getDocumentElement()); |
| } catch (Exception e) { |
| if (e instanceof InterruptedException || e instanceof InterruptedIOException) { |
| Thread.currentThread().interrupt(); |
| } |
| // I know this is miserable... |
| LOGGER.error("Could not parse " + action.toString() + ".", e); |
| } |
| } |
| |
| /** |
| * Delegates unrecognized content to created instance if it supports UnrecognizedElementParser. |
| * |
| * @param instance instance, may be null. |
| * @param element element, may not be null. |
| * @param props properties |
| * @throws IOException thrown if configuration of owner object should be abandoned. |
| */ |
| private void parseUnrecognizedElement(final Object instance, final Element element, |
| final Properties props) throws Exception { |
| boolean recognized = false; |
| if (instance instanceof UnrecognizedElementHandler) { |
| recognized = ((UnrecognizedElementHandler) instance).parseUnrecognizedElement( |
| element, props); |
| } |
| if (!recognized) { |
| LOGGER.warn("Unrecognized element {}", element.getNodeName()); |
| } |
| } |
| |
| /** |
| * Delegates unrecognized content to created instance if |
| * it supports UnrecognizedElementParser and catches and |
| * logs any exception. |
| * |
| * @param instance instance, may be null. |
| * @param element element, may not be null. |
| * @param props properties |
| * @since 1.2.15 |
| */ |
| private void quietParseUnrecognizedElement(final Object instance, |
| final Element element, |
| final Properties props) { |
| try { |
| parseUnrecognizedElement(instance, element, props); |
| } catch (Exception ex) { |
| if (ex instanceof InterruptedException || ex instanceof InterruptedIOException) { |
| Thread.currentThread().interrupt(); |
| } |
| LOGGER.error("Error in extension content: ", ex); |
| } |
| } |
| |
| /** |
| * Substitutes property value for any references in expression. |
| * |
| * @param value value from configuration file, may contain |
| * literal text, property references or both |
| * @param props properties. |
| * @return evaluated expression, may still contain expressions |
| * if unable to expand. |
| */ |
| public String subst(final String value, final Properties props) { |
| try { |
| return OptionConverter.substVars(value, props); |
| } catch (IllegalArgumentException e) { |
| LOGGER.warn("Could not perform variable substitution.", e); |
| return value; |
| } |
| } |
| |
| /** |
| * Sets a parameter based from configuration file content. |
| * |
| * @param elem param element, may not be null. |
| * @param propSetter property setter, may not be null. |
| * @param props properties |
| * @since 1.2.15 |
| */ |
| public void setParameter(final Element elem, final PropertySetter propSetter, final Properties props) { |
| String name = subst(elem.getAttribute("name"), props); |
| String value = (elem.getAttribute("value")); |
| value = subst(OptionConverter.convertSpecialChars(value), props); |
| propSetter.setProperty(name, value); |
| } |
| |
| /** |
| * Creates an object and processes any nested param elements |
| * but does not call activateOptions. If the class also supports |
| * UnrecognizedElementParser, the parseUnrecognizedElement method |
| * will be call for any child elements other than param. |
| * |
| * @param element element, may not be null. |
| * @param props properties |
| * @param expectedClass interface or class expected to be implemented |
| * by created class |
| * @return created class or null. |
| * @throws Exception thrown if the contain object should be abandoned. |
| * @since 1.2.15 |
| */ |
| public Object parseElement(final Element element, final Properties props, |
| @SuppressWarnings("rawtypes") final Class expectedClass) throws Exception { |
| String clazz = subst(element.getAttribute("class"), props); |
| Object instance = OptionConverter.instantiateByClassName(clazz, |
| expectedClass, null); |
| |
| if (instance != null) { |
| PropertySetter propSetter = new PropertySetter(instance); |
| NodeList children = element.getChildNodes(); |
| final int length = children.getLength(); |
| |
| for (int loop = 0; loop < length; loop++) { |
| Node currentNode = children.item(loop); |
| if (currentNode.getNodeType() == Node.ELEMENT_NODE) { |
| Element currentElement = (Element) currentNode; |
| String tagName = currentElement.getTagName(); |
| if (tagName.equals("param")) { |
| setParameter(currentElement, propSetter, props); |
| } else { |
| parseUnrecognizedElement(instance, currentElement, props); |
| } |
| } |
| } |
| return instance; |
| } |
| return null; |
| } |
| |
| /** |
| * Used internally to parse appenders by IDREF name. |
| */ |
| private Appender findAppenderByName(Document doc, String appenderName) { |
| Appender appender = appenderMap.get(appenderName); |
| |
| if (appender != null) { |
| return appender; |
| } else { |
| // Doesn't work on DOM Level 1 : |
| // Element element = doc.getElementById(appenderName); |
| |
| // Endre's hack: |
| Element element = null; |
| NodeList list = doc.getElementsByTagName("appender"); |
| for (int t = 0; t < list.getLength(); t++) { |
| Node node = list.item(t); |
| NamedNodeMap map = node.getAttributes(); |
| Node attrNode = map.getNamedItem("name"); |
| if (appenderName.equals(attrNode.getNodeValue())) { |
| element = (Element) node; |
| break; |
| } |
| } |
| // Hack finished. |
| |
| if (element == null) { |
| |
| LOGGER.error("No appender named [{}] could be found.", appenderName); |
| return null; |
| } else { |
| appender = parseAppender(element); |
| if (appender != null) { |
| appenderMap.put(appenderName, appender); |
| } |
| return appender; |
| } |
| } |
| } |
| |
| /** |
| * Used internally to parse appenders by IDREF element. |
| */ |
| public Appender findAppenderByReference(Element appenderRef) { |
| String appenderName = subst(appenderRef.getAttribute(REF_ATTR)); |
| Document doc = appenderRef.getOwnerDocument(); |
| return findAppenderByName(doc, appenderName); |
| } |
| |
| /** |
| * Used internally to parse an appender element. |
| */ |
| public Appender parseAppender(Element appenderElement) { |
| String className = subst(appenderElement.getAttribute(CLASS_ATTR)); |
| LOGGER.debug("Class name: [" + className + ']'); |
| Appender appender = manager.parseAppender(className, appenderElement, this); |
| if (appender == null) { |
| appender = buildAppender(className, appenderElement); |
| } |
| return appender; |
| } |
| |
| private Appender buildAppender(String className, Element appenderElement) { |
| try { |
| Appender appender = LoaderUtil.newInstanceOf(className); |
| PropertySetter propSetter = new PropertySetter(appender); |
| |
| appender.setName(subst(appenderElement.getAttribute(NAME_ATTR))); |
| forEachElement(appenderElement.getChildNodes(), (currentElement) -> { |
| // Parse appender parameters |
| switch (currentElement.getTagName()) { |
| case PARAM_TAG: |
| setParameter(currentElement, propSetter); |
| break; |
| case LAYOUT_TAG: |
| appender.setLayout(parseLayout(currentElement)); |
| break; |
| case FILTER_TAG: |
| Filter filter = parseFilters(currentElement); |
| if (filter != null) { |
| LOGGER.debug("Adding filter of type [{}] to appender named [{}]", |
| filter.getClass(), appender.getName()); |
| appender.addFilter(filter); |
| } |
| break; |
| case ERROR_HANDLER_TAG: |
| parseErrorHandler(currentElement, appender); |
| break; |
| case APPENDER_REF_TAG: |
| String refName = subst(currentElement.getAttribute(REF_ATTR)); |
| if (appender instanceof AppenderAttachable) { |
| AppenderAttachable aa = (AppenderAttachable) appender; |
| Appender child = findAppenderByReference(currentElement); |
| LOGGER.debug("Attaching appender named [{}] to appender named [{}].", refName, |
| appender.getName()); |
| aa.addAppender(child); |
| } else { |
| LOGGER.error("Requesting attachment of appender named [{}] to appender named [{}}]" |
| + "which does not implement org.apache.log4j.spi.AppenderAttachable.", |
| refName, appender.getName()); |
| } |
| break; |
| default: |
| try { |
| parseUnrecognizedElement(appender, currentElement, props); |
| } catch (Exception ex) { |
| throw new ConsumerException(ex); |
| } |
| } |
| }); |
| propSetter.activate(); |
| return appender; |
| } catch (ConsumerException ex) { |
| Throwable t = ex.getCause(); |
| if (t instanceof InterruptedException || t instanceof InterruptedIOException) { |
| Thread.currentThread().interrupt(); |
| } |
| LOGGER.error("Could not create an Appender. Reported error follows.", t); |
| } catch (Exception oops) { |
| if (oops instanceof InterruptedException || oops instanceof InterruptedIOException) { |
| Thread.currentThread().interrupt(); |
| } |
| LOGGER.error("Could not create an Appender. Reported error follows.", oops); |
| } |
| return null; |
| } |
| |
| |
| public RewritePolicy parseRewritePolicy(Element rewritePolicyElement) { |
| |
| String className = subst(rewritePolicyElement.getAttribute(CLASS_ATTR)); |
| LOGGER.debug("Class name: [" + className + ']'); |
| RewritePolicy policy = manager.parseRewritePolicy(className, rewritePolicyElement, this); |
| if (policy == null) { |
| policy = buildRewritePolicy(className, rewritePolicyElement); |
| } |
| return policy; |
| } |
| |
| private RewritePolicy buildRewritePolicy(String className, Element element) { |
| try { |
| RewritePolicy policy = LoaderUtil.newInstanceOf(className); |
| PropertySetter propSetter = new PropertySetter(policy); |
| |
| forEachElement(element.getChildNodes(), (currentElement) -> { |
| if (currentElement.getTagName().equalsIgnoreCase(PARAM_TAG)) { |
| setParameter(currentElement, propSetter); |
| } |
| }); |
| propSetter.activate(); |
| return policy; |
| } catch (ConsumerException ex) { |
| Throwable t = ex.getCause(); |
| if (t instanceof InterruptedException || t instanceof InterruptedIOException) { |
| Thread.currentThread().interrupt(); |
| } |
| LOGGER.error("Could not create an RewritePolicy. Reported error follows.", t); |
| } catch (Exception oops) { |
| if (oops instanceof InterruptedException || oops instanceof InterruptedIOException) { |
| Thread.currentThread().interrupt(); |
| } |
| LOGGER.error("Could not create an RewritePolicy. Reported error follows.", oops); |
| } |
| return null; |
| } |
| |
| /** |
| * Used internally to parse an {@link ErrorHandler} element. |
| */ |
| private void parseErrorHandler(Element element, Appender appender) { |
| ErrorHandler eh = (ErrorHandler) OptionConverter.instantiateByClassName( |
| subst(element.getAttribute(CLASS_ATTR)), |
| ErrorHandler.class, |
| null); |
| |
| if (eh != null) { |
| eh.setAppender(appender); |
| |
| PropertySetter propSetter = new PropertySetter(eh); |
| forEachElement(element.getChildNodes(), (currentElement) -> { |
| String tagName = currentElement.getTagName(); |
| if (tagName.equals(PARAM_TAG)) { |
| setParameter(currentElement, propSetter); |
| } |
| }); |
| propSetter.activate(); |
| appender.setErrorHandler(eh); |
| } |
| } |
| |
| /** |
| * Used internally to parse a filter element. |
| */ |
| public Filter parseFilters(Element filterElement) { |
| String className = subst(filterElement.getAttribute(CLASS_ATTR)); |
| LOGGER.debug("Class name: [" + className + ']'); |
| Filter filter = manager.parseFilter(className, filterElement, this); |
| if (filter == null) { |
| PropertySetter propSetter = new PropertySetter(filter); |
| forEachElement(filterElement.getChildNodes(), (currentElement) -> { |
| String tagName = currentElement.getTagName(); |
| if (tagName.equals(PARAM_TAG)) { |
| setParameter(currentElement, propSetter); |
| } else { |
| quietParseUnrecognizedElement(filter, currentElement, props); |
| } |
| }); |
| propSetter.activate(); |
| } |
| return filter; |
| } |
| |
| /** |
| * Used internally to parse an category element. |
| */ |
| private void parseCategory(Element loggerElement) { |
| // Create a new org.apache.log4j.Category object from the <category> element. |
| String catName = subst(loggerElement.getAttribute(NAME_ATTR)); |
| boolean additivity = OptionConverter.toBoolean(subst(loggerElement.getAttribute(ADDITIVITY_ATTR)), true); |
| LoggerConfig loggerConfig = getLogger(catName); |
| if (loggerConfig == null) { |
| loggerConfig = new LoggerConfig(catName, org.apache.logging.log4j.Level.ERROR, additivity); |
| addLogger(catName, loggerConfig); |
| } else { |
| loggerConfig.setAdditive(additivity); |
| } |
| parseChildrenOfLoggerElement(loggerElement, loggerConfig, false); |
| } |
| |
| /** |
| * Used internally to parse the roor category element. |
| */ |
| private void parseRoot(Element rootElement) { |
| LoggerConfig root = getRootLogger(); |
| parseChildrenOfLoggerElement(rootElement, root, true); |
| } |
| |
| /** |
| * Used internally to parse the children of a LoggerConfig element. |
| */ |
| private void parseChildrenOfLoggerElement(Element catElement, LoggerConfig loggerConfig, boolean isRoot) { |
| |
| final PropertySetter propSetter = new PropertySetter(loggerConfig); |
| loggerConfig.getAppenderRefs().clear(); |
| forEachElement(catElement.getChildNodes(), (currentElement) -> { |
| switch (currentElement.getTagName()) { |
| case APPENDER_REF_TAG: { |
| Appender appender = findAppenderByReference(currentElement); |
| String refName = subst(currentElement.getAttribute(REF_ATTR)); |
| if (appender != null) { |
| LOGGER.debug("Adding appender named [{}] to loggerConfig [{}].", refName, |
| loggerConfig.getName()); |
| loggerConfig.addAppender(getAppender(refName), null, null); |
| } else { |
| LOGGER.debug("Appender named [{}}] not found.", refName); |
| } |
| break; |
| } |
| case LEVEL_TAG: case PRIORITY_TAG: { |
| parseLevel(currentElement, loggerConfig, isRoot); |
| break; |
| } |
| case PARAM_TAG: { |
| setParameter(currentElement, propSetter); |
| break; |
| } |
| default: { |
| quietParseUnrecognizedElement(loggerConfig, currentElement, props); |
| } |
| } |
| }); |
| propSetter.activate(); |
| } |
| |
| /** |
| * Used internally to parse a layout element. |
| */ |
| public Layout parseLayout(Element layoutElement) { |
| String className = subst(layoutElement.getAttribute(CLASS_ATTR)); |
| LOGGER.debug("Parsing layout of class: \"{}\"", className); |
| Layout layout = manager.parseLayout(className, layoutElement, this); |
| if (layout == null) { |
| layout = buildLayout(className, layoutElement); |
| } |
| return layout; |
| } |
| |
| private Layout buildLayout(String className, Element layout_element) { |
| try { |
| Layout layout = LoaderUtil.newInstanceOf(className); |
| PropertySetter propSetter = new PropertySetter(layout); |
| forEachElement(layout_element.getChildNodes(), (currentElement) -> { |
| String tagName = currentElement.getTagName(); |
| if (tagName.equals(PARAM_TAG)) { |
| setParameter(currentElement, propSetter); |
| } else { |
| try { |
| parseUnrecognizedElement(layout, currentElement, props); |
| } catch (Exception ex) { |
| throw new ConsumerException(ex); |
| } |
| } |
| }); |
| |
| propSetter.activate(); |
| return layout; |
| } catch (ConsumerException ce) { |
| Throwable cause = ce.getCause(); |
| if (cause instanceof InterruptedException || cause instanceof InterruptedIOException) { |
| Thread.currentThread().interrupt(); |
| } |
| LOGGER.error("Could not create the Layout. Reported error follows.", cause); |
| } catch (Exception oops) { |
| if (oops instanceof InterruptedException || oops instanceof InterruptedIOException) { |
| Thread.currentThread().interrupt(); |
| } |
| LOGGER.error("Could not create the Layout. Reported error follows.", oops); |
| } |
| return null; |
| } |
| |
| /** |
| * Used internally to parse a level element. |
| */ |
| private void parseLevel(Element element, LoggerConfig logger, boolean isRoot) { |
| String catName = logger.getName(); |
| if (isRoot) { |
| catName = "root"; |
| } |
| |
| String priStr = subst(element.getAttribute(VALUE_ATTR)); |
| LOGGER.debug("Level value for {} is [{}}].", catName, priStr); |
| |
| if (INHERITED.equalsIgnoreCase(priStr) || NULL.equalsIgnoreCase(priStr)) { |
| if (isRoot) { |
| LOGGER.error("Root level cannot be inherited. Ignoring directive."); |
| } else { |
| logger.setLevel(null); |
| } |
| } else { |
| String className = subst(element.getAttribute(CLASS_ATTR)); |
| if (EMPTY_STR.equals(className)) { |
| logger.setLevel(OptionConverter.convertLevel(priStr, org.apache.logging.log4j.Level.DEBUG)); |
| } else { |
| LOGGER.debug("Desired Level sub-class: [{}]", className); |
| try { |
| Class<?> clazz = LoaderUtil.loadClass(className); |
| Method toLevelMethod = clazz.getMethod("toLevel", ONE_STRING_PARAM); |
| Level pri = (Level) toLevelMethod.invoke(null, new Object[]{priStr}); |
| logger.setLevel(OptionConverter.convertLevel(pri)); |
| } catch (Exception oops) { |
| if (oops instanceof InterruptedException || oops instanceof InterruptedIOException) { |
| Thread.currentThread().interrupt(); |
| } |
| LOGGER.error("Could not create level [" + priStr + |
| "]. Reported error follows.", oops); |
| return; |
| } |
| } |
| } |
| LOGGER.debug("{} level set to {}", catName, logger.getLevel()); |
| } |
| |
| private void setParameter(Element elem, PropertySetter propSetter) { |
| String name = subst(elem.getAttribute(NAME_ATTR)); |
| String value = (elem.getAttribute(VALUE_ATTR)); |
| value = subst(OptionConverter.convertSpecialChars(value)); |
| propSetter.setProperty(name, value); |
| } |
| |
| /** |
| * Used internally to configure the log4j framework by parsing a DOM |
| * tree of XML elements based on <a |
| * href="doc-files/log4j.dtd">log4j.dtd</a>. |
| */ |
| private void parse(Element element) { |
| String rootElementName = element.getTagName(); |
| |
| if (!rootElementName.equals(CONFIGURATION_TAG)) { |
| if (rootElementName.equals(OLD_CONFIGURATION_TAG)) { |
| LOGGER.warn("The <" + OLD_CONFIGURATION_TAG + |
| "> element has been deprecated."); |
| LOGGER.warn("Use the <" + CONFIGURATION_TAG + "> element instead."); |
| } else { |
| LOGGER.error("DOM element is - not a <" + CONFIGURATION_TAG + "> element."); |
| return; |
| } |
| } |
| |
| |
| String debugAttrib = subst(element.getAttribute(INTERNAL_DEBUG_ATTR)); |
| |
| LOGGER.debug("debug attribute= \"" + debugAttrib + "\"."); |
| // if the log4j.dtd is not specified in the XML file, then the |
| // "debug" attribute is returned as the empty string. |
| String status = "error"; |
| if (!debugAttrib.equals("") && !debugAttrib.equals("null")) { |
| status = OptionConverter.toBoolean(debugAttrib, true) ? "debug" : "error"; |
| |
| } else { |
| LOGGER.debug("Ignoring " + INTERNAL_DEBUG_ATTR + " attribute."); |
| } |
| |
| String confDebug = subst(element.getAttribute(CONFIG_DEBUG_ATTR)); |
| if (!confDebug.equals("") && !confDebug.equals("null")) { |
| LOGGER.warn("The \"" + CONFIG_DEBUG_ATTR + "\" attribute is deprecated."); |
| LOGGER.warn("Use the \"" + INTERNAL_DEBUG_ATTR + "\" attribute instead."); |
| status = OptionConverter.toBoolean(confDebug, true) ? "debug" : "error"; |
| } |
| |
| final StatusConfiguration statusConfig = new StatusConfiguration().setStatus(status); |
| statusConfig.initialize(); |
| |
| forEachElement(element.getChildNodes(), (currentElement) -> { |
| switch (currentElement.getTagName()) { |
| case CATEGORY: case LOGGER_ELEMENT: |
| parseCategory(currentElement); |
| break; |
| case ROOT_TAG: |
| parseRoot(currentElement); |
| break; |
| case RENDERER_TAG: |
| LOGGER.warn("Renderers are not supported by Log4j 2 and will be ignored."); |
| break; |
| case THROWABLE_RENDERER_TAG: |
| LOGGER.warn("Throwable Renderers are not supported by Log4j 2 and will be ignored."); |
| break; |
| case CATEGORY_FACTORY_TAG: case LOGGER_FACTORY_TAG: |
| LOGGER.warn("Log4j 1 Logger factories are not supported by Log4j 2 and will be ignored."); |
| break; |
| case APPENDER_TAG: |
| Appender appender = parseAppender(currentElement); |
| appenderMap.put(appender.getName(), appender); |
| if (appender instanceof AppenderWrapper) { |
| addAppender(((AppenderWrapper) appender).getAppender()); |
| } else { |
| addAppender(new AppenderAdapter(appender).getAdapter()); |
| } |
| break; |
| default: |
| quietParseUnrecognizedElement(null, currentElement, props); |
| } |
| }); |
| } |
| |
| private String subst(final String value) { |
| return getStrSubstitutor().replace(value); |
| } |
| |
| public static void forEachElement(NodeList list, Consumer<Element> consumer) { |
| final int length = list.getLength(); |
| for (int loop = 0; loop < length; loop++) { |
| Node currentNode = list.item(loop); |
| |
| if (currentNode.getNodeType() == Node.ELEMENT_NODE) { |
| Element currentElement = (Element) currentNode; |
| consumer.accept(currentElement); |
| } |
| } |
| } |
| |
| private interface ParseAction { |
| Document parse(final DocumentBuilder parser) throws SAXException, IOException; |
| } |
| |
| private static class SAXErrorHandler implements org.xml.sax.ErrorHandler { |
| private static final org.apache.logging.log4j.Logger LOGGER = StatusLogger.getLogger(); |
| |
| public void error(final SAXParseException ex) { |
| emitMessage("Continuable parsing error ", ex); |
| } |
| |
| public void fatalError(final SAXParseException ex) { |
| emitMessage("Fatal parsing error ", ex); |
| } |
| |
| public void warning(final SAXParseException ex) { |
| emitMessage("Parsing warning ", ex); |
| } |
| |
| private static void emitMessage(final String msg, final SAXParseException ex) { |
| LOGGER.warn("{} {} and column {}", msg, ex.getLineNumber(), ex.getColumnNumber()); |
| LOGGER.warn(ex.getMessage(), ex.getException()); |
| } |
| } |
| |
| private static class ConsumerException extends RuntimeException { |
| |
| ConsumerException(Exception ex) { |
| super(ex); |
| } |
| } |
| } |
