Attachment #21436 for bug #44308

View | Details | Raw Unified | Return to bug 44308
Collapse All | Expand All




/**
 *
 */
package org.apache.log4j.jmx;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.log4j.Level;
import org.apache.log4j.Logger;

/**
 * LoggerManager implementation with additional rollback support to be able to undo the changes
 * done by this class.
 * @see LoggerManager
 * @author Stefan Fleiter
 */
public class RollbackableLoggerManager extends LoggerManager {

    /**
     * Thread safety guaranteed by locking on this (instance of LoggerManager) on every access.
     */
    private final Map savedLoggerConfiguration = new HashMap();

    /**
     * Sets the level of the specified logger.
     * Can be overriden to do something additional when modifying loggers.
     * @param logger Log4j Logger Instance
     * @param level New level as string
     * @return true, if level has changed, false if level is same as before
     */
    protected boolean doSetLogLogLevel(Logger logger, String level) {
        Level originalLevel = logger.getLevel();
        boolean modified = super.doSetLogLogLevel(logger, level);
        synchronized (savedLoggerConfiguration) {
            if (!savedLoggerConfiguration.containsKey(logger)) {
                savedLoggerConfiguration.put(logger, originalLevel);
            }
        }
        return modified;
    }

    /**
     * Rolls back all modifications which where done to the log configuration by this instance.
     */
    public synchronized void rollbackLogConfiguration() {
        synchronized (savedLoggerConfiguration) {
            for (Iterator it = savedLoggerConfiguration.entrySet().iterator(); it.hasNext(); ) {
                Map.Entry entry = (Entry) it.next();
                Logger logger = (Logger) entry.getKey();
                Level originalLevel = (Level) entry.getValue();
                logger.setLevel(originalLevel);
            }
            savedLoggerConfiguration.clear();
        }
    }

    /**
     * Shutdown hook which clears all references, but does not call <code>resetLogConfiguration</code>
     * @see #resetLogConfiguration()
     */
    public void destroy() {
        synchronized (savedLoggerConfiguration) {
            savedLoggerConfiguration.clear();
        }
    }

}




package org.apache.log4j.jmx;

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Level;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.apache.log4j.spi.LoggerRepository;

/**
 * Helper for reading and modifying the logger configuration of a running log4j instance.
 * This class is thread safe.
 * @author Stefan Fleiter
 */
public class LoggerManager {

    /**
     * Returns a Level instance matching the given string representation.
     * @param levelName Name of the level of INHERITED to inherit level from the next ancestor.
     * @return Level matching levelName, null for INHERITED
     * @throws IllegalArgumentException levelName does not represent a known level
     */
    Level getLevelByName(String levelName) throws IllegalArgumentException {
        Level level = Level.toLevel(levelName, null);
        if (null == level && null != levelName) {
            String lowerLevelName = levelName.toLowerCase();
            if (!"inherit".equals(lowerLevelName) &&
                    !"inherited".equals(lowerLevelName) &&
                    !"null".equals(lowerLevelName)) {
                throw new IllegalArgumentException('"' + levelName + "\" is not a valid level");
            }
        }
        return level;
    }

    /**
     * Returns the string representation of the given Level.
     * @param level Level instance
     * @return Name of level or null if level is null
     */
    String getLogLevelString(Level level) {
        return null == level ? null : level.toString();
    }


    /**
     * Returns the explicit set level of a specified logger.
     * @param loggerName Name of the logger
     * @return Level of the logger
     */
    public String getLogLevel(String loggerName) {
        return getLogLevelString(LogManager.getLogger(loggerName).getLevel());
    }

    /**
     * Returns the effective level (the level set on this logger or if not set explicitly the
     * level of the next ancestor) of the specified logger.
     * @param loggerName Name of logger either existing or to be created
     * @return Effective level of the logger
     */
    public String getEffectiveLogLevel(String loggerName) {
        return getLogLevelString(LogManager.getLogger(loggerName).getEffectiveLevel());
    }

    /**
     * Compares two levels and returns whether they are equal.
     * @param first first level
     * @param second second level
     * @return true if levels are equal
     */
    boolean levelEquals(Level first, Level second) {
        if (null == first) {
            return null == second;
        } else {
            return first.equals(second);
        }
    }

    /**
     * Sets the level of the specified logger.
     * @param loggerName Name of logger either existing or to be created
     * @param level New level
     * @throws IllegalArgumentException levelName does not represent a known level
     */
    public void setLogLevel(String loggerName, String level) throws IllegalArgumentException {
        Logger logger = LogManager.getLogger(loggerName);
        doSetLogLogLevel(logger, level);
    }

    /**
     * Returns the level of the root logger.
     * @return Level of the logger
     */
    public String getRootLogLevel() {
        return getLogLevelString(LogManager.getRootLogger().getLevel());
    }

    /**
     * Sets the level of the specified logger.
     * @param level New level
     * @throws IllegalArgumentException levelName does not represent a known level
     */
    public void setRootLogLevel(String level) throws IllegalArgumentException {
        Logger logger = LogManager.getRootLogger();
        doSetLogLogLevel(logger, level);
    }

    /**
     * Sets the level of the specified logger.
     * Can be overriden to do something additional when modifying loggers.
     * @param logger Log4j Logger Instance
     * @param level New level as string
     * @return true, if level has changed, false if level is same as before
     */
    protected boolean doSetLogLogLevel(Logger logger, String level) {
        Level originalLevel = logger.getLevel();
        Level newLevel = getLevelByName(level);
        boolean modified = false;
        if (!levelEquals(newLevel, originalLevel)) {
            modified  = true;
            logger.setLevel(newLevel);
        }
        return modified;
    }

    /**
     * Shutdown hook.
     */
    public void destroy() {
        // nothing to do
    }

    /**
     * Returns a map of all explicitly configured loggers with the level as value.
     * @return map of logger names and level names
     */
    public Map getLogConfiguration() {
        Map result = new HashMap();
        List loggers = getConfiguredLoggersInternal();
        for (Iterator it = loggers.iterator(); it.hasNext(); ) {
            Logger logger = (Logger) it.next();
            result.put(logger.getName(), logger.getEffectiveLevel().toString());
        }
        return result;
    }

    /**
     * @return all explicitly configured loggers
     */
    List getConfiguredLoggersInternal() {
        List result = new ArrayList();
        LoggerRepository r = LogManager.getLoggerRepository();
        Enumeration loggers = r.getCurrentLoggers();
        while (loggers.hasMoreElements()) {
            Logger logger = (Logger) loggers.nextElement();
            if (null != logger.getLevel()) {
                result.add(logger);
            }
        }
        result.add(LogManager.getRootLogger());
        return result;
    }

    /**
     * Returns the names of all loggers with an explicit set level
     * (Logger{@link #getLogLevel(String)} is not null).
     * @return array of names of all explicitly configured loggers
     */
    public String[] getConfiguredLoggers() {
        List configuredLoggers = getConfiguredLoggersInternal();
        String[] result = new String[configuredLoggers.size()];
        for (int i = 0; i < configuredLoggers.size(); ++i) {
            result[i] = ((Logger) configuredLoggers.get(i)).getName();
        }
        return result;
    }

}




package org.apache.log4j.jmx;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.management.Descriptor;
import javax.management.MBeanException;
import javax.management.MBeanOperationInfo;
import javax.management.MBeanParameterInfo;
import javax.management.RuntimeOperationsException;
import javax.management.modelmbean.DescriptorSupport;
import javax.management.modelmbean.ModelMBeanAttributeInfo;
import javax.management.modelmbean.ModelMBeanConstructorInfo;
import javax.management.modelmbean.ModelMBeanInfo;
import javax.management.modelmbean.ModelMBeanInfoSupport;
import javax.management.modelmbean.ModelMBeanNotificationInfo;
import javax.management.modelmbean.ModelMBeanOperationInfo;
import javax.management.modelmbean.RequiredModelMBean;

/**
 * Model MBean which makes the methods of <code>LoggerManager</code> available per JMX.
 * @author Stefan Fleiter
 * @see LoggerManager
 */
public class LoggerManagerModelMBean extends RequiredModelMBean {

    private final LoggerManager loggerManager;

    /**
     * Constructor.
     * @throws MBeanException user Exception of MBean
     * @throws RuntimeOperationsException Runtime Exceptions in the MBeanServer
     */
    public LoggerManagerModelMBean() throws MBeanException, RuntimeOperationsException {
        this(new LoggerManager());
    }

    /**
     * Constructor to use an own instance of LoggerManager to represent per JMX.
     * @param loggerManager Instance of LoggerManager to represent as MBean
     * @throws MBeanException user Exception of MBean
     * @throws RuntimeOperationsException Runtime Exceptions in the MBeanServer
     */
    public LoggerManagerModelMBean(LoggerManager loggerManager) throws MBeanException, RuntimeOperationsException {
        this.loggerManager = loggerManager;
        setModelMBeanInfo(getModelMBeanInfo());
        try {
            setManagedResource(loggerManager, "ObjectReference");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Constructs the ModelMBeanInfo for this Model MBean.
     * @return ModelMBeanInfo instance
     * @throws MBeanException user Exception of MBean
     * @throws RuntimeOperationsException Runtime Exceptions in the MBeanServer
     */
    ModelMBeanInfo getModelMBeanInfo() throws RuntimeOperationsException, MBeanException {
        Descriptor managerDescriptor = new DescriptorSupport(new String[] {
                "name=" + "log4j:manager",
                "descriptorType=mbean",
                "displayName=Log4jManager",
                "type=" + LoggerManager.class.getName(),
        });

        ModelMBeanOperationInfo getLogConfiguration = createOperationInfo(
                "getLogConfiguration",
                "Return the levels of all explicitly configured loggers",
                new MBeanParameterInfo[0],
                Map.class,
                ModelMBeanOperationInfo.INFO
                );
        ModelMBeanOperationInfo getConfiguredLoggers = createOperationInfo(
                "getConfiguredLoggers",
                "Return the names of the explicitly configured loggers",
                new MBeanParameterInfo[0],
                String[].class,
                ModelMBeanOperationInfo.INFO
                );


        ModelMBeanOperationInfo getRootLogLevel = createOperationInfo(
                "getRootLogLevel",
                "Return the level of the root logger",
                new MBeanParameterInfo[0],
                String.class,
                MBeanOperationInfo.INFO
                );
        ModelMBeanOperationInfo setRootLogLevel = createOperationInfo(
                "setRootLogLevel",
                "Set the level of the root logger",
                new MBeanParameterInfo[] {
                        new MBeanParameterInfo(
                                "level",
                                String.class.getName(),
                                "New level of root logger (INHERITED to inherit level from next ancestor)"
                                ),

                },
                void.class,
                ModelMBeanOperationInfo.ACTION
                );

        ModelMBeanOperationInfo getLogLevel = createOperationInfo(
                "getLogLevel",
                "Return the level explicitly set at the specified logger, null if this logger INHERITS its level",
                new MBeanParameterInfo[] {
                        new MBeanParameterInfo(
                                "logger",
                                String.class.getName(),
                                "Name of logger to query level"
                                ),
                },
                String.class,
                MBeanOperationInfo.INFO
                );
        ModelMBeanOperationInfo getEffectiveLogLevel = createOperationInfo(
                "getEffectiveLogLevel",
                "Return the effective level of the specified logger " +
                        "(the explicitly specified level or the level of the next ancestor)",
                new MBeanParameterInfo[] {
                        new MBeanParameterInfo(
                                "logger",
                                String.class.getName(),
                                "Name of logger to query level"
                                ),
                },
                String.class,
                MBeanOperationInfo.INFO
                );
        ModelMBeanOperationInfo setLogLevel = createOperationInfo(
                "setLogLevel",
                "Set the level of the specified logger",
                new MBeanParameterInfo[] {
                        new MBeanParameterInfo(
                                "logger",
                                String.class.getName(),
                                "name of logger to modify level"

                                ),
                            new MBeanParameterInfo(
                                    "level",
                                    String.class.getName(),
                                    "new level of specified logger (INHERITED to inherit level from next ancestor)"
                                    ),
                },
                void.class,
                MBeanOperationInfo.ACTION
                );

        ModelMBeanOperationInfo rollbackLogConfiguration = createOperationInfo(
                "rollbackLogConfiguration",
                "Resets all loggers to its' states before calling actions in this MBean",
                new MBeanParameterInfo[0],
                void.class,
                MBeanOperationInfo.ACTION
                );


        ModelMBeanAttributeInfo rootLoggerAttribute = createAttributeInfo(
                "rootLogger",
                "Level of root logger",
                String.class,
                true,
                true,
                false,
                "getRootLogLevel",
                "setRootLogLevel"
                );

        ModelMBeanAttributeInfo configuredLoggersAttribute = createAttributeInfo(
                "configuredLoggers",
                "Names of all loggers with explicitly set log levels",
                String[].class,
                true,
                false,
                false,
                "getConfiguredLoggers",
                null
                );

        ModelMBeanAttributeInfo logConfigurationAttribute = createAttributeInfo(
                "logConfiguration",
                "Name of all explicitly configured loggers with their log level",
                Map.class,
                true,
                false,
                false,
                "getLogConfiguration",
                null
                );


        ModelMBeanOperationInfo[] infoArray = new ModelMBeanOperationInfo[] {
                getLogConfiguration, getConfiguredLoggers,
                getRootLogLevel, setRootLogLevel,
                getLogLevel, getEffectiveLogLevel, setLogLevel,
                };

        // dynamically register rollbackLogConfiguration, but only if our LoggerManager has that method
        List modelMBeanOperations = new ArrayList();
        try {
            loggerManager.getClass().getMethod("rollbackLogConfiguration", null);
            modelMBeanOperations.add(rollbackLogConfiguration);
        } catch (NoSuchMethodException expected) {
            // nothing to do
        }
        for (int i = 0; i < infoArray.length; ++i) {
            modelMBeanOperations.add(infoArray[i]);
        }

        ModelMBeanInfo mbeanInfo = new ModelMBeanInfoSupport(
                loggerManager.getClass().getName(),
                "Model MBean for Manager Logger Configuration of Log4j",
                new ModelMBeanAttributeInfo[] {
                    rootLoggerAttribute,
                    configuredLoggersAttribute,
                    logConfigurationAttribute,
                    },
                new ModelMBeanConstructorInfo[] {},
                (ModelMBeanOperationInfo[]) modelMBeanOperations.toArray(
                        new ModelMBeanOperationInfo[modelMBeanOperations.size()]),
                new ModelMBeanNotificationInfo[] {},
                managerDescriptor
                );


        return mbeanInfo;
    }


    /**
     * Helper Method for registering operations of LoggerManager.
     * @param name Name of operation
     * @param description describes what the operation does
     * @param parameters parameters of the operation
     * @param returnType class which is returned by the to be registered method
     * @param operationInfo INFO if non-modifying and ACTION if modifying status
     * @return ModelMBeanOperationInfo for the described method
     */
    ModelMBeanOperationInfo createOperationInfo(String name,
            String description, MBeanParameterInfo[] parameters,
            Class returnType, int operationInfo) {
        return new ModelMBeanOperationInfo(
                name,
                description,
                parameters,
                returnType.getName(),
                operationInfo,
                new DescriptorSupport(new String[] {
                        "name=" + name,
                        "displayName=" + description,
                        "descriptorType=operation",
                        "class=" + loggerManager.getClass().getName(),
                        "role=operation",
                    })
                );
    }

    /**
     * Helper Method for registering attributes of LoggerManager.
     * @param name Name of attribute
     * @param description describes what the attribute is for
     * @param type type of attribute (return value of get and parameter of set Operation)
     * @param readable true, if attribute can be read
     * @param writable true, if attribute can be set
     * @param is true if the attribute has an "is" getter, false otherwise
     * @param getMethod name of getter Method
     * @param setMethod name of setter Method
     * @return ModelMBeanAttributeInfo for the described method
     */
    ModelMBeanAttributeInfo createAttributeInfo(String name,
            String description, Class type,
            boolean readable, boolean writable, boolean is,
            String getMethod, String setMethod) {
        return new ModelMBeanAttributeInfo(
                name,
                type.getName(),
                description,
                readable, writable, is,
                new DescriptorSupport(new String[] {
                        "name=" + name,
                        "descriptorType=attribute",
                        "displayName=" + description,
                        "getMethod=" + getMethod,
                        "setMethod=" + setMethod,
                    })
                );
    }

    /**
     * Calls <code>LoggerManager#destroy()</code>.
     * @see LoggerManager#destroy()
     * {@inheritDoc}}
     */
    public void postDeregister() {
        loggerManager.destroy();
        super.postDeregister();
    }


}

Return to bug 44308

Line 0 Link Here

(-)src/main/java/org/apache/log4j/jmx/LoggerManager.java (+183 lines)
		1	package org.apache.log4j.jmx;
		2
		3	import java.util.ArrayList;
		4	import java.util.Enumeration;
		5	import java.util.HashMap;
		6	import java.util.Iterator;
		7	import java.util.List;
		8	import java.util.Map;
		9
		10	import org.apache.log4j.Level;
		11	import org.apache.log4j.LogManager;
		12	import org.apache.log4j.Logger;
		13	import org.apache.log4j.spi.LoggerRepository;
		14
		15	/**
		16	* Helper for reading and modifying the logger configuration of a running log4j instance.
		17	* This class is thread safe.
		18	* @author Stefan Fleiter
		19	*/
		20	public class LoggerManager {
		21
		22	/**
		23	* Returns a Level instance matching the given string representation.
		24	* @param levelName Name of the level of INHERITED to inherit level from the next ancestor.
		25	* @return Level matching levelName, null for INHERITED
		26	* @throws IllegalArgumentException levelName does not represent a known level
		27	*/
		28	Level getLevelByName(String levelName) throws IllegalArgumentException {
		29	Level level = Level.toLevel(levelName, null);
		30	if (null == level && null != levelName) {
		31	String lowerLevelName = levelName.toLowerCase();
		32	if (!"inherit".equals(lowerLevelName) &&
		33	!"inherited".equals(lowerLevelName) &&
		34	!"null".equals(lowerLevelName)) {
		35	throw new IllegalArgumentException('"' + levelName + "\" is not a valid level");
		36	}
		37	}
		38	return level;
		39	}
		40
		41	/**
		42	* Returns the string representation of the given Level.
		43	* @param level Level instance
		44	* @return Name of level or null if level is null
		45	*/
		46	String getLogLevelString(Level level) {
		47	return null == level ? null : level.toString();
		48	}
		49
		50
		51	/**
		52	* Returns the explicit set level of a specified logger.
		53	* @param loggerName Name of the logger
		54	* @return Level of the logger
		55	*/
		56	public String getLogLevel(String loggerName) {
		57	return getLogLevelString(LogManager.getLogger(loggerName).getLevel());
		58	}
		59
		60	/**
		61	* Returns the effective level (the level set on this logger or if not set explicitly the
		62	* level of the next ancestor) of the specified logger.
		63	* @param loggerName Name of logger either existing or to be created
		64	* @return Effective level of the logger
65	*/
66	public String getEffectiveLogLevel(String loggerName) {
67	return getLogLevelString(LogManager.getLogger(loggerName).getEffectiveLevel());
68	}
69
70	/**
71	* Compares two levels and returns whether they are equal.
72	* @param first first level
73	* @param second second level
74	* @return true if levels are equal
75	*/
76	boolean levelEquals(Level first, Level second) {
77	if (null == first) {
78	return null == second;
79	} else {
80	return first.equals(second);
81	}
82	}
83
84	/**
85	* Sets the level of the specified logger.
86	* @param loggerName Name of logger either existing or to be created
87	* @param level New level
88	* @throws IllegalArgumentException levelName does not represent a known level
89	*/
90	public void setLogLevel(String loggerName, String level) throws IllegalArgumentException {
91	Logger logger = LogManager.getLogger(loggerName);
92	doSetLogLogLevel(logger, level);
93	}
94
95	/**
96	* Returns the level of the root logger.
97	* @return Level of the logger
98	*/
99	public String getRootLogLevel() {
100	return getLogLevelString(LogManager.getRootLogger().getLevel());
101	}
102
103	/**
104	* Sets the level of the specified logger.
105	* @param level New level
106	* @throws IllegalArgumentException levelName does not represent a known level
107	*/
108	public void setRootLogLevel(String level) throws IllegalArgumentException {
109	Logger logger = LogManager.getRootLogger();
110	doSetLogLogLevel(logger, level);
111	}
112
113	/**
114	* Sets the level of the specified logger.
115	* Can be overriden to do something additional when modifying loggers.
116	* @param logger Log4j Logger Instance
117	* @param level New level as string
118	* @return true, if level has changed, false if level is same as before
119	*/
120	protected boolean doSetLogLogLevel(Logger logger, String level) {
121	Level originalLevel = logger.getLevel();
122	Level newLevel = getLevelByName(level);
123	boolean modified = false;
124	if (!levelEquals(newLevel, originalLevel)) {
125	modified = true;
126	logger.setLevel(newLevel);
127	}
128	return modified;
129	}
130
131	/**
132	* Shutdown hook.
133	*/
134	public void destroy() {
135	// nothing to do
136	}
137
138	/**
139	* Returns a map of all explicitly configured loggers with the level as value.
140	* @return map of logger names and level names
141	*/
142	public Map getLogConfiguration() {
143	Map result = new HashMap();
144	List loggers = getConfiguredLoggersInternal();
145	for (Iterator it = loggers.iterator(); it.hasNext(); ) {
146	Logger logger = (Logger) it.next();
147	result.put(logger.getName(), logger.getEffectiveLevel().toString());
148	}
149	return result;
150	}
151
152	/**
153	* @return all explicitly configured loggers
154	*/
155	List getConfiguredLoggersInternal() {
156	List result = new ArrayList();
157	LoggerRepository r = LogManager.getLoggerRepository();
158	Enumeration loggers = r.getCurrentLoggers();
159	while (loggers.hasMoreElements()) {
160	Logger logger = (Logger) loggers.nextElement();
161	if (null != logger.getLevel()) {
162	result.add(logger);
163	}
164	}
165	result.add(LogManager.getRootLogger());
166	return result;
167	}
168
169	/**
170	* Returns the names of all loggers with an explicit set level
171	* (Logger{@link #getLogLevel(String)} is not null).
172	* @return array of names of all explicitly configured loggers
173	*/
174	public String[] getConfiguredLoggers() {
175	List configuredLoggers = getConfiguredLoggersInternal();
176	String[] result = new String[configuredLoggers.size()];
177	for (int i = 0; i < configuredLoggers.size(); ++i) {
178	result[i] = ((Logger) configuredLoggers.get(i)).getName();
179	}
180	return result;
181	}
182
183	}

Line 0 Link Here

(-)src/main/java/org/apache/log4j/jmx/RollbackableLoggerManager.java (+70 lines)
		1	/**
		2	*
		3	*/
		4	package org.apache.log4j.jmx;
		5
		6	import java.util.HashMap;
		7	import java.util.Iterator;
		8	import java.util.Map;
		9	import java.util.Map.Entry;
		10
		11	import org.apache.log4j.Level;
		12	import org.apache.log4j.Logger;
		13
		14	/**
		15	* LoggerManager implementation with additional rollback support to be able to undo the changes
		16	* done by this class.
		17	* @see LoggerManager
		18	* @author Stefan Fleiter
		19	*/
		20	public class RollbackableLoggerManager extends LoggerManager {
		21
		22	/**
		23	* Thread safety guaranteed by locking on this (instance of LoggerManager) on every access.
		24	*/
		25	private final Map savedLoggerConfiguration = new HashMap();
		26
		27	/**
		28	* Sets the level of the specified logger.
		29	* Can be overriden to do something additional when modifying loggers.
		30	* @param logger Log4j Logger Instance
		31	* @param level New level as string
		32	* @return true, if level has changed, false if level is same as before
		33	*/
		34	protected boolean doSetLogLogLevel(Logger logger, String level) {
		35	Level originalLevel = logger.getLevel();
		36	boolean modified = super.doSetLogLogLevel(logger, level);
		37	synchronized (savedLoggerConfiguration) {
		38	if (!savedLoggerConfiguration.containsKey(logger)) {
		39	savedLoggerConfiguration.put(logger, originalLevel);
		40	}
		41	}
		42	return modified;
		43	}
		44
		45	/**
		46	* Rolls back all modifications which where done to the log configuration by this instance.
		47	*/
		48	public synchronized void rollbackLogConfiguration() {
		49	synchronized (savedLoggerConfiguration) {
		50	for (Iterator it = savedLoggerConfiguration.entrySet().iterator(); it.hasNext(); ) {
		51	Map.Entry entry = (Entry) it.next();
		52	Logger logger = (Logger) entry.getKey();
		53	Level originalLevel = (Level) entry.getValue();
		54	logger.setLevel(originalLevel);
		55	}
		56	savedLoggerConfiguration.clear();
		57	}
		58	}
		59
		60	/**
		61	* Shutdown hook which clears all references, but does not call <code>resetLogConfiguration</code>
		62	* @see #resetLogConfiguration()
		63	*/
		64	public void destroy() {
65	synchronized (savedLoggerConfiguration) {
66	savedLoggerConfiguration.clear();
67	}
68	}
69
70	}