QPID-1648: Add LoggingManagement and associated MBean to enable dynamic reloading of log4j file. Update sample log4js so that they aren't arbitrarily rewritten.

Patch from Robbie Gemmell <gemmellr@dcs.gla.ac.uk>

merged from trunk r747870


git-svn-id: https://svn.apache.org/repos/asf/qpid/branches/0.5-fix@764443 13f79535-47bb-0310-9956-ffa450edef68

7 files changed, 2485 insertions, 42 deletions

diff --git a/qpid/java/broker/etc/debug.log4j.xml b/qpid/java/broker/etc/debug.log4j.xml
index 71f9502b75..fc0bd9f34f 100644
--- a/qpid/java/broker/etc/debug.log4j.xml
+++ b/qpid/java/broker/etc/debug.log4j.xml
@@ -1,4 +1,4 @@
-<?xml version="1.0"?>
+<?xml version="1.0" encoding="UTF-8"?>
 <!--
  -
  - Licensed to the Apache Software Foundation (ASF) under one
@@ -18,10 +18,10 @@
  - specific language governing permissions and limitations
  - under the License.
  -
- -->
-<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
-<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
-    <appender name="ArchivingFileAppender" class="org.apache.log4j.QpidCompositeRollingAppender">
+ --><!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
+
+<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/" debug="null" threshold="null">
+    <appender class="org.apache.log4j.QpidCompositeRollingAppender" name="ArchivingFileAppender">
         <!-- Ensure that logs allways have the dateFormat set-->
         <param name="StaticLogFileName" value="false"/>
         <param name="File" value="${QPID_WORK}/log/${logprefix}qpid${logsuffix}.log"/>
@@ -48,7 +48,7 @@
         </layout>
     </appender>
 
-    <appender name="FileAppender" class="org.apache.log4j.FileAppender">
+    <appender class="org.apache.log4j.FileAppender" name="FileAppender">
         <param name="File" value="${QPID_WORK}/log/${logprefix}qpid${logsuffix}.log"/>
         <param name="Append" value="false"/>
 
@@ -57,7 +57,7 @@
         </layout>
     </appender>
 
-    <appender name="AlertFile" class="org.apache.log4j.FileAppender">
+    <appender class="org.apache.log4j.FileAppender" name="AlertFile">
         <param name="File" value="${QPID_WORK}/log/alert.log"/>
         <param name="Append" value="false"/>
 
@@ -66,28 +66,28 @@
         </layout>
     </appender>
 
-    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
+    <appender class="org.apache.log4j.ConsoleAppender" name="STDOUT">
 
         <layout class="org.apache.log4j.PatternLayout">
             <param name="ConversionPattern" value="%d %-5p [%t] %C{2} (%F:%L) - %m%n"/>
         </layout>
     </appender>
 
-    <category name="Qpid.Broker">
+    <category additivity="true" name="Qpid.Broker">
         <priority value="debug"/>
         <appender-ref ref="AlertFile"/>
         <!--appender-ref ref="STDOUT"/-->        
     </category>
 
 
-    <category name="org.apache.qpid.server.queue.AMQQueueMBean">
+    <category additivity="true" name="org.apache.qpid.server.queue.AMQQueueMBean">
         <priority value="info"/>
         <appender-ref ref="AlertFile"/>
     </category>
 
 
     <!-- Provide warnings to standard output -->
-    <!--category name="org.apache.qpid">
+    <!--category additivity="true" name="org.apache.qpid">
         <priority value="warn"/>
         <appender-ref ref="STDOUT"/>
     </category-->
@@ -96,11 +96,11 @@
     <!-- Additional level settings for debugging -->
     <!-- Each class in the Broker is a category that can have its logging level adjusted. -->
     <!-- This will provide more details if available about that classes processing. -->
-    <!--category name="org.apache.qpid.server.txn">
+    <!--category additivity="true" name="org.apache.qpid.server.txn">
         <priority value="debug"/>
     </category>-->
 
-    <!--<category name="org.apache.qpid.server.store">
+    <!--<category additivity="true" name="org.apache.qpid.server.store">
         <priority value="debug"/>
     </category-->
 
diff --git a/qpid/java/broker/etc/log4j.xml b/qpid/java/broker/etc/log4j.xml
index eff5d17588..a395d0fd56 100644
--- a/qpid/java/broker/etc/log4j.xml
+++ b/qpid/java/broker/etc/log4j.xml
@@ -1,4 +1,4 @@
-<?xml version="1.0"?>
+<?xml version="1.0" encoding="UTF-8"?>
 <!--
  -
  - Licensed to the Apache Software Foundation (ASF) under one
@@ -18,10 +18,10 @@
  - specific language governing permissions and limitations
  - under the License.
  -
- -->
-<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
-<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
-    <appender name="ArchivingFileAppender" class="org.apache.log4j.QpidCompositeRollingAppender">
+ --><!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
+
+<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/" debug="null" threshold="null">
+    <appender class="org.apache.log4j.QpidCompositeRollingAppender" name="ArchivingFileAppender">
         <!-- Ensure that logs allways have the dateFormat set-->
         <param name="StaticLogFileName" value="false"/>
         <param name="File" value="${QPID_WORK}/log/${logprefix}qpid${logsuffix}.log"/>
@@ -48,7 +48,7 @@
         </layout>
     </appender>
 
-    <appender name="FileAppender" class="org.apache.log4j.FileAppender">
+    <appender class="org.apache.log4j.FileAppender" name="FileAppender">
         <param name="File" value="${QPID_WORK}/log/${logprefix}qpid${logsuffix}.log"/>
         <param name="Append" value="false"/>
 
@@ -57,25 +57,25 @@
         </layout>
     </appender>
 
-    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
+    <appender class="org.apache.log4j.ConsoleAppender" name="STDOUT">
 
         <layout class="org.apache.log4j.PatternLayout">
             <param name="ConversionPattern" value="%d %-5p [%t] %C{2} (%F:%L) - %m%n"/>
         </layout>
     </appender>
 
-    <!-- Qpid.Broker log is a special log category used to only useful broker startup details -->
-    <category name="Qpid.Broker">
+    <!-- Qpid.Broker log is a special log category used to log only useful broker startup details -->
+    <category additivity="true" name="Qpid.Broker">
         <priority value="debug"/>
         <appender-ref ref="STDOUT"/>
     </category>
 
-    <category name="org.apache.qpid.server.queue.AMQQueueMBean">
+    <category additivity="true" name="org.apache.qpid.server.queue.AMQQueueMBean">
         <priority value="info"/>
     </category>
 
     <!-- Provide warnings to standard output -->
-    <category name="org.apache.qpid">
+    <category additivity="true" name="org.apache.qpid">
         <priority value="warn"/>
     </category>
 
@@ -83,7 +83,7 @@
     <!-- Examples of additional logging settings -->
     <!-- Used to generate extra debug. See debug.log4j.xml -->
     
-    <!--<category name="org.apache.qpid.server.store">
+    <!--<category additivity="true" name="org.apache.qpid.server.store">
         <priority value="debug"/>
     </category-->
 
diff --git a/qpid/java/broker/src/main/java/org/apache/qpid/server/Main.java b/qpid/java/broker/src/main/java/org/apache/qpid/server/Main.java
index 780a17940e..0e5facfefe 100644
--- a/qpid/java/broker/src/main/java/org/apache/qpid/server/Main.java
+++ b/qpid/java/broker/src/main/java/org/apache/qpid/server/Main.java
@@ -42,10 +42,12 @@ import org.apache.mina.common.IoAcceptor;
 import org.apache.mina.transport.socket.nio.SocketAcceptorConfig;
 import org.apache.mina.transport.socket.nio.SocketSessionConfig;
 import org.apache.mina.util.NewThreadExecutor;
+import org.apache.qpid.AMQException;
 import org.apache.qpid.common.QpidProperties;
 import org.apache.qpid.framing.ProtocolVersion;
 import org.apache.qpid.pool.ReadWriteThreadModel;
 import org.apache.qpid.server.configuration.ServerConfiguration;
+import org.apache.qpid.server.logging.management.LoggingManagementMBean;
 import org.apache.qpid.server.protocol.AMQPFastProtocolHandler;
 import org.apache.qpid.server.protocol.AMQPProtocolProvider;
 import org.apache.qpid.server.registry.ApplicationRegistry;
@@ -232,16 +234,29 @@ public class Main
 
         String logConfig = commandLine.getOptionValue("l");
         String logWatchConfig = commandLine.getOptionValue("w", "0");
+        
+        int logWatchTime = 0;
+        try
+        {
+            logWatchTime = Integer.parseInt(logWatchConfig);
+        }
+        catch (NumberFormatException e)
+        {
+            System.err.println("Log watch configuration value of " + logWatchConfig + " is invalid. Must be "
+                               + "a non-negative integer. Using default of zero (no watching configured");
+        }
+        
+        File logConfigFile;
         if (logConfig != null)
         {
-            File logConfigFile = new File(logConfig);
-            configureLogging(logConfigFile, logWatchConfig);
+            logConfigFile = new File(logConfig);
+            configureLogging(logConfigFile, logWatchTime);
         }
         else
         {
             File configFileDirectory = configFile.getParentFile();
-            File logConfigFile = new File(configFileDirectory, DEFAULT_LOG_CONFIG_FILENAME);
-            configureLogging(logConfigFile, logWatchConfig);
+            logConfigFile = new File(configFileDirectory, DEFAULT_LOG_CONFIG_FILENAME);
+            configureLogging(logConfigFile, logWatchTime);
         }
 
         ConfigurationFileApplicationRegistry config = new ConfigurationFileApplicationRegistry(configFile);
@@ -249,6 +264,8 @@ public class Main
         updateManagementPort(serverConfig, commandLine.getOptionValue("m"));
 
         ApplicationRegistry.initialise(config);
+        
+        configureLoggingManagementMBean(logConfigFile, logWatchTime);
 
         //fixme .. use QpidProperties.getVersionString when we have fixed the classpath issues
         // that are causing the broker build to pick up the wrong properties file and hence say
@@ -445,19 +462,8 @@ public class Main
         return ip;
     }
 
-    private void configureLogging(File logConfigFile, String logWatchConfig)
+    private void configureLogging(File logConfigFile, int logWatchTime)
     {
-        int logWatchTime = 0;
-        try
-        {
-            logWatchTime = Integer.parseInt(logWatchConfig);
-        }
-        catch (NumberFormatException e)
-        {
-            System.err.println("Log watch configuration value of " + logWatchConfig + " is invalid. Must be "
-                               + "a non-negative integer. Using default of zero (no watching configured");
-        }
-
         if (logConfigFile.exists() && logConfigFile.canRead())
         {
             System.out.println("Configuring logger using configuration file " + logConfigFile.getAbsolutePath());
@@ -481,4 +487,17 @@ public class Main
         }
     }
 
+    private void configureLoggingManagementMBean(File logConfigFile, int logWatchTime) throws Exception
+    {
+        LoggingManagementMBean blm = new LoggingManagementMBean(logConfigFile.getPath(),logWatchTime);
+        
+        try
+        {
+            blm.register();
+        }
+        catch (AMQException e)
+        {
+            throw new InitException("Unable to initialise the Logging Management MBean: ", e);
+        }
+    }
 }
diff --git a/qpid/java/broker/src/main/java/org/apache/qpid/server/logging/management/LoggingManagement.java b/qpid/java/broker/src/main/java/org/apache/qpid/server/logging/management/LoggingManagement.java
new file mode 100644
index 0000000000..d60b9c304a
--- /dev/null
+++ b/qpid/java/broker/src/main/java/org/apache/qpid/server/logging/management/LoggingManagement.java
@@ -0,0 +1,258 @@
+/*
+ *  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.management;
+
+import java.io.IOException;
+
+import org.apache.qpid.server.management.MBeanAttribute;
+import org.apache.qpid.server.management.MBeanOperation;
+import org.apache.qpid.server.management.MBeanOperationParameter;
+
+import javax.management.MBeanOperationInfo;
+import javax.management.openmbean.TabularData;
+
+public interface LoggingManagement
+{
+    String TYPE = "LoggingManagement";
+    int VERSION = 1;
+    
+    //TabularType and contained CompositeType key/description information
+    String[] COMPOSITE_ITEM_NAMES = {"LoggerName", "Level"};
+    String[] COMPOSITE_ITEM_DESCRIPTIONS = {"Name of the logger", "Level of the logger"};
+    String[] TABULAR_UNIQUE_INDEX = {COMPOSITE_ITEM_NAMES[0]};
+    
+    /**
+     * Attribute to represent the log4j xml configuration file's LogWatch interval.
+     * @return The logwatch interval in seconds.
+     */
+    @MBeanAttribute(name="Log4jLogWatchInterval", 
+                    description = "The log4j xml configuration file LogWatch interval (in seconds). 0 indicates not being checked.")
+    Integer getLog4jLogWatchInterval();
+    
+    
+    //****** log4j runtime operations ****** //
+
+    /**
+     * Sets the level of an active Log4J logger
+     * @param logger The name of the logger
+     * @param level The level to set the logger to
+     * @return True if successful, false if unsuccessful (eg if an invalid level is specified) 
+     */
+    @MBeanOperation(name = "setRuntimeLoggerLevel", description = "Set the runtime logging level for an active log4j logger.",
+                    impact = MBeanOperationInfo.ACTION)
+    boolean setRuntimeLoggerLevel(@MBeanOperationParameter(name = "logger", description = "Logger name")String logger,
+                                @MBeanOperationParameter(name = "level", description = "Logger level")String level);
+
+    /**
+     * Retrieves a TabularData set of the active log4j loggers and their levels
+     * @return TabularData set of CompositeData rows with logger name and level, or null if there is a problem with the TabularData type 
+     */
+    @MBeanOperation(name = "viewEffectiveRuntimeLoggerLevels", description = "View the effective runtime logging level " +
+    		        "for active log4j logger's.", impact = MBeanOperationInfo.INFO)
+    TabularData viewEffectiveRuntimeLoggerLevels();
+    
+    /**
+     * Sets the level of the active Log4J RootLogger
+     * @param level The level to set the RootLogger to
+     * @return True if successful, false if unsuccessful (eg if an invalid level is specified) 
+     */
+    @MBeanOperation(name = "setRuntimeRootLoggerLevel", description = "Set the runtime logging level for the active log4j Root Logger.",
+                    impact = MBeanOperationInfo.ACTION)
+    boolean setRuntimeRootLoggerLevel(@MBeanOperationParameter(name = "level", description = "Logger level")String level);
+
+    /**
+     * Attribute to represent the level of the active Log4J RootLogger
+     * @return The level of the RootLogger.
+     */
+    @MBeanAttribute(name = "getRuntimeRootLoggerLevel", description = "Get the runtime logging level for the active log4j Root Logger.")
+    String getRuntimeRootLoggerLevel();
+    
+    
+    //****** log4j XML configuration file operations ****** //
+    
+    /**
+     * Updates the level of an existing Log4J logger within the xml configuration file
+     * @param logger The name of the logger
+     * @param level The level to set the logger to
+     * @return True if successful, false if unsuccessful (eg if an invalid logger or level is specified) 
+     * @throws IOException if there is an error parsing the configuration file.
+     */
+    @MBeanOperation(name = "setConfigFileLoggerLevel", description = "Set the logging level for an existing logger " +
+    		         "in the log4j xml configuration file", impact = MBeanOperationInfo.ACTION)
+    boolean setConfigFileLoggerLevel(@MBeanOperationParameter(name = "logger", description = "logger name")String logger,
+                                    @MBeanOperationParameter(name = "level", description = "Logger level")String level) throws IOException;
+    
+    /**
+     * Retrieves a TabularData set of the existing Log4J loggers within the xml configuration file
+     * @return TabularData set of CompositeData rows with logger name and level, or null if there is a problem with the TabularData type 
+     * @throws IOException if there is an error parsing the configuration file.
+     */
+    @MBeanOperation(name = "viewConfigFileLoggerLevels", description = "Get the logging level defined for the logger's " +
+    		        "in the log4j xml configuration file.", impact = MBeanOperationInfo.INFO)
+    TabularData viewConfigFileLoggerLevels() throws IOException;
+ 
+    /**
+     * Updates the level of the Log4J RootLogger within the xml configuration file if it is present
+     * @param level The level to set the logger to
+     * @return True if successful, false if not (eg an invalid level is specified, or root logger level isnt already defined) 
+     * @throws IOException if there is an error parsing the configuration file.
+     */
+    @MBeanOperation(name = "setConfigFileRootLoggerLevel", description = "Set the logging level for the Root Logger " +
+    		        "in the log4j xml configuration file.", impact = MBeanOperationInfo.ACTION)
+    boolean setConfigFileRootLoggerLevel(@MBeanOperationParameter(name = "level", description = "Logger level")String level) throws IOException;
+
+    /**
+     * Attribute to represent the level of the Log4J RootLogger within the xml configuration file
+     * @return The level of the RootLogger, or null if it is not present
+     */
+    @MBeanAttribute(name = "getConfigFileRootLoggerLevel", description = "Get the logging level for the Root Logger " +
+                    "in the log4j xml configuration file.")
+    String getConfigFileRootLoggerLevel() throws IOException;
+}
+/*
+ *  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.management;
+
+import java.io.IOException;
+
+import org.apache.qpid.server.management.MBeanAttribute;
+import org.apache.qpid.server.management.MBeanOperation;
+import org.apache.qpid.server.management.MBeanOperationParameter;
+
+import javax.management.MBeanOperationInfo;
+import javax.management.openmbean.TabularData;
+
+public interface LoggingManagement
+{
+    String TYPE = "LoggingManagement";
+    int VERSION = 1;
+    
+    //TabularType and contained CompositeType key/description information
+    String[] COMPOSITE_ITEM_NAMES = {"LoggerName", "Level"};
+    String[] COMPOSITE_ITEM_DESCRIPTIONS = {"Name of the logger", "Level of the logger"};
+    String[] TABULAR_UNIQUE_INDEX = {COMPOSITE_ITEM_NAMES[0]};
+    
+    /**
+     * Attribute to represent the log4j xml configuration file's LogWatch interval.
+     * @return The logwatch interval in seconds.
+     */
+    @MBeanAttribute(name="Log4jLogWatchInterval", 
+                    description = "The log4j xml configuration file LogWatch interval (in seconds). 0 indicates not being checked.")
+    Integer getLog4jLogWatchInterval();
+    
+    
+    //****** log4j runtime operations ****** //
+
+    /**
+     * Sets the level of an active Log4J logger
+     * @param logger The name of the logger
+     * @param level The level to set the logger to
+     * @return True if successful, false if unsuccessful (eg if an invalid level is specified) 
+     */
+    @MBeanOperation(name = "setRuntimeLoggerLevel", description = "Set the runtime logging level for an active log4j logger.",
+                    impact = MBeanOperationInfo.ACTION)
+    boolean setRuntimeLoggerLevel(@MBeanOperationParameter(name = "logger", description = "Logger name")String logger,
+                                @MBeanOperationParameter(name = "level", description = "Logger level")String level);
+
+    /**
+     * Retrieves a TabularData set of the active log4j loggers and their levels
+     * @return TabularData set of CompositeData rows with logger name and level, or null if there is a problem with the TabularData type 
+     */
+    @MBeanOperation(name = "viewEffectiveRuntimeLoggerLevels", description = "View the effective runtime logging level " +
+    		        "for active log4j logger's.", impact = MBeanOperationInfo.INFO)
+    TabularData viewEffectiveRuntimeLoggerLevels();
+    
+    /**
+     * Sets the level of the active Log4J RootLogger
+     * @param level The level to set the RootLogger to
+     * @return True if successful, false if unsuccessful (eg if an invalid level is specified) 
+     */
+    @MBeanOperation(name = "setRuntimeRootLoggerLevel", description = "Set the runtime logging level for the active log4j Root Logger.",
+                    impact = MBeanOperationInfo.ACTION)
+    boolean setRuntimeRootLoggerLevel(@MBeanOperationParameter(name = "level", description = "Logger level")String level);
+
+    /**
+     * Attribute to represent the level of the active Log4J RootLogger
+     * @return The level of the RootLogger.
+     */
+    @MBeanAttribute(name = "getRuntimeRootLoggerLevel", description = "Get the runtime logging level for the active log4j Root Logger.")
+    String getRuntimeRootLoggerLevel();
+    
+    
+    //****** log4j XML configuration file operations ****** //
+    
+    /**
+     * Updates the level of an existing Log4J logger within the xml configuration file
+     * @param logger The name of the logger
+     * @param level The level to set the logger to
+     * @return True if successful, false if unsuccessful (eg if an invalid logger or level is specified) 
+     * @throws IOException if there is an error parsing the configuration file.
+     */
+    @MBeanOperation(name = "setConfigFileLoggerLevel", description = "Set the logging level for an existing logger " +
+    		         "in the log4j xml configuration file", impact = MBeanOperationInfo.ACTION)
+    boolean setConfigFileLoggerLevel(@MBeanOperationParameter(name = "logger", description = "logger name")String logger,
+                                    @MBeanOperationParameter(name = "level", description = "Logger level")String level) throws IOException;
+    
+    /**
+     * Retrieves a TabularData set of the existing Log4J loggers within the xml configuration file
+     * @return TabularData set of CompositeData rows with logger name and level, or null if there is a problem with the TabularData type 
+     * @throws IOException if there is an error parsing the configuration file.
+     */
+    @MBeanOperation(name = "viewConfigFileLoggerLevels", description = "Get the logging level defined for the logger's " +
+    		        "in the log4j xml configuration file.", impact = MBeanOperationInfo.INFO)
+    TabularData viewConfigFileLoggerLevels() throws IOException;
+ 
+    /**
+     * Updates the level of the Log4J RootLogger within the xml configuration file if it is present
+     * @param level The level to set the logger to
+     * @return True if successful, false if not (eg an invalid level is specified, or root logger level isnt already defined) 
+     * @throws IOException if there is an error parsing the configuration file.
+     */
+    @MBeanOperation(name = "setConfigFileRootLoggerLevel", description = "Set the logging level for the Root Logger " +
+    		        "in the log4j xml configuration file.", impact = MBeanOperationInfo.ACTION)
+    boolean setConfigFileRootLoggerLevel(@MBeanOperationParameter(name = "level", description = "Logger level")String level) throws IOException;
+
+    /**
+     * Attribute to represent the level of the Log4J RootLogger within the xml configuration file
+     * @return The level of the RootLogger, or null if it is not present
+     */
+    @MBeanAttribute(name = "getConfigFileRootLoggerLevel", description = "Get the logging level for the Root Logger " +
+                    "in the log4j xml configuration file.")
+    String getConfigFileRootLoggerLevel() throws IOException;
+}
diff --git a/qpid/java/broker/src/main/java/org/apache/qpid/server/logging/management/LoggingManagementMBean.java b/qpid/java/broker/src/main/java/org/apache/qpid/server/logging/management/LoggingManagementMBean.java
new file mode 100644
index 0000000000..e35292c4b0
--- /dev/null
+++ b/qpid/java/broker/src/main/java/org/apache/qpid/server/logging/management/LoggingManagementMBean.java
@@ -0,0 +1,1334 @@
+/*
+ *  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.management;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.List;
+
+import org.apache.qpid.server.management.MBeanDescription;
+import org.apache.qpid.server.management.AMQManagedObject;
+
+import org.apache.log4j.Level;
+import org.apache.log4j.LogManager;
+import org.apache.log4j.Logger;
+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.management.JMException;
+import javax.management.openmbean.CompositeData;
+import javax.management.openmbean.CompositeDataSupport;
+import javax.management.openmbean.CompositeType;
+import javax.management.openmbean.OpenDataException;
+import javax.management.openmbean.OpenType;
+import javax.management.openmbean.SimpleType;
+import javax.management.openmbean.TabularData;
+import javax.management.openmbean.TabularDataSupport;
+import javax.management.openmbean.TabularType;
+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.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+
+/** MBean class for BrokerLoggingManagerMBean. It implements all the management features exposed for managing logging. */
+@MBeanDescription("Logging Management Interface")
+public class LoggingManagementMBean extends AMQManagedObject implements LoggingManagement
+{
+
+    private static final Logger _logger = Logger.getLogger(LoggingManagementMBean.class);
+    private String _log4jConfigFileName;
+    private int _log4jLogWatchInterval;
+    
+    static TabularType _loggerLevelTabularType;
+    static CompositeType _loggerLevelCompositeType;
+
+    static
+    {
+        try
+        {
+            OpenType[] loggerLevelItemTypes = new OpenType[]{SimpleType.STRING, SimpleType.STRING};
+
+            _loggerLevelCompositeType = new CompositeType("LoggerLevelList", "Logger Level Data", 
+                                                         COMPOSITE_ITEM_NAMES, COMPOSITE_ITEM_DESCRIPTIONS, loggerLevelItemTypes);
+
+            _loggerLevelTabularType = new TabularType("LoggerLevel", "List of loggers with levels",
+                                                       _loggerLevelCompositeType, TABULAR_UNIQUE_INDEX);
+        }
+        catch (OpenDataException e)
+        {
+            _logger.error("Tabular data setup for viewing logger levels was incorrect.");
+            _loggerLevelTabularType = null;
+        }
+    }
+    
+    public LoggingManagementMBean(String log4jConfigFileName, int log4jLogWatchInterval) throws JMException
+    {
+        super(LoggingManagement.class, LoggingManagement.TYPE, LoggingManagement.VERSION);
+        _log4jConfigFileName = log4jConfigFileName;
+        _log4jLogWatchInterval = log4jLogWatchInterval;
+    }
+
+    public String getObjectInstanceName()
+    {
+        return LoggingManagement.TYPE;
+    }
+    
+    public Integer getLog4jLogWatchInterval()
+    {
+        return _log4jLogWatchInterval;
+    }
+
+    @SuppressWarnings("unchecked")
+    public synchronized boolean setRuntimeLoggerLevel(String logger, String level)
+    {   
+        //check specified level is valid
+        Level newLevel;
+        try
+        {
+            newLevel = getLevel(level);
+        }
+        catch (Exception e)
+        {
+            return false;
+        }
+        
+        //check specified logger exists
+        Enumeration loggers = LogManager.getCurrentLoggers();
+        Boolean loggerExists = false;
+        
+        while(loggers.hasMoreElements())
+        {
+            Logger log = (Logger) loggers.nextElement();
+            if (log.getName().equals(logger))
+            {
+                loggerExists = true;
+                break;
+            }
+        }
+        
+        if(!loggerExists)
+        {
+            return false;
+        }
+        
+        //set the logger to the new level
+        _logger.info("Setting level to " + level + " for logger: " + logger);
+        
+        Logger log = Logger.getLogger(logger);
+        log.setLevel(newLevel);
+        
+        return true;
+    }
+    
+    @SuppressWarnings("unchecked")
+    public synchronized TabularData viewEffectiveRuntimeLoggerLevels()
+    {
+        if (_loggerLevelTabularType == null)
+        {
+            _logger.warn("TabluarData type not set up correctly");
+            return null;
+        }
+
+        _logger.info("Getting levels for currently active log4j loggers");
+        
+        Enumeration loggers = LogManager.getCurrentLoggers();
+
+        TabularData loggerLevelList = new TabularDataSupport(_loggerLevelTabularType);
+
+        Logger logger;
+        String loggerName;
+        String level;
+        
+        try
+        {
+            while(loggers.hasMoreElements()){
+                logger = (Logger) loggers.nextElement();
+
+                loggerName = logger.getName();
+                level = logger.getEffectiveLevel().toString();
+
+                Object[] itemData = {loggerName, level};
+                CompositeData loggerData = new CompositeDataSupport(_loggerLevelCompositeType, COMPOSITE_ITEM_NAMES, itemData);
+                loggerLevelList.put(loggerData);
+            }
+        }
+        catch (OpenDataException e)
+        {
+            _logger.warn("Unable to create logger level list due to :" + e);
+            return null;
+        }
+
+        return loggerLevelList;
+        
+    }
+    
+    public synchronized String getRuntimeRootLoggerLevel()
+    {
+        Logger rootLogger = Logger.getRootLogger();
+
+        return rootLogger.getLevel().toString();
+    }
+
+    public synchronized boolean setRuntimeRootLoggerLevel(String level)
+    {
+            Level newLevel;
+            try
+            {
+                newLevel = getLevel(level);
+            }
+            catch (Exception e)
+            {
+                return false;
+            }
+            
+            _logger.info("Setting RootLogger level to " + level);
+            
+            Logger log = Logger.getRootLogger();
+            log.setLevel(newLevel);
+            
+            return true;
+    }
+    
+    //method to convert from a string to a log4j Level, throws exception if the given value is invalid
+    private Level getLevel(String level) throws Exception
+    {
+        Level newLevel = Level.toLevel(level);
+        
+        //above Level.toLevel call returns a DEBUG Level if the request fails. Check the result.
+        if (newLevel.equals(Level.DEBUG) && !(level.equalsIgnoreCase("debug")))
+        {
+            //received DEBUG but we did not ask for it, the Level request failed.
+            throw new Exception("Invalid level name");
+        }
+        
+        return newLevel;
+    }
+    
+    //handler to catch errors signalled by the JAXP parser and throw an appropriate exception
+    private class SaxErrorHandler implements ErrorHandler
+    {
+        
+        public void error(SAXParseException e) throws SAXException
+        {
+            throw new SAXException("Error parsing XML file: " + e.getMessage());
+        }
+
+        public void fatalError(SAXParseException e) throws SAXException
+        {
+            throw new SAXException("Fatal error parsing XML file: " + e.getMessage());
+        }
+
+        public void warning(SAXParseException e) throws SAXException
+        {
+            throw new SAXException("Warning parsing XML file: " + e.getMessage());
+        }
+    }
+
+    //method to parse the XML configuration file, validating it in the process, and returning a DOM Document of the content.
+    private synchronized Document parseConfigFile(String fileName) throws IOException
+    {
+        //check file was specified, exists, and is readable
+        if(fileName == null)
+        {
+            _logger.warn("No log4j XML configuration file has been set");
+            throw new IOException("No log4j XML configuration file has been set");
+        }
+
+        File configFile = new File(fileName);
+
+        if (!configFile.exists())
+        {
+            _logger.warn("Specified log4j XML configuration file does not exist: " + fileName);
+            throw new IOException("Specified log4j XML configuration file does not exist");
+        }
+        else if (!configFile.canRead())
+        {
+            _logger.warn("Specified log4j XML configuration file is not readable: " + fileName);
+            throw new IOException("Specified log4j XML configuration file is not readable");
+        }
+
+        //parse it
+        DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
+        DocumentBuilder docBuilder;
+        Document doc;
+
+        ErrorHandler errHandler = new SaxErrorHandler();
+        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);
+            //recommended that MBeans should use java.* and javax.* exceptions only
+            throw new IOException("Unable to parse the log4j XML file due to possible configuration error: " + e.getMessage());
+        }
+        catch (SAXException e)
+        {
+            _logger.warn("The specified log4j XML file is invalid: " + e);
+            //recommended that MBeans should use standard java.* and javax.* exceptions only
+            throw new IOException("The specified log4j XML file is invalid: " + e.getMessage());
+        }
+        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 synchronized boolean writeUpdatedConfigFile(String log4jConfigFileName, Document doc) throws IOException
+    {
+        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;
+        try
+        {
+            transformer = TransformerFactory.newInstance().newTransformer();
+        }
+        catch (Exception e)
+        {
+            _logger.warn("Could not create an XML transformer: " +e);
+            return false;
+        }
+
+        transformer.setOutputProperty(OutputKeys.INDENT, "yes");
+        transformer.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, "log4j.dtd");
+        DOMSource source = new DOMSource(doc);
+        
+        File tmp;
+        try
+        {
+            tmp = File.createTempFile("LogManMBeanTemp", ".tmp");
+            tmp.deleteOnExit();
+            StreamResult result = new StreamResult(tmp);
+            transformer.transform(source, result);
+        }
+        catch (TransformerException e)
+        {
+            _logger.warn("Could not transform the XML into new file: " +e);
+            return false;
+        }
+        catch (IOException e)
+        {
+            _logger.warn("Could not create the new file: " +e);
+            return false;
+        }
+
+        // Swap temp file in to replace existing configuration file.
+        File old = new File(log4jConfigFile.getAbsoluteFile() + ".old");
+        if (old.exists())
+        {
+            old.delete();
+        }
+        log4jConfigFile.renameTo(old);
+        return tmp.renameTo(log4jConfigFile);
+    }
+
+
+    /* 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 TabularData viewConfigFileLoggerLevels() throws IOException
+    {
+        if (_loggerLevelTabularType == null)
+        {
+            _logger.warn("TabluarData type not set up correctly");
+            return null;
+        }
+        
+        _logger.info("Getting logger levels from log4j configuration file");
+        
+        Document doc = parseConfigFile(_log4jConfigFileName);
+
+        TabularData loggerLevelList = new TabularDataSupport(_loggerLevelTabularType);
+
+        //retrieve the 'category' element nodes
+        NodeList categoryElements = doc.getElementsByTagName("category");
+        
+        String categoryName;
+        String priority = null;
+        
+        for (int i = 0; i < categoryElements.getLength(); i++)
+        {
+            Element categoryElement = (Element) categoryElements.item(i);
+            categoryName = categoryElement.getAttribute("name");
+
+            //retrieve the category's mandatory 'priority' or 'level' element's value.
+            //It may not be the only child node, so request by tag name.
+            NodeList priorityElements = categoryElement.getElementsByTagName("priority");
+            NodeList levelElements = categoryElement.getElementsByTagName("level");
+
+            if (priorityElements.getLength() != 0)
+            {
+                Element priorityElement = (Element) priorityElements.item(0);
+                priority = priorityElement.getAttribute("value").toUpperCase();
+            }
+            else if (levelElements.getLength() != 0)
+            {
+                Element levelElement = (Element) levelElements.item(0);
+                priority = levelElement.getAttribute("value").toUpperCase();
+            }
+            else
+            {
+                //there is no exiting priority or level to view, move onto next category/logger
+                continue;
+            }
+
+            try
+            {
+                Object[] itemData = {categoryName, priority};
+                CompositeData loggerData = new CompositeDataSupport(_loggerLevelCompositeType, COMPOSITE_ITEM_NAMES, itemData);
+                loggerLevelList.put(loggerData);
+            }
+            catch (OpenDataException e)
+            {
+                _logger.warn("Unable to create logger level list due to :" + e);
+                return null;
+            }
+        }
+
+        //retrieve the 'logger' element nodes
+        NodeList loggerElements = doc.getElementsByTagName("logger");
+        
+        String loggerName;
+        String level;
+
+        for (int i = 0; i < loggerElements.getLength(); i++)
+        {
+            Element loggerElement = (Element) loggerElements.item(i);
+            loggerName = loggerElement.getAttribute("name");
+
+            //retrieve the logger's mandatory 'level' element's value
+            //It may not be the only child node, so request by tag name.
+            NodeList levelElements = loggerElement.getElementsByTagName("level");
+
+            Element levelElement = (Element) levelElements.item(0);
+            level = levelElement.getAttribute("value").toUpperCase();
+            
+            try
+            {
+                Object[] itemData = {loggerName, level};
+                CompositeData loggerData = new CompositeDataSupport(_loggerLevelCompositeType, COMPOSITE_ITEM_NAMES, itemData);
+                loggerLevelList.put(loggerData);
+            }
+            catch (OpenDataException e)
+            {
+                _logger.warn("Unable to create logger level list due to :" + e);
+                return null;
+            }
+        }
+        
+        return loggerLevelList;
+    }
+
+    public synchronized boolean setConfigFileLoggerLevel(String logger, String level) throws IOException
+    {
+        //check that the specified level is a valid log4j Level
+        try
+        {
+            getLevel(level);
+        }
+        catch (Exception e)
+        {
+            //it isnt a valid level
+            return false;
+        }
+        
+        _logger.info("Setting level to " + level + " for logger '" + logger
+                + "' in log4j xml configuration file: " + _log4jConfigFileName);
+        
+        Document doc = parseConfigFile(_log4jConfigFileName);
+
+        //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));
+        }
+
+        //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)
+        {
+            //no loggers/categories with given name found, does not exist to update
+            _logger.warn("Specified logger does not exist in the configuration file: " +logger);
+            return false;
+        }
+
+        //retrieve the optional 'priority' or 'level' sub-element value.
+        //It may not be the only child node, so request by tag name.
+        NodeList priorityElements = logElement.getElementsByTagName("priority");
+        NodeList levelElements = logElement.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
+        {
+            //there is no exiting priority or level element to update
+            return false;
+        }
+        
+        //update the element with the new level/priority
+        levelElement.setAttribute("value", level);
+        
+        //output the new file
+        return writeUpdatedConfigFile(_log4jConfigFileName, doc);
+    }
+
+    
+    /* 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 getConfigFileRootLoggerLevel() throws IOException
+    {
+        _logger.info("Getting root logger level from log4j configuration file");
+
+        Document doc = parseConfigFile(_log4jConfigFileName);
+       
+        //retrieve the optional 'root' element node
+        NodeList rootElements = doc.getElementsByTagName("root");
+
+        if (rootElements.getLength() == 0)
+        {
+            //there is not root logger definition
+            return null;
+        }
+
+        Element rootElement = (Element) rootElements.item(0);
+
+        //retrieve the optional 'priority' or 'level' element value.
+        //It may not be the only child node, so request by tag name.
+        NodeList priorityElements = rootElement.getElementsByTagName("priority");
+        NodeList levelElements = rootElement.getElementsByTagName("level");
+        String priority = null;
+        
+        if (priorityElements.getLength() != 0)
+        {
+            Element priorityElement = (Element) priorityElements.item(0);
+            priority = priorityElement.getAttribute("value");
+        }
+        else if(levelElements.getLength() != 0)
+        {
+            Element levelElement = (Element) levelElements.item(0);
+            priority = levelElement.getAttribute("value");
+        }
+
+        if(priority != null)
+        {
+            return priority.toUpperCase();
+        }
+        else
+        {
+            return null;
+        }
+    }
+    
+    public synchronized boolean setConfigFileRootLoggerLevel(String level) throws IOException
+    {
+        //check that the specified level is a valid log4j Level
+        try
+        {
+            getLevel(level);
+        }
+        catch (Exception e)
+        {
+            //it isnt a valid level
+            return false;
+        }
+        
+        _logger.info("Setting level to " + level + " for the Root logger in " +
+        		"log4j xml configuration file: " + _log4jConfigFileName);
+
+        Document doc = parseConfigFile(_log4jConfigFileName);
+        
+        //retrieve the optional 'root' element node
+        NodeList rootElements = doc.getElementsByTagName("root");
+
+        if (rootElements.getLength() == 0)
+        {
+            return false;
+        }
+
+        Element rootElement = (Element) rootElements.item(0);
+
+        //retrieve the optional 'priority' or 'level' sub-element value.
+        //It may not be the only child node, so request by tag name.
+        NodeList priorityElements = rootElement.getElementsByTagName("priority");
+        NodeList levelElements = rootElement.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
+        {
+            //there is no exiting priority/level to update
+            return false;
+        }
+        
+        //update the element with the new level/priority
+        levelElement.setAttribute("value", level);
+
+        //output the new file
+        return writeUpdatedConfigFile(_log4jConfigFileName, doc);
+    }
+}
+/*
+ *  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.management;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.List;
+
+import org.apache.qpid.server.management.MBeanDescription;
+import org.apache.qpid.server.management.AMQManagedObject;
+
+import org.apache.log4j.Level;
+import org.apache.log4j.LogManager;
+import org.apache.log4j.Logger;
+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.management.JMException;
+import javax.management.openmbean.CompositeData;
+import javax.management.openmbean.CompositeDataSupport;
+import javax.management.openmbean.CompositeType;
+import javax.management.openmbean.OpenDataException;
+import javax.management.openmbean.OpenType;
+import javax.management.openmbean.SimpleType;
+import javax.management.openmbean.TabularData;
+import javax.management.openmbean.TabularDataSupport;
+import javax.management.openmbean.TabularType;
+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.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+
+/** MBean class for BrokerLoggingManagerMBean. It implements all the management features exposed for managing logging. */
+@MBeanDescription("Logging Management Interface")
+public class LoggingManagementMBean extends AMQManagedObject implements LoggingManagement
+{
+
+    private static final Logger _logger = Logger.getLogger(LoggingManagementMBean.class);
+    private String _log4jConfigFileName;
+    private int _log4jLogWatchInterval;
+    
+    static TabularType _loggerLevelTabularType;
+    static CompositeType _loggerLevelCompositeType;
+
+    static
+    {
+        try
+        {
+            OpenType[] loggerLevelItemTypes = new OpenType[]{SimpleType.STRING, SimpleType.STRING};
+
+            _loggerLevelCompositeType = new CompositeType("LoggerLevelList", "Logger Level Data", 
+                                                         COMPOSITE_ITEM_NAMES, COMPOSITE_ITEM_DESCRIPTIONS, loggerLevelItemTypes);
+
+            _loggerLevelTabularType = new TabularType("LoggerLevel", "List of loggers with levels",
+                                                       _loggerLevelCompositeType, TABULAR_UNIQUE_INDEX);
+        }
+        catch (OpenDataException e)
+        {
+            _logger.error("Tabular data setup for viewing logger levels was incorrect.");
+            _loggerLevelTabularType = null;
+        }
+    }
+    
+    public LoggingManagementMBean(String log4jConfigFileName, int log4jLogWatchInterval) throws JMException
+    {
+        super(LoggingManagement.class, LoggingManagement.TYPE, LoggingManagement.VERSION);
+        _log4jConfigFileName = log4jConfigFileName;
+        _log4jLogWatchInterval = log4jLogWatchInterval;
+    }
+
+    public String getObjectInstanceName()
+    {
+        return LoggingManagement.TYPE;
+    }
+    
+    public Integer getLog4jLogWatchInterval()
+    {
+        return _log4jLogWatchInterval;
+    }
+
+    @SuppressWarnings("unchecked")
+    public synchronized boolean setRuntimeLoggerLevel(String logger, String level)
+    {   
+        //check specified level is valid
+        Level newLevel;
+        try
+        {
+            newLevel = getLevel(level);
+        }
+        catch (Exception e)
+        {
+            return false;
+        }
+        
+        //check specified logger exists
+        Enumeration loggers = LogManager.getCurrentLoggers();
+        Boolean loggerExists = false;
+        
+        while(loggers.hasMoreElements())
+        {
+            Logger log = (Logger) loggers.nextElement();
+            if (log.getName().equals(logger))
+            {
+                loggerExists = true;
+                break;
+            }
+        }
+        
+        if(!loggerExists)
+        {
+            return false;
+        }
+        
+        //set the logger to the new level
+        _logger.info("Setting level to " + level + " for logger: " + logger);
+        
+        Logger log = Logger.getLogger(logger);
+        log.setLevel(newLevel);
+        
+        return true;
+    }
+    
+    @SuppressWarnings("unchecked")
+    public synchronized TabularData viewEffectiveRuntimeLoggerLevels()
+    {
+        if (_loggerLevelTabularType == null)
+        {
+            _logger.warn("TabluarData type not set up correctly");
+            return null;
+        }
+
+        _logger.info("Getting levels for currently active log4j loggers");
+        
+        Enumeration loggers = LogManager.getCurrentLoggers();
+
+        TabularData loggerLevelList = new TabularDataSupport(_loggerLevelTabularType);
+
+        Logger logger;
+        String loggerName;
+        String level;
+        
+        try
+        {
+            while(loggers.hasMoreElements()){
+                logger = (Logger) loggers.nextElement();
+
+                loggerName = logger.getName();
+                level = logger.getEffectiveLevel().toString();
+
+                Object[] itemData = {loggerName, level};
+                CompositeData loggerData = new CompositeDataSupport(_loggerLevelCompositeType, COMPOSITE_ITEM_NAMES, itemData);
+                loggerLevelList.put(loggerData);
+            }
+        }
+        catch (OpenDataException e)
+        {
+            _logger.warn("Unable to create logger level list due to :" + e);
+            return null;
+        }
+
+        return loggerLevelList;
+        
+    }
+    
+    public synchronized String getRuntimeRootLoggerLevel()
+    {
+        Logger rootLogger = Logger.getRootLogger();
+
+        return rootLogger.getLevel().toString();
+    }
+
+    public synchronized boolean setRuntimeRootLoggerLevel(String level)
+    {
+            Level newLevel;
+            try
+            {
+                newLevel = getLevel(level);
+            }
+            catch (Exception e)
+            {
+                return false;
+            }
+            
+            _logger.info("Setting RootLogger level to " + level);
+            
+            Logger log = Logger.getRootLogger();
+            log.setLevel(newLevel);
+            
+            return true;
+    }
+    
+    //method to convert from a string to a log4j Level, throws exception if the given value is invalid
+    private Level getLevel(String level) throws Exception
+    {
+        Level newLevel = Level.toLevel(level);
+        
+        //above Level.toLevel call returns a DEBUG Level if the request fails. Check the result.
+        if (newLevel.equals(Level.DEBUG) && !(level.equalsIgnoreCase("debug")))
+        {
+            //received DEBUG but we did not ask for it, the Level request failed.
+            throw new Exception("Invalid level name");
+        }
+        
+        return newLevel;
+    }
+    
+    //handler to catch errors signalled by the JAXP parser and throw an appropriate exception
+    private class SaxErrorHandler implements ErrorHandler
+    {
+        
+        public void error(SAXParseException e) throws SAXException
+        {
+            throw new SAXException("Error parsing XML file: " + e.getMessage());
+        }
+
+        public void fatalError(SAXParseException e) throws SAXException
+        {
+            throw new SAXException("Fatal error parsing XML file: " + e.getMessage());
+        }
+
+        public void warning(SAXParseException e) throws SAXException
+        {
+            throw new SAXException("Warning parsing XML file: " + e.getMessage());
+        }
+    }
+
+    //method to parse the XML configuration file, validating it in the process, and returning a DOM Document of the content.
+    private synchronized Document parseConfigFile(String fileName) throws IOException
+    {
+        //check file was specified, exists, and is readable
+        if(fileName == null)
+        {
+            _logger.warn("No log4j XML configuration file has been set");
+            throw new IOException("No log4j XML configuration file has been set");
+        }
+
+        File configFile = new File(fileName);
+
+        if (!configFile.exists())
+        {
+            _logger.warn("Specified log4j XML configuration file does not exist: " + fileName);
+            throw new IOException("Specified log4j XML configuration file does not exist");
+        }
+        else if (!configFile.canRead())
+        {
+            _logger.warn("Specified log4j XML configuration file is not readable: " + fileName);
+            throw new IOException("Specified log4j XML configuration file is not readable");
+        }
+
+        //parse it
+        DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
+        DocumentBuilder docBuilder;
+        Document doc;
+
+        ErrorHandler errHandler = new SaxErrorHandler();
+        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);
+            //recommended that MBeans should use java.* and javax.* exceptions only
+            throw new IOException("Unable to parse the log4j XML file due to possible configuration error: " + e.getMessage());
+        }
+        catch (SAXException e)
+        {
+            _logger.warn("The specified log4j XML file is invalid: " + e);
+            //recommended that MBeans should use standard java.* and javax.* exceptions only
+            throw new IOException("The specified log4j XML file is invalid: " + e.getMessage());
+        }
+        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 synchronized boolean writeUpdatedConfigFile(String log4jConfigFileName, Document doc) throws IOException
+    {
+        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;
+        try
+        {
+            transformer = TransformerFactory.newInstance().newTransformer();
+        }
+        catch (Exception e)
+        {
+            _logger.warn("Could not create an XML transformer: " +e);
+            return false;
+        }
+
+        transformer.setOutputProperty(OutputKeys.INDENT, "yes");
+        transformer.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, "log4j.dtd");
+        DOMSource source = new DOMSource(doc);
+        
+        File tmp;
+        try
+        {
+            tmp = File.createTempFile("LogManMBeanTemp", ".tmp");
+            tmp.deleteOnExit();
+            StreamResult result = new StreamResult(tmp);
+            transformer.transform(source, result);
+        }
+        catch (TransformerException e)
+        {
+            _logger.warn("Could not transform the XML into new file: " +e);
+            return false;
+        }
+        catch (IOException e)
+        {
+            _logger.warn("Could not create the new file: " +e);
+            return false;
+        }
+
+        // Swap temp file in to replace existing configuration file.
+        File old = new File(log4jConfigFile.getAbsoluteFile() + ".old");
+        if (old.exists())
+        {
+            old.delete();
+        }
+        log4jConfigFile.renameTo(old);
+        return tmp.renameTo(log4jConfigFile);
+    }
+
+
+    /* 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 TabularData viewConfigFileLoggerLevels() throws IOException
+    {
+        if (_loggerLevelTabularType == null)
+        {
+            _logger.warn("TabluarData type not set up correctly");
+            return null;
+        }
+        
+        _logger.info("Getting logger levels from log4j configuration file");
+        
+        Document doc = parseConfigFile(_log4jConfigFileName);
+
+        TabularData loggerLevelList = new TabularDataSupport(_loggerLevelTabularType);
+
+        //retrieve the 'category' element nodes
+        NodeList categoryElements = doc.getElementsByTagName("category");
+        
+        String categoryName;
+        String priority = null;
+        
+        for (int i = 0; i < categoryElements.getLength(); i++)
+        {
+            Element categoryElement = (Element) categoryElements.item(i);
+            categoryName = categoryElement.getAttribute("name");
+
+            //retrieve the category's mandatory 'priority' or 'level' element's value.
+            //It may not be the only child node, so request by tag name.
+            NodeList priorityElements = categoryElement.getElementsByTagName("priority");
+            NodeList levelElements = categoryElement.getElementsByTagName("level");
+
+            if (priorityElements.getLength() != 0)
+            {
+                Element priorityElement = (Element) priorityElements.item(0);
+                priority = priorityElement.getAttribute("value").toUpperCase();
+            }
+            else if (levelElements.getLength() != 0)
+            {
+                Element levelElement = (Element) levelElements.item(0);
+                priority = levelElement.getAttribute("value").toUpperCase();
+            }
+            else
+            {
+                //there is no exiting priority or level to view, move onto next category/logger
+                continue;
+            }
+
+            try
+            {
+                Object[] itemData = {categoryName, priority};
+                CompositeData loggerData = new CompositeDataSupport(_loggerLevelCompositeType, COMPOSITE_ITEM_NAMES, itemData);
+                loggerLevelList.put(loggerData);
+            }
+            catch (OpenDataException e)
+            {
+                _logger.warn("Unable to create logger level list due to :" + e);
+                return null;
+            }
+        }
+
+        //retrieve the 'logger' element nodes
+        NodeList loggerElements = doc.getElementsByTagName("logger");
+        
+        String loggerName;
+        String level;
+
+        for (int i = 0; i < loggerElements.getLength(); i++)
+        {
+            Element loggerElement = (Element) loggerElements.item(i);
+            loggerName = loggerElement.getAttribute("name");
+
+            //retrieve the logger's mandatory 'level' element's value
+            //It may not be the only child node, so request by tag name.
+            NodeList levelElements = loggerElement.getElementsByTagName("level");
+
+            Element levelElement = (Element) levelElements.item(0);
+            level = levelElement.getAttribute("value").toUpperCase();
+            
+            try
+            {
+                Object[] itemData = {loggerName, level};
+                CompositeData loggerData = new CompositeDataSupport(_loggerLevelCompositeType, COMPOSITE_ITEM_NAMES, itemData);
+                loggerLevelList.put(loggerData);
+            }
+            catch (OpenDataException e)
+            {
+                _logger.warn("Unable to create logger level list due to :" + e);
+                return null;
+            }
+        }
+        
+        return loggerLevelList;
+    }
+
+    public synchronized boolean setConfigFileLoggerLevel(String logger, String level) throws IOException
+    {
+        //check that the specified level is a valid log4j Level
+        try
+        {
+            getLevel(level);
+        }
+        catch (Exception e)
+        {
+            //it isnt a valid level
+            return false;
+        }
+        
+        _logger.info("Setting level to " + level + " for logger '" + logger
+                + "' in log4j xml configuration file: " + _log4jConfigFileName);
+        
+        Document doc = parseConfigFile(_log4jConfigFileName);
+
+        //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));
+        }
+
+        //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)
+        {
+            //no loggers/categories with given name found, does not exist to update
+            _logger.warn("Specified logger does not exist in the configuration file: " +logger);
+            return false;
+        }
+
+        //retrieve the optional 'priority' or 'level' sub-element value.
+        //It may not be the only child node, so request by tag name.
+        NodeList priorityElements = logElement.getElementsByTagName("priority");
+        NodeList levelElements = logElement.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
+        {
+            //there is no exiting priority or level element to update
+            return false;
+        }
+        
+        //update the element with the new level/priority
+        levelElement.setAttribute("value", level);
+        
+        //output the new file
+        return writeUpdatedConfigFile(_log4jConfigFileName, doc);
+    }
+
+    
+    /* 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 getConfigFileRootLoggerLevel() throws IOException
+    {
+        _logger.info("Getting root logger level from log4j configuration file");
+
+        Document doc = parseConfigFile(_log4jConfigFileName);
+       
+        //retrieve the optional 'root' element node
+        NodeList rootElements = doc.getElementsByTagName("root");
+
+        if (rootElements.getLength() == 0)
+        {
+            //there is not root logger definition
+            return null;
+        }
+
+        Element rootElement = (Element) rootElements.item(0);
+
+        //retrieve the optional 'priority' or 'level' element value.
+        //It may not be the only child node, so request by tag name.
+        NodeList priorityElements = rootElement.getElementsByTagName("priority");
+        NodeList levelElements = rootElement.getElementsByTagName("level");
+        String priority = null;
+        
+        if (priorityElements.getLength() != 0)
+        {
+            Element priorityElement = (Element) priorityElements.item(0);
+            priority = priorityElement.getAttribute("value");
+        }
+        else if(levelElements.getLength() != 0)
+        {
+            Element levelElement = (Element) levelElements.item(0);
+            priority = levelElement.getAttribute("value");
+        }
+
+        if(priority != null)
+        {
+            return priority.toUpperCase();
+        }
+        else
+        {
+            return null;
+        }
+    }
+    
+    public synchronized boolean setConfigFileRootLoggerLevel(String level) throws IOException
+    {
+        //check that the specified level is a valid log4j Level
+        try
+        {
+            getLevel(level);
+        }
+        catch (Exception e)
+        {
+            //it isnt a valid level
+            return false;
+        }
+        
+        _logger.info("Setting level to " + level + " for the Root logger in " +
+        		"log4j xml configuration file: " + _log4jConfigFileName);
+
+        Document doc = parseConfigFile(_log4jConfigFileName);
+        
+        //retrieve the optional 'root' element node
+        NodeList rootElements = doc.getElementsByTagName("root");
+
+        if (rootElements.getLength() == 0)
+        {
+            return false;
+        }
+
+        Element rootElement = (Element) rootElements.item(0);
+
+        //retrieve the optional 'priority' or 'level' sub-element value.
+        //It may not be the only child node, so request by tag name.
+        NodeList priorityElements = rootElement.getElementsByTagName("priority");
+        NodeList levelElements = rootElement.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
+        {
+            //there is no exiting priority/level to update
+            return false;
+        }
+        
+        //update the element with the new level/priority
+        levelElement.setAttribute("value", level);
+
+        //output the new file
+        return writeUpdatedConfigFile(_log4jConfigFileName, doc);
+    }
+}
diff --git a/qpid/java/broker/src/main/java/org/apache/qpid/server/management/MBeanInvocationHandlerImpl.java b/qpid/java/broker/src/main/java/org/apache/qpid/server/management/MBeanInvocationHandlerImpl.java
index 6a81646cae..fccd91ffdb 100644
--- a/qpid/java/broker/src/main/java/org/apache/qpid/server/management/MBeanInvocationHandlerImpl.java
+++ b/qpid/java/broker/src/main/java/org/apache/qpid/server/management/MBeanInvocationHandlerImpl.java
@@ -20,6 +20,7 @@
  */
 package org.apache.qpid.server.management;
 
+import org.apache.qpid.server.logging.management.LoggingManagement;
 import org.apache.qpid.server.security.access.management.UserManagement;
 import org.apache.log4j.Logger;
 
@@ -153,7 +154,12 @@ public class MBeanInvocationHandlerImpl implements InvocationHandler
         if (args[0] instanceof ObjectName)
         {
             ObjectName object = (ObjectName) args[0];
-            return UserManagement.TYPE.equals(object.getKeyProperty("type"));
+            
+            if (UserManagement.TYPE.equals(object.getKeyProperty("type"))
+                    || LoggingManagement.TYPE.equals(object.getKeyProperty("type")))
+            {
+                return true;
+            }
         }
 
         return false;
diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/logging/management/LoggingManagementMBeanTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/logging/management/LoggingManagementMBeanTest.java
new file mode 100644
index 0000000000..087b24f9a8
--- /dev/null
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/logging/management/LoggingManagementMBeanTest.java
@@ -0,0 +1,826 @@
+/*
+ *  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.management;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.management.JMException;
+import javax.management.openmbean.CompositeData;
+import javax.management.openmbean.TabularDataSupport;
+
+import org.apache.log4j.Level;
+import org.apache.log4j.Logger;
+
+import junit.framework.TestCase;
+
+public class LoggingManagementMBeanTest extends TestCase
+{
+    private static final String TEST_LOGGER = "LoggingManagementMBeanTestLogger";
+    private static final String TEST_LOGGER_CHILD1 = "LoggingManagementMBeanTestLogger.child1";
+    private static final String TEST_LOGGER_CHILD2 = "LoggingManagementMBeanTestLogger.child2";
+
+    private static final String CATEGORY_PRIORITY = "LogManMBeanTest.category.priority";
+    private static final String CATEGORY_LEVEL = "LogManMBeanTest.category.level";
+    private static final String LOGGER_LEVEL = "LogManMBeanTest.logger.level";
+    
+    private static final String NAME_INDEX = LoggingManagement.COMPOSITE_ITEM_NAMES[0];
+    private static final String LEVEL_INDEX = LoggingManagement.COMPOSITE_ITEM_NAMES[1];
+
+    private static final String NEWLINE = System.getProperty("line.separator");
+
+    private File _testConfigFile;
+
+    protected void setUp() throws Exception
+    {
+        _testConfigFile = createTempTestLog4JConfig();
+    }
+
+    private File createTempTestLog4JConfig()
+    {
+        File tmpFile = null;
+        try
+        {
+            tmpFile = File.createTempFile("LogManMBeanTestLog4jConfig", ".tmp");
+            tmpFile.deleteOnExit();
+
+            FileWriter fstream = new FileWriter(tmpFile);
+            BufferedWriter writer = new BufferedWriter(fstream);
+
+            writer.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>"+NEWLINE);
+            writer.write("<!DOCTYPE log4j:configuration SYSTEM \"log4j.dtd\">"+NEWLINE);
+
+            writer.write("<log4j:configuration xmlns:log4j=\"http://jakarta.apache.org/log4j/\" debug=\"null\" " +
+            		                                                                "threshold=\"null\">"+NEWLINE);
+
+            writer.write("  <appender class=\"org.apache.log4j.ConsoleAppender\" name=\"STDOUT\">"+NEWLINE);
+            writer.write("      <layout class=\"org.apache.log4j.PatternLayout\">"+NEWLINE);
+            writer.write("          <param name=\"ConversionPattern\" value=\"%d %-5p [%t] %C{2} (%F:%L) - %m%n\"/>"+NEWLINE);
+            writer.write("      </layout>"+NEWLINE);
+            writer.write("  </appender>"+NEWLINE);
+
+            //Example of a 'category' with a 'priority'
+            writer.write("  <category additivity=\"true\" name=\"" + CATEGORY_PRIORITY +"\">"+NEWLINE);
+            writer.write("      <priority value=\"info\"/>"+NEWLINE);
+            writer.write("      <appender-ref ref=\"STDOUT\"/>"+NEWLINE);
+            writer.write("  </category>"+NEWLINE);
+
+            //Example of a 'category' with a 'level'
+            writer.write("  <category additivity=\"true\" name=\"" + CATEGORY_LEVEL +"\">"+NEWLINE);
+            writer.write("      <level value=\"warn\"/>"+NEWLINE);
+            writer.write("      <appender-ref ref=\"STDOUT\"/>"+NEWLINE);
+            writer.write("  </category>"+NEWLINE);
+
+            //Example of a 'logger' with a 'level'
+            writer.write("  <logger additivity=\"true\" name=\"" + LOGGER_LEVEL + "\">"+NEWLINE);
+            writer.write("      <level value=\"error\"/>"+NEWLINE);
+            writer.write("      <appender-ref ref=\"STDOUT\"/>"+NEWLINE);
+            writer.write("  </logger>"+NEWLINE);
+
+            //'root' logger
+            writer.write("  <root>"+NEWLINE);
+            writer.write("      <priority value=\"info\"/>"+NEWLINE);
+            writer.write("      <appender-ref ref=\"STDOUT\"/>"+NEWLINE);
+            writer.write("  </root>"+NEWLINE);
+
+            writer.write("</log4j:configuration>"+NEWLINE);
+
+            writer.flush();
+            writer.close();
+        }
+        catch (IOException e)
+        {
+            fail("Unable to create temporary test log4j configuration");
+        }
+
+        return tmpFile;
+    }
+
+
+
+    //******* Test Methods ******* //
+   
+    public void testSetRuntimeLoggerLevel()
+    {
+        LoggingManagementMBean lm = null;
+        try
+        {
+            lm = new LoggingManagementMBean(_testConfigFile.getAbsolutePath(), 0);
+        }
+        catch (JMException e)
+        {
+            fail("Could not create test LoggingManagementMBean");
+        }
+
+        //create a parent test logger, set its level explicitly
+        Logger log = Logger.getLogger(TEST_LOGGER);
+        log.setLevel(Level.toLevel("info"));
+
+        //create child1 test logger, check its *effective* level is the same as the parent, "info"
+        Logger log1 = Logger.getLogger(TEST_LOGGER_CHILD1);
+        assertTrue("Test logger's level was not the expected value", 
+                    log1.getEffectiveLevel().toString().equalsIgnoreCase("info"));
+
+        //now change its level to "warn"
+        assertTrue("Failed to set logger level", lm.setRuntimeLoggerLevel(TEST_LOGGER_CHILD1, "warn"));
+
+        //check the change, see its actual level is "warn
+        assertTrue("Test logger's level was not the expected value", 
+                    log1.getLevel().toString().equalsIgnoreCase("warn"));
+
+        //try an invalid level
+        assertFalse("Trying to set an invalid level succeded", lm.setRuntimeLoggerLevel(TEST_LOGGER_CHILD1, "made.up.level"));
+    }
+    
+    public void testSetRuntimeRootLoggerLevel()
+    {
+        LoggingManagementMBean lm = null;
+        try
+        {
+            lm = new LoggingManagementMBean(_testConfigFile.getAbsolutePath(), 0);
+        }
+        catch (JMException e)
+        {
+            fail("Could not create test LoggingManagementMBean");
+        }
+
+        Logger log = Logger.getRootLogger();
+        
+        //get current root logger level
+        Level origLevel = log.getLevel();
+        
+        //change level twice to ensure a new level is actually selected
+        
+        //set root loggers level to info
+        assertTrue("Failed to set root logger level", lm.setRuntimeRootLoggerLevel("debug"));
+        //check it is now actually info
+        Level currentLevel = log.getLevel();
+        assertTrue("Logger level was not expected value", currentLevel.equals(Level.toLevel("debug")));
+        
+        //try an invalid level
+        assertFalse("Trying to set an invalid level succeded", lm.setRuntimeRootLoggerLevel("made.up.level"));
+        
+        //set root loggers level to warn
+        assertTrue("Failed to set logger level", lm.setRuntimeRootLoggerLevel("info"));
+        //check it is now actually warn
+        currentLevel = log.getLevel();
+        assertTrue("Logger level was not expected value", currentLevel.equals(Level.toLevel("info")));
+        
+        //restore original level
+        log.setLevel(origLevel);
+    }
+
+    public void testGetRuntimeRootLoggerLevel()
+    {
+        LoggingManagementMBean lm = null;
+        try
+        {
+            lm = new LoggingManagementMBean(_testConfigFile.getAbsolutePath(), 0);
+        }
+        catch (JMException e)
+        {
+            fail("Could not create test LoggingManagementMBean");
+        }
+
+        Logger log = Logger.getRootLogger();
+        
+        //get current root logger level
+        Level origLevel = log.getLevel();
+        
+        //change level twice to ensure a new level is actually selected
+        
+        //set root loggers level to debug
+        log.setLevel(Level.toLevel("debug"));
+        //check it is now actually debug
+        assertTrue("Logger level was not expected value", lm.getRuntimeRootLoggerLevel().equalsIgnoreCase("debug"));
+        
+        
+        //set root loggers level to warn
+        log.setLevel(Level.toLevel("info"));
+        //check it is now actually warn
+        assertTrue("Logger level was not expected value", lm.getRuntimeRootLoggerLevel().equalsIgnoreCase("info"));
+
+        //restore original level
+        log.setLevel(origLevel);
+    }
+    
+    public void testViewEffectiveRuntimeLoggerLevels()
+    {
+        LoggingManagementMBean lm = null;
+        try
+        {
+            lm = new LoggingManagementMBean(_testConfigFile.getAbsolutePath(), 0);
+        }
+        catch (JMException e)
+        {
+            fail("Could not create test LoggingManagementMBean");
+        }
+
+        //(re)create a parent test logger, set its level explicitly
+        Logger log = Logger.getLogger(TEST_LOGGER);
+        log.setLevel(Level.toLevel("info"));
+        
+        //retrieve the current effective runtime logger level values
+        TabularDataSupport levels = (TabularDataSupport) lm.viewEffectiveRuntimeLoggerLevels();
+        Collection<Object> records = levels.values();
+        Map<String,String> list = new HashMap<String,String>();
+        for (Object o : records)
+        {
+            CompositeData data = (CompositeData) o;
+            list.put(data.get(NAME_INDEX).toString(), data.get(LEVEL_INDEX).toString());
+        }
+        
+        //check child2 does not exist already
+        assertFalse("Did not expect this logger to exist already", list.containsKey(TEST_LOGGER_CHILD2));
+
+        //create child2 test logger
+        Logger log2 = Logger.getLogger(TEST_LOGGER_CHILD2);
+        
+        //retrieve the current effective runtime logger level values
+        levels = (TabularDataSupport) lm.viewEffectiveRuntimeLoggerLevels();
+        records = levels.values();
+        list = new HashMap<String,String>();
+        for (Object o : records)
+        {
+            CompositeData data = (CompositeData) o;
+            list.put(data.get(NAME_INDEX).toString(), data.get(LEVEL_INDEX).toString());
+        }
+
+        //verify the parent and child2 loggers are present in returned values
+        assertTrue(TEST_LOGGER + " logger was not in the returned list", list.containsKey(TEST_LOGGER));
+        assertTrue(TEST_LOGGER_CHILD2 + " logger was not in the returned list", list.containsKey(TEST_LOGGER_CHILD2));
+        
+        //check child2's effective level is the same as the parent, "info"
+        assertTrue("Test logger's level was not the expected value", 
+                    list.get(TEST_LOGGER_CHILD2).equalsIgnoreCase("info"));
+
+        //now change its level explicitly to "warn"
+        log2.setLevel(Level.toLevel("warn"));
+        
+        //retrieve the current effective runtime logger level values
+        levels = (TabularDataSupport) lm.viewEffectiveRuntimeLoggerLevels();
+        records = levels.values();
+        list = new HashMap<String,String>();
+        for (Object o : records)
+        {
+            CompositeData data = (CompositeData) o;
+            list.put(data.get(NAME_INDEX).toString(), data.get(LEVEL_INDEX).toString());
+        }
+
+        //check child2's effective level is now "warn"
+        assertTrue("Test logger's level was not the expected value", 
+                    list.get(TEST_LOGGER_CHILD2).equalsIgnoreCase("warn"));
+    }
+
+    public void testViewAndSetConfigFileLoggerLevel() throws Exception
+    {
+        LoggingManagementMBean lm =null;
+        try
+        {
+            lm = new LoggingManagementMBean(_testConfigFile.getAbsolutePath(), 0);
+        }
+        catch (JMException e)
+        {
+            fail("Could not create test LoggingManagementMBean");
+        }
+
+        //retrieve the current values
+        TabularDataSupport levels = (TabularDataSupport) lm.viewConfigFileLoggerLevels();
+        Collection<Object> records = levels.values();
+        Map<String,String> list = new HashMap<String,String>();
+        for (Object o : records)
+        {
+            CompositeData data = (CompositeData) o;
+            list.put(data.get(NAME_INDEX).toString(), data.get(LEVEL_INDEX).toString());
+        }
+
+        //check the 3 different types of logger definition are successfully retrieved before update
+        assertTrue("Wrong number of items in returned list", list.size() == 3);
+        assertTrue(CATEGORY_PRIORITY + " logger was not in the returned list", list.containsKey(CATEGORY_PRIORITY));
+        assertTrue(CATEGORY_LEVEL + " logger was not in the returned list", list.containsKey(CATEGORY_LEVEL));
+        assertTrue(LOGGER_LEVEL + " logger was not in the returned list", list.containsKey(LOGGER_LEVEL));
+
+        //check that their level is as expected
+        assertTrue(CATEGORY_PRIORITY + " logger's level was incorrect", list.get(CATEGORY_PRIORITY).equalsIgnoreCase("info"));
+        assertTrue(CATEGORY_LEVEL + " logger's level was incorrect", list.get(CATEGORY_LEVEL).equalsIgnoreCase("warn"));
+        assertTrue(LOGGER_LEVEL + " logger's level was incorrect", list.get(LOGGER_LEVEL).equalsIgnoreCase("error"));
+
+        //increase their levels a notch to test the 3 different types of logger definition are successfully updated
+        //change the category+priority to warn
+        assertTrue("failed to set new level", lm.setConfigFileLoggerLevel(CATEGORY_PRIORITY, "warn"));
+        //change the category+level to error
+        assertTrue("failed to set new level", lm.setConfigFileLoggerLevel(CATEGORY_LEVEL, "error"));
+        //change the logger+level to trace
+        assertTrue("failed to set new level", lm.setConfigFileLoggerLevel(LOGGER_LEVEL, "trace"));
+
+        //try an invalid level
+        assertFalse("Use of an invalid logger level was successfull", lm.setConfigFileLoggerLevel(LOGGER_LEVEL, "made.up.level"));
+
+        //try an invalid logger name
+        assertFalse("Use of an invalid logger name was successfull", lm.setConfigFileLoggerLevel("made.up.logger.name", "info"));
+
+        //retrieve the new values from the file and check them
+        levels = (TabularDataSupport) lm.viewConfigFileLoggerLevels();
+        records = levels.values();
+        list = new HashMap<String,String>();
+        for (Object o : records)
+        {
+            CompositeData data = (CompositeData) o;
+            list.put(data.get(NAME_INDEX).toString(), data.get(LEVEL_INDEX).toString());
+        }
+
+        //check the 3 different types of logger definition are successfully retrieved after update
+        assertTrue("Wrong number of items in returned list", list.size() == 3);
+        assertTrue(CATEGORY_PRIORITY + " logger was not in the returned list", list.containsKey(CATEGORY_PRIORITY));
+        assertTrue(CATEGORY_LEVEL + " logger was not in the returned list", list.containsKey(CATEGORY_LEVEL));
+        assertTrue(LOGGER_LEVEL + " logger was not in the returned list", list.containsKey(LOGGER_LEVEL));
+
+        //check that their level is as expected after the changes
+        assertTrue(CATEGORY_PRIORITY + " logger's level was incorrect", list.get(CATEGORY_PRIORITY).equalsIgnoreCase("warn"));
+        assertTrue(CATEGORY_LEVEL + " logger's level was incorrect", list.get(CATEGORY_LEVEL).equalsIgnoreCase("error"));
+        assertTrue(LOGGER_LEVEL + " logger's level was incorrect", list.get(LOGGER_LEVEL).equalsIgnoreCase("trace"));
+    }
+    
+    public void testGetAndSetConfigFileRootLoggerLevel() throws Exception
+    {
+        LoggingManagementMBean lm =null;
+        try
+        {
+            lm = new LoggingManagementMBean(_testConfigFile.getAbsolutePath(), 0);
+        }
+        catch (JMException e)
+        {
+            fail("Could not create test LoggingManagementMBean");
+        }
+
+        //retrieve the current value
+        String level = lm.getConfigFileRootLoggerLevel();
+
+        //check the value was successfully retrieved before update
+        assertTrue("Retrieved RootLogger level was incorrect", level.equalsIgnoreCase("info"));
+
+        //try an invalid level
+        assertFalse("Use of an invalid RootLogger level was successfull", lm.setConfigFileRootLoggerLevel("made.up.level"));
+        
+        //change the level to warn
+        assertTrue("Failed to set new RootLogger level", lm.setConfigFileRootLoggerLevel("warn"));
+
+        //retrieve the current value
+        level = lm.getConfigFileRootLoggerLevel();
+
+        //check the value was successfully retrieved after update
+        assertTrue("Retrieved RootLogger level was incorrect", level.equalsIgnoreCase("warn"));
+    }
+
+    public void testGetLog4jLogWatchInterval()
+    {
+        LoggingManagementMBean lm =null;
+        try
+        {
+            lm = new LoggingManagementMBean(_testConfigFile.getAbsolutePath(), 5000);
+        }
+        catch (JMException e)
+        {
+            fail("Could not create test LoggingManagementMBean");
+        }
+
+        assertTrue("Wrong value returned for logWatch period", lm.getLog4jLogWatchInterval() == 5000);
+    }
+
+}
+/*
+ *  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.management;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.management.JMException;
+import javax.management.openmbean.CompositeData;
+import javax.management.openmbean.TabularDataSupport;
+
+import org.apache.log4j.Level;
+import org.apache.log4j.Logger;
+
+import junit.framework.TestCase;
+
+public class LoggingManagementMBeanTest extends TestCase
+{
+    private static final String TEST_LOGGER = "LoggingManagementMBeanTestLogger";
+    private static final String TEST_LOGGER_CHILD1 = "LoggingManagementMBeanTestLogger.child1";
+    private static final String TEST_LOGGER_CHILD2 = "LoggingManagementMBeanTestLogger.child2";
+
+    private static final String CATEGORY_PRIORITY = "LogManMBeanTest.category.priority";
+    private static final String CATEGORY_LEVEL = "LogManMBeanTest.category.level";
+    private static final String LOGGER_LEVEL = "LogManMBeanTest.logger.level";
+    
+    private static final String NAME_INDEX = LoggingManagement.COMPOSITE_ITEM_NAMES[0];
+    private static final String LEVEL_INDEX = LoggingManagement.COMPOSITE_ITEM_NAMES[1];
+
+    private static final String NEWLINE = System.getProperty("line.separator");
+
+    private File _testConfigFile;
+
+    protected void setUp() throws Exception
+    {
+        _testConfigFile = createTempTestLog4JConfig();
+    }
+
+    private File createTempTestLog4JConfig()
+    {
+        File tmpFile = null;
+        try
+        {
+            tmpFile = File.createTempFile("LogManMBeanTestLog4jConfig", ".tmp");
+            tmpFile.deleteOnExit();
+
+            FileWriter fstream = new FileWriter(tmpFile);
+            BufferedWriter writer = new BufferedWriter(fstream);
+
+            writer.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>"+NEWLINE);
+            writer.write("<!DOCTYPE log4j:configuration SYSTEM \"log4j.dtd\">"+NEWLINE);
+
+            writer.write("<log4j:configuration xmlns:log4j=\"http://jakarta.apache.org/log4j/\" debug=\"null\" " +
+            		                                                                "threshold=\"null\">"+NEWLINE);
+
+            writer.write("  <appender class=\"org.apache.log4j.ConsoleAppender\" name=\"STDOUT\">"+NEWLINE);
+            writer.write("      <layout class=\"org.apache.log4j.PatternLayout\">"+NEWLINE);
+            writer.write("          <param name=\"ConversionPattern\" value=\"%d %-5p [%t] %C{2} (%F:%L) - %m%n\"/>"+NEWLINE);
+            writer.write("      </layout>"+NEWLINE);
+            writer.write("  </appender>"+NEWLINE);
+
+            //Example of a 'category' with a 'priority'
+            writer.write("  <category additivity=\"true\" name=\"" + CATEGORY_PRIORITY +"\">"+NEWLINE);
+            writer.write("      <priority value=\"info\"/>"+NEWLINE);
+            writer.write("      <appender-ref ref=\"STDOUT\"/>"+NEWLINE);
+            writer.write("  </category>"+NEWLINE);
+
+            //Example of a 'category' with a 'level'
+            writer.write("  <category additivity=\"true\" name=\"" + CATEGORY_LEVEL +"\">"+NEWLINE);
+            writer.write("      <level value=\"warn\"/>"+NEWLINE);
+            writer.write("      <appender-ref ref=\"STDOUT\"/>"+NEWLINE);
+            writer.write("  </category>"+NEWLINE);
+
+            //Example of a 'logger' with a 'level'
+            writer.write("  <logger additivity=\"true\" name=\"" + LOGGER_LEVEL + "\">"+NEWLINE);
+            writer.write("      <level value=\"error\"/>"+NEWLINE);
+            writer.write("      <appender-ref ref=\"STDOUT\"/>"+NEWLINE);
+            writer.write("  </logger>"+NEWLINE);
+
+            //'root' logger
+            writer.write("  <root>"+NEWLINE);
+            writer.write("      <priority value=\"info\"/>"+NEWLINE);
+            writer.write("      <appender-ref ref=\"STDOUT\"/>"+NEWLINE);
+            writer.write("  </root>"+NEWLINE);
+
+            writer.write("</log4j:configuration>"+NEWLINE);
+
+            writer.flush();
+            writer.close();
+        }
+        catch (IOException e)
+        {
+            fail("Unable to create temporary test log4j configuration");
+        }
+
+        return tmpFile;
+    }
+
+
+
+    //******* Test Methods ******* //
+   
+    public void testSetRuntimeLoggerLevel()
+    {
+        LoggingManagementMBean lm = null;
+        try
+        {
+            lm = new LoggingManagementMBean(_testConfigFile.getAbsolutePath(), 0);
+        }
+        catch (JMException e)
+        {
+            fail("Could not create test LoggingManagementMBean");
+        }
+
+        //create a parent test logger, set its level explicitly
+        Logger log = Logger.getLogger(TEST_LOGGER);
+        log.setLevel(Level.toLevel("info"));
+
+        //create child1 test logger, check its *effective* level is the same as the parent, "info"
+        Logger log1 = Logger.getLogger(TEST_LOGGER_CHILD1);
+        assertTrue("Test logger's level was not the expected value", 
+                    log1.getEffectiveLevel().toString().equalsIgnoreCase("info"));
+
+        //now change its level to "warn"
+        assertTrue("Failed to set logger level", lm.setRuntimeLoggerLevel(TEST_LOGGER_CHILD1, "warn"));
+
+        //check the change, see its actual level is "warn
+        assertTrue("Test logger's level was not the expected value", 
+                    log1.getLevel().toString().equalsIgnoreCase("warn"));
+
+        //try an invalid level
+        assertFalse("Trying to set an invalid level succeded", lm.setRuntimeLoggerLevel(TEST_LOGGER_CHILD1, "made.up.level"));
+    }
+    
+    public void testSetRuntimeRootLoggerLevel()
+    {
+        LoggingManagementMBean lm = null;
+        try
+        {
+            lm = new LoggingManagementMBean(_testConfigFile.getAbsolutePath(), 0);
+        }
+        catch (JMException e)
+        {
+            fail("Could not create test LoggingManagementMBean");
+        }
+
+        Logger log = Logger.getRootLogger();
+        
+        //get current root logger level
+        Level origLevel = log.getLevel();
+        
+        //change level twice to ensure a new level is actually selected
+        
+        //set root loggers level to info
+        assertTrue("Failed to set root logger level", lm.setRuntimeRootLoggerLevel("debug"));
+        //check it is now actually info
+        Level currentLevel = log.getLevel();
+        assertTrue("Logger level was not expected value", currentLevel.equals(Level.toLevel("debug")));
+        
+        //try an invalid level
+        assertFalse("Trying to set an invalid level succeded", lm.setRuntimeRootLoggerLevel("made.up.level"));
+        
+        //set root loggers level to warn
+        assertTrue("Failed to set logger level", lm.setRuntimeRootLoggerLevel("info"));
+        //check it is now actually warn
+        currentLevel = log.getLevel();
+        assertTrue("Logger level was not expected value", currentLevel.equals(Level.toLevel("info")));
+        
+        //restore original level
+        log.setLevel(origLevel);
+    }
+
+    public void testGetRuntimeRootLoggerLevel()
+    {
+        LoggingManagementMBean lm = null;
+        try
+        {
+            lm = new LoggingManagementMBean(_testConfigFile.getAbsolutePath(), 0);
+        }
+        catch (JMException e)
+        {
+            fail("Could not create test LoggingManagementMBean");
+        }
+
+        Logger log = Logger.getRootLogger();
+        
+        //get current root logger level
+        Level origLevel = log.getLevel();
+        
+        //change level twice to ensure a new level is actually selected
+        
+        //set root loggers level to debug
+        log.setLevel(Level.toLevel("debug"));
+        //check it is now actually debug
+        assertTrue("Logger level was not expected value", lm.getRuntimeRootLoggerLevel().equalsIgnoreCase("debug"));
+        
+        
+        //set root loggers level to warn
+        log.setLevel(Level.toLevel("info"));
+        //check it is now actually warn
+        assertTrue("Logger level was not expected value", lm.getRuntimeRootLoggerLevel().equalsIgnoreCase("info"));
+
+        //restore original level
+        log.setLevel(origLevel);
+    }
+    
+    public void testViewEffectiveRuntimeLoggerLevels()
+    {
+        LoggingManagementMBean lm = null;
+        try
+        {
+            lm = new LoggingManagementMBean(_testConfigFile.getAbsolutePath(), 0);
+        }
+        catch (JMException e)
+        {
+            fail("Could not create test LoggingManagementMBean");
+        }
+
+        //(re)create a parent test logger, set its level explicitly
+        Logger log = Logger.getLogger(TEST_LOGGER);
+        log.setLevel(Level.toLevel("info"));
+        
+        //retrieve the current effective runtime logger level values
+        TabularDataSupport levels = (TabularDataSupport) lm.viewEffectiveRuntimeLoggerLevels();
+        Collection<Object> records = levels.values();
+        Map<String,String> list = new HashMap<String,String>();
+        for (Object o : records)
+        {
+            CompositeData data = (CompositeData) o;
+            list.put(data.get(NAME_INDEX).toString(), data.get(LEVEL_INDEX).toString());
+        }
+        
+        //check child2 does not exist already
+        assertFalse("Did not expect this logger to exist already", list.containsKey(TEST_LOGGER_CHILD2));
+
+        //create child2 test logger
+        Logger log2 = Logger.getLogger(TEST_LOGGER_CHILD2);
+        
+        //retrieve the current effective runtime logger level values
+        levels = (TabularDataSupport) lm.viewEffectiveRuntimeLoggerLevels();
+        records = levels.values();
+        list = new HashMap<String,String>();
+        for (Object o : records)
+        {
+            CompositeData data = (CompositeData) o;
+            list.put(data.get(NAME_INDEX).toString(), data.get(LEVEL_INDEX).toString());
+        }
+
+        //verify the parent and child2 loggers are present in returned values
+        assertTrue(TEST_LOGGER + " logger was not in the returned list", list.containsKey(TEST_LOGGER));
+        assertTrue(TEST_LOGGER_CHILD2 + " logger was not in the returned list", list.containsKey(TEST_LOGGER_CHILD2));
+        
+        //check child2's effective level is the same as the parent, "info"
+        assertTrue("Test logger's level was not the expected value", 
+                    list.get(TEST_LOGGER_CHILD2).equalsIgnoreCase("info"));
+
+        //now change its level explicitly to "warn"
+        log2.setLevel(Level.toLevel("warn"));
+        
+        //retrieve the current effective runtime logger level values
+        levels = (TabularDataSupport) lm.viewEffectiveRuntimeLoggerLevels();
+        records = levels.values();
+        list = new HashMap<String,String>();
+        for (Object o : records)
+        {
+            CompositeData data = (CompositeData) o;
+            list.put(data.get(NAME_INDEX).toString(), data.get(LEVEL_INDEX).toString());
+        }
+
+        //check child2's effective level is now "warn"
+        assertTrue("Test logger's level was not the expected value", 
+                    list.get(TEST_LOGGER_CHILD2).equalsIgnoreCase("warn"));
+    }
+
+    public void testViewAndSetConfigFileLoggerLevel() throws Exception
+    {
+        LoggingManagementMBean lm =null;
+        try
+        {
+            lm = new LoggingManagementMBean(_testConfigFile.getAbsolutePath(), 0);
+        }
+        catch (JMException e)
+        {
+            fail("Could not create test LoggingManagementMBean");
+        }
+
+        //retrieve the current values
+        TabularDataSupport levels = (TabularDataSupport) lm.viewConfigFileLoggerLevels();
+        Collection<Object> records = levels.values();
+        Map<String,String> list = new HashMap<String,String>();
+        for (Object o : records)
+        {
+            CompositeData data = (CompositeData) o;
+            list.put(data.get(NAME_INDEX).toString(), data.get(LEVEL_INDEX).toString());
+        }
+
+        //check the 3 different types of logger definition are successfully retrieved before update
+        assertTrue("Wrong number of items in returned list", list.size() == 3);
+        assertTrue(CATEGORY_PRIORITY + " logger was not in the returned list", list.containsKey(CATEGORY_PRIORITY));
+        assertTrue(CATEGORY_LEVEL + " logger was not in the returned list", list.containsKey(CATEGORY_LEVEL));
+        assertTrue(LOGGER_LEVEL + " logger was not in the returned list", list.containsKey(LOGGER_LEVEL));
+
+        //check that their level is as expected
+        assertTrue(CATEGORY_PRIORITY + " logger's level was incorrect", list.get(CATEGORY_PRIORITY).equalsIgnoreCase("info"));
+        assertTrue(CATEGORY_LEVEL + " logger's level was incorrect", list.get(CATEGORY_LEVEL).equalsIgnoreCase("warn"));
+        assertTrue(LOGGER_LEVEL + " logger's level was incorrect", list.get(LOGGER_LEVEL).equalsIgnoreCase("error"));
+
+        //increase their levels a notch to test the 3 different types of logger definition are successfully updated
+        //change the category+priority to warn
+        assertTrue("failed to set new level", lm.setConfigFileLoggerLevel(CATEGORY_PRIORITY, "warn"));
+        //change the category+level to error
+        assertTrue("failed to set new level", lm.setConfigFileLoggerLevel(CATEGORY_LEVEL, "error"));
+        //change the logger+level to trace
+        assertTrue("failed to set new level", lm.setConfigFileLoggerLevel(LOGGER_LEVEL, "trace"));
+
+        //try an invalid level
+        assertFalse("Use of an invalid logger level was successfull", lm.setConfigFileLoggerLevel(LOGGER_LEVEL, "made.up.level"));
+
+        //try an invalid logger name
+        assertFalse("Use of an invalid logger name was successfull", lm.setConfigFileLoggerLevel("made.up.logger.name", "info"));
+
+        //retrieve the new values from the file and check them
+        levels = (TabularDataSupport) lm.viewConfigFileLoggerLevels();
+        records = levels.values();
+        list = new HashMap<String,String>();
+        for (Object o : records)
+        {
+            CompositeData data = (CompositeData) o;
+            list.put(data.get(NAME_INDEX).toString(), data.get(LEVEL_INDEX).toString());
+        }
+
+        //check the 3 different types of logger definition are successfully retrieved after update
+        assertTrue("Wrong number of items in returned list", list.size() == 3);
+        assertTrue(CATEGORY_PRIORITY + " logger was not in the returned list", list.containsKey(CATEGORY_PRIORITY));
+        assertTrue(CATEGORY_LEVEL + " logger was not in the returned list", list.containsKey(CATEGORY_LEVEL));
+        assertTrue(LOGGER_LEVEL + " logger was not in the returned list", list.containsKey(LOGGER_LEVEL));
+
+        //check that their level is as expected after the changes
+        assertTrue(CATEGORY_PRIORITY + " logger's level was incorrect", list.get(CATEGORY_PRIORITY).equalsIgnoreCase("warn"));
+        assertTrue(CATEGORY_LEVEL + " logger's level was incorrect", list.get(CATEGORY_LEVEL).equalsIgnoreCase("error"));
+        assertTrue(LOGGER_LEVEL + " logger's level was incorrect", list.get(LOGGER_LEVEL).equalsIgnoreCase("trace"));
+    }
+    
+    public void testGetAndSetConfigFileRootLoggerLevel() throws Exception
+    {
+        LoggingManagementMBean lm =null;
+        try
+        {
+            lm = new LoggingManagementMBean(_testConfigFile.getAbsolutePath(), 0);
+        }
+        catch (JMException e)
+        {
+            fail("Could not create test LoggingManagementMBean");
+        }
+
+        //retrieve the current value
+        String level = lm.getConfigFileRootLoggerLevel();
+
+        //check the value was successfully retrieved before update
+        assertTrue("Retrieved RootLogger level was incorrect", level.equalsIgnoreCase("info"));
+
+        //try an invalid level
+        assertFalse("Use of an invalid RootLogger level was successfull", lm.setConfigFileRootLoggerLevel("made.up.level"));
+        
+        //change the level to warn
+        assertTrue("Failed to set new RootLogger level", lm.setConfigFileRootLoggerLevel("warn"));
+
+        //retrieve the current value
+        level = lm.getConfigFileRootLoggerLevel();
+
+        //check the value was successfully retrieved after update
+        assertTrue("Retrieved RootLogger level was incorrect", level.equalsIgnoreCase("warn"));
+    }
+
+    public void testGetLog4jLogWatchInterval()
+    {
+        LoggingManagementMBean lm =null;
+        try
+        {
+            lm = new LoggingManagementMBean(_testConfigFile.getAbsolutePath(), 5000);
+        }
+        catch (JMException e)
+        {
+            fail("Could not create test LoggingManagementMBean");
+        }
+
+        assertTrue("Wrong value returned for logWatch period", lm.getLog4jLogWatchInterval() == 5000);
+    }
+
+}