String className = subst(factoryElement.getAttribute(CLASS_ATTR)); LogLog.error("Category Factory tag " + CLASS_ATTR + " attribute not found."); LogLog.debug("No Category Factory configured."); LogLog.debug("Desired category factory: ["+className+']'); Object factory = OptionConverter.instantiateByClassName(className, LoggerFactory.class, null); LogLog.error("Category Factory class " + className + " does not implement org.apache.log4j.LoggerFactory"); PropertySetter propSetter = new PropertySetter(factory); NodeList children = factoryElement.getChildNodes(); final int length = children.getLength(); currentNode = children.item(loop); if (currentNode.getNodeType() == Node.ELEMENT_NODE) { currentElement = (Element)currentNode; if (currentElement.getTagName().equals(PARAM_TAG)) { setParameter(currentElement, propSetter); } else { quietParseUnrecognizedElement(factory, currentElement, props);
/** Set the maximum size that the output file is allowed to reach before being rolled over to backup files. <p>In configuration files, the <b>MaxFileSize</b> option takes an long integer in the range 0 - 2^63. You can specify the value with the suffixes "KB", "MB" or "GB" so that the integer is interpreted being expressed respectively in kilobytes, megabytes or gigabytes. For example, the value "10KB" will be interpreted as 10240. */ public void setMaxFileSize(String value) { maxFileSize = OptionConverter.toFileSize(value, maxFileSize + 1); }
this.repository = repository; try { LogLog.debug("System property is :"+ OptionConverter.getSystemProperty(dbfKey, null)); dbf = DocumentBuilderFactory.newInstance(); LogLog.debug("Standard DocumentBuilderFactory search succeded."); LogLog.debug("DocumentBuilderFactory is: "+dbf.getClass().getName()); } catch(FactoryConfigurationError fce) { Exception e = fce.getException(); parse(doc.getDocumentElement()); } catch (Exception e) { if (e instanceof InterruptedException || e instanceof InterruptedIOException) {
public static Object instantiateByKey(Properties props, String key, Class superClass, Object defaultValue) { // Get the value of the property in string form String className = findAndSubst(key, props); if(className == null) { LogLog.error("Could not find value for key " + key); return defaultValue; } // Trim className to avoid trailing spaces that cause problems. return OptionConverter.instantiateByClassName(className.trim(), superClass, defaultValue); }
/** Check the provided <code>Properties</code> object for a {@link org.apache.log4j.spi.LoggerFactory LoggerFactory} entry specified by {@link #LOGGER_FACTORY_KEY}. If such an entry exists, an attempt is made to create an instance using the default constructor. This instance is used for subsequent Category creations within this configurator. @see #parseCatsAndRenderers */ protected void configureLoggerFactory(Properties props) { String factoryClassName = OptionConverter.findAndSubst(LOGGER_FACTORY_KEY, props); if(factoryClassName != null) { LogLog.debug("Setting category factory to ["+factoryClassName+"]."); loggerFactory = (LoggerFactory) OptionConverter.instantiateByClassName(factoryClassName, LoggerFactory.class, loggerFactory); PropertySetter.setProperties(loggerFactory, props, FACTORY_PREFIX + "."); } }
/** Parse the additivity option for a non-root category. */ void parseAdditivityForLogger(Properties props, Logger cat, String loggerName) { String value = OptionConverter.findAndSubst(ADDITIVITY_PREFIX + loggerName, props); LogLog.debug("Handling "+ADDITIVITY_PREFIX + loggerName+"=["+value+"]"); // touch additivity only if necessary if((value != null) && (!value.equals(""))) { boolean additivity = OptionConverter.toBoolean(value, true); LogLog.debug("Setting additivity for \""+loggerName+"\" to "+ additivity); cat.setAdditivity(additivity); } }
final Properties props, final Class expectedClass) throws Exception { String clazz = subst(element.getAttribute("class"), props); Object instance = OptionConverter.instantiateByClassName(clazz, expectedClass, null); PropertySetter propSetter = new PropertySetter(instance); NodeList children = element.getChildNodes(); final int length = children.getLength(); 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);
void parse(Element element) { String rootElementName = element.getTagName(); String debugAttrib = subst(element.getAttribute(INTERNAL_DEBUG_ATTR)); LogLog.setInternalDebugging(OptionConverter.toBoolean(debugAttrib, true)); String resetAttrib = subst(element.getAttribute(RESET_ATTR)); if (OptionConverter.toBoolean(resetAttrib, false)) { repository.resetConfiguration(); String confDebug = subst(element.getAttribute(CONFIG_DEBUG_ATTR)); LogLog.setInternalDebugging(OptionConverter.toBoolean(confDebug, true)); final int length = children.getLength(); currentNode = children.item(loop); if (currentNode.getNodeType() == Node.ELEMENT_NODE) { currentElement = (Element) currentNode; currentNode = children.item(loop); if (currentNode.getNodeType() == Node.ELEMENT_NODE) { currentElement = (Element) currentNode;
protected 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); }
void parseCategory (Element loggerElement) { String catName = subst(loggerElement.getAttribute(NAME_ATTR)); String className = subst(loggerElement.getAttribute(CLASS_ATTR)); LogLog.debug("Retreiving an instance of org.apache.log4j.Logger."); cat = (catFactory == null) ? repository.getLogger(catName) : repository.getLogger(catName, catFactory); LogLog.debug("Desired logger sub-class: ["+className+']'); try { Class clazz = Loader.loadClass(className); Thread.currentThread().interrupt(); LogLog.error("Could not retrieve category ["+catName+ "]. Reported error follows.", oops); return; boolean additivity = OptionConverter.toBoolean( subst(loggerElement.getAttribute(ADDITIVITY_ATTR)), true);
String priStr = subst(element.getAttribute(VALUE_ATTR)); LogLog.debug("Level value for "+catName+" is ["+priStr+"]."); LogLog.error("Root level cannot be inherited. Ignoring directive."); } else { logger.setLevel(null); String className = subst(element.getAttribute(CLASS_ATTR)); if(EMPTY_STR.equals(className)) { logger.setLevel(OptionConverter.toLevel(priStr, Level.DEBUG)); } else { LogLog.debug("Desired Level sub-class: ["+className+']'); try { Class clazz = Loader.loadClass(className);
@Override protected void setParameter(Element elem, PropertySetter propSetter) { String paramName = OptionConverter.substVars(elem.getAttribute("name"), properties); String value = elem.getAttribute("value"); value = OptionConverter.substVars(OptionConverter.convertSpecialChars(value), properties); propSetter.setProperty(paramName, value); } }
String layoutPrefix = prefix + ".layout"; appender = (Appender) OptionConverter.instantiateByKey(props, prefix, org.apache.log4j.Appender.class, null); if(appender == null) { LogLog.error( "Could not instantiate appender named \"" + appenderName+"\"."); return null; Layout layout = (Layout) OptionConverter.instantiateByKey(props, layoutPrefix, Layout.class, if(layout != null) { appender.setLayout(layout); LogLog.debug("Parsing layout options for \"" + appenderName +"\"."); PropertySetter.setProperties(layout, props, layoutPrefix + "."); LogLog.debug("End of parsing for \"" + appenderName +"\"."); PropertySetter.setProperties(appender, props, prefix + "."); LogLog.debug("Parsed \"" + appenderName +"\" options."); registryPut(appender); return appender;
value = properties.getProperty("log4j.configDebug"); if(value != null) LogLog.warn("[log4j.configDebug] is deprecated. Use [log4j.debug] instead."); LogLog.setInternalDebugging(OptionConverter.toBoolean(value, true)); if (reset != null && OptionConverter.toBoolean(reset, false)) { hierarchy.resetConfiguration(); String thresholdStr = OptionConverter.findAndSubst(THRESHOLD_PREFIX, properties); if(thresholdStr != null) { hierarchy.setThreshold(OptionConverter.toLevel(thresholdStr, (Level) Level.ALL)); LogLog.debug("Hierarchy threshold set to ["+hierarchy.getThreshold()+"]."); configureRootCategory(properties, hierarchy); configureLoggerFactory(properties); parseCatsAndRenderers(properties, hierarchy); LogLog.debug("Finished configuring.");
String layoutPrefix = prefix + ".layout"; appender = (Appender) OptionConverter.instantiateByKey(props, prefix, org.apache.log4j.Appender.class, null); if(appender == null) { LogLog.error( "Could not instantiate appender named \"" + appenderName+"\"."); return null; Layout layout = (Layout) OptionConverter.instantiateByKey(props, layoutPrefix, Layout.class, PropertySetter.setProperties(layout, props, layoutPrefix + "."); String errorHandlerClass = OptionConverter.findAndSubst(errorHandlerPrefix, props); if (errorHandlerClass != null) { ErrorHandler eh = (ErrorHandler) OptionConverter.instantiateByKey(props, errorHandlerPrefix, ErrorHandler.class, PropertySetter.setProperties(eh, edited, errorHandlerPrefix + "."); PropertySetter.setProperties(appender, props, prefix + "."); parseAppenderFilters(props, appenderName, appender);
String value = OptionConverter.findAndSubst(key, props); filterOpts.add(new NameValue(name, value)); String clazz = props.getProperty(key); if (clazz != null) { LogLog.debug("Filter key: ["+key+"] class: ["+props.getProperty(key) +"] props: "+filters.get(key)); Filter filter = (Filter) OptionConverter.instantiateByClassName(clazz, Filter.class, null); if (filter != null) { PropertySetter propSetter = new PropertySetter(filter); Vector v = (Vector)filters.get(key); Enumeration filterProps = v.elements(); while (filterProps.hasMoreElements()) { NameValue kv = (NameValue)filterProps.nextElement(); propSetter.setProperty(kv.key, kv.value); propSetter.activate(); LogLog.debug("Adding filter of type ["+filter.getClass() +"] to appender named ["+appender.getName()+"]."); appender.addFilter(filter); LogLog.warn("Missing class definition for filter: ["+key+"]");
LogLog.debug("Preferred configurator class: " + clazz); configurator = (Configurator) instantiateByClassName(clazz, Configurator.class, null); if(configurator == null) { LogLog.error("Could not instantiate configurator ["+clazz+"]."); return; configurator = new PropertyConfigurator();
String value = OptionConverter.findAndSubst(key, properties); key = key.substring(len); if (("layout".equals(key) || "errorhandler".equals(key)) && obj instanceof Appender) { PropertyDescriptor prop = getPropertyDescriptor(Introspector.decapitalize(key)); if (prop != null && OptionHandler.class.isAssignableFrom(prop.getPropertyType()) && prop.getWriteMethod() != null) { OptionHandler opt = (OptionHandler) OptionConverter.instantiateByKey(properties, prefix + key, prop.getPropertyType(), null); PropertySetter setter = new PropertySetter(opt); setter.setProperties(properties, prefix + key + "."); try { prop.getWriteMethod().invoke(this.obj, new Object[] { opt }); } catch(IllegalAccessException ex) { LogLog.warn("Failed to set property [" + key + "] to value \"" + value + "\". ", ex); } catch(InvocationTargetException ex) { Thread.currentThread().interrupt(); LogLog.warn("Failed to set property [" + key + "] to value \"" + value + "\". ", ex); } catch(RuntimeException ex) { LogLog.warn("Failed to set property [" + key + "] to value \"" + value + "\". ", ex);
loggerName = key.substring(LOGGER_PREFIX.length()); String value = OptionConverter.findAndSubst(key, props); Logger logger = hierarchy.getLogger(loggerName, loggerFactory); synchronized(logger) { parseCategory(props, logger, key, loggerName, value); parseAdditivityForLogger(props, logger, loggerName); String renderingClass = OptionConverter.findAndSubst(key, props); if(hierarchy instanceof RendererSupport) { RendererMap.addRenderer((RendererSupport) hierarchy, renderedClass, if (hierarchy instanceof ThrowableRendererSupport) { ThrowableRenderer tr = (ThrowableRenderer) OptionConverter.instantiateByKey(props, THROWABLE_RENDERER_PREFIX, org.apache.log4j.spi.ThrowableRenderer.class, null); if(tr == null) { LogLog.error( "Could not instantiate throwableRenderer."); } else { PropertySetter setter = new PropertySetter(tr); setter.setProperties(props, THROWABLE_RENDERER_PREFIX + "."); ((ThrowableRendererSupport) hierarchy).setThrowableRenderer(tr);
/** Add a renderer to a hierarchy passed as parameter. */ static public void addRenderer(RendererSupport repository, String renderedClassName, String renderingClassName) { LogLog.debug("Rendering class: ["+renderingClassName+"], Rendered class: ["+ renderedClassName+"]."); ObjectRenderer renderer = (ObjectRenderer) OptionConverter.instantiateByClassName(renderingClassName, ObjectRenderer.class, null); if(renderer == null) { LogLog.error("Could not instantiate renderer ["+renderingClassName+"]."); return; } else { try { Class renderedClass = Loader.loadClass(renderedClassName); repository.setRenderer(renderedClass, renderer); } catch(ClassNotFoundException e) { LogLog.error("Could not find class ["+renderedClassName+"].", e); } } }