8172971: java.management could use System.Logger
authordfuchs
Fri, 20 Jan 2017 18:41:12 +0000
changeset 43235 da1786d695b6
parent 43234 cb2a6851b837
child 43237 4a75a9d840a2
8172971: java.management could use System.Logger Summary: java.management is updated to use System.Logger instead of java.util.logging.Logger. Reviewed-by: mchung, rriggs
jdk/src/java.management/share/classes/com/sun/jmx/defaults/JmxProperties.java
jdk/src/java.management/share/classes/com/sun/jmx/interceptor/DefaultMBeanServerInterceptor.java
jdk/src/java.management/share/classes/com/sun/jmx/mbeanserver/ClassLoaderRepositorySupport.java
jdk/src/java.management/share/classes/com/sun/jmx/mbeanserver/JmxMBeanServer.java
jdk/src/java.management/share/classes/com/sun/jmx/mbeanserver/MBeanInstantiator.java
jdk/src/java.management/share/classes/com/sun/jmx/mbeanserver/MBeanServerDelegateImpl.java
jdk/src/java.management/share/classes/com/sun/jmx/mbeanserver/Repository.java
jdk/src/java.management/share/classes/com/sun/jmx/remote/util/ClassLogger.java
jdk/src/java.management/share/classes/javax/management/MBeanServerDelegate.java
jdk/src/java.management/share/classes/javax/management/MBeanServerFactory.java
jdk/src/java.management/share/classes/javax/management/StandardMBean.java
jdk/src/java.management/share/classes/javax/management/loading/DefaultLoaderRepository.java
jdk/src/java.management/share/classes/javax/management/loading/MLet.java
jdk/src/java.management/share/classes/javax/management/loading/MLetParser.java
jdk/src/java.management/share/classes/javax/management/modelmbean/DescriptorSupport.java
jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanAttributeInfo.java
jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanConstructorInfo.java
jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanInfoSupport.java
jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanNotificationInfo.java
jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanOperationInfo.java
jdk/src/java.management/share/classes/javax/management/modelmbean/RequiredModelMBean.java
jdk/src/java.management/share/classes/javax/management/monitor/CounterMonitor.java
jdk/src/java.management/share/classes/javax/management/monitor/GaugeMonitor.java
jdk/src/java.management/share/classes/javax/management/monitor/Monitor.java
jdk/src/java.management/share/classes/javax/management/monitor/StringMonitor.java
jdk/src/java.management/share/classes/javax/management/relation/MBeanServerNotificationFilter.java
jdk/src/java.management/share/classes/javax/management/relation/RelationService.java
jdk/src/java.management/share/classes/javax/management/relation/RelationSupport.java
jdk/src/java.management/share/classes/javax/management/relation/RelationTypeSupport.java
jdk/src/java.management/share/classes/javax/management/timer/Timer.java
jdk/src/java.management/share/classes/javax/management/timer/TimerAlarmClock.java
jdk/src/java.management/share/classes/module-info.java
jdk/test/sun/management/LoggingTest/LoggingTest.java
jdk/test/sun/management/LoggingTest/LoggingWithJULTest.java
jdk/test/sun/management/LoggingTest/LoggingWithLoggerFinderTest.java
jdk/test/sun/management/LoggingTest/logging.properties
jdk/test/sun/management/LoggingTest/test.loggerfinder/module-info.java
jdk/test/sun/management/LoggingTest/test.loggerfinder/test/loggerfinder/TestLoggerFinder.java
--- a/jdk/src/java.management/share/classes/com/sun/jmx/defaults/JmxProperties.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/com/sun/jmx/defaults/JmxProperties.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2007, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -25,7 +25,7 @@
 
 package com.sun.jmx.defaults;
 
-import java.util.logging.Logger;
+import java.lang.System.Logger;
 
 /**
  * This contains the property list defined for this
@@ -120,7 +120,7 @@
      * Logger for MBean Server information.
      */
     public static final Logger MBEANSERVER_LOGGER =
-            Logger.getLogger(MBEANSERVER_LOGGER_NAME);
+            System.getLogger(MBEANSERVER_LOGGER_NAME);
 
     /**
      * Logger name for MLet service information.
@@ -132,7 +132,7 @@
      * Logger for MLet service information.
      */
     public static final Logger MLET_LOGGER =
-            Logger.getLogger(MLET_LOGGER_NAME);
+            System.getLogger(MLET_LOGGER_NAME);
 
     /**
      * Logger name for Monitor information.
@@ -144,7 +144,7 @@
      * Logger for Monitor information.
      */
     public static final Logger MONITOR_LOGGER =
-            Logger.getLogger(MONITOR_LOGGER_NAME);
+            System.getLogger(MONITOR_LOGGER_NAME);
 
     /**
      * Logger name for Timer information.
@@ -156,7 +156,7 @@
      * Logger for Timer information.
      */
     public static final Logger TIMER_LOGGER =
-            Logger.getLogger(TIMER_LOGGER_NAME);
+            System.getLogger(TIMER_LOGGER_NAME);
 
     /**
      * Logger name for Event Management information.
@@ -168,7 +168,7 @@
      * Logger for Event Management information.
      */
     public static final Logger NOTIFICATION_LOGGER =
-            Logger.getLogger(NOTIFICATION_LOGGER_NAME);
+            System.getLogger(NOTIFICATION_LOGGER_NAME);
 
     /**
      * Logger name for Relation Service.
@@ -180,7 +180,7 @@
      * Logger for Relation Service.
      */
     public static final Logger RELATION_LOGGER =
-            Logger.getLogger(RELATION_LOGGER_NAME);
+            System.getLogger(RELATION_LOGGER_NAME);
 
     /**
      * Logger name for Model MBean.
@@ -192,7 +192,7 @@
      * Logger for Model MBean.
      */
     public static final Logger MODELMBEAN_LOGGER =
-            Logger.getLogger(MODELMBEAN_LOGGER_NAME);
+            System.getLogger(MODELMBEAN_LOGGER_NAME);
 
     /**
      * Logger name for all other JMX classes.
@@ -204,5 +204,5 @@
      * Logger for all other JMX classes.
      */
     public static final Logger MISC_LOGGER =
-            Logger.getLogger(MISC_LOGGER_NAME);
+            System.getLogger(MISC_LOGGER_NAME);
 }
--- a/jdk/src/java.management/share/classes/com/sun/jmx/interceptor/DefaultMBeanServerInterceptor.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/com/sun/jmx/interceptor/DefaultMBeanServerInterceptor.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -50,7 +50,7 @@
 import java.util.List;
 import java.util.Set;
 import java.util.WeakHashMap;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 
 // JMX import
 import javax.management.Attribute;
@@ -258,19 +258,16 @@
 
         /* Load the appropriate class. */
         if (withDefaultLoaderRepository) {
-            if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-                MBEANSERVER_LOGGER.logp(Level.FINER,
-                        DefaultMBeanServerInterceptor.class.getName(),
-                        "createMBean",
+            if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+                MBEANSERVER_LOGGER.log(Level.TRACE,
                         "ClassName = " + className + ", ObjectName = " + name);
             }
             theClass =
                 instantiator.findClassWithDefaultLoaderRepository(className);
         } else if (loaderName == null) {
-            if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-                MBEANSERVER_LOGGER.logp(Level.FINER,
-                        DefaultMBeanServerInterceptor.class.getName(),
-                        "createMBean", "ClassName = " + className +
+            if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+                MBEANSERVER_LOGGER.log(Level.TRACE,
+                        "ClassName = " + className +
                         ", ObjectName = " + name + ", Loader name = null");
             }
 
@@ -279,10 +276,9 @@
         } else {
             loaderName = nonDefaultDomain(loaderName);
 
-            if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-                MBEANSERVER_LOGGER.logp(Level.FINER,
-                        DefaultMBeanServerInterceptor.class.getName(),
-                        "createMBean", "ClassName = " + className +
+            if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+                MBEANSERVER_LOGGER.log(Level.TRACE,
+                        "ClassName = " + className +
                         ", ObjectName = " + name +
                         ", Loader name = " + loaderName);
             }
@@ -633,10 +629,8 @@
 
         name = nonDefaultDomain(name);
 
-        if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-            MBEANSERVER_LOGGER.logp(Level.FINER,
-                    DefaultMBeanServerInterceptor.class.getName(),
-                    "getAttribute",
+        if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+            MBEANSERVER_LOGGER.log(Level.TRACE,
                     "Attribute = " + attribute + ", ObjectName = " + name);
         }
 
@@ -670,10 +664,8 @@
 
         name = nonDefaultDomain(name);
 
-        if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-            MBEANSERVER_LOGGER.logp(Level.FINER,
-                    DefaultMBeanServerInterceptor.class.getName(),
-                    "getAttributes", "ObjectName = " + name);
+        if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+            MBEANSERVER_LOGGER.log(Level.TRACE, "ObjectName = " + name);
         }
 
         final DynamicMBean instance = getMBean(name);
@@ -732,10 +724,8 @@
 
         name = nonDefaultDomain(name);
 
-        if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-            MBEANSERVER_LOGGER.logp(Level.FINER,
-                    DefaultMBeanServerInterceptor.class.getName(),
-                    "setAttribute", "ObjectName = " + name +
+        if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+            MBEANSERVER_LOGGER.log(Level.TRACE, "ObjectName = " + name +
                     ", Attribute = " + attribute.getName());
         }
 
@@ -910,10 +900,9 @@
 
         name = nonDefaultDomain(name);
 
-        if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-            MBEANSERVER_LOGGER.logp(Level.FINER,
-                    DefaultMBeanServerInterceptor.class.getName(),
-                    "registerMBean", "ObjectName = " + name);
+        if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+            MBEANSERVER_LOGGER.log(Level.TRACE,
+                    "ObjectName = " + name);
         }
 
         ObjectName logicalName = preRegister(mbean, server, name);
@@ -1023,14 +1012,14 @@
             if (mbean instanceof MBeanRegistration)
                 ((MBeanRegistration) mbean).postRegister(registrationDone);
         } catch (RuntimeException e) {
-            MBEANSERVER_LOGGER.fine("While registering MBean ["+logicalName+
+            MBEANSERVER_LOGGER.log(Level.DEBUG, "While registering MBean ["+logicalName+
                     "]: " + "Exception thrown by postRegister: " +
                     "rethrowing <"+e+">, but keeping the MBean registered");
             throw new RuntimeMBeanException(e,
                       "RuntimeException thrown in postRegister method: "+
                       "rethrowing <"+e+">, but keeping the MBean registered");
         } catch (Error er) {
-            MBEANSERVER_LOGGER.fine("While registering MBean ["+logicalName+
+            MBEANSERVER_LOGGER.log(Level.DEBUG, "While registering MBean ["+logicalName+
                     "]: " + "Error thrown by postRegister: " +
                     "rethrowing <"+er+">, but keeping the MBean registered");
             throw new RuntimeErrorException(er,
@@ -1053,7 +1042,7 @@
         try {
             moi.postDeregister();
         } catch (RuntimeException e) {
-            MBEANSERVER_LOGGER.fine("While unregistering MBean ["+mbean+
+            MBEANSERVER_LOGGER.log(Level.DEBUG, "While unregistering MBean ["+mbean+
                     "]: " + "Exception thrown by postDeregister: " +
                     "rethrowing <"+e+">, although the MBean is succesfully " +
                     "unregistered");
@@ -1062,7 +1051,7 @@
                       "rethrowing <"+e+
                       ">, although the MBean is sucessfully unregistered");
         } catch (Error er) {
-            MBEANSERVER_LOGGER.fine("While unregistering MBean ["+mbean+
+            MBEANSERVER_LOGGER.log(Level.DEBUG, "While unregistering MBean ["+mbean+
                     "]: " + "Error thrown by postDeregister: " +
                     "rethrowing <"+er+">, although the MBean is succesfully " +
                     "unregistered");
@@ -1087,10 +1076,9 @@
         }
         DynamicMBean obj = repository.retrieve(name);
         if (obj == null) {
-            if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-                MBEANSERVER_LOGGER.logp(Level.FINER,
-                        DefaultMBeanServerInterceptor.class.getName(),
-                        "getMBean", name + " : Found no object");
+            if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+                MBEANSERVER_LOGGER.log(Level.TRACE,
+                        name + " : Found no object");
             }
             throw new InstanceNotFoundException(name.toString());
         }
@@ -1176,10 +1164,8 @@
 
         // ------------------------------
         // ------------------------------
-        if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-            MBEANSERVER_LOGGER.logp(Level.FINER,
-                    DefaultMBeanServerInterceptor.class.getName(),
-                    "addNotificationListener", "ObjectName = " + name);
+        if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+            MBEANSERVER_LOGGER.log(Level.TRACE, "ObjectName = " + name);
         }
 
         DynamicMBean instance = getMBean(name);
@@ -1226,10 +1212,8 @@
         // ----------------
         // Add a listener on an MBean
         // ----------------
-        if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-            MBEANSERVER_LOGGER.logp(Level.FINER,
-                    DefaultMBeanServerInterceptor.class.getName(),
-                    "addNotificationListener",
+        if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+            MBEANSERVER_LOGGER.log(Level.TRACE,
                     "ObjectName = " + name + ", Listener = " + listener);
         }
         server.addNotificationListener(name,(NotificationListener) resource,
@@ -1255,10 +1239,8 @@
             throws InstanceNotFoundException, ListenerNotFoundException {
         NotificationListener instance = getListener(listener);
 
-        if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-            MBEANSERVER_LOGGER.logp(Level.FINER,
-                    DefaultMBeanServerInterceptor.class.getName(),
-                    "removeNotificationListener",
+        if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+            MBEANSERVER_LOGGER.log(Level.TRACE,
                     "ObjectName = " + name + ", Listener = " + listener);
         }
         server.removeNotificationListener(name, instance);
@@ -1272,10 +1254,8 @@
 
         NotificationListener instance = getListener(listener);
 
-        if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-            MBEANSERVER_LOGGER.logp(Level.FINER,
-                    DefaultMBeanServerInterceptor.class.getName(),
-                    "removeNotificationListener",
+        if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+            MBEANSERVER_LOGGER.log(Level.TRACE,
                     "ObjectName = " + name + ", Listener = " + listener);
         }
         server.removeNotificationListener(name, instance, filter, handback);
@@ -1313,10 +1293,8 @@
                                             boolean removeAll)
             throws InstanceNotFoundException, ListenerNotFoundException {
 
-        if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-            MBEANSERVER_LOGGER.logp(Level.FINER,
-                    DefaultMBeanServerInterceptor.class.getName(),
-                    "removeNotificationListener", "ObjectName = " + name);
+        if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+            MBEANSERVER_LOGGER.log(Level.TRACE, "ObjectName = " + name);
         }
 
         DynamicMBean instance = getMBean(name);
@@ -1421,10 +1399,9 @@
             return classNameClass.isAssignableFrom(resourceClass);
         } catch (Exception x) {
             /* Could be SecurityException or ClassNotFoundException */
-            if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
-                MBEANSERVER_LOGGER.logp(Level.FINEST,
-                        DefaultMBeanServerInterceptor.class.getName(),
-                        "isInstanceOf", "Exception calling isInstanceOf", x);
+            if (MBEANSERVER_LOGGER.isLoggable(Level.DEBUG)) {
+                MBEANSERVER_LOGGER.log(Level.DEBUG,
+                        "Exception calling isInstanceOf", x);
             }
             return false;
         }
@@ -1489,10 +1466,8 @@
         MBeanServerNotification notif = new MBeanServerNotification(
             NotifType,MBeanServerDelegate.DELEGATE_NAME,0,name);
 
-        if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-            MBEANSERVER_LOGGER.logp(Level.FINER,
-                    DefaultMBeanServerInterceptor.class.getName(),
-                    "sendNotification", NotifType + " " + name);
+        if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+            MBEANSERVER_LOGGER.log(Level.TRACE, NotifType + " " + name);
         }
 
         delegate.sendNotification(notif);
@@ -1594,10 +1569,8 @@
         try {
             return getClassName(mbean);
         } catch (Exception e) {
-            if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
-                MBEANSERVER_LOGGER.logp(Level.FINEST,
-                        DefaultMBeanServerInterceptor.class.getName(),
-                        "safeGetClassName",
+            if (MBEANSERVER_LOGGER.isLoggable(Level.DEBUG)) {
+                MBEANSERVER_LOGGER.log(Level.DEBUG,
                         "Exception getting MBean class name", e);
             }
             return null;
@@ -1885,10 +1858,9 @@
         // ---------------------
         // Send create event
         // ---------------------
-        if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-            MBEANSERVER_LOGGER.logp(Level.FINER,
-                    DefaultMBeanServerInterceptor.class.getName(),
-                    "addObject", "Send create notification of object " +
+        if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+            MBEANSERVER_LOGGER.log(Level.TRACE,
+                    "Send create notification of object " +
                     logicalName.getCanonicalName());
         }
 
@@ -1926,10 +1898,9 @@
         // ---------------------
         // Send deletion event
         // ---------------------
-        if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-            MBEANSERVER_LOGGER.logp(Level.FINER,
-                    DefaultMBeanServerInterceptor.class.getName(),
-                    "unregisterMBean", "Send delete notification of object " +
+        if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+            MBEANSERVER_LOGGER.log(Level.TRACE,
+                    "Send delete notification of object " +
                     logicalName.getCanonicalName());
         }
 
--- a/jdk/src/java.management/share/classes/com/sun/jmx/mbeanserver/ClassLoaderRepositorySupport.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/com/sun/jmx/mbeanserver/ClassLoaderRepositorySupport.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -33,7 +33,7 @@
 import java.util.Hashtable;
 import java.util.List;
 import java.util.Map;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 import javax.management.MBeanPermission;
 
 import javax.management.ObjectName;
@@ -148,10 +148,9 @@
     // from javax.management.loading.DefaultLoaderRepository
     public final Class<?> loadClassWithout(ClassLoader without, String className)
             throws ClassNotFoundException {
-        if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-            MBEANSERVER_LOGGER.logp(Level.FINER,
-                    ClassLoaderRepositorySupport.class.getName(),
-                    "loadClassWithout", className + " without " + without);
+        if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+            MBEANSERVER_LOGGER.log(Level.TRACE,
+                    className + " without " + without);
         }
 
         // without is null => just behave as loadClass
@@ -172,10 +171,9 @@
 
     public final Class<?> loadClassBefore(ClassLoader stop, String className)
             throws ClassNotFoundException {
-        if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-            MBEANSERVER_LOGGER.logp(Level.FINER,
-                    ClassLoaderRepositorySupport.class.getName(),
-                    "loadClassBefore", className + " before " + stop);
+        if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+            MBEANSERVER_LOGGER.log(Level.TRACE,
+                    className + " before " + stop);
         }
 
         if (stop == null)
@@ -206,10 +204,8 @@
                     continue;
                 if (cl == stop)
                     break;
-                if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-                    MBEANSERVER_LOGGER.logp(Level.FINER,
-                            ClassLoaderRepositorySupport.class.getName(),
-                            "loadClass", "Trying loader = " + cl);
+                if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+                    MBEANSERVER_LOGGER.log(Level.TRACE, "Trying loader = " + cl);
                 }
                 /* We used to have a special case for "instanceof
                    MLet" here, where we invoked the method
@@ -239,10 +235,9 @@
         //
         List<ClassLoader> excluded = search.get(className);
         if ((excluded!= null) && (excluded.contains(aloader))) {
-            if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-                MBEANSERVER_LOGGER.logp(Level.FINER,
-                        ClassLoaderRepositorySupport.class.getName(),
-                        "startValidSearch", "Already requested loader = " +
+            if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+                MBEANSERVER_LOGGER.log(Level.TRACE,
+                        "Already requested loader = " +
                         aloader + " class = " + className);
             }
             throw new ClassNotFoundException(className);
@@ -255,10 +250,8 @@
             search.put(className, excluded);
         }
         excluded.add(aloader);
-        if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-            MBEANSERVER_LOGGER.logp(Level.FINER,
-                    ClassLoaderRepositorySupport.class.getName(),
-                    "startValidSearch",
+        if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+            MBEANSERVER_LOGGER.log(Level.TRACE,
                     "loader = " + aloader + " class = " + className);
         }
     }
@@ -271,10 +264,8 @@
         List<ClassLoader> excluded = search.get(className);
         if (excluded != null) {
             excluded.remove(aloader);
-            if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-                MBEANSERVER_LOGGER.logp(Level.FINER,
-                        ClassLoaderRepositorySupport.class.getName(),
-                        "stopValidSearch",
+            if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+                MBEANSERVER_LOGGER.log(Level.TRACE,
                         "loader = " + aloader + " class = " + className);
             }
         }
--- a/jdk/src/java.management/share/classes/com/sun/jmx/mbeanserver/JmxMBeanServer.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/com/sun/jmx/mbeanserver/JmxMBeanServer.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -36,7 +36,7 @@
 import java.security.PrivilegedExceptionAction;
 import java.util.List;
 import java.util.Set;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 
 import javax.management.Attribute;
 import javax.management.AttributeList;
@@ -1229,16 +1229,14 @@
                 }
             });
         } catch (SecurityException e) {
-            if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
-                MBEANSERVER_LOGGER.logp(Level.FINEST,
-                        JmxMBeanServer.class.getName(), "initialize",
+            if (MBEANSERVER_LOGGER.isLoggable(Level.DEBUG)) {
+                MBEANSERVER_LOGGER.log(Level.DEBUG,
                         "Unexpected security exception occurred", e);
             }
             throw e;
         } catch (Exception e) {
-            if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
-                MBEANSERVER_LOGGER.logp(Level.FINEST,
-                        JmxMBeanServer.class.getName(), "initialize",
+            if (MBEANSERVER_LOGGER.isLoggable(Level.DEBUG)) {
+                MBEANSERVER_LOGGER.log(Level.DEBUG,
                         "Unexpected exception occurred", e);
             }
             throw new
--- a/jdk/src/java.management/share/classes/com/sun/jmx/mbeanserver/MBeanInstantiator.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/com/sun/jmx/mbeanserver/MBeanInstantiator.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -40,7 +40,7 @@
 import java.security.PrivilegedAction;
 import java.security.ProtectionDomain;
 import java.util.Map;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 
 import javax.management.InstanceNotFoundException;
 import javax.management.MBeanException;
@@ -186,19 +186,15 @@
                 }
             }
         } catch (ClassNotFoundException e) {
-            if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
-                MBEANSERVER_LOGGER.logp(Level.FINEST,
-                        MBeanInstantiator.class.getName(),
-                        "findSignatureClasses",
+            if (MBEANSERVER_LOGGER.isLoggable(Level.DEBUG)) {
+                MBEANSERVER_LOGGER.log(Level.DEBUG,
                         "The parameter class could not be found", e);
             }
             throw new ReflectionException(e,
                       "The parameter class could not be found");
         } catch (RuntimeException e) {
-            if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
-                MBEANSERVER_LOGGER.logp(Level.FINEST,
-                        MBeanInstantiator.class.getName(),
-                        "findSignatureClasses",
+            if (MBEANSERVER_LOGGER.isLoggable(Level.DEBUG)) {
+                MBEANSERVER_LOGGER.log(Level.DEBUG,
                         "Unexpected exception", e);
             }
             throw e;
@@ -696,19 +692,15 @@
                 tab[i] = Class.forName(signature[i], false, aLoader);
             }
         } catch (ClassNotFoundException e) {
-            if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
-                MBEANSERVER_LOGGER.logp(Level.FINEST,
-                        MBeanInstantiator.class.getName(),
-                        "findSignatureClasses",
+            if (MBEANSERVER_LOGGER.isLoggable(Level.DEBUG)) {
+                MBEANSERVER_LOGGER.log(Level.DEBUG,
                         "The parameter class could not be found", e);
             }
             throw new ReflectionException(e,
                       "The parameter class could not be found");
         } catch (RuntimeException e) {
-            if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
-                MBEANSERVER_LOGGER.logp(Level.FINEST,
-                        MBeanInstantiator.class.getName(),
-                        "findSignatureClasses",
+            if (MBEANSERVER_LOGGER.isLoggable(Level.DEBUG)) {
+                MBEANSERVER_LOGGER.log(Level.DEBUG,
                         "Unexpected exception", e);
             }
             throw e;
--- a/jdk/src/java.management/share/classes/com/sun/jmx/mbeanserver/MBeanServerDelegateImpl.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/com/sun/jmx/mbeanserver/MBeanServerDelegateImpl.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2006, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -24,7 +24,7 @@
  */
 package com.sun.jmx.mbeanserver;
 
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 
 import javax.management.Attribute;
 import javax.management.AttributeList;
@@ -244,10 +244,8 @@
             } catch (Exception x) {
                 // Skip the attribute that couldn't be obtained.
                 //
-                if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
-                    MBEANSERVER_LOGGER.logp(Level.FINEST,
-                            MBeanServerDelegateImpl.class.getName(),
-                            "getAttributes",
+                if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+                    MBEANSERVER_LOGGER.log(Level.TRACE,
                             "Attribute " + attn[i] + " not found");
                 }
             }
--- a/jdk/src/java.management/share/classes/com/sun/jmx/mbeanserver/Repository.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/com/sun/jmx/mbeanserver/Repository.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2008, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -34,7 +34,7 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 import java.util.Map;
 import java.util.Set;
 import javax.management.DynamicMBean;
@@ -264,7 +264,7 @@
             context.unregistered();
         } catch (Exception x) {
             // shouldn't come here...
-            MBEANSERVER_LOGGER.log(Level.FINE,
+            MBEANSERVER_LOGGER.log(Level.DEBUG,
                     "Unexpected exception while unregistering "+name,
                     x);
         }
@@ -385,9 +385,8 @@
             final RegistrationContext context)
         throws InstanceAlreadyExistsException {
 
-        if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-            MBEANSERVER_LOGGER.logp(Level.FINER, Repository.class.getName(),
-                    "addMBean", "name = " + name);
+        if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+            MBEANSERVER_LOGGER.log(Level.TRACE, "name = " + name);
         }
 
         // Extract the domain name.
@@ -456,9 +455,8 @@
      *          false otherwise.
      */
     public boolean contains(ObjectName name) {
-        if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-            MBEANSERVER_LOGGER.logp(Level.FINER, Repository.class.getName(),
-                    "contains", " name = " + name);
+        if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+            MBEANSERVER_LOGGER.log(Level.TRACE, "name = " + name);
         }
         lock.readLock().lock();
         try {
@@ -478,9 +476,8 @@
      *          null otherwise.
      */
     public DynamicMBean retrieve(ObjectName name) {
-        if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-            MBEANSERVER_LOGGER.logp(Level.FINER, Repository.class.getName(),
-                    "retrieve", "name = " + name);
+        if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+            MBEANSERVER_LOGGER.log(Level.TRACE, "name = " + name);
         }
 
         // Calls internal retrieve method to get the named object
@@ -609,9 +606,8 @@
         throws InstanceNotFoundException {
 
         // Debugging stuff
-        if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
-            MBEANSERVER_LOGGER.logp(Level.FINER, Repository.class.getName(),
-                    "remove", "name = " + name);
+        if (MBEANSERVER_LOGGER.isLoggable(Level.TRACE)) {
+            MBEANSERVER_LOGGER.log(Level.TRACE, "name = " + name);
         }
 
         // Extract domain name.
--- a/jdk/src/java.management/share/classes/com/sun/jmx/remote/util/ClassLogger.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/com/sun/jmx/remote/util/ClassLogger.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2008, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -25,222 +25,188 @@
 
 package com.sun.jmx.remote.util;
 
-import java.util.logging.Logger;
+import java.lang.System.Logger;
+import java.lang.System.Logger.Level;
+import java.util.ResourceBundle;
 
-public class ClassLogger {
+public class ClassLogger implements System.Logger {
 
-    private static final boolean ok;
     private final String className;
     private final Logger logger;
 
-    static {
-        /* We attempt to work even if we are running in J2SE 1.3, where
-           there is no java.util.logging.  The technique we use here is
-           not strictly portable, but it does work with Sun's J2SE 1.3
-           at least.  This is just a best effort: the Right Thing is for
-           people to use at least J2SE 1.4.  */
-        boolean loaded = false;
-        try {
-            Class<?> c = java.util.logging.Logger.class;
-            loaded = true;
-        } catch (Error e) {
-            // OK.
-            // java.util.logger package is not available in this jvm.
-        }
-        ok = loaded;
-    }
-
     public ClassLogger(String subsystem, String className) {
-        if (ok)
-            logger = Logger.getLogger(subsystem);
-        else
-            logger = null;
+        logger = System.getLogger(subsystem);
         this.className = className;
     }
 
     public final boolean traceOn() {
-        return finerOn();
+        return logger.isLoggable(Level.TRACE);
     }
 
     public final boolean debugOn() {
-        return finestOn();
+        return logger.isLoggable(Level.DEBUG);
     }
 
     public final boolean warningOn() {
-        return ok && logger.isLoggable(java.util.logging.Level.WARNING);
+        return logger.isLoggable(Level.WARNING);
     }
 
     public final boolean infoOn() {
-        return ok && logger.isLoggable(java.util.logging.Level.INFO);
+        return logger.isLoggable(Level.INFO);
     }
 
     public final boolean configOn() {
-        return ok && logger.isLoggable(java.util.logging.Level.CONFIG);
+        return logger.isLoggable(Level.DEBUG);
     }
 
     public final boolean fineOn() {
-        return ok && logger.isLoggable(java.util.logging.Level.FINE);
+        return logger.isLoggable(Level.DEBUG);
     }
 
     public final boolean finerOn() {
-        return ok && logger.isLoggable(java.util.logging.Level.FINER);
+        return logger.isLoggable(Level.TRACE);
     }
 
     public final boolean finestOn() {
-        return ok && logger.isLoggable(java.util.logging.Level.FINEST);
+        return logger.isLoggable(Level.TRACE);
     }
 
     public final void debug(String func, String msg) {
-        finest(func,msg);
+        logger.log(Level.DEBUG, msg);
     }
 
     public final void debug(String func, Throwable t) {
-        finest(func,t);
+        logger.log(Level.DEBUG, className + "::" + func, t);
     }
 
     public final void debug(String func, String msg, Throwable t) {
-        finest(func,msg,t);
+        logger.log(Level.DEBUG, msg, t);
     }
 
     public final void trace(String func, String msg) {
-        finer(func,msg);
+        logger.log(Level.TRACE, msg);
     }
 
     public final void trace(String func, Throwable t) {
-        finer(func,t);
+        logger.log(Level.TRACE, className + "::" + func, t);
     }
 
     public final void trace(String func, String msg, Throwable t) {
-        finer(func,msg,t);
+        logger.log(Level.TRACE, msg, t);
     }
 
     public final void error(String func, String msg) {
-        severe(func,msg);
+        logger.log(Level.ERROR, msg);
     }
 
     public final void error(String func, Throwable t) {
-        severe(func,t);
+        logger.log(Level.ERROR, className + "::" + func, t);
     }
 
     public final void error(String func, String msg, Throwable t) {
-        severe(func,msg,t);
+        logger.log(Level.ERROR, msg, t);
     }
 
     public final void finest(String func, String msg) {
-        if (ok)
-            logger.logp(java.util.logging.Level.FINEST, className, func, msg);
+        logger.log(Level.TRACE, msg);
     }
 
     public final void finest(String func, Throwable t) {
-        if (ok)
-            logger.logp(java.util.logging.Level.FINEST, className, func,
-                        t.toString(), t);
+        logger.log(Level.TRACE, className + "::" + func, t);
     }
 
     public final void finest(String func, String msg, Throwable t) {
-        if (ok)
-            logger.logp(java.util.logging.Level.FINEST, className, func, msg,
-                        t);
+        logger.log(Level.TRACE, msg, t);
     }
 
     public final void finer(String func, String msg) {
-        if (ok)
-            logger.logp(java.util.logging.Level.FINER, className, func, msg);
+        logger.log(Level.TRACE, msg);
     }
 
     public final void finer(String func, Throwable t) {
-        if (ok)
-            logger.logp(java.util.logging.Level.FINER, className, func,
-                        t.toString(), t);
+        logger.log(Level.TRACE, className + "::" + func, t);
     }
 
     public final void finer(String func, String msg, Throwable t) {
-        if (ok)
-            logger.logp(java.util.logging.Level.FINER, className, func, msg,t);
+        logger.log(Level.DEBUG, msg, t);
     }
 
     public final void fine(String func, String msg) {
-        if (ok)
-            logger.logp(java.util.logging.Level.FINE, className, func, msg);
+        logger.log(Level.DEBUG, msg);
     }
 
     public final void fine(String func, Throwable t) {
-        if (ok)
-            logger.logp(java.util.logging.Level.FINE, className, func,
-                        t.toString(), t);
+        logger.log(Level.DEBUG, className + "::" + func, t);
     }
 
     public final void fine(String func, String msg, Throwable t) {
-        if (ok)
-            logger.logp(java.util.logging.Level.FINE, className, func, msg,
-                        t);
+        logger.log(Level.DEBUG, msg, t);
     }
 
     public final void config(String func, String msg) {
-        if (ok)
-            logger.logp(java.util.logging.Level.CONFIG, className, func, msg);
+        logger.log(Level.DEBUG, msg);
     }
 
     public final void config(String func, Throwable t) {
-        if (ok)
-            logger.logp(java.util.logging.Level.CONFIG, className, func,
-                        t.toString(), t);
+        logger.log(Level.DEBUG, className + "::" + func, t);
     }
 
     public final void config(String func, String msg, Throwable t) {
-        if (ok)
-            logger.logp(java.util.logging.Level.CONFIG, className, func, msg,
-                        t);
+        logger.log(Level.DEBUG, msg, t);
     }
 
     public final void info(String func, String msg) {
-        if (ok)
-            logger.logp(java.util.logging.Level.INFO, className, func, msg);
+        logger.log(Level.INFO, msg);
     }
 
     public final void info(String func, Throwable t) {
-        if (ok)
-            logger.logp(java.util.logging.Level.INFO, className, func,
-                        t.toString(), t);
+        logger.log(Level.INFO, className + "::" + func, t);
     }
 
     public final void info(String func, String msg, Throwable t) {
-        if (ok)
-            logger.logp(java.util.logging.Level.INFO, className, func, msg,
-                        t);
+        logger.log(Level.INFO, msg, t);
     }
 
     public final void warning(String func, String msg) {
-        if (ok)
-            logger.logp(java.util.logging.Level.WARNING, className, func, msg);
+        logger.log(Level.WARNING, msg);
     }
 
     public final void warning(String func, Throwable t) {
-        if (ok)
-            logger.logp(java.util.logging.Level.WARNING, className, func,
-                        t.toString(), t);
+        logger.log(Level.WARNING, className + "::" + func, t);
     }
 
     public final void warning(String func, String msg, Throwable t) {
-        if (ok)
-            logger.logp(java.util.logging.Level.WARNING, className, func, msg,
-                        t);
+        logger.log(Level.WARNING, msg, t);
     }
 
     public final void severe(String func, String msg) {
-        if (ok)
-            logger.logp(java.util.logging.Level.SEVERE, className, func, msg);
+        logger.log(Level.ERROR, msg);
     }
 
     public final void severe(String func, Throwable t) {
-        if (ok)
-            logger.logp(java.util.logging.Level.SEVERE, className, func,
-                        t.toString(), t);
+        logger.log(Level.ERROR, className + "::" + func, t);
     }
 
     public final void severe(String func, String msg, Throwable t) {
-        if (ok)
-            logger.logp(java.util.logging.Level.SEVERE, className, func, msg,
-                        t);
+        logger.log(Level.ERROR, msg, t);
+    }
+
+    public final String getName() {
+        return logger.getName();
+    }
+
+    public final boolean isLoggable(Level level) {
+        return logger.isLoggable(level);
     }
+
+    public final void log(Level level, ResourceBundle bundle, String msg,
+            Throwable thrown) {
+        logger.log(level, bundle, msg, thrown);
+    }
+
+    public final void log(Level level, ResourceBundle bundle, String format,
+                    Object... params) {
+        logger.log(level, bundle, format, params);
+    }
+
 }
--- a/jdk/src/java.management/share/classes/javax/management/MBeanServerDelegate.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/MBeanServerDelegate.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2008, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -25,6 +25,7 @@
 
 package javax.management;
 
+import java.lang.System.Logger.Level;
 import com.sun.jmx.defaults.JmxProperties;
 import com.sun.jmx.defaults.ServiceName;
 import com.sun.jmx.mbeanserver.Util;
@@ -84,7 +85,8 @@
             try {
                 localHost = java.net.InetAddress.getLocalHost().getHostName();
             } catch (java.net.UnknownHostException e) {
-                JmxProperties.MISC_LOGGER.finest("Can't get local host name, " +
+                JmxProperties.MISC_LOGGER.log(Level.TRACE,
+                        "Can't get local host name, " +
                         "using \"localhost\" instead. Cause is: "+e);
                 localHost = "localhost";
             }
--- a/jdk/src/java.management/share/classes/javax/management/MBeanServerFactory.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/MBeanServerFactory.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -32,7 +32,7 @@
 import java.security.AccessController;
 import java.security.Permission;
 import java.util.ArrayList;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 import javax.management.loading.ClassLoaderRepository;
 import sun.reflect.misc.ReflectUtil;
 
@@ -399,7 +399,7 @@
             return (String) mbs.getAttribute(MBeanServerDelegate.DELEGATE_NAME,
                     "MBeanServerId");
         } catch (JMException e) {
-            JmxProperties.MISC_LOGGER.finest(
+            JmxProperties.MISC_LOGGER.log(Level.TRACE,
                     "Ignoring exception while getting MBeanServerId: "+e);
             return null;
         }
@@ -421,9 +421,7 @@
     private static synchronized void removeMBeanServer(MBeanServer mbs) {
         boolean removed = mBeanServerList.remove(mbs);
         if (!removed) {
-            MBEANSERVER_LOGGER.logp(Level.FINER,
-                    MBeanServerFactory.class.getName(),
-                    "removeMBeanServer(MBeanServer)",
+            MBEANSERVER_LOGGER.log(Level.TRACE,
                     "MBeanServer was not in list!");
             throw new IllegalArgumentException("MBeanServer was not in list!");
         }
@@ -504,15 +502,12 @@
                 throw new JMRuntimeException(msg, x);
             }
         } catch (RuntimeException x) {
-            if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
+            if (MBEANSERVER_LOGGER.isLoggable(Level.DEBUG)) {
                 StringBuilder strb = new StringBuilder()
                 .append("Failed to instantiate MBeanServerBuilder: ").append(x)
                 .append("\n\t\tCheck the value of the ")
                 .append(JMX_INITIAL_BUILDER).append(" property.");
-                MBEANSERVER_LOGGER.logp(Level.FINEST,
-                        MBeanServerFactory.class.getName(),
-                        "checkMBeanServerBuilder",
-                        strb.toString());
+                MBEANSERVER_LOGGER.log(Level.DEBUG, strb::toString);
             }
             throw x;
         }
--- a/jdk/src/java.management/share/classes/javax/management/StandardMBean.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/StandardMBean.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2008, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -38,7 +38,7 @@
 import java.util.HashMap;
 import java.util.Map;
 import java.util.WeakHashMap;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 import javax.management.openmbean.OpenMBeanAttributeInfo;
 import javax.management.openmbean.OpenMBeanAttributeInfoSupport;
 import javax.management.openmbean.OpenMBeanConstructorInfo;
@@ -432,16 +432,14 @@
             final MBeanInfo cached = getCachedMBeanInfo();
             if (cached != null) return cached;
         } catch (RuntimeException x) {
-            if (MISC_LOGGER.isLoggable(Level.FINEST)) {
-                MISC_LOGGER.logp(Level.FINEST,
-                        MBeanServerFactory.class.getName(), "getMBeanInfo",
+            if (MISC_LOGGER.isLoggable(Level.DEBUG)) {
+                MISC_LOGGER.log(Level.DEBUG,
                         "Failed to get cached MBeanInfo", x);
             }
         }
 
-        if (MISC_LOGGER.isLoggable(Level.FINER)) {
-            MISC_LOGGER.logp(Level.FINER,
-                    MBeanServerFactory.class.getName(), "getMBeanInfo",
+        if (MISC_LOGGER.isLoggable(Level.TRACE)) {
+            MISC_LOGGER.log(Level.TRACE,
                     "Building MBeanInfo for " +
                     getImplementationClass().getName());
         }
@@ -465,9 +463,8 @@
         try {
             cacheMBeanInfo(nmbi);
         } catch (RuntimeException x) {
-            if (MISC_LOGGER.isLoggable(Level.FINEST)) {
-                MISC_LOGGER.logp(Level.FINEST,
-                        MBeanServerFactory.class.getName(), "getMBeanInfo",
+            if (MISC_LOGGER.isLoggable(Level.DEBUG)) {
+                MISC_LOGGER.log(Level.DEBUG,
                         "Failed to cache MBeanInfo", x);
             }
         }
--- a/jdk/src/java.management/share/classes/javax/management/loading/DefaultLoaderRepository.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/loading/DefaultLoaderRepository.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2008, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -28,7 +28,7 @@
 import static com.sun.jmx.defaults.JmxProperties.MBEANSERVER_LOGGER;
 import java.util.Iterator;
 import java.util.List;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 import javax.management.MBeanServer;
 import javax.management.MBeanServerFactory;
 
@@ -71,9 +71,7 @@
      */
     public static Class<?> loadClass(String className)
         throws ClassNotFoundException {
-        MBEANSERVER_LOGGER.logp(Level.FINEST,
-                DefaultLoaderRepository.class.getName(),
-                "loadClass", className);
+        MBEANSERVER_LOGGER.log(Level.TRACE, className);
         return load(null, className);
     }
 
@@ -96,9 +94,7 @@
     public static Class<?> loadClassWithout(ClassLoader loader,
                                          String className)
         throws ClassNotFoundException {
-        MBEANSERVER_LOGGER.logp(Level.FINEST,
-                DefaultLoaderRepository.class.getName(),
-                "loadClassWithout", className);
+        MBEANSERVER_LOGGER.log(Level.TRACE, className);
         return load(loader, className);
     }
 
--- a/jdk/src/java.management/share/classes/javax/management/loading/MLet.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/loading/MLet.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -52,7 +52,7 @@
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 import java.util.Map;
 import java.util.Set;
 import java.util.StringTokenizer;
@@ -412,9 +412,8 @@
              if (!Arrays.asList(getURLs()).contains(ur))
                  super.addURL(ur);
          } catch (MalformedURLException e) {
-             if (MLET_LOGGER.isLoggable(Level.FINEST)) {
-                 MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
-                         "addUrl", "Malformed URL: " + url, e);
+             if (MLET_LOGGER.isLoggable(Level.DEBUG)) {
+                 MLET_LOGGER.log(Level.DEBUG, "Malformed URL: " + url, e);
              }
              throw new
                  ServiceNotFoundException("The specified URL is malformed");
@@ -481,23 +480,19 @@
      public Set<Object> getMBeansFromURL(String url)
              throws ServiceNotFoundException  {
 
-         String mth = "getMBeansFromURL";
-
          if (server == null) {
              throw new IllegalStateException("This MLet MBean is not " +
                                              "registered with an MBeanServer.");
          }
          // Parse arguments
          if (url == null) {
-             MLET_LOGGER.logp(Level.FINER, MLet.class.getName(),
-                     mth, "URL is null");
+             MLET_LOGGER.log(Level.TRACE, "URL is null");
              throw new ServiceNotFoundException("The specified URL is null");
          } else {
              url = url.replace(File.separatorChar,'/');
          }
-         if (MLET_LOGGER.isLoggable(Level.FINER)) {
-             MLET_LOGGER.logp(Level.FINER, MLet.class.getName(),
-                     mth, "<URL = " + url + ">");
+         if (MLET_LOGGER.isLoggable(Level.TRACE)) {
+             MLET_LOGGER.log(Level.TRACE, "<URL = " + url + ">");
          }
 
          // Parse URL
@@ -508,7 +503,7 @@
              final String msg =
                  "Problems while parsing URL [" + url +
                  "], got exception [" + e.toString() + "]";
-             MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth, msg);
+             MLET_LOGGER.log(Level.TRACE, msg);
              throw EnvHelp.initCause(new ServiceNotFoundException(msg), e);
          }
 
@@ -516,7 +511,7 @@
          if (mletList.size() == 0) {
              final String msg =
                  "File " + url + " not found or MLET tag not defined in file";
-             MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth, msg);
+             MLET_LOGGER.log(Level.TRACE, msg);
              throw new ServiceNotFoundException(msg);
          }
 
@@ -538,7 +533,7 @@
              URL documentBase = elmt.getDocumentBase();
 
              // Display debug information
-             if (MLET_LOGGER.isLoggable(Level.FINER)) {
+             if (MLET_LOGGER.isLoggable(Level.TRACE)) {
                  final StringBuilder strb = new StringBuilder()
                  .append("\n\tMLET TAG     = ").append(elmt.getAttributes())
                  .append("\n\tCODEBASE     = ").append(codebase)
@@ -548,16 +543,15 @@
                  .append("\n\tNAME         = ").append(name)
                  .append("\n\tVERSION      = ").append(version)
                  .append("\n\tDOCUMENT URL = ").append(documentBase);
-                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(),
-                         mth, strb.toString());
+                 MLET_LOGGER.log(Level.TRACE, strb::toString);
              }
 
              // Load classes from JAR files
              StringTokenizer st = new StringTokenizer(jarFiles, ",", false);
              while (st.hasMoreTokens()) {
                  String tok = st.nextToken().trim();
-                 if (MLET_LOGGER.isLoggable(Level.FINER)) {
-                     MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
+                 if (MLET_LOGGER.isLoggable(Level.TRACE)) {
+                     MLET_LOGGER.log(Level.TRACE,
                              "Load archive for codebase <" + codebase +
                              ">, file <" + tok + ">");
                  }
@@ -570,8 +564,8 @@
                  try {
                      codebase = check(version, codebase, tok, elmt);
                  } catch (Exception ex) {
-                     MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
-                             mth, "Got unexpected exception", ex);
+                     MLET_LOGGER.log(Level.DEBUG,
+                             "Got unexpected exception", ex);
                      mbeans.add(ex);
                      continue;
                  }
@@ -599,7 +593,7 @@
                  final String msg =
                      "CODE and OBJECT parameters cannot be specified at the " +
                      "same time in tag MLET";
-                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth, msg);
+                 MLET_LOGGER.log(Level.TRACE, msg);
                  mbeans.add(new Error(msg));
                  continue;
              }
@@ -607,7 +601,7 @@
                  final String msg =
                      "Either CODE or OBJECT parameter must be specified in " +
                      "tag MLET";
-                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth, msg);
+                 MLET_LOGGER.log(Level.TRACE, msg);
                  mbeans.add(new Error(msg));
                  continue;
              }
@@ -635,7 +629,7 @@
                          Object[] parms = objectPars.toArray();
                          String[] signature = new String[signat.size()];
                          signat.toArray(signature);
-                         if (MLET_LOGGER.isLoggable(Level.FINEST)) {
+                         if (MLET_LOGGER.isLoggable(Level.TRACE)) {
                              final StringBuilder strb = new StringBuilder();
                              for (int i = 0; i < signature.length; i++) {
                                  strb.append("\n\tSignature     = ")
@@ -643,9 +637,7 @@
                                  .append("\t\nParams        = ")
                                  .append(parms[i]);
                              }
-                             MLET_LOGGER.logp(Level.FINEST,
-                                     MLet.class.getName(),
-                                     mth, strb.toString());
+                             MLET_LOGGER.log(Level.TRACE, strb::toString);
                          }
                          if (name == null) {
                              objInst =
@@ -668,53 +660,46 @@
                      objInst = new ObjectInstance(name, o.getClass().getName());
                  }
              } catch (ReflectionException  ex) {
-                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
-                         "ReflectionException", ex);
+                 MLET_LOGGER.log(Level.TRACE, "ReflectionException", ex);
                  mbeans.add(ex);
                  continue;
              } catch (InstanceAlreadyExistsException  ex) {
-                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
+                 MLET_LOGGER.log(Level.TRACE,
                          "InstanceAlreadyExistsException", ex);
                  mbeans.add(ex);
                  continue;
              } catch (MBeanRegistrationException ex) {
-                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
-                         "MBeanRegistrationException", ex);
+                 MLET_LOGGER.log(Level.TRACE, "MBeanRegistrationException", ex);
                  mbeans.add(ex);
                  continue;
              } catch (MBeanException  ex) {
-                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
-                         "MBeanException", ex);
+                 MLET_LOGGER.log(Level.TRACE, "MBeanException", ex);
                  mbeans.add(ex);
                  continue;
              } catch (NotCompliantMBeanException  ex) {
-                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
+                 MLET_LOGGER.log(Level.TRACE,
                          "NotCompliantMBeanException", ex);
                  mbeans.add(ex);
                  continue;
              } catch (InstanceNotFoundException   ex) {
-                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
+                 MLET_LOGGER.log(Level.TRACE,
                          "InstanceNotFoundException", ex);
                  mbeans.add(ex);
                  continue;
              } catch (IOException ex) {
-                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
-                         "IOException", ex);
+                 MLET_LOGGER.log(Level.TRACE, "IOException", ex);
                  mbeans.add(ex);
                  continue;
              } catch (SecurityException ex) {
-                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
-                         "SecurityException", ex);
+                 MLET_LOGGER.log(Level.TRACE, "SecurityException", ex);
                  mbeans.add(ex);
                  continue;
              } catch (Exception ex) {
-                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
-                         "Exception", ex);
+                 MLET_LOGGER.log(Level.TRACE, "Exception", ex);
                  mbeans.add(ex);
                  continue;
              } catch (Error ex) {
-                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
-                         "Error", ex);
+                 MLET_LOGGER.log(Level.TRACE, "Error", ex);
                  mbeans.add(ex);
                  continue;
              }
@@ -937,20 +922,18 @@
      Class<?> findClass(String name, ClassLoaderRepository clr)
          throws ClassNotFoundException {
          Class<?> c = null;
-         MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), "findClass", name);
+         MLET_LOGGER.log(Level.TRACE, name);
          // Try looking in the JAR:
          try {
              c = super.findClass(name);
-             if (MLET_LOGGER.isLoggable(Level.FINER)) {
-                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(),
-                         "findClass",
+             if (MLET_LOGGER.isLoggable(Level.TRACE)) {
+                 MLET_LOGGER.log(Level.TRACE,
                          "Class " + name + " loaded through MLet classloader");
              }
          } catch (ClassNotFoundException e) {
              // Drop through
-             if (MLET_LOGGER.isLoggable(Level.FINEST)) {
-                 MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
-                         "findClass",
+             if (MLET_LOGGER.isLoggable(Level.TRACE)) {
+                 MLET_LOGGER.log(Level.TRACE,
                          "Class " + name + " not found locally");
              }
          }
@@ -959,32 +942,28 @@
              // Try the classloader repository:
              //
              try {
-                 if (MLET_LOGGER.isLoggable(Level.FINEST)) {
-                     MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
-                             "findClass",
+                 if (MLET_LOGGER.isLoggable(Level.TRACE)) {
+                     MLET_LOGGER.log(Level.TRACE,
                              "Class " + name + " : looking in CLR");
                  }
                  c = clr.loadClassBefore(this, name);
                  // The loadClassBefore method never returns null.
                  // If the class is not found we get an exception.
-                 if (MLET_LOGGER.isLoggable(Level.FINER)) {
-                     MLET_LOGGER.logp(Level.FINER, MLet.class.getName(),
-                             "findClass",
+                 if (MLET_LOGGER.isLoggable(Level.TRACE)) {
+                     MLET_LOGGER.log(Level.TRACE,
                              "Class " + name + " loaded through " +
                              "the default classloader repository");
                  }
              } catch (ClassNotFoundException e) {
                  // Drop through
-                 if (MLET_LOGGER.isLoggable(Level.FINEST)) {
-                     MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
-                             "findClass",
+                 if (MLET_LOGGER.isLoggable(Level.TRACE)) {
+                     MLET_LOGGER.log(Level.TRACE,
                              "Class " + name + " not found in CLR");
                  }
              }
          }
          if (c == null) {
-             MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
-                     "findClass", "Failed to load class " + name);
+             MLET_LOGGER.log(Level.TRACE, "Failed to load class " + name);
              throw new ClassNotFoundException(name);
          }
          return c;
@@ -1041,8 +1020,8 @@
          //
          // See if the native library is accessible as a resource through the JAR file.
          //
-         if (MLET_LOGGER.isLoggable(Level.FINER)) {
-             MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
+         if (MLET_LOGGER.isLoggable(Level.TRACE)) {
+             MLET_LOGGER.log(Level.TRACE,
                      "Search " + libname + " in all JAR files");
          }
 
@@ -1051,14 +1030,14 @@
          // for "foo" on Solaris SPARC 5.7 we try to load "libfoo.so"
          // from the JAR file.
          //
-         if (MLET_LOGGER.isLoggable(Level.FINER)) {
-             MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
+         if (MLET_LOGGER.isLoggable(Level.TRACE)) {
+             MLET_LOGGER.log(Level.TRACE,
                      "loadLibraryAsResource(" + nativelibname + ")");
          }
          abs_path = loadLibraryAsResource(nativelibname);
          if (abs_path != null) {
-             if (MLET_LOGGER.isLoggable(Level.FINER)) {
-                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
+             if (MLET_LOGGER.isLoggable(Level.TRACE)) {
+                 MLET_LOGGER.log(Level.TRACE,
                          nativelibname + " loaded, absolute path = " + abs_path);
              }
              return abs_path;
@@ -1073,15 +1052,15 @@
              removeSpace(System.getProperty("os.arch")) + File.separator +
              removeSpace(System.getProperty("os.version")) + File.separator +
              "lib" + File.separator + nativelibname;
-         if (MLET_LOGGER.isLoggable(Level.FINER)) {
-             MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
+         if (MLET_LOGGER.isLoggable(Level.TRACE)) {
+             MLET_LOGGER.log(Level.TRACE,
                      "loadLibraryAsResource(" + nativelibname + ")");
          }
 
          abs_path = loadLibraryAsResource(nativelibname);
          if (abs_path != null) {
-             if (MLET_LOGGER.isLoggable(Level.FINER)) {
-                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
+             if (MLET_LOGGER.isLoggable(Level.TRACE)) {
+                 MLET_LOGGER.log(Level.TRACE,
                          nativelibname + " loaded, absolute path = " + abs_path);
              }
              return abs_path;
@@ -1091,10 +1070,10 @@
          // All paths exhausted, library not found in JAR file.
          //
 
-         if (MLET_LOGGER.isLoggable(Level.FINER)) {
-             MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
+         if (MLET_LOGGER.isLoggable(Level.TRACE)) {
+             MLET_LOGGER.log(Level.TRACE,
                      libname + " not found in any JAR file");
-             MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
+             MLET_LOGGER.log(Level.TRACE,
                      "Search " + libname + " along the path " +
                      "specified as the java.library.path property");
          }
@@ -1127,8 +1106,8 @@
              if (tmpDirFile == null) return null;
              return tmpDirFile.getAbsolutePath();
          } catch (Exception x) {
-             MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
-                     "getTmpDir", "Failed to determine system temporary dir");
+             MLET_LOGGER.log(Level.DEBUG,
+                     "Failed to determine system temporary dir");
              return null;
          } finally {
              // Cleanup ...
@@ -1136,12 +1115,12 @@
                  try {
                      boolean deleted = tmpFile.delete();
                      if (!deleted) {
-                         MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
-                                 "getTmpDir", "Failed to delete temp file");
+                         MLET_LOGGER.log(Level.DEBUG,
+                                 "Failed to delete temp file");
                      }
                  } catch (Exception x) {
-                     MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
-                             "getTmpDir", "Failed to delete temporary file", x);
+                     MLET_LOGGER.log(Level.DEBUG,
+                             "Failed to delete temporary file", x);
                  }
              }
         }
@@ -1183,8 +1162,7 @@
                  }
              }
          } catch (Exception e) {
-             MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
-                     "loadLibraryAsResource",
+             MLET_LOGGER.log(Level.DEBUG,
                      "Failed to load library : " + libname, e);
              return null;
          }
@@ -1248,9 +1226,8 @@
         if (filename != null) {
             filename = filename.replace(File.separatorChar,'/');
         }
-        if (MLET_LOGGER.isLoggable(Level.FINER)) {
-            MLET_LOGGER.logp(Level.FINER, MLet.class.getName(),
-                    "loadSerializedObject", codebase.toString() + filename);
+        if (MLET_LOGGER.isLoggable(Level.TRACE)) {
+            MLET_LOGGER.log(Level.TRACE, codebase.toString() + filename);
         }
         InputStream is = getResourceAsStream(filename);
         if (is != null) {
@@ -1260,24 +1237,21 @@
                 ois.close();
                 return serObject;
             } catch (IOException e) {
-                if (MLET_LOGGER.isLoggable(Level.FINEST)) {
-                    MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
-                            "loadSerializedObject",
+                if (MLET_LOGGER.isLoggable(Level.DEBUG)) {
+                    MLET_LOGGER.log(Level.DEBUG,
                             "Exception while deserializing " + filename, e);
                 }
                 throw e;
             } catch (ClassNotFoundException e) {
-                if (MLET_LOGGER.isLoggable(Level.FINEST)) {
-                    MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
-                            "loadSerializedObject",
+                if (MLET_LOGGER.isLoggable(Level.DEBUG)) {
+                    MLET_LOGGER.log(Level.DEBUG,
                             "Exception while deserializing " + filename, e);
                 }
                 throw e;
             }
         } else {
-            if (MLET_LOGGER.isLoggable(Level.FINEST)) {
-                MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
-                        "loadSerializedObject", "Error: File " + filename +
+            if (MLET_LOGGER.isLoggable(Level.DEBUG)) {
+                MLET_LOGGER.log(Level.DEBUG, "Error: File " + filename +
                         " containing serialized object not found");
             }
             throw new Error("File " + filename + " containing serialized object not found");
@@ -1300,8 +1274,7 @@
                 return(cons.newInstance(oo));
 
             } catch (Exception  e) {
-                MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
-                        "constructParameter", "Got unexpected exception", e);
+                MLET_LOGGER.log(Level.DEBUG, "Got unexpected exception", e);
             }
         }
         if (type.compareTo("java.lang.Boolean") == 0)
--- a/jdk/src/java.management/share/classes/javax/management/loading/MLetParser.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/loading/MLetParser.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -39,7 +39,7 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 
 /**
  * This class is used for parsing URLs.
@@ -153,7 +153,6 @@
      * Scan an html file for {@literal <mlet>} tags.
      */
     public List<MLetContent> parse(URL url) throws IOException {
-        String mth = "parse";
         // Warning Messages
         String requiresTypeWarning = "<arg type=... value=...> tag requires type parameter.";
         String requiresValueWarning = "<arg type=... value=...> tag requires value parameter.";
@@ -204,33 +203,25 @@
                         Map<String,String> t = scanTag(in);
                         String att = t.get("type");
                         if (att == null) {
-                            MLET_LOGGER.logp(Level.FINER,
-                                    MLetParser.class.getName(),
-                                    mth, requiresTypeWarning);
+                            MLET_LOGGER.log(Level.TRACE, requiresTypeWarning);
                             throw new IOException(requiresTypeWarning);
                         } else {
                             if (atts != null) {
                                 types.add(att);
                             } else {
-                                MLET_LOGGER.logp(Level.FINER,
-                                        MLetParser.class.getName(),
-                                        mth, paramOutsideWarning);
+                                MLET_LOGGER.log(Level.TRACE, paramOutsideWarning);
                                 throw new IOException(paramOutsideWarning);
                             }
                         }
                         String val = t.get("value");
                         if (val == null) {
-                            MLET_LOGGER.logp(Level.FINER,
-                                    MLetParser.class.getName(),
-                                    mth, requiresValueWarning);
+                            MLET_LOGGER.log(Level.TRACE, requiresValueWarning);
                             throw new IOException(requiresValueWarning);
                         } else {
                             if (atts != null) {
                                 values.add(val);
                             } else {
-                                MLET_LOGGER.logp(Level.FINER,
-                                        MLetParser.class.getName(),
-                                        mth, paramOutsideWarning);
+                                MLET_LOGGER.log(Level.TRACE, paramOutsideWarning);
                                 throw new IOException(paramOutsideWarning);
                             }
                         }
@@ -238,15 +229,11 @@
                         if (nm.equalsIgnoreCase(tag)) {
                             atts = scanTag(in);
                             if (atts.get("code") == null && atts.get("object") == null) {
-                                MLET_LOGGER.logp(Level.FINER,
-                                        MLetParser.class.getName(),
-                                        mth, requiresCodeWarning);
+                                MLET_LOGGER.log(Level.TRACE, requiresCodeWarning);
                                 throw new IOException(requiresCodeWarning);
                             }
                             if (atts.get("archive") == null) {
-                                MLET_LOGGER.logp(Level.FINER,
-                                        MLetParser.class.getName(),
-                                        mth, requiresJarsWarning);
+                                MLET_LOGGER.log(Level.TRACE, requiresJarsWarning);
                                 throw new IOException(requiresJarsWarning);
                             }
                         }
--- a/jdk/src/java.management/share/classes/javax/management/modelmbean/DescriptorSupport.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/modelmbean/DescriptorSupport.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -51,7 +51,7 @@
 import java.util.SortedMap;
 import java.util.StringTokenizer;
 import java.util.TreeMap;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 
 import javax.management.Descriptor;
 import javax.management.ImmutableDescriptor;
@@ -164,10 +164,8 @@
      * (the method {@link #isValid isValid} returns <CODE>false</CODE>)
      */
     public DescriptorSupport() {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "DescriptorSupport()" , "Constructor");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Constructor");
         }
         init(null);
     }
@@ -188,17 +186,14 @@
      */
     public DescriptorSupport(int initNumFields)
             throws MBeanException, RuntimeOperationsException {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "Descriptor(initNumFields = " + initNumFields + ")",
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
+                    "Descriptor(initNumFields = " + initNumFields + ") " +
                     "Constructor");
         }
         if (initNumFields <= 0) {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-                MODELMBEAN_LOGGER.logp(Level.FINEST,
-                        DescriptorSupport.class.getName(),
-                        "Descriptor(initNumFields)",
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE,
                         "Illegal arguments: initNumFields <= 0");
             }
             final String msg =
@@ -219,10 +214,9 @@
      * fields, an empty Descriptor will be created.
      */
     public DescriptorSupport(DescriptorSupport inDescr) {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "Descriptor(Descriptor)", "Constructor");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
+                    "Descriptor(Descriptor) Constructor");
         }
         if (inDescr == null)
             init(null);
@@ -268,16 +262,14 @@
                    XMLParseException {
         /* parse an XML-formatted string and populate internal
          * structure with it */
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "Descriptor(String = '" + inStr + "')", "Constructor");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
+                    "Descriptor(String = '" + inStr + "') Constructor");
         }
         if (inStr == null) {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-                MODELMBEAN_LOGGER.logp(Level.FINEST,
-                        DescriptorSupport.class.getName(),
-                        "Descriptor(String = null)", "Illegal arguments");
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE,
+                        "Descriptor(String = null) Illegal arguments");
             }
             final String msg = "String in parameter is null";
             final RuntimeException iae = new IllegalArgumentException(msg);
@@ -350,10 +342,9 @@
                 }
             }
         }  // while tokens
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "Descriptor(XMLString)", "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
+                    "Descriptor(XMLString) Exit");
         }
     }
 
@@ -380,19 +371,17 @@
      */
     public DescriptorSupport(String[] fieldNames, Object[] fieldValues)
             throws RuntimeOperationsException {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "Descriptor(fieldNames,fieldObjects)", "Constructor");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
+                    "Descriptor(fieldNames,fieldObjects) Constructor");
         }
 
         if ((fieldNames == null) || (fieldValues == null) ||
             (fieldNames.length != fieldValues.length)) {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-                MODELMBEAN_LOGGER.logp(Level.FINEST,
-                        DescriptorSupport.class.getName(),
-                        "Descriptor(fieldNames,fieldObjects)",
-                        "Illegal arguments");
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE,
+                        "Descriptor(fieldNames,fieldObjects)" +
+                        " Illegal arguments");
             }
 
             final String msg =
@@ -408,10 +397,9 @@
             // the fieldName and fieldValue will be validated in setField.
             setField(fieldNames[i], fieldValues[i]);
         }
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "Descriptor(fieldNames,fieldObjects)", "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
+                    "Descriptor(fieldNames,fieldObjects) Exit");
         }
     }
 
@@ -444,10 +432,9 @@
      */
     public DescriptorSupport(String... fields)
     {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "Descriptor(String... fields)", "Constructor");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
+                    "Descriptor(String... fields) Constructor");
         }
         init(null);
         if (( fields == null ) || ( fields.length == 0))
@@ -462,10 +449,9 @@
             int eq_separator = fields[i].indexOf('=');
             if (eq_separator < 0) {
                 // illegal if no = or is first character
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINEST,
-                            DescriptorSupport.class.getName(),
-                            "Descriptor(String... fields)",
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
+                            "Descriptor(String... fields) " +
                             "Illegal arguments: field does not have " +
                             "'=' as a name and value separator");
                 }
@@ -482,10 +468,9 @@
             }
 
             if (fieldName.equals("")) {
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINEST,
-                            DescriptorSupport.class.getName(),
-                            "Descriptor(String... fields)",
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
+                            "Descriptor(String... fields) " +
                             "Illegal arguments: fieldName is empty");
                 }
 
@@ -496,10 +481,9 @@
 
             setField(fieldName,fieldValue);
         }
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "Descriptor(String... fields)", "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
+                    "Descriptor(String... fields) Exit");
         }
     }
 
@@ -517,10 +501,8 @@
             throws RuntimeOperationsException {
 
         if ((fieldName == null) || (fieldName.equals(""))) {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-                MODELMBEAN_LOGGER.logp(Level.FINEST,
-                        DescriptorSupport.class.getName(),
-                        "getFieldValue(String fieldName)",
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE,
                         "Illegal arguments: null field name");
             }
             final String msg = "Fieldname requested is null";
@@ -528,10 +510,9 @@
             throw new RuntimeOperationsException(iae, msg);
         }
         Object retValue = descriptorMap.get(fieldName);
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "getFieldValue(String fieldName = " + fieldName + ")",
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
+                    "getFieldValue(String fieldName = " + fieldName + ") " +
                     "Returns '" + retValue + "'");
         }
         return(retValue);
@@ -542,10 +523,8 @@
 
         // field name cannot be null or empty
         if ((fieldName == null) || (fieldName.equals(""))) {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-                MODELMBEAN_LOGGER.logp(Level.FINEST,
-                        DescriptorSupport.class.getName(),
-                        "setField(fieldName,fieldValue)",
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE,
                         "Illegal arguments: null or empty field name");
             }
 
@@ -555,10 +534,8 @@
         }
 
         if (!validateField(fieldName, fieldValue)) {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-                MODELMBEAN_LOGGER.logp(Level.FINEST,
-                        DescriptorSupport.class.getName(),
-                        "setField(fieldName,fieldValue)",
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE,
                         "Illegal arguments");
             }
 
@@ -568,10 +545,8 @@
             throw new RuntimeOperationsException(iae, msg);
         }
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "setField(fieldName,fieldValue)", "Entry: setting '"
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry: setting '"
                     + fieldName + "' to '" + fieldValue + "'");
         }
 
@@ -582,10 +557,8 @@
     }
 
     public synchronized String[] getFields() {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "getFields()", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
         int numberOfEntries = descriptorMap.size();
 
@@ -594,20 +567,18 @@
 
         int i = 0;
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "getFields()", "Returning " + numberOfEntries + " fields");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
+                    "Returning " + numberOfEntries + " fields");
         }
         for (Iterator<Map.Entry<String, Object>> iter = returnedSet.iterator();
              iter.hasNext(); i++) {
             Map.Entry<String, Object> currElement = iter.next();
 
             if (currElement == null) {
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINEST,
-                            DescriptorSupport.class.getName(),
-                            "getFields()", "Element is null");
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
+                            "Element is null");
                 }
             } else {
                 Object currValue = currElement.getValue();
@@ -626,20 +597,16 @@
             }
         }
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "getFields()", "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
 
         return responseFields;
     }
 
     public synchronized String[] getFieldNames() {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "getFieldNames()", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
         int numberOfEntries = descriptorMap.size();
 
@@ -648,10 +615,8 @@
 
         int i = 0;
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "getFieldNames()",
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
                     "Returning " + numberOfEntries + " fields");
         }
 
@@ -660,20 +625,16 @@
             Map.Entry<String, Object> currElement = iter.next();
 
             if (( currElement == null ) || (currElement.getKey() == null)) {
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINEST,
-                            DescriptorSupport.class.getName(),
-                            "getFieldNames()", "Field is null");
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE, "Field is null");
                 }
             } else {
                 responseFields[i] = currElement.getKey().toString();
             }
         }
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "getFieldNames()", "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
 
         return responseFields;
@@ -681,10 +642,8 @@
 
 
     public synchronized Object[] getFieldValues(String... fieldNames) {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "getFieldValues(String... fieldNames)", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
         // if fieldNames == null return all values
         // if fieldNames is String[0] return no values
@@ -695,10 +654,8 @@
 
         int i = 0;
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "getFieldValues(String... fieldNames)",
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
                     "Returning " + numberOfEntries + " fields");
         }
 
@@ -715,10 +672,8 @@
             }
         }
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "getFieldValues(String... fieldNames)", "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
 
         return responseFields;
@@ -728,18 +683,14 @@
                                        Object[] fieldValues)
             throws RuntimeOperationsException {
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "setFields(fieldNames,fieldValues)", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         if ((fieldNames == null) || (fieldValues == null) ||
             (fieldNames.length != fieldValues.length)) {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-                MODELMBEAN_LOGGER.logp(Level.FINEST,
-                        DescriptorSupport.class.getName(),
-                        "setFields(fieldNames,fieldValues)",
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE,
                         "Illegal arguments");
             }
 
@@ -750,10 +701,8 @@
 
         for (int i=0; i < fieldNames.length; i++) {
             if (( fieldNames[i] == null) || (fieldNames[i].equals(""))) {
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINEST,
-                            DescriptorSupport.class.getName(),
-                            "setFields(fieldNames,fieldValues)",
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
                             "Null field name encountered at element " + i);
                 }
                 final String msg = "fieldNames is null or invalid";
@@ -762,10 +711,8 @@
             }
             setField(fieldNames[i], fieldValues[i]);
         }
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "setFields(fieldNames,fieldValues)", "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
     }
 
@@ -779,10 +726,8 @@
 
     @Override
     public synchronized Object clone() throws RuntimeOperationsException {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "clone()", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
         return(new DescriptorSupport(this));
     }
@@ -898,20 +843,17 @@
      */
 
     public synchronized boolean isValid() throws RuntimeOperationsException {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "isValid()", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
         // verify that the descriptor is valid, by iterating over each field...
 
         Set<Map.Entry<String, Object>> returnedSet = descriptorMap.entrySet();
 
         if (returnedSet == null) {   // null descriptor, not valid
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-                MODELMBEAN_LOGGER.logp(Level.FINEST,
-                        DescriptorSupport.class.getName(),
-                        "isValid()", "Returns false (null set)");
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE,
+                        "isValid() Returns false (null set)");
             }
             return false;
         }
@@ -934,10 +876,8 @@
                                       (currElement.getValue()).toString())) {
                         continue;
                     } else {
-                        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-                            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                                    DescriptorSupport.class.getName(),
-                                    "isValid()",
+                        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                            MODELMBEAN_LOGGER.log(Level.TRACE,
                                     "Field " + currElement.getKey() + "=" +
                                     currElement.getValue() + " is not valid");
                         }
@@ -948,10 +888,9 @@
         }
 
         // fell through, all fields OK
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "isValid()", "Returns true");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
+                    "isValid() Returns true");
         }
         return true;
     }
@@ -1287,28 +1226,23 @@
      */
     @Override
     public synchronized String toString() {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "toString()", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         String respStr = "";
         String[] fields = getFields();
 
         if ((fields == null) || (fields.length == 0)) {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-                MODELMBEAN_LOGGER.logp(Level.FINEST,
-                        DescriptorSupport.class.getName(),
-                        "toString()", "Empty Descriptor");
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Empty Descriptor");
             }
             return respStr;
         }
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "toString()", "Printing " + fields.length + " fields");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
+                    "Printing " + fields.length + " fields");
         }
 
         for (int i=0; i < fields.length; i++) {
@@ -1319,10 +1253,8 @@
             }
         }
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINEST)) {
-            MODELMBEAN_LOGGER.logp(Level.FINEST,
-                    DescriptorSupport.class.getName(),
-                    "toString()", "Exit returning " + respStr);
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit returning " + respStr);
         }
 
         return respStr;
--- a/jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanAttributeInfo.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanAttributeInfo.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -39,7 +39,7 @@
 import java.io.ObjectStreamField;
 import java.lang.reflect.Method;
 import java.security.AccessController;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 
 import javax.management.Descriptor;
 import javax.management.DescriptorKey;
@@ -201,12 +201,11 @@
         throws javax.management.IntrospectionException {
                 super(name, description, getter, setter);
 
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            ModelMBeanAttributeInfo.class.getName(),
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
                             "ModelMBeanAttributeInfo(" +
-                            "String,String,Method,Method)",
-                            "Entry", name);
+                            "String,String,Method,Method) " +
+                            "Entry " + name);
                 }
 
                 attrDescriptor = validDescriptor(null);
@@ -251,12 +250,11 @@
 
                 super(name, description, getter, setter);
                 // put getter and setter methods in operations list
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            ModelMBeanAttributeInfo.class.getName(),
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
                             "ModelMBeanAttributeInfo(" +
-                            "String,String,Method,Method,Descriptor)",
-                            "Entry", name);
+                            "String,String,Method,Method,Descriptor) " +
+                            "Entry " + name);
                 }
                 attrDescriptor = validDescriptor(descriptor);
         }
@@ -282,8 +280,8 @@
 
                 super(name, type, description, isReadable, isWritable, isIs);
                 // create default descriptor
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
                             ModelMBeanAttributeInfo.class.getName(),
                             "ModelMBeanAttributeInfo(" +
                             "String,String,String,boolean,boolean,boolean)",
@@ -321,12 +319,11 @@
                                        Descriptor descriptor)
         {
                 super(name, type, description, isReadable, isWritable, isIs);
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            ModelMBeanAttributeInfo.class.getName(),
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
                             "ModelMBeanAttributeInfo(String,String,String," +
-                            "boolean,boolean,boolean,Descriptor)",
-                            "Entry", name);
+                            "boolean,boolean,boolean,Descriptor)" +
+                            "Entry " + name);
                 }
                 attrDescriptor = validDescriptor(descriptor);
         }
@@ -347,10 +344,9 @@
                           inInfo.isReadable(),
                           inInfo.isWritable(),
                           inInfo.isIs());
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            ModelMBeanAttributeInfo.class.getName(),
-                            "ModelMBeanAttributeInfo(ModelMBeanAttributeInfo)",
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
+                            "ModelMBeanAttributeInfo(ModelMBeanAttributeInfo) " +
                             "Entry");
                 }
                 Descriptor newDesc = inInfo.getDescriptor();
@@ -368,10 +364,8 @@
          */
 
         public Descriptor getDescriptor() {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        ModelMBeanAttributeInfo.class.getName(),
-                        "getDescriptor()", "Entry");
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
             }
                 if (attrDescriptor == null) {
                     attrDescriptor = validDescriptor(null);
@@ -411,10 +405,8 @@
         @Override
         public Object clone()
         {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        ModelMBeanAttributeInfo.class.getName(),
-                        "clone()", "Entry");
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
             }
                 return(new ModelMBeanAttributeInfo(this));
         }
@@ -454,7 +446,7 @@
             boolean defaulted = (in == null);
             if (defaulted) {
                 clone = new DescriptorSupport();
-                MODELMBEAN_LOGGER.finer("Null Descriptor, creating new.");
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Null Descriptor, creating new.");
             } else {
                 clone = (Descriptor) in.clone();
             }
@@ -462,15 +454,15 @@
             //Setting defaults.
             if (defaulted && clone.getFieldValue("name")==null) {
                 clone.setField("name", this.getName());
-                MODELMBEAN_LOGGER.finer("Defaulting Descriptor name to " + this.getName());
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor name to " + this.getName());
             }
             if (defaulted && clone.getFieldValue("descriptorType")==null) {
                 clone.setField("descriptorType", "attribute");
-                MODELMBEAN_LOGGER.finer("Defaulting descriptorType to \"attribute\"");
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting descriptorType to \"attribute\"");
             }
             if (clone.getFieldValue("displayName") == null) {
                 clone.setField("displayName",this.getName());
-                MODELMBEAN_LOGGER.finer("Defaulting Descriptor displayName to " + this.getName());
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor displayName to " + this.getName());
             }
 
             //Checking validity
--- a/jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanConstructorInfo.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanConstructorInfo.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -39,7 +39,7 @@
 import java.io.ObjectStreamField;
 import java.lang.reflect.Constructor;
 import java.security.AccessController;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 
 import javax.management.Descriptor;
 import javax.management.DescriptorAccess;
@@ -164,10 +164,9 @@
                                          Constructor<?> constructorMethod)
     {
                 super(description, constructorMethod);
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            ModelMBeanConstructorInfo.class.getName(),
-                            "ModelMBeanConstructorInfo(String,Constructor)",
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
+                            "ModelMBeanConstructorInfo(String,Constructor) " +
                             "Entry");
                 }
                 consDescriptor = validDescriptor(null);
@@ -209,11 +208,10 @@
 
                 super(description, constructorMethod);
                 // put getter and setter methods in constructors list
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            ModelMBeanConstructorInfo.class.getName(),
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
                             "ModelMBeanConstructorInfo(" +
-                            "String,Constructor,Descriptor)", "Entry");
+                            "String,Constructor,Descriptor) Entry");
                 }
                 consDescriptor = validDescriptor(descriptor);
         }
@@ -232,11 +230,10 @@
 
                 super(name, description, signature);
                 // create default descriptor
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            ModelMBeanConstructorInfo.class.getName(),
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
                             "ModelMBeanConstructorInfo(" +
-                            "String,String,MBeanParameterInfo[])", "Entry");
+                            "String,String,MBeanParameterInfo[]) Entry");
                 }
                 consDescriptor = validDescriptor(null);
         }
@@ -265,11 +262,10 @@
                                          Descriptor descriptor)
         {
                 super(name, description, signature);
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            ModelMBeanConstructorInfo.class.getName(),
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
                             "ModelMBeanConstructorInfo(" +
-                            "String,String,MBeanParameterInfo[],Descriptor)",
+                            "String,String,MBeanParameterInfo[],Descriptor) " +
                             "Entry");
                 }
                 consDescriptor = validDescriptor(descriptor);
@@ -284,11 +280,10 @@
         ModelMBeanConstructorInfo(ModelMBeanConstructorInfo old)
         {
                 super(old.getName(), old.getDescription(), old.getSignature());
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            ModelMBeanConstructorInfo.class.getName(),
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
                             "ModelMBeanConstructorInfo(" +
-                            "ModelMBeanConstructorInfo)", "Entry");
+                            "ModelMBeanConstructorInfo) Entry");
                 }
                 consDescriptor = validDescriptor(consDescriptor);
         }
@@ -300,10 +295,8 @@
         @Override
         public Object clone ()
         {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        ModelMBeanConstructorInfo.class.getName(),
-                        "clone()", "Entry");
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
             }
                 return(new ModelMBeanConstructorInfo(this)) ;
         }
@@ -321,10 +314,8 @@
         @Override
         public Descriptor getDescriptor()
         {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        ModelMBeanConstructorInfo.class.getName(),
-                        "getDescriptor()", "Entry");
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
             }
             if (consDescriptor == null){
                 consDescriptor = validDescriptor(null);
@@ -356,10 +347,8 @@
         */
         public void setDescriptor(Descriptor inDescriptor)
         {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        ModelMBeanConstructorInfo.class.getName(),
-                        "setDescriptor()", "Entry");
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
             }
             consDescriptor = validDescriptor(inDescriptor);
         }
@@ -370,10 +359,8 @@
         @Override
         public String toString()
         {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        ModelMBeanConstructorInfo.class.getName(),
-                        "toString()", "Entry");
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
             }
                 String retStr =
                     "ModelMBeanConstructorInfo: " + this.getName() +
@@ -408,7 +395,7 @@
             boolean defaulted = (in == null);
             if (defaulted) {
                 clone = new DescriptorSupport();
-                MODELMBEAN_LOGGER.finer("Null Descriptor, creating new.");
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Null Descriptor, creating new.");
             } else {
                 clone = (Descriptor) in.clone();
             }
@@ -416,19 +403,19 @@
             //Setting defaults.
             if (defaulted && clone.getFieldValue("name")==null) {
                 clone.setField("name", this.getName());
-                MODELMBEAN_LOGGER.finer("Defaulting Descriptor name to " + this.getName());
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor name to " + this.getName());
             }
             if (defaulted && clone.getFieldValue("descriptorType")==null) {
                 clone.setField("descriptorType", "operation");
-                MODELMBEAN_LOGGER.finer("Defaulting descriptorType to \"operation\"");
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting descriptorType to \"operation\"");
             }
             if (clone.getFieldValue("displayName") == null) {
                 clone.setField("displayName",this.getName());
-                MODELMBEAN_LOGGER.finer("Defaulting Descriptor displayName to " + this.getName());
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor displayName to " + this.getName());
             }
             if (clone.getFieldValue("role") == null) {
                 clone.setField("role","constructor");
-                MODELMBEAN_LOGGER.finer("Defaulting Descriptor role field to \"constructor\"");
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor role field to \"constructor\"");
             }
 
             //Checking validity
--- a/jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanInfoSupport.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanInfoSupport.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2008, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -38,7 +38,7 @@
 import java.io.ObjectOutputStream;
 import java.io.ObjectStreamField;
 import java.security.AccessController;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 
 import javax.management.Descriptor;
 import javax.management.MBeanAttributeInfo;
@@ -231,19 +231,16 @@
             modelMBeanDescriptor = validDescriptor(mbeandescriptor);
         } catch (MBeanException mbe) {
             modelMBeanDescriptor = validDescriptor(null);
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        ModelMBeanInfoSupport.class.getName(),
-                        "ModelMBeanInfo(ModelMBeanInfo)",
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE,
+                        "ModelMBeanInfo(ModelMBeanInfo) " +
                         "Could not get a valid modelMBeanDescriptor, " +
                         "setting a default Descriptor");
             }
         }
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanInfoSupport.class.getName(),
-                    "ModelMBeanInfo(ModelMBeanInfo)", "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
     }
 
@@ -330,12 +327,11 @@
         modelMBeanOperations = operations;
         modelMBeanNotifications = notifications;
         modelMBeanDescriptor = validDescriptor(mbeandescriptor);
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanInfoSupport.class.getName(),
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
                     "ModelMBeanInfoSupport(String,String,ModelMBeanAttributeInfo[]," +
                     "ModelMBeanConstructorInfo[],ModelMBeanOperationInfo[]," +
-                    "ModelMBeanNotificationInfo[],Descriptor)",
+                    "ModelMBeanNotificationInfo[],Descriptor) " +
                     "Exit");
         }
     }
@@ -367,10 +363,8 @@
 
     public Descriptor[] getDescriptors(String inDescriptorType)
     throws MBeanException, RuntimeOperationsException {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanInfoSupport.class.getName(),
-                    "getDescriptors(String)", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         if ((inDescriptorType == null) || (inDescriptorType.equals(""))) {
@@ -474,10 +468,8 @@
                     " the descriptors of the MBean";
             throw new RuntimeOperationsException(iae,msg);
         }
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanInfoSupport.class.getName(),
-                    "getDescriptors(String)", "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
 
         return retList;
@@ -486,10 +478,8 @@
 
     public void setDescriptors(Descriptor[] inDescriptors)
     throws MBeanException, RuntimeOperationsException {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanInfoSupport.class.getName(),
-                    "setDescriptors(Descriptor[])", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
         if (inDescriptors==null) {
             // throw RuntimeOperationsException - invalid descriptor
@@ -504,10 +494,8 @@
         for (int j=0; j < inDescriptors.length; j++) {
             setDescriptor(inDescriptors[j],null);
         }
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanInfoSupport.class.getName(),
-                    "setDescriptors(Descriptor[])", "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
 
     }
@@ -530,10 +518,8 @@
 
     public Descriptor getDescriptor(String inDescriptorName)
     throws MBeanException, RuntimeOperationsException {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanInfoSupport.class.getName(),
-                    "getDescriptor(String)", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
         return(getDescriptor(inDescriptorName, null));
     }
@@ -606,10 +592,8 @@
             throws MBeanException, RuntimeOperationsException {
         final String excMsg =
                 "Exception occurred trying to set the descriptors of the MBean";
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanInfoSupport.class.getName(),
-                    "setDescriptor(Descriptor,String)", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         if (inDescriptor==null) {
@@ -621,10 +605,9 @@
                     (String) inDescriptor.getFieldValue("descriptorType");
 
             if (inDescriptorType == null) {
-                   MODELMBEAN_LOGGER.logp(Level.FINER,
-                                ModelMBeanInfoSupport.class.getName(),
-                                "setDescriptor(Descriptor,String)",
-                                "descriptorType null in both String parameter and Descriptor, defaulting to "+ MMB);
+                   MODELMBEAN_LOGGER.log(Level.TRACE,
+                                "descriptorType null in both String parameter " +
+                                "and Descriptor, defaulting to "+ MMB);
                 inDescriptorType = MMB;
             }
         }
@@ -632,10 +615,9 @@
         String inDescriptorName =
                 (String) inDescriptor.getFieldValue("name");
         if (inDescriptorName == null) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                                ModelMBeanInfoSupport.class.getName(),
-                                "setDescriptor(Descriptor,String)",
-                                "descriptor name null, defaulting to "+ this.getClassName());
+            MODELMBEAN_LOGGER.log(Level.TRACE,
+                                "descriptor name null, defaulting to " +
+                                this.getClassName());
             inDescriptorName = this.getClassName();
         }
         boolean found = false;
@@ -653,17 +635,14 @@
                     ModelMBeanAttributeInfo mmbai =
                             (ModelMBeanAttributeInfo) attrList[i];
                     mmbai.setDescriptor(inDescriptor);
-                    if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
+                    if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
                         StringBuilder strb = new StringBuilder()
                         .append("Setting descriptor to ").append(inDescriptor)
                         .append("\t\n local: AttributeInfo descriptor is ")
                         .append(mmbai.getDescriptor())
                         .append("\t\n modelMBeanInfo: AttributeInfo descriptor is ")
                         .append(this.getDescriptor(inDescriptorName,"attribute"));
-                        MODELMBEAN_LOGGER.logp(Level.FINER,
-                                ModelMBeanInfoSupport.class.getName(),
-                                "setDescriptor(Descriptor,String)",
-                                strb.toString());
+                        MODELMBEAN_LOGGER.log(Level.TRACE, strb::toString);
                     }
                 }
             }
@@ -720,10 +699,8 @@
                     "; name=" + inDescriptorName);
             throw new RuntimeOperationsException(iae, excMsg);
         }
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanInfoSupport.class.getName(),
-                    "setDescriptor(Descriptor,String)", "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
 
     }
@@ -732,10 +709,8 @@
     public ModelMBeanAttributeInfo getAttribute(String inName)
     throws MBeanException, RuntimeOperationsException {
         ModelMBeanAttributeInfo retInfo = null;
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanInfoSupport.class.getName(),
-                    "getAttribute(String)", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
         if (inName == null) {
             throw new RuntimeOperationsException(
@@ -748,7 +723,7 @@
         if (attrList != null) numAttrs = attrList.length;
 
         for (int i=0; (i < numAttrs) && (retInfo == null); i++) {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
                 final StringBuilder strb = new StringBuilder()
                 .append("\t\n this.getAttributes() MBeanAttributeInfo Array ")
                 .append(i).append(":")
@@ -756,18 +731,14 @@
                 .append("\t\n this.modelMBeanAttributes MBeanAttributeInfo Array ")
                 .append(i).append(":")
                 .append(((ModelMBeanAttributeInfo)modelMBeanAttributes[i]).getDescriptor());
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        ModelMBeanInfoSupport.class.getName(),
-                        "getAttribute(String)", strb.toString());
+                MODELMBEAN_LOGGER.log(Level.TRACE, strb::toString);
             }
             if (inName.equals(attrList[i].getName())) {
                 retInfo = ((ModelMBeanAttributeInfo)attrList[i].clone());
             }
         }
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanInfoSupport.class.getName(),
-                    "getAttribute(String)", "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
 
         return retInfo;
@@ -778,10 +749,8 @@
     public ModelMBeanOperationInfo getOperation(String inName)
     throws MBeanException, RuntimeOperationsException {
         ModelMBeanOperationInfo retInfo = null;
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanInfoSupport.class.getName(),
-                    "getOperation(String)", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
         if (inName == null) {
             throw new RuntimeOperationsException(
@@ -798,10 +767,8 @@
                 retInfo = ((ModelMBeanOperationInfo) operList[i].clone());
             }
         }
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanInfoSupport.class.getName(),
-                    "getOperation(String)", "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
 
         return retInfo;
@@ -824,10 +791,8 @@
     public ModelMBeanConstructorInfo getConstructor(String inName)
     throws MBeanException, RuntimeOperationsException {
         ModelMBeanConstructorInfo retInfo = null;
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanInfoSupport.class.getName(),
-                    "getConstructor(String)", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
         if (inName == null) {
             throw new RuntimeOperationsException(
@@ -844,10 +809,8 @@
                 retInfo = ((ModelMBeanConstructorInfo) consList[i].clone());
             }
         }
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanInfoSupport.class.getName(),
-                    "getConstructor(String)", "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
 
         return retInfo;
@@ -857,10 +820,8 @@
     public ModelMBeanNotificationInfo getNotification(String inName)
     throws MBeanException, RuntimeOperationsException {
         ModelMBeanNotificationInfo retInfo = null;
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanInfoSupport.class.getName(),
-                    "getNotification(String)", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
         if (inName == null) {
             throw new RuntimeOperationsException(
@@ -877,10 +838,8 @@
                 retInfo = ((ModelMBeanNotificationInfo) notifList[i].clone());
             }
         }
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanInfoSupport.class.getName(),
-                    "getNotification(String)", "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
 
         return retInfo;
@@ -901,19 +860,15 @@
     }
 
     private Descriptor getMBeanDescriptorNoException() {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanInfoSupport.class.getName(),
-                    "getMBeanDescriptorNoException()", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         if (modelMBeanDescriptor == null)
             modelMBeanDescriptor = validDescriptor(null);
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanInfoSupport.class.getName(),
-                    "getMBeanDescriptorNoException()",
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
                     "Exit, returning: " + modelMBeanDescriptor);
         }
         return (Descriptor) modelMBeanDescriptor.clone();
@@ -921,10 +876,8 @@
 
     public void setMBeanDescriptor(Descriptor inMBeanDescriptor)
     throws MBeanException, RuntimeOperationsException {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanInfoSupport.class.getName(),
-                    "setMBeanDescriptor(Descriptor)", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
         modelMBeanDescriptor = validDescriptor(inMBeanDescriptor);
     }
@@ -948,7 +901,7 @@
         boolean defaulted = (in == null);
         if (defaulted) {
             clone = new DescriptorSupport();
-            MODELMBEAN_LOGGER.finer("Null Descriptor, creating new.");
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Null Descriptor, creating new.");
         } else {
             clone = (Descriptor) in.clone();
         }
@@ -956,27 +909,27 @@
         //Setting defaults.
         if (defaulted && clone.getFieldValue("name")==null) {
             clone.setField("name", this.getClassName());
-            MODELMBEAN_LOGGER.finer("Defaulting Descriptor name to " + this.getClassName());
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor name to " + this.getClassName());
         }
         if (defaulted && clone.getFieldValue("descriptorType")==null) {
             clone.setField("descriptorType", MMB);
-            MODELMBEAN_LOGGER.finer("Defaulting descriptorType to \"" + MMB + "\"");
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting descriptorType to \"" + MMB + "\"");
         }
         if (clone.getFieldValue("displayName") == null) {
             clone.setField("displayName",this.getClassName());
-            MODELMBEAN_LOGGER.finer("Defaulting Descriptor displayName to " + this.getClassName());
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor displayName to " + this.getClassName());
         }
         if (clone.getFieldValue("persistPolicy") == null) {
             clone.setField("persistPolicy","never");
-            MODELMBEAN_LOGGER.finer("Defaulting Descriptor persistPolicy to \"never\"");
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor persistPolicy to \"never\"");
         }
         if (clone.getFieldValue("log") == null) {
             clone.setField("log","F");
-            MODELMBEAN_LOGGER.finer("Defaulting Descriptor \"log\" field to \"F\"");
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor \"log\" field to \"F\"");
         }
         if (clone.getFieldValue("visibility") == null) {
             clone.setField("visibility","1");
-            MODELMBEAN_LOGGER.finer("Defaulting Descriptor visibility to 1");
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor visibility to 1");
         }
 
         //Checking validity
--- a/jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanNotificationInfo.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanNotificationInfo.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -38,7 +38,7 @@
 import java.io.ObjectOutputStream;
 import java.io.ObjectStreamField;
 import java.security.AccessController;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 
 import javax.management.Descriptor;
 import javax.management.DescriptorAccess;
@@ -199,10 +199,8 @@
                                       String description,
                                       Descriptor descriptor) {
         super(notifTypes, name, description);
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanNotificationInfo.class.getName(),
-                    "ModelMBeanNotificationInfo", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
         notificationDescriptor = validDescriptor(descriptor);
     }
@@ -225,10 +223,8 @@
      * duplicate of this ModelMBeanNotificationInfo.
      **/
     public Object clone () {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanNotificationInfo.class.getName(),
-                    "clone()", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
         return(new ModelMBeanNotificationInfo(this));
     }
@@ -243,18 +239,15 @@
      * @see #setDescriptor
      **/
     public Descriptor getDescriptor() {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanNotificationInfo.class.getName(),
-                    "getDescriptor()", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         if (notificationDescriptor == null) {
             // Dead code. Should never happen.
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        ModelMBeanNotificationInfo.class.getName(),
-                        "getDescriptor()", "Descriptor value is null, " +
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE,
+                        "Descriptor value is null, " +
                         "setting descriptor to default values");
             }
             notificationDescriptor = validDescriptor(null);
@@ -281,10 +274,8 @@
      * @see #getDescriptor
      **/
     public void setDescriptor(Descriptor inDescriptor) {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanNotificationInfo.class.getName(),
-                    "setDescriptor(Descriptor)", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
         notificationDescriptor = validDescriptor(inDescriptor);
     }
@@ -296,10 +287,8 @@
      * @return a string describing this object.
      **/
     public String toString() {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    ModelMBeanNotificationInfo.class.getName(),
-                    "toString()", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         final StringBuilder retStr = new StringBuilder();
@@ -342,7 +331,7 @@
         boolean defaulted = (in == null);
         if (defaulted) {
             clone = new DescriptorSupport();
-            MODELMBEAN_LOGGER.finer("Null Descriptor, creating new.");
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Null Descriptor, creating new.");
         } else {
             clone = (Descriptor) in.clone();
         }
@@ -350,19 +339,19 @@
         //Setting defaults.
         if (defaulted && clone.getFieldValue("name")==null) {
             clone.setField("name", this.getName());
-            MODELMBEAN_LOGGER.finer("Defaulting Descriptor name to " + this.getName());
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor name to " + this.getName());
         }
         if (defaulted && clone.getFieldValue("descriptorType")==null) {
             clone.setField("descriptorType", "notification");
-            MODELMBEAN_LOGGER.finer("Defaulting descriptorType to \"notification\"");
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting descriptorType to \"notification\"");
         }
         if (clone.getFieldValue("displayName") == null) {
             clone.setField("displayName",this.getName());
-            MODELMBEAN_LOGGER.finer("Defaulting Descriptor displayName to " + this.getName());
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor displayName to " + this.getName());
         }
         if (clone.getFieldValue("severity") == null) {
             clone.setField("severity", "6");
-            MODELMBEAN_LOGGER.finer("Defaulting Descriptor severity field to 6");
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor severity field to 6");
         }
 
         //Checking validity
--- a/jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanOperationInfo.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanOperationInfo.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -39,7 +39,7 @@
 import java.io.ObjectStreamField;
 import java.lang.reflect.Method;
 import java.security.AccessController;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 
 import javax.management.Descriptor;
 import javax.management.DescriptorAccess;
@@ -185,10 +185,9 @@
         {
                 super(description, operationMethod);
                 // create default descriptor
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            ModelMBeanOperationInfo.class.getName(),
-                            "ModelMBeanOperationInfo(String,Method)",
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
+                            "ModelMBeanOperationInfo(String,Method) " +
                             "Entry");
                 }
                 operationDescriptor = validDescriptor(null);
@@ -228,11 +227,10 @@
         {
 
                 super(description, operationMethod);
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            ModelMBeanOperationInfo.class.getName(),
-                            "ModelMBeanOperationInfo(String,Method,Descriptor)",
-                            "Entry");
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
+                            "ModelMBeanOperationInfo(String,Method,Descriptor) "
+                            + "Entry");
                 }
                 operationDescriptor = validDescriptor(descriptor);
         }
@@ -258,11 +256,10 @@
 
                 super(name, description, signature, type, impact);
                 // create default descriptor
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            ModelMBeanOperationInfo.class.getName(),
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
                             "ModelMBeanOperationInfo(" +
-                            "String,String,MBeanParameterInfo[],String,int)",
+                            "String,String,MBeanParameterInfo[],String,int) " +
                             "Entry");
                 }
                 operationDescriptor = validDescriptor(null);
@@ -302,11 +299,10 @@
                                        Descriptor descriptor)
         {
                 super(name, description, signature, type, impact);
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            ModelMBeanOperationInfo.class.getName(),
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
                             "ModelMBeanOperationInfo(String,String," +
-                            "MBeanParameterInfo[],String,int,Descriptor)",
+                            "MBeanParameterInfo[],String,int,Descriptor) " +
                             "Entry");
                 }
                 operationDescriptor = validDescriptor(descriptor);
@@ -327,10 +323,9 @@
                           inInfo.getSignature(),
                           inInfo.getReturnType(),
                           inInfo.getImpact());
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            ModelMBeanOperationInfo.class.getName(),
-                            "ModelMBeanOperationInfo(ModelMBeanOperationInfo)",
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
+                            "ModelMBeanOperationInfo(ModelMBeanOperationInfo)" +
                             "Entry");
                 }
                 Descriptor newDesc = inInfo.getDescriptor();
@@ -345,10 +340,8 @@
 
         public Object clone ()
         {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        ModelMBeanOperationInfo.class.getName(),
-                        "clone()", "Entry");
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
             }
                 return(new ModelMBeanOperationInfo(this)) ;
         }
@@ -365,10 +358,8 @@
 
         public Descriptor getDescriptor()
         {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        ModelMBeanOperationInfo.class.getName(),
-                        "getDescriptor()", "Entry");
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
             }
             if (operationDescriptor == null) {
                 operationDescriptor = validDescriptor(null);
@@ -396,10 +387,8 @@
          */
         public void setDescriptor(Descriptor inDescriptor)
         {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        ModelMBeanOperationInfo.class.getName(),
-                        "setDescriptor(Descriptor)", "Entry");
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
             }
             operationDescriptor = validDescriptor(inDescriptor);
         }
@@ -410,10 +399,8 @@
         */
         public String toString()
         {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        ModelMBeanOperationInfo.class.getName(),
-                        "toString()", "Entry");
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
             }
                 String retStr =
                     "ModelMBeanOperationInfo: " + this.getName() +
@@ -449,7 +436,7 @@
             boolean defaulted = (in == null);
             if (defaulted) {
                 clone = new DescriptorSupport();
-                MODELMBEAN_LOGGER.finer("Null Descriptor, creating new.");
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Null Descriptor, creating new.");
             } else {
                 clone = (Descriptor) in.clone();
             }
@@ -457,19 +444,19 @@
             //Setting defaults.
             if (defaulted && clone.getFieldValue("name")==null) {
                 clone.setField("name", this.getName());
-                MODELMBEAN_LOGGER.finer("Defaulting Descriptor name to " + this.getName());
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor name to " + this.getName());
             }
             if (defaulted && clone.getFieldValue("descriptorType")==null) {
                 clone.setField("descriptorType", "operation");
-                MODELMBEAN_LOGGER.finer("Defaulting descriptorType to \"operation\"");
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting descriptorType to \"operation\"");
             }
             if (clone.getFieldValue("displayName") == null) {
                 clone.setField("displayName",this.getName());
-                MODELMBEAN_LOGGER.finer("Defaulting Descriptor displayName to " + this.getName());
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor displayName to " + this.getName());
             }
             if (clone.getFieldValue("role") == null) {
                 clone.setField("role","operation");
-                MODELMBEAN_LOGGER.finer("Defaulting Descriptor role field to \"operation\"");
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Defaulting Descriptor role field to \"operation\"");
             }
 
             //Checking validity
--- a/jdk/src/java.management/share/classes/javax/management/modelmbean/RequiredModelMBean.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/modelmbean/RequiredModelMBean.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -46,7 +46,7 @@
 import java.util.Date;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 import java.util.Map;
 import java.util.Set;
 
@@ -166,16 +166,12 @@
      **/
     public RequiredModelMBean()
         throws MBeanException, RuntimeOperationsException {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                    "RequiredModelMBean()", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
         modelMBeanInfo = createDefaultModelMBeanInfo();
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                    "RequiredModelMBean()", "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
     }
 
@@ -202,17 +198,13 @@
     public RequiredModelMBean(ModelMBeanInfo mbi)
         throws MBeanException, RuntimeOperationsException {
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                    "RequiredModelMBean(MBeanInfo)", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
         setModelMBeanInfo(mbi);
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                    "RequiredModelMBean(MBeanInfo)", "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
     }
 
@@ -257,17 +249,13 @@
     public void setModelMBeanInfo(ModelMBeanInfo mbi)
         throws MBeanException, RuntimeOperationsException {
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                "setModelMBeanInfo(ModelMBeanInfo)","Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         if (mbi == null) {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        RequiredModelMBean.class.getName(),
-                    "setModelMBeanInfo(ModelMBeanInfo)",
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE,
                     "ModelMBeanInfo is null: Raising exception.");
             }
             final RuntimeException x = new
@@ -279,10 +267,8 @@
         }
 
         if (registered) {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        RequiredModelMBean.class.getName(),
-                    "setModelMBeanInfo(ModelMBeanInfo)",
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE,
                     "RequiredMBean is registered: Raising exception.");
             }
             final String exceptionText =
@@ -293,32 +279,24 @@
             throw new RuntimeOperationsException(x,exceptionText);
         }
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                "setModelMBeanInfo(ModelMBeanInfo)",
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
                 "Setting ModelMBeanInfo to " + printModelMBeanInfo(mbi));
             int noOfNotifications = 0;
             if (mbi.getNotifications() != null) {
                 noOfNotifications = mbi.getNotifications().length;
             }
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                "setModelMBeanInfo(ModelMBeanInfo)",
+            MODELMBEAN_LOGGER.log(Level.TRACE,
                 "ModelMBeanInfo notifications has " +
                 noOfNotifications + " elements");
         }
 
         modelMBeanInfo = (ModelMBeanInfo)mbi.clone();
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                "setModelMBeanInfo(ModelMBeanInfo)","set mbeanInfo to: "+
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "set mbeanInfo to: "+
                  printModelMBeanInfo(modelMBeanInfo));
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                "setModelMBeanInfo(ModelMBeanInfo)","Exit");
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
     }
 
@@ -346,37 +324,29 @@
     public void setManagedResource(Object mr, String mr_type)
         throws MBeanException, RuntimeOperationsException,
                InstanceNotFoundException, InvalidTargetObjectTypeException {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                "setManagedResource(Object,String)","Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         // check that the mr_type is supported by this JMXAgent
         // only "objectReference" is supported
         if ((mr_type == null) ||
             (! mr_type.equalsIgnoreCase("objectReference"))) {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        RequiredModelMBean.class.getName(),
-                    "setManagedResource(Object,String)",
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE,
                     "Managed Resource Type is not supported: " + mr_type);
             }
             throw new InvalidTargetObjectTypeException(mr_type);
         }
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                "setManagedResource(Object,String)",
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
                 "Managed Resource is valid");
         }
         managedResource = mr;
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                "setManagedResource(Object, String)", "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
     }
 
@@ -482,11 +452,9 @@
     private Object resolveForCacheValue(Descriptor descr)
         throws MBeanException, RuntimeOperationsException {
 
-        final boolean tracing = MODELMBEAN_LOGGER.isLoggable(Level.FINER);
-        final String mth = "resolveForCacheValue(Descriptor)";
+        final boolean tracing = MODELMBEAN_LOGGER.isLoggable(Level.TRACE);
         if (tracing) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),mth,"Entry");
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         Object response = null;
@@ -495,25 +463,22 @@
 
         if (descr == null) {
             if (tracing) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        RequiredModelMBean.class.getName(),mth,
+                MODELMBEAN_LOGGER.log(Level.TRACE,
                     "Input Descriptor is null");
             }
             return response;
         }
 
         if (tracing) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                    mth, "descriptor is " + descr);
+            MODELMBEAN_LOGGER.log(Level.TRACE,
+                    "descriptor is " + descr);
         }
 
         final Descriptor mmbDescr = modelMBeanInfo.getMBeanDescriptor();
         if (mmbDescr == null) {
             if (tracing) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                        mth,"MBean Descriptor is null");
+                MODELMBEAN_LOGGER.log(Level.TRACE,
+                        "MBean Descriptor is null");
             }
             //return response;
         }
@@ -538,9 +503,8 @@
 
         if (expTime != null) {
             if (tracing) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                        mth,"currencyTimeLimit: " + expTime);
+                MODELMBEAN_LOGGER.log(Level.TRACE,
+                        "currencyTimeLimit: " + expTime);
             }
 
             // convert seconds to milliseconds for time comparison
@@ -550,8 +514,7 @@
                 returnCachedValue = false;
                 resetValue = true;
                 if (tracing) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            RequiredModelMBean.class.getName(),mth,
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
                         currencyPeriod + ": never Cached");
                 }
             } else if (currencyPeriod == 0) {
@@ -559,9 +522,7 @@
                 returnCachedValue = true;
                 resetValue = false;
                 if (tracing) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            RequiredModelMBean.class.getName(),mth,
-                        "always valid Cache");
+                    MODELMBEAN_LOGGER.log(Level.TRACE, "always valid Cache");
                 }
             } else {
                 Object objtStamp =
@@ -572,8 +533,7 @@
                 else tStamp = null;
 
                 if (tracing) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            RequiredModelMBean.class.getName(),mth,
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
                         "lastUpdatedTimeStamp: " + tStamp);
                 }
 
@@ -583,8 +543,7 @@
                 long lastTime = Long.parseLong(tStamp);
 
                 if (tracing) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            RequiredModelMBean.class.getName(),mth,
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
                         "currencyPeriod:" + currencyPeriod +
                         " lastUpdatedTimeStamp:" + lastTime);
                 }
@@ -595,8 +554,7 @@
                     returnCachedValue = true;
                     resetValue = false;
                     if (tracing) {
-                        MODELMBEAN_LOGGER.logp(Level.FINER,
-                                RequiredModelMBean.class.getName(),mth,
+                        MODELMBEAN_LOGGER.log(Level.TRACE,
                             " timed valid Cache for " + now + " < " +
                             (lastTime + currencyPeriod));
                     }
@@ -604,16 +562,14 @@
                     returnCachedValue = false;
                     resetValue = true;
                     if (tracing) {
-                        MODELMBEAN_LOGGER.logp(Level.FINER,
-                                RequiredModelMBean.class.getName(),mth,
+                        MODELMBEAN_LOGGER.log(Level.TRACE,
                             "timed expired cache for " + now + " > " +
                             (lastTime + currencyPeriod));
                     }
                 }
             }
             if (tracing) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        RequiredModelMBean.class.getName(),mth,
+                MODELMBEAN_LOGGER.log(Level.TRACE,
                     "returnCachedValue:" + returnCachedValue +
                     " resetValue: " + resetValue);
             }
@@ -625,17 +581,15 @@
                     response = currValue;
                     /* need to cast string cached value to type */
                     if (tracing) {
-                        MODELMBEAN_LOGGER.logp(Level.FINER,
-                                RequiredModelMBean.class.getName(),mth,
+                        MODELMBEAN_LOGGER.log(Level.TRACE,
                             "valid Cache value: " + currValue);
                     }
 
                 } else {
                     response = null;
                     if (tracing) {
-                        MODELMBEAN_LOGGER.logp(Level.FINER,
-                            RequiredModelMBean.class.getName(),
-                                mth,"no Cached value");
+                        MODELMBEAN_LOGGER.log(Level.TRACE,
+                                 "no Cached value");
                     }
                 }
             }
@@ -647,16 +601,14 @@
                 response = null;
                 modelMBeanInfo.setDescriptor(descr,null);
                 if (tracing) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                        RequiredModelMBean.class.getName(),
-                            mth,"reset cached value to null");
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
+                        "reset cached value to null");
                 }
             }
         }
 
         if (tracing) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),mth,"Exit");
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
 
         return response;
@@ -672,31 +624,24 @@
      **/
     public MBeanInfo getMBeanInfo() {
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                    "getMBeanInfo()","Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         if (modelMBeanInfo == null) {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        RequiredModelMBean.class.getName(),
-                    "getMBeanInfo()","modelMBeanInfo is null");
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE, "modelMBeanInfo is null");
             }
             modelMBeanInfo = createDefaultModelMBeanInfo();
             //return new ModelMBeanInfo(" ", "", null, null, null, null);
         }
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                "getMBeanInfo()","ModelMBeanInfo is " +
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "ModelMBeanInfo is " +
                   modelMBeanInfo.getClassName() + " for " +
                   modelMBeanInfo.getDescription());
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                "getMBeanInfo()",printModelMBeanInfo(modelMBeanInfo));
+            MODELMBEAN_LOGGER.log(Level.TRACE,
+                    printModelMBeanInfo(modelMBeanInfo));
         }
 
         return((MBeanInfo) modelMBeanInfo.clone());
@@ -705,10 +650,8 @@
     private String printModelMBeanInfo(ModelMBeanInfo info) {
         final StringBuilder retStr = new StringBuilder();
         if (info == null) {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        RequiredModelMBean.class.getName(),
-                        "printModelMBeanInfo(ModelMBeanInfo)",
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE,
                         "ModelMBeanInfo to print is null, " +
                         "printing local ModelMBeanInfo");
             }
@@ -909,12 +852,10 @@
     public Object invoke(String opName, Object[] opArgs, String[] sig)
             throws MBeanException, ReflectionException {
 
-        final boolean tracing = MODELMBEAN_LOGGER.isLoggable(Level.FINER);
-        final String mth = "invoke(String, Object[], String[])";
+        final boolean tracing = MODELMBEAN_LOGGER.isLoggable(Level.TRACE);
 
         if (tracing) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(), mth, "Entry");
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         if (opName == null) {
@@ -943,9 +884,8 @@
             opMethodName = opMethodName.substring(0,opSplitter);
 
         if (tracing) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                    mth, "Finding operation " + opName + " as " + opMethodName);
+            MODELMBEAN_LOGGER.log(Level.TRACE,
+                    "Finding operation " + opName + " as " + opMethodName);
         }
 
         ModelMBeanOperationInfo opInfo =
@@ -965,10 +905,7 @@
         final Object cached = resolveForCacheValue(opDescr);
         if (cached != null) {
             if (tracing) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        RequiredModelMBean.class.getName(),
-                        mth,
-                        "Returning cached value");
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Returning cached value");
             }
             return cached;
         }
@@ -996,9 +933,8 @@
 
         final Object targetObjectField = opDescr.getFieldValue("targetObject");
         if (tracing && targetObjectField != null)
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                        mth, "Found target object in descriptor");
+                MODELMBEAN_LOGGER.log(Level.TRACE,
+                        "Found target object in descriptor");
 
         /* Now look for the method, either in RequiredModelMBean itself
            or in the target object.  Set "method" and "targetObject"
@@ -1013,9 +949,8 @@
             targetObject = this;
         else {
             if (tracing) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                        mth, "looking for method in managedResource class");
+                MODELMBEAN_LOGGER.log(Level.TRACE,
+                        "looking for method in managedResource class");
             }
             if (targetObjectField != null)
                 targetObject = targetObjectField;
@@ -1071,18 +1006,15 @@
         }
 
         if (tracing) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                RequiredModelMBean.class.getName(),
-                    mth, "found " + opMethodName + ", now invoking");
+            MODELMBEAN_LOGGER.log(Level.TRACE,
+                    "found " + opMethodName + ", now invoking");
         }
 
         final Object result =
             invokeMethod(opName, method, targetObject, opArgs);
 
         if (tracing) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                RequiredModelMBean.class.getName(),
-                    mth, "successfully invoked method");
+            MODELMBEAN_LOGGER.log(Level.TRACE, "successfully invoked method");
         }
 
         if (result != null)
@@ -1095,12 +1027,11 @@
                                         String opMethodName,
                                         final String[] sig)
             throws ReflectionException {
-        final boolean tracing = MODELMBEAN_LOGGER.isLoggable(Level.FINER);
+        final boolean tracing = MODELMBEAN_LOGGER.isLoggable(Level.TRACE);
 
         if (tracing) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                RequiredModelMBean.class.getName(),"resolveMethod",
-                  "resolving " + targetClass.getName() + "." + opMethodName);
+            MODELMBEAN_LOGGER.log(Level.TRACE,
+                    "resolving " + targetClass.getName() + "." + opMethodName);
         }
 
         final Class<?>[] argClasses;
@@ -1119,8 +1050,7 @@
                 public Void run() {
                     for (int i = 0; i < sig.length; i++) {
                         if (tracing) {
-                            MODELMBEAN_LOGGER.logp(Level.FINER,
-                                RequiredModelMBean.class.getName(),"resolveMethod",
+                            MODELMBEAN_LOGGER.log(Level.TRACE,
                                     "resolve type " + sig[i]);
                         }
                         argClasses[i] = (Class<?>) primitiveClassMap.get(sig[i]);
@@ -1131,9 +1061,7 @@
                                     Class.forName(sig[i], false, targetClassLoader);
                             } catch (ClassNotFoundException e) {
                                 if (tracing) {
-                                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                                            RequiredModelMBean.class.getName(),
-                                            "resolveMethod",
+                                    MODELMBEAN_LOGGER.log(Level.TRACE,
                                             "class not found");
                                 }
                                 final String msg = "Parameter class not found";
@@ -1182,12 +1110,10 @@
                                          Object targetObjectField,
                                          String opClassName,
                                          String[] sig) {
-        final boolean tracing = MODELMBEAN_LOGGER.isLoggable(Level.FINER);
+        final boolean tracing = MODELMBEAN_LOGGER.isLoggable(Level.TRACE);
 
         if (tracing) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                RequiredModelMBean.class.getName(),
-                    "invoke(String, Object[], String[])",
+            MODELMBEAN_LOGGER.log(Level.TRACE,
                   "looking for method in RequiredModelMBean class");
         }
 
@@ -1340,10 +1266,8 @@
 
             modelMBeanInfo.setDescriptor(opDescr,
                                          "operation");
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        RequiredModelMBean.class.getName(),
-                        "invoke(String,Object[],Object[])",
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE,
                         "new descriptor is " + opDescr);
             }
         }
@@ -1495,12 +1419,9 @@
                 IllegalArgumentException("attributeName must not be null"),
                 "Exception occurred trying to get attribute of a " +
                 "RequiredModelMBean");
-        final String mth = "getAttribute(String)";
-        final boolean tracing = MODELMBEAN_LOGGER.isLoggable(Level.FINER);
+        final boolean tracing = MODELMBEAN_LOGGER.isLoggable(Level.TRACE);
         if (tracing) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                mth, "Entry with " + attrName);
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry with " + attrName);
         }
 
         /* Check attributeDescriptor for getMethod */
@@ -1530,16 +1451,14 @@
 
                 /* return current cached value */
                 if (tracing) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            RequiredModelMBean.class.getName(), mth,
-                        "*** cached value is " + response);
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
+                            "*** cached value is " + response);
                 }
 
                 if (response == null) {
                     /* no cached value, run getMethod */
                     if (tracing) {
-                        MODELMBEAN_LOGGER.logp(Level.FINER,
-                                RequiredModelMBean.class.getName(), mth,
+                        MODELMBEAN_LOGGER.log(Level.TRACE,
                             "**** cached value is null - getting getMethod");
                     }
                     String attrGetMethod =
@@ -1548,9 +1467,8 @@
                     if (attrGetMethod != null) {
                         /* run method from operations descriptor */
                         if (tracing) {
-                            MODELMBEAN_LOGGER.logp(Level.FINER,
-                                    RequiredModelMBean.class.getName(),
-                                mth, "invoking a getMethod for " +  attrName);
+                            MODELMBEAN_LOGGER.log(Level.TRACE,
+                                "invoking a getMethod for " +  attrName);
                         }
 
                         Object getResponse =
@@ -1560,9 +1478,8 @@
                         if (getResponse != null) {
                             // error/validity check return value here
                             if (tracing) {
-                                MODELMBEAN_LOGGER.logp(Level.FINER,
-                                        RequiredModelMBean.class.getName(),
-                                        mth, "got a non-null response " +
+                                MODELMBEAN_LOGGER.log(Level.TRACE,
+                                        "got a non-null response " +
                                         "from getMethod\n");
                             }
 
@@ -1585,9 +1502,7 @@
 
                             if ((ctl != null) && !(ctl.equals("-1"))) {
                                 if (tracing) {
-                                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                                            RequiredModelMBean.class.getName(),
-                                            mth,
+                                    MODELMBEAN_LOGGER.log(Level.TRACE,
                                             "setting cached value and " +
                                             "lastUpdatedTime in descriptor");
                                 }
@@ -1600,19 +1515,15 @@
                                 modelMBeanInfo.setDescriptor(attrDescr,
                                                              "attribute");
                                 if (tracing) {
-                                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                                            RequiredModelMBean.class.getName(),
-                                        mth,"new descriptor is " +attrDescr);
-                                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                                            RequiredModelMBean.class.getName(),
-                                        mth,"AttributeInfo descriptor is " +
+                                    MODELMBEAN_LOGGER.log(Level.TRACE,
+                                            "new descriptor is " +attrDescr);
+                                    MODELMBEAN_LOGGER.log(Level.TRACE,
+                                            "AttributeInfo descriptor is " +
                                             attrInfo.getDescriptor());
                                     final String attStr = modelMBeanInfo.
                                         getDescriptor(attrName,"attribute").
                                             toString();
-                                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                                            RequiredModelMBean.class.getName(),
-                                            mth,
+                                    MODELMBEAN_LOGGER.log(Level.TRACE,
                                             "modelMBeanInfo: AttributeInfo " +
                                             "descriptor is " + attStr);
                                 }
@@ -1620,8 +1531,7 @@
                         } else {
                             // response was invalid or really returned null
                             if (tracing) {
-                                MODELMBEAN_LOGGER.logp(Level.FINER,
-                                        RequiredModelMBean.class.getName(), mth,
+                                MODELMBEAN_LOGGER.log(Level.TRACE,
                                     "got a null response from getMethod\n");
                             }
                             response = null;
@@ -1635,8 +1545,7 @@
                             response = attrDescr.getFieldValue("default");
                         }
                         if (tracing) {
-                            MODELMBEAN_LOGGER.logp(Level.FINER,
-                                    RequiredModelMBean.class.getName(), mth,
+                            MODELMBEAN_LOGGER.log(Level.TRACE,
                                 "could not find getMethod for " +attrName +
                                 ", returning descriptor " +qualifier + "value");
                         }
@@ -1698,9 +1607,8 @@
                                 subtype = false;
 
                                 if (tracing) {
-                                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                                            RequiredModelMBean.class.getName(),
-                                        mth, "Exception: ",e);
+                                    MODELMBEAN_LOGGER.log(Level.TRACE,
+                                            "Exception: ", e);
                                 }
                             }
                             if (!subtype)
@@ -1708,9 +1616,8 @@
                         }
                         if (wrongType) {
                             if (tracing) {
-                                MODELMBEAN_LOGGER.logp(Level.FINER,
-                                        RequiredModelMBean.class.getName(), mth,
-                                    "Wrong response type '" + respType + "'");
+                                MODELMBEAN_LOGGER.log(Level.TRACE,
+                                     "Wrong response type '" + respType + "'");
                             }
                             // throw exception, didn't get
                             // back right attribute type
@@ -1724,8 +1631,7 @@
                 }
             } else {
                 if (tracing) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            RequiredModelMBean.class.getName(), mth,
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
                             "getMethod failed " + attrName +
                             " not in attributeDescriptor\n");
                 }
@@ -1743,8 +1649,7 @@
             throw t;
         } catch (Exception e) {
             if (tracing) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        RequiredModelMBean.class.getName(), mth,
+                MODELMBEAN_LOGGER.log(Level.TRACE,
                         "getMethod failed with " + e.getMessage() +
                         " exception type " + (e.getClass()).toString());
             }
@@ -1753,8 +1658,7 @@
         }
 
         if (tracing) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(), mth, "Exit");
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
 
         return response;
@@ -1777,10 +1681,9 @@
      * @see #setAttributes(javax.management.AttributeList)
      */
     public AttributeList getAttributes(String[] attrNames)      {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-            "getAttributes(String[])","Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
+                    RequiredModelMBean.class.getName(), "Entry");
         }
 
         if (attrNames == null)
@@ -1797,19 +1700,15 @@
             } catch (Exception e) {
                 // eat exceptions because interface doesn't have an
                 // exception on it
-                if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            RequiredModelMBean.class.getName(),
-                        "getAttributes(String[])",
+                if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
                             "Failed to get \"" + attrNames[i] + "\": ", e);
                 }
             }
         }
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                RequiredModelMBean.class.getName(),
-                    "getAttributes(String[])","Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
 
         return responseList;
@@ -1894,11 +1793,9 @@
     public void setAttribute(Attribute attribute)
         throws AttributeNotFoundException, InvalidAttributeValueException,
                MBeanException, ReflectionException {
-        final boolean tracing = MODELMBEAN_LOGGER.isLoggable(Level.FINER);
+        final boolean tracing = MODELMBEAN_LOGGER.isLoggable(Level.TRACE);
         if (tracing) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                "setAttribute()","Entry");
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         if (attribute == null)
@@ -1958,11 +1855,9 @@
                                             attrValue.getClass().getName() +
                                                            " received.");
                     } catch (ClassNotFoundException x) {
-                        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                            MODELMBEAN_LOGGER.logp(Level.FINER,
-                                    RequiredModelMBean.class.getName(),
-                                "setAttribute(Attribute)","Class " +
-                                    attrType + " for attribute "
+                        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                            MODELMBEAN_LOGGER.log(Level.TRACE,
+                                "Class " + attrType + " for attribute "
                                 + attrName + " not found: ", x);
                         }
                     }
@@ -1996,9 +1891,7 @@
 
             if (updateCache || updateDescriptor) {
                 if (tracing) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                        RequiredModelMBean.class.getName(),
-                            "setAttribute(Attribute)",
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
                             "setting cached value of " +
                             attrName + " to " + attrValue);
                 }
@@ -2022,26 +1915,22 @@
                     .append(attrInfo.getDescriptor())
                     .append(". AttributeInfo descriptor is ")
                     .append(modelMBeanInfo.getDescriptor(attrName,"attribute"));
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            RequiredModelMBean.class.getName(),
-                            "setAttribute(Attribute)",strb.toString());
+                    MODELMBEAN_LOGGER.log(Level.TRACE, strb::toString);
                 }
 
             }
 
             if (tracing) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        RequiredModelMBean.class.getName(),
-                "setAttribute(Attribute)","sending sendAttributeNotification");
+                MODELMBEAN_LOGGER.log(Level.TRACE,
+                        "sending sendAttributeNotification");
             }
             sendAttributeChangeNotification(oldAttr,attribute);
 
         } else { // if descriptor ... else no descriptor
 
             if (tracing) {
-                    MODELMBEAN_LOGGER.logp(Level.FINER,
-                            RequiredModelMBean.class.getName(),
-                        "setAttribute(Attribute)","setMethod failed "+attrName+
+                    MODELMBEAN_LOGGER.log(Level.TRACE,
+                        "setMethod failed " + attrName +
                         " not in attributeDescriptor\n");
             }
 
@@ -2051,9 +1940,7 @@
         } // else no descriptor
 
         if (tracing) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                "setAttribute(Attribute)", "Exit");
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
 
     }
@@ -2076,10 +1963,8 @@
      **/
     public AttributeList setAttributes(AttributeList attributes) {
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                "setAttribute(Attribute)", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         if (attributes == null)
@@ -2118,17 +2003,13 @@
     private synchronized void writeToLog(String logFileName,
                                          String logEntry) throws Exception {
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                "writeToLog(String, String)",
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
                 "Notification Logging to " + logFileName + ": " + logEntry);
         }
         if ((logFileName == null) || (logEntry == null)) {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        RequiredModelMBean.class.getName(),
-                    "writeToLog(String, String)",
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE,
                     "Bad input parameters, will not log this entry.");
             }
             return;
@@ -2139,17 +2020,13 @@
             PrintStream logOut = new PrintStream(fos);
             logOut.println(logEntry);
             logOut.close();
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        RequiredModelMBean.class.getName(),
-                    "writeToLog(String, String)","Successfully opened log " +
-                        logFileName);
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE,
+                    "Successfully opened log " + logFileName);
             }
         } catch (Exception e) {
-            if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                        "writeToLog(String, String)",
+            if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE,
                         "Exception " + e.toString() +
                         " trying to write to the Notification log file " +
                         logFileName);
@@ -2184,11 +2061,8 @@
                                         NotificationFilter filter,
                                         Object handback)
         throws java.lang.IllegalArgumentException {
-        final String mth = "addNotificationListener(" +
-                "NotificationListener, NotificationFilter, Object)";
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        RequiredModelMBean.class.getName(), mth, "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         if (listener == null)
@@ -2200,12 +2074,10 @@
 
         generalBroadcaster.addNotificationListener(listener, filter,
                                                    handback);
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        RequiredModelMBean.class.getName(), mth,
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE,
                     "NotificationListener added");
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                        RequiredModelMBean.class.getName(), mth, "Exit");
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
     }
 
@@ -2227,10 +2099,8 @@
             throw new ListenerNotFoundException(
                       "Notification listener is null");
 
-        final String mth="removeNotificationListener(NotificationListener)";
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-                MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(), mth, "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+                MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         if (generalBroadcaster == null)
@@ -2239,9 +2109,8 @@
 
 
         generalBroadcaster.removeNotificationListener(listener);
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(), mth, "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
 
     }
@@ -2255,12 +2124,8 @@
             throw new ListenerNotFoundException(
                       "Notification listener is null");
 
-        final String mth = "removeNotificationListener(" +
-                "NotificationListener, NotificationFilter, Object)";
-
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(), mth, "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         if (generalBroadcaster == null)
@@ -2271,19 +2136,16 @@
         generalBroadcaster.removeNotificationListener(listener,filter,
                                                       handback);
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(), mth, "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
 
     }
 
     public void sendNotification(Notification ntfyObj)
         throws MBeanException, RuntimeOperationsException {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                "sendNotification(Notification)", "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         if (ntfyObj == null)
@@ -2324,10 +2186,8 @@
                             ntfyObj.getMessage() + " Severity = " +
                             (String)ntfyDesc.getFieldValue("severity"));
                     } catch (Exception e) {
-                        if (MODELMBEAN_LOGGER.isLoggable(Level.FINE)) {
-                            MODELMBEAN_LOGGER.logp(Level.FINE,
-                                    RequiredModelMBean.class.getName(),
-                                    "sendNotification(Notification)",
+                        if (MODELMBEAN_LOGGER.isLoggable(Level.DEBUG)) {
+                            MODELMBEAN_LOGGER.log(Level.DEBUG,
                                     "Failed to log " +
                                     ntfyObj.getType() + " notification: ", e);
                         }
@@ -2339,14 +2199,10 @@
             generalBroadcaster.sendNotification(ntfyObj);
         }
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                RequiredModelMBean.class.getName(),
-                    "sendNotification(Notification)",
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
                     "sendNotification sent provided notification object");
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                RequiredModelMBean.class.getName(),
-                    "sendNotification(Notification)"," Exit");
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
 
     }
@@ -2354,10 +2210,8 @@
 
     public void sendNotification(String ntfyText)
         throws MBeanException, RuntimeOperationsException {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                "sendNotification(String)","Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         if (ntfyText == null)
@@ -2370,13 +2224,9 @@
         Notification myNtfyObj = new Notification("jmx.modelmbean.generic",
                                                   this, 1, ntfyText);
         sendNotification(myNtfyObj);
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                "sendNotification(String)","Notification sent");
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                "sendNotification(String)","Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Notification sent");
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
     }
 
@@ -2456,10 +2306,8 @@
      *
      **/
     public MBeanNotificationInfo[] getNotificationInfo() {
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                "getNotificationInfo()","Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         // Using hasNotification() is not optimal, but shouldn't really
@@ -2518,10 +2366,8 @@
             respInfo[offset+j] = currInfo[j];
         }
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),
-                "getNotificationInfo()","Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
 
         return respInfo;
@@ -2535,12 +2381,8 @@
                                                        Object inhandback)
         throws MBeanException, RuntimeOperationsException,
                IllegalArgumentException {
-        final String mth="addAttributeChangeNotificationListener(" +
-                "NotificationListener, String, Object)";
-
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),mth,"Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         if (inlistener == null)
@@ -2581,24 +2423,21 @@
             }
         }
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
             Vector<String> enabledAttrs = currFilter.getEnabledAttributes();
             String s = (enabledAttrs.size() > 1) ?
                         "[" + enabledAttrs.firstElement() + ", ...]" :
                         enabledAttrs.toString();
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(), mth,
+            MODELMBEAN_LOGGER.log(Level.TRACE,
                 "Set attribute change filter to " + s);
         }
 
         attributeBroadcaster.addNotificationListener(inlistener,currFilter,
                                                      inhandback);
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),mth,
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
                     "Notification listener added for " + inAttributeName);
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),mth,"Exit");
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
     }
 
@@ -2609,12 +2448,9 @@
         if (inlistener == null) throw new
             ListenerNotFoundException("Notification listener is null");
 
-        final String mth = "removeAttributeChangeNotificationListener(" +
-                "NotificationListener, String)";
-
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),mth,"Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
+                    RequiredModelMBean.class.getName(), "Entry");
         }
 
 
@@ -2648,21 +2484,17 @@
 
         attributeBroadcaster.removeNotificationListener(inlistener);
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),mth,"Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
     }
 
     public void sendAttributeChangeNotification(AttributeChangeNotification
                                                 ntfyObj)
         throws MBeanException, RuntimeOperationsException {
-        final String mth = "sendAttributeChangeNotification(" +
-                "AttributeChangeNotification)";
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),mth,"Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         if (ntfyObj == null)
@@ -2678,9 +2510,8 @@
         if (oldv == null) oldv = "null";
         if (newv == null) newv = "null";
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),mth,
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE,
                 "Sending AttributeChangeNotification with " +
                 ntfyObj.getAttributeName() + ntfyObj.getAttributeType() +
                 ntfyObj.getNewValue() + ntfyObj.getOldValue());
@@ -2718,9 +2549,8 @@
                            " Old value = " + oldv +
                            " New value = " + newv);
                     } catch (Exception e) {
-                        if (MODELMBEAN_LOGGER.isLoggable(Level.FINE)) {
-                            MODELMBEAN_LOGGER.logp(Level.FINE,
-                                    RequiredModelMBean.class.getName(),mth,
+                        if (MODELMBEAN_LOGGER.isLoggable(Level.DEBUG)) {
+                            MODELMBEAN_LOGGER.log(Level.DEBUG,
                                 "Failed to log " + ntfyObj.getType() +
                                     " notification: ", e);
                         }
@@ -2744,9 +2574,8 @@
                            " Old value = " + oldv +
                            " New value = " + newv);
                     } catch (Exception e) {
-                        if (MODELMBEAN_LOGGER.isLoggable(Level.FINE)) {
-                            MODELMBEAN_LOGGER.logp(Level.FINE,
-                                    RequiredModelMBean.class.getName(),mth,
+                        if (MODELMBEAN_LOGGER.isLoggable(Level.DEBUG)) {
+                            MODELMBEAN_LOGGER.log(Level.DEBUG,
                                 "Failed to log " + ntfyObj.getType() +
                                     " notification: ", e);
                         }
@@ -2768,25 +2597,17 @@
             generalBroadcaster.sendNotification(ntfyObj);
         }
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),mth,
-                "sent notification");
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),mth,
-                "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "sent notification");
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
     }
 
     public void sendAttributeChangeNotification(Attribute inOldVal,
                                                 Attribute inNewVal)
         throws MBeanException, RuntimeOperationsException {
-        final String mth =
-            "sendAttributeChangeNotification(Attribute, Attribute)";
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),mth,
-                "Entry");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Entry");
         }
 
         // do we really want to do this?
@@ -2824,10 +2645,8 @@
 
         sendAttributeChangeNotification(myNtfyObj);
 
-        if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
-            MODELMBEAN_LOGGER.logp(Level.FINER,
-                    RequiredModelMBean.class.getName(),mth,
-                "Exit");
+        if (MODELMBEAN_LOGGER.isLoggable(Level.TRACE)) {
+            MODELMBEAN_LOGGER.log(Level.TRACE, "Exit");
         }
 
     }
--- a/jdk/src/java.management/share/classes/javax/management/monitor/CounterMonitor.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/monitor/CounterMonitor.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2008, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -26,7 +26,7 @@
 package javax.management.monitor;
 
 import static com.sun.jmx.defaults.JmxProperties.MONITOR_LOGGER;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 import javax.management.ObjectName;
 import javax.management.MBeanNotificationInfo;
 import static javax.management.monitor.Monitor.NumericalType.*;
@@ -228,8 +228,7 @@
      */
     public synchronized void start() {
         if (isActive()) {
-            MONITOR_LOGGER.logp(Level.FINER, CounterMonitor.class.getName(),
-                    "start", "the monitor is already active");
+            MONITOR_LOGGER.log(Level.TRACE, "the monitor is already active");
             return;
         }
         // Reset values.
@@ -696,7 +695,7 @@
                 }
             }
         } else {
-            if (MONITOR_LOGGER.isLoggable(Level.FINER)) {
+            if (MONITOR_LOGGER.isLoggable(Level.TRACE)) {
                 final StringBuilder strb = new StringBuilder()
                 .append("The notification:")
                 .append("\n\tNotification observed object = ")
@@ -708,8 +707,7 @@
                 .append("\n\tNotification derived gauge = ")
                 .append(o.getDerivedGauge())
                 .append("\nhas already been sent");
-                MONITOR_LOGGER.logp(Level.FINER, CounterMonitor.class.getName(),
-                        "updateNotifications", strb.toString());
+                MONITOR_LOGGER.log(Level.TRACE, strb::toString);
             }
         }
 
@@ -756,9 +754,7 @@
                         break;
                     default:
                         // Should never occur...
-                        MONITOR_LOGGER.logp(Level.FINEST,
-                                CounterMonitor.class.getName(),
-                                "updateThreshold",
+                        MONITOR_LOGGER.log(Level.TRACE,
                                 "the threshold type is invalid");
                         break;
                 }
@@ -819,8 +815,7 @@
         case LONG: o.setDerivedGauge(Long.valueOf(derived)); break;
         default:
             // Should never occur...
-            MONITOR_LOGGER.logp(Level.FINEST, CounterMonitor.class.getName(),
-                    "setDerivedGaugeWithDifference",
+            MONITOR_LOGGER.log(Level.TRACE,
                     "the threshold type is invalid");
             break;
         }
--- a/jdk/src/java.management/share/classes/javax/management/monitor/GaugeMonitor.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/monitor/GaugeMonitor.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2008, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -26,7 +26,7 @@
 package javax.management.monitor;
 
 import static com.sun.jmx.defaults.JmxProperties.MONITOR_LOGGER;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 import javax.management.MBeanNotificationInfo;
 import javax.management.ObjectName;
 import static javax.management.monitor.Monitor.NumericalType.*;
@@ -224,8 +224,7 @@
      */
     public synchronized void start() {
         if (isActive()) {
-            MONITOR_LOGGER.logp(Level.FINER, GaugeMonitor.class.getName(),
-                    "start", "the monitor is already active");
+            MONITOR_LOGGER.log(Level.TRACE, "the monitor is already active");
             return;
         }
         // Reset values.
@@ -664,8 +663,7 @@
             break;
         default:
             // Should never occur...
-            MONITOR_LOGGER.logp(Level.FINEST, GaugeMonitor.class.getName(),
-                    "setDerivedGaugeWithDifference",
+            MONITOR_LOGGER.log(Level.TRACE,
                     "the threshold type is invalid");
             return;
         }
@@ -698,8 +696,7 @@
             return (greater.doubleValue() >= less.doubleValue());
         default:
             // Should never occur...
-            MONITOR_LOGGER.logp(Level.FINEST, GaugeMonitor.class.getName(),
-                    "isFirstGreaterThanLast",
+            MONITOR_LOGGER.log(Level.TRACE,
                     "the threshold type is invalid");
             return false;
         }
@@ -733,8 +730,7 @@
         }
         else {
             // Should never occur...
-            MONITOR_LOGGER.logp(Level.FINEST, GaugeMonitor.class.getName(),
-                    "isFirstStrictlyGreaterThanLast",
+            MONITOR_LOGGER.log(Level.TRACE,
                     "the threshold type is invalid");
             return false;
         }
--- a/jdk/src/java.management/share/classes/javax/management/monitor/Monitor.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/monitor/Monitor.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -47,7 +47,7 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 import javax.management.AttributeNotFoundException;
 import javax.management.InstanceNotFoundException;
 import javax.management.IntrospectionException;
@@ -205,13 +205,11 @@
             try {
                 maximumPoolSizeTmp = Integer.parseInt(maximumPoolSizeStr);
             } catch (NumberFormatException e) {
-                if (MONITOR_LOGGER.isLoggable(Level.FINER)) {
-                    MONITOR_LOGGER.logp(Level.FINER, Monitor.class.getName(),
-                            "<static initializer>",
+                if (MONITOR_LOGGER.isLoggable(Level.TRACE)) {
+                    MONITOR_LOGGER.log(Level.TRACE,
                             "Wrong value for " + maximumPoolSizeSysProp +
                             " system property", e);
-                    MONITOR_LOGGER.logp(Level.FINER, Monitor.class.getName(),
-                            "<static initializer>",
+                    MONITOR_LOGGER.log(Level.TRACE,
                             maximumPoolSizeSysProp + " defaults to 10");
                 }
                 maximumPoolSizeTmp = 10;
@@ -391,8 +389,7 @@
     public ObjectName preRegister(MBeanServer server, ObjectName name)
         throws Exception {
 
-        MONITOR_LOGGER.logp(Level.FINER, Monitor.class.getName(),
-                "preRegister(MBeanServer, ObjectName)",
+        MONITOR_LOGGER.log(Level.TRACE,
                 "initialize the reference on the MBean server");
 
         this.server = server;
@@ -419,8 +416,7 @@
      */
     public void preDeregister() throws Exception {
 
-        MONITOR_LOGGER.logp(Level.FINER, Monitor.class.getName(),
-                "preDeregister()", "stop the monitor");
+        MONITOR_LOGGER.log(Level.TRACE, "stop the monitor");
 
         // Stop the Monitor.
         //
@@ -693,13 +689,11 @@
      * Starts the monitor.
      */
     void doStart() {
-            MONITOR_LOGGER.logp(Level.FINER, Monitor.class.getName(),
-                "doStart()", "start the monitor");
+            MONITOR_LOGGER.log(Level.TRACE, "start the monitor");
 
         synchronized (this) {
             if (isActive()) {
-                MONITOR_LOGGER.logp(Level.FINER, Monitor.class.getName(),
-                        "doStart()", "the monitor is already active");
+                MONITOR_LOGGER.log(Level.TRACE, "the monitor is already active");
                 return;
             }
 
@@ -729,13 +723,11 @@
      * Stops the monitor.
      */
     void doStop() {
-        MONITOR_LOGGER.logp(Level.FINER, Monitor.class.getName(),
-                "doStop()", "stop the monitor");
+        MONITOR_LOGGER.log(Level.TRACE, "stop the monitor");
 
         synchronized (this) {
             if (!isActive()) {
-                MONITOR_LOGGER.logp(Level.FINER, Monitor.class.getName(),
-                        "doStop()", "the monitor is not active");
+                MONITOR_LOGGER.log(Level.TRACE, "the monitor is not active");
                 return;
             }
 
@@ -1089,9 +1081,8 @@
         if (!isActive())
             return;
 
-        if (MONITOR_LOGGER.isLoggable(Level.FINER)) {
-            MONITOR_LOGGER.logp(Level.FINER, Monitor.class.getName(),
-                    "sendNotification", "send notification: " +
+        if (MONITOR_LOGGER.isLoggable(Level.TRACE)) {
+            MONITOR_LOGGER.log(Level.TRACE, "send notification: " +
                     "\n\tNotification observed object = " + object +
                     "\n\tNotification observed attribute = " + observedAttribute +
                     "\n\tNotification derived gauge = " + derGauge);
@@ -1163,8 +1154,7 @@
                     setAlreadyNotified(
                         o, index, OBSERVED_ATTRIBUTE_TYPE_ERROR_NOTIFIED, an);
                     msg = "The observed attribute value is null.";
-                    MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
-                            "monitor", msg);
+                    MONITOR_LOGGER.log(Level.TRACE, msg);
                 }
         } catch (NullPointerException np_ex) {
             if (isAlreadyNotified(o, RUNTIME_ERROR_NOTIFIED))
@@ -1176,10 +1166,8 @@
                     "The monitor must be registered in the MBean " +
                     "server or an MBeanServerConnection must be " +
                     "explicitly supplied.";
-                MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
-                        "monitor", msg);
-                MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
-                        "monitor", np_ex.toString());
+                MONITOR_LOGGER.log(Level.TRACE, msg);
+                MONITOR_LOGGER.log(Level.TRACE, np_ex::toString);
             }
         } catch (InstanceNotFoundException inf_ex) {
             if (isAlreadyNotified(o, OBSERVED_OBJECT_ERROR_NOTIFIED))
@@ -1191,10 +1179,8 @@
                 msg =
                     "The observed object must be accessible in " +
                     "the MBeanServerConnection.";
-                MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
-                        "monitor", msg);
-                MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
-                        "monitor", inf_ex.toString());
+                MONITOR_LOGGER.log(Level.TRACE, msg);
+                MONITOR_LOGGER.log(Level.TRACE, inf_ex::toString);
             }
         } catch (AttributeNotFoundException anf_ex) {
             if (isAlreadyNotified(o, OBSERVED_ATTRIBUTE_ERROR_NOTIFIED))
@@ -1206,10 +1192,8 @@
                 msg =
                     "The observed attribute must be accessible in " +
                     "the observed object.";
-                MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
-                        "monitor", msg);
-                MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
-                        "monitor", anf_ex.toString());
+                MONITOR_LOGGER.log(Level.TRACE, msg);
+                MONITOR_LOGGER.log(Level.TRACE, anf_ex::toString);
             }
         } catch (MBeanException mb_ex) {
             if (isAlreadyNotified(o, RUNTIME_ERROR_NOTIFIED))
@@ -1218,10 +1202,8 @@
                 notifType = RUNTIME_ERROR;
                 setAlreadyNotified(o, index, RUNTIME_ERROR_NOTIFIED, an);
                 msg = mb_ex.getMessage() == null ? "" : mb_ex.getMessage();
-                MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
-                        "monitor", msg);
-                MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
-                        "monitor", mb_ex.toString());
+                MONITOR_LOGGER.log(Level.TRACE, msg);
+                MONITOR_LOGGER.log(Level.TRACE, mb_ex::toString);
             }
         } catch (ReflectionException ref_ex) {
             if (isAlreadyNotified(o, RUNTIME_ERROR_NOTIFIED)) {
@@ -1230,10 +1212,8 @@
                 notifType = RUNTIME_ERROR;
                 setAlreadyNotified(o, index, RUNTIME_ERROR_NOTIFIED, an);
                 msg = ref_ex.getMessage() == null ? "" : ref_ex.getMessage();
-                MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
-                        "monitor", msg);
-                MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
-                        "monitor", ref_ex.toString());
+                MONITOR_LOGGER.log(Level.TRACE, msg);
+                MONITOR_LOGGER.log(Level.TRACE, ref_ex::toString);
             }
         } catch (IOException io_ex) {
             if (isAlreadyNotified(o, RUNTIME_ERROR_NOTIFIED))
@@ -1242,10 +1222,8 @@
                 notifType = RUNTIME_ERROR;
                 setAlreadyNotified(o, index, RUNTIME_ERROR_NOTIFIED, an);
                 msg = io_ex.getMessage() == null ? "" : io_ex.getMessage();
-                MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
-                        "monitor", msg);
-                MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
-                        "monitor", io_ex.toString());
+                MONITOR_LOGGER.log(Level.TRACE, msg);
+                MONITOR_LOGGER.log(Level.TRACE, io_ex::toString);
             }
         } catch (RuntimeException rt_ex) {
             if (isAlreadyNotified(o, RUNTIME_ERROR_NOTIFIED))
@@ -1254,10 +1232,8 @@
                 notifType = RUNTIME_ERROR;
                 setAlreadyNotified(o, index, RUNTIME_ERROR_NOTIFIED, an);
                 msg = rt_ex.getMessage() == null ? "" : rt_ex.getMessage();
-                MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
-                        "monitor", msg);
-                MONITOR_LOGGER.logp(Level.FINEST, Monitor.class.getName(),
-                        "monitor", rt_ex.toString());
+                MONITOR_LOGGER.log(Level.TRACE, msg);
+                MONITOR_LOGGER.log(Level.TRACE, rt_ex::toString);
             }
         }
 
@@ -1297,10 +1273,8 @@
                         msg =
                             "The observed attribute value does not " +
                             "implement the Comparable interface.";
-                        MONITOR_LOGGER.logp(Level.FINEST,
-                                Monitor.class.getName(), "monitor", msg);
-                        MONITOR_LOGGER.logp(Level.FINEST,
-                                Monitor.class.getName(), "monitor", e.toString());
+                        MONITOR_LOGGER.log(Level.TRACE, msg);
+                        MONITOR_LOGGER.log(Level.TRACE, e::toString);
                     }
                 } catch (AttributeNotFoundException e) {
                     if (isAlreadyNotified(o, OBSERVED_ATTRIBUTE_ERROR_NOTIFIED))
@@ -1312,10 +1286,8 @@
                         msg =
                             "The observed attribute must be accessible in " +
                             "the observed object.";
-                        MONITOR_LOGGER.logp(Level.FINEST,
-                                Monitor.class.getName(), "monitor", msg);
-                        MONITOR_LOGGER.logp(Level.FINEST,
-                                Monitor.class.getName(), "monitor", e.toString());
+                        MONITOR_LOGGER.log(Level.TRACE, msg);
+                        MONITOR_LOGGER.log(Level.TRACE, e::toString);
                     }
                 } catch (RuntimeException e) {
                     if (isAlreadyNotified(o, RUNTIME_ERROR_NOTIFIED))
@@ -1325,10 +1297,8 @@
                         setAlreadyNotified(o, index,
                             RUNTIME_ERROR_NOTIFIED, an);
                         msg = e.getMessage() == null ? "" : e.getMessage();
-                        MONITOR_LOGGER.logp(Level.FINEST,
-                                Monitor.class.getName(), "monitor", msg);
-                        MONITOR_LOGGER.logp(Level.FINEST,
-                                Monitor.class.getName(), "monitor", e.toString());
+                        MONITOR_LOGGER.log(Level.TRACE, msg);
+                        MONITOR_LOGGER.log(Level.TRACE, e::toString);
                     }
                 }
             }
@@ -1346,8 +1316,7 @@
                         setAlreadyNotified(o, index,
                             OBSERVED_ATTRIBUTE_TYPE_ERROR_NOTIFIED, an);
                         msg = "The observed attribute type is not valid.";
-                        MONITOR_LOGGER.logp(Level.FINEST,
-                                Monitor.class.getName(), "monitor", msg);
+                        MONITOR_LOGGER.log(Level.TRACE, msg);
                     }
                 }
             }
@@ -1363,8 +1332,7 @@
                         setAlreadyNotified(o, index,
                             THRESHOLD_ERROR_NOTIFIED, an);
                         msg = "The threshold type is not valid.";
-                        MONITOR_LOGGER.logp(Level.FINEST,
-                                Monitor.class.getName(), "monitor", msg);
+                        MONITOR_LOGGER.log(Level.TRACE, msg);
                     }
                 }
             }
@@ -1381,8 +1349,7 @@
                         notifType = RUNTIME_ERROR;
                         setAlreadyNotified(o, index,
                             RUNTIME_ERROR_NOTIFIED, an);
-                        MONITOR_LOGGER.logp(Level.FINEST,
-                                Monitor.class.getName(), "monitor", msg);
+                        MONITOR_LOGGER.log(Level.TRACE, msg);
                     }
                 }
             }
--- a/jdk/src/java.management/share/classes/javax/management/monitor/StringMonitor.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/monitor/StringMonitor.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2007, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -26,7 +26,7 @@
 package javax.management.monitor;
 
 import static com.sun.jmx.defaults.JmxProperties.MONITOR_LOGGER;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 import javax.management.ObjectName;
 import javax.management.MBeanNotificationInfo;
 import static javax.management.monitor.MonitorNotification.*;
@@ -151,8 +151,7 @@
      */
     public synchronized void start() {
         if (isActive()) {
-            MONITOR_LOGGER.logp(Level.FINER, StringMonitor.class.getName(),
-                    "start", "the monitor is already active");
+            MONITOR_LOGGER.log(Level.TRACE, "the monitor is already active");
             return;
         }
         // Reset values.
--- a/jdk/src/java.management/share/classes/javax/management/relation/MBeanServerNotificationFilter.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/relation/MBeanServerNotificationFilter.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2008, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -45,7 +45,7 @@
 import javax.management.ObjectName;
 
 import java.util.List;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 import java.util.Vector;
 
 /**
@@ -160,14 +160,12 @@
     public MBeanServerNotificationFilter() {
 
         super();
-        RELATION_LOGGER.entering(MBeanServerNotificationFilter.class.getName(),
-                "MBeanServerNotificationFilter");
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY");
 
         enableType(MBeanServerNotification.REGISTRATION_NOTIFICATION);
         enableType(MBeanServerNotification.UNREGISTRATION_NOTIFICATION);
 
-        RELATION_LOGGER.exiting(MBeanServerNotificationFilter.class.getName(),
-                "MBeanServerNotificationFilter");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -181,14 +179,12 @@
      */
     public synchronized void disableAllObjectNames() {
 
-        RELATION_LOGGER.entering(MBeanServerNotificationFilter.class.getName(),
-                "disableAllObjectNames");
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY");
 
         selectedNames = new Vector<ObjectName>();
         deselectedNames = null;
 
-        RELATION_LOGGER.exiting(MBeanServerNotificationFilter.class.getName(),
-                "disableAllObjectNames");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -207,8 +203,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(MBeanServerNotificationFilter.class.getName(),
-                "disableObjectName", objectName);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}" + objectName);
 
         // Removes from selected ObjectNames, if present
         if (selectedNames != null) {
@@ -226,8 +221,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(MBeanServerNotificationFilter.class.getName(),
-                "disableObjectName");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -236,14 +230,12 @@
      */
     public synchronized void enableAllObjectNames() {
 
-        RELATION_LOGGER.entering(MBeanServerNotificationFilter.class.getName(),
-                "enableAllObjectNames");
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY");
 
         selectedNames = null;
         deselectedNames = new Vector<ObjectName>();
 
-        RELATION_LOGGER.exiting(MBeanServerNotificationFilter.class.getName(),
-                "enableAllObjectNames");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -262,8 +254,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(MBeanServerNotificationFilter.class.getName(),
-                "enableObjectName", objectName);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", objectName);
 
         // Removes from deselected ObjectNames, if present
         if (deselectedNames != null) {
@@ -281,8 +272,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(MBeanServerNotificationFilter.class.getName(),
-                "enableObjectName");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -349,16 +339,13 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(MBeanServerNotificationFilter.class.getName(),
-                "isNotificationEnabled", notif);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", notif);
 
         // Checks the type first
         String ntfType = notif.getType();
         Vector<String> enabledTypes = getEnabledTypes();
         if (!(enabledTypes.contains(ntfType))) {
-            RELATION_LOGGER.logp(Level.FINER,
-                    MBeanServerNotificationFilter.class.getName(),
-                    "isNotificationEnabled",
+            RELATION_LOGGER.log(Level.TRACE,
                     "Type not selected, exiting");
             return false;
         }
@@ -375,9 +362,7 @@
             // checks for explicit selection
             if (selectedNames.size() == 0) {
                 // All are explicitly not selected
-                RELATION_LOGGER.logp(Level.FINER,
-                        MBeanServerNotificationFilter.class.getName(),
-                        "isNotificationEnabled",
+                RELATION_LOGGER.log(Level.TRACE,
                         "No ObjectNames selected, exiting");
                 return false;
             }
@@ -385,9 +370,7 @@
             isSelectedFlg = selectedNames.contains(objName);
             if (!isSelectedFlg) {
                 // Not in the explicit selected list
-                RELATION_LOGGER.logp(Level.FINER,
-                        MBeanServerNotificationFilter.class.getName(),
-                        "isNotificationEnabled",
+                RELATION_LOGGER.log(Level.TRACE,
                         "ObjectName not in selected list, exiting");
                 return false;
             }
@@ -399,26 +382,20 @@
             if (deselectedNames == null) {
                 // All are implicitly deselected and it is not explicitly
                 // selected
-                RELATION_LOGGER.logp(Level.FINER,
-                        MBeanServerNotificationFilter.class.getName(),
-                        "isNotificationEnabled",
+                RELATION_LOGGER.log(Level.TRACE,
                         "ObjectName not selected, and all " +
                         "names deselected, exiting");
                 return false;
 
             } else if (deselectedNames.contains(objName)) {
                 // Explicitly deselected
-                RELATION_LOGGER.logp(Level.FINER,
-                        MBeanServerNotificationFilter.class.getName(),
-                        "isNotificationEnabled",
+                RELATION_LOGGER.log(Level.TRACE,
                         "ObjectName explicitly not selected, exiting");
                 return false;
             }
         }
 
-        RELATION_LOGGER.logp(Level.FINER,
-                MBeanServerNotificationFilter.class.getName(),
-                "isNotificationEnabled",
+        RELATION_LOGGER.log(Level.TRACE,
                 "ObjectName selected, exiting");
         return true;
     }
--- a/jdk/src/java.management/share/classes/javax/management/relation/RelationService.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/relation/RelationService.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -36,7 +36,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicLong;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 
 import javax.management.Attribute;
 import javax.management.AttributeNotFoundException;
@@ -157,13 +157,11 @@
      */
     public RelationService(boolean immediatePurgeFlag) {
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "RelationService");
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY");
 
         setPurgeFlag(immediatePurgeFlag);
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "RelationService");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -286,8 +284,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "createRelationType", relationTypeName);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationTypeName);
 
         // Can throw an InvalidRelationTypeException
         RelationType relType =
@@ -295,8 +292,7 @@
 
         addRelationTypeInt(relType);
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "createRelationType");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -325,8 +321,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "addRelationType");
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY");
 
         // Checks the role infos
         List<RoleInfo> roleInfoList = relationTypeObj.getRoleInfos();
@@ -346,8 +341,7 @@
 
         addRelationTypeInt(relationTypeObj);
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "addRelationType");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
      }
 
@@ -385,14 +379,12 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "getRoleInfos", relationTypeName);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationTypeName);
 
         // Can throw a RelationTypeNotFoundException
         RelationType relType = getRelationType(relationTypeName);
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "getRoleInfos");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return relType.getRoleInfos();
     }
 
@@ -421,8 +413,8 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "getRoleInfo", new Object[] {relationTypeName, roleInfoName});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1}",
+                            relationTypeName, roleInfoName);
 
         // Can throw a RelationTypeNotFoundException
         RelationType relType = getRelationType(relationTypeName);
@@ -430,8 +422,7 @@
         // Can throw a RoleInfoNotFoundException
         RoleInfo roleInfo = relType.getRoleInfo(roleInfoName);
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "getRoleInfo");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return roleInfo;
     }
 
@@ -461,8 +452,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "removeRelationType", relationTypeName);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationTypeName);
 
         // Checks if the relation type to be removed exists
         // Can throw a RelationTypeNotFoundException
@@ -504,8 +494,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "removeRelationType");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -566,9 +555,8 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "createRelation",
-                new Object[] {relationId, relationTypeName, roleList});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2}",
+                            relationId, relationTypeName, roleList);
 
         // Creates RelationSupport object
         // Can throw InvalidRoleValueException
@@ -588,8 +576,7 @@
                        relationId,
                        relationTypeName,
                        roleList);
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "createRelation");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -654,8 +641,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "addRelation", relationObjectName);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationObjectName);
 
         // Can throw RelationServiceNotRegisteredException
         isActive();
@@ -791,8 +777,7 @@
         newRefList.add(relationObjectName);
         updateUnregistrationListener(newRefList, null);
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "addRelation");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -819,8 +804,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "isRelationMBean", relationId);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationId);
 
         // Can throw RelationNotFoundException
         Object result = getRelation(relationId);
@@ -850,8 +834,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "isRelation", objectName);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", objectName);
 
         String result = null;
         synchronized(myRelMBeanObjName2RelIdMap) {
@@ -881,8 +864,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "hasRelation", relationId);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationId);
 
         try {
             // Can throw RelationNotFoundException
@@ -933,8 +915,8 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "checkRoleReading", new Object[] {roleName, relationTypeName});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1}",
+                            roleName, relationTypeName);
 
         Integer result;
 
@@ -956,8 +938,7 @@
             result = Integer.valueOf(RoleStatus.NO_ROLE_WITH_NAME);
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "checkRoleReading");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -995,9 +976,8 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "checkRoleWriting",
-                new Object[] {role, relationTypeName, initFlag});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2}",
+                            role, relationTypeName, initFlag);
 
         // Can throw a RelationTypeNotFoundException
         RelationType relType = getRelationType(relationTypeName);
@@ -1013,8 +993,7 @@
         try {
             roleInfo = relType.getRoleInfo(roleName);
         } catch (RoleInfoNotFoundException exc) {
-            RELATION_LOGGER.exiting(RelationService.class.getName(),
-                    "checkRoleWriting");
+            RELATION_LOGGER.log(Level.TRACE, "RETURN");
             return Integer.valueOf(RoleStatus.NO_ROLE_WITH_NAME);
         }
 
@@ -1024,8 +1003,7 @@
                                       roleInfo,
                                       writeChkFlag);
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "checkRoleWriting");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -1055,8 +1033,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "sendRelationCreationNotification", relationId);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationId);
 
         // Message
         StringBuilder ntfMsg = new StringBuilder("Creation of relation ");
@@ -1071,8 +1048,7 @@
                             null,
                             null);
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "sendRelationCreationNotification");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -1114,9 +1090,8 @@
         if (!(oldValue instanceof ArrayList<?>))
             oldValue = new ArrayList<ObjectName>(oldValue);
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "sendRoleUpdateNotification",
-                new Object[] {relationId, newRole, oldValue});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2}",
+                            relationId, newRole, oldValue);
 
         String roleName = newRole.getRoleName();
         List<ObjectName> newRoleVal = newRole.getRoleValue();
@@ -1140,8 +1115,7 @@
                             newRoleVal,
                             oldValue);
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "sendRoleUpdateNotification");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
     }
 
     /**
@@ -1172,9 +1146,8 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "sendRelationRemovalNotification",
-                new Object[] {relationId, unregMBeanList});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1}",
+                            relationId, unregMBeanList);
 
         // Can throw RelationNotFoundException
         sendNotificationInt(3,
@@ -1186,8 +1159,7 @@
                             null);
 
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "sendRelationRemovalNotification");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -1226,8 +1198,8 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "updateRoleMap", new Object[] {relationId, newRole, oldValue});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2}",
+                            relationId, newRole, oldValue);
 
         // Can throw RelationServiceNotRegisteredException
         isActive();
@@ -1303,8 +1275,7 @@
         // all ObjectNames of interest
         updateUnregistrationListener(newRefList, obsRefList);
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "updateRoleMap");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -1338,8 +1309,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "removeRelation", relationId);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationId);
 
         // Checks there is a relation with this id
         // Can throw RelationNotFoundException
@@ -1442,8 +1412,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "removeRelation");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -1476,8 +1445,7 @@
     public void purgeRelations()
         throws RelationServiceNotRegisteredException {
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "purgeRelations");
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY");
 
         // Can throw RelationServiceNotRegisteredException
         isActive();
@@ -1574,8 +1542,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "purgeRelations");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -1610,9 +1577,8 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "findReferencingRelations",
-                new Object[] {mbeanName, relationTypeName, roleName});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2}",
+                            mbeanName, relationTypeName, roleName);
 
         Map<String,List<String>> result = new HashMap<String,List<String>>();
 
@@ -1684,8 +1650,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "findReferencingRelations");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -1720,9 +1685,8 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "findAssociatedMBeans",
-                new Object[] {mbeanName, relationTypeName, roleName});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2}",
+                            mbeanName, relationTypeName, roleName);
 
         // Retrieves the map <relation id> -> <role names> for those
         // criterias
@@ -1769,8 +1733,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "findAssociatedMBeans");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -1794,8 +1757,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "findRelationsOfType");
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY");
 
         // Can throw RelationTypeNotFoundException
         RelationType relType = getRelationType(relationTypeName);
@@ -1809,8 +1771,7 @@
                 result = new ArrayList<String>(result1);
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "findRelationsOfType");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -1845,8 +1806,8 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "getRole", new Object[] {relationId, roleName});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1}",
+                            relationId, roleName);
 
         // Can throw RelationServiceNotRegisteredException
         isActive();
@@ -1899,7 +1860,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(), "getRole");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -1931,8 +1892,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "getRoles", relationId);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationId);
 
         // Can throw RelationServiceNotRegisteredException
         isActive();
@@ -1976,7 +1936,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(), "getRoles");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -2004,8 +1964,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "getRoles", relationId);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationId);
 
         // Can throw a RelationNotFoundException
         Object relObj = getRelation(relationId);
@@ -2028,7 +1987,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(), "getRoles");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -2055,8 +2014,8 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "getRoleCardinality", new Object[] {relationId, roleName});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1}",
+                            relationId, roleName);
 
         // Can throw a RelationNotFoundException
         Object relObj = getRelation(relationId);
@@ -2098,8 +2057,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "getRoleCardinality");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -2147,8 +2105,8 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "setRole", new Object[] {relationId, role});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1}",
+                            relationId, role);
 
         // Can throw RelationServiceNotRegisteredException
         isActive();
@@ -2211,7 +2169,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(), "setRole");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -2247,8 +2205,8 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "setRoles", new Object[] {relationId, roleList});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1}",
+                            relationId, roleList);
 
         // Can throw RelationServiceNotRegisteredException
         isActive();
@@ -2296,7 +2254,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(), "setRoles");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -2322,8 +2280,8 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "getReferencedMBeans", relationId);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}",
+                            relationId);
 
         // Can throw a RelationNotFoundException
         Object relObj = getRelation(relationId);
@@ -2346,8 +2304,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "getReferencedMBeans");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -2371,8 +2328,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "getRelationTypeName", relationId);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationId);
 
         // Can throw a RelationNotFoundException
         Object relObj = getRelation(relationId);
@@ -2395,8 +2351,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "getRelationTypeName");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -2421,8 +2376,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "handleNotification", notif);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", notif);
 
         if (notif instanceof MBeanServerNotification) {
 
@@ -2480,8 +2434,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "handleNotification");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -2495,8 +2448,7 @@
      */
     public MBeanNotificationInfo[] getNotificationInfo() {
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "getNotificationInfo");
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY");
 
         String ntfClass = "javax.management.relation.RelationNotification";
 
@@ -2514,8 +2466,7 @@
         MBeanNotificationInfo ntfInfo =
             new MBeanNotificationInfo(ntfTypes, ntfClass, ntfDesc);
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "getNotificationInfo");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return new MBeanNotificationInfo[] {ntfInfo};
     }
 
@@ -2539,8 +2490,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "addRelationTypeInt");
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY");
 
         String relTypeName = relationTypeObj.getRelationTypeName();
 
@@ -2570,8 +2520,7 @@
             ((RelationTypeSupport)relationTypeObj).setRelationServiceFlag(true);
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "addRelationTypeInt");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
      }
 
@@ -2595,8 +2544,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "getRelationType", relationTypeName);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationTypeName);
 
         // No null relation type accepted, so can use get()
         RelationType relType;
@@ -2611,8 +2559,7 @@
             throw new RelationTypeNotFoundException(excMsgStrB.toString());
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "getRelationType");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return relType;
     }
 
@@ -2639,8 +2586,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "getRelation", relationId);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationId);
 
         // No null relation  accepted, so can use get()
         Object rel;
@@ -2653,8 +2599,7 @@
             throw new RelationNotFoundException(excMsg);
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "getRelation");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return rel;
     }
 
@@ -2684,9 +2629,8 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "addNewMBeanReference",
-                new Object[] {objectName, relationId, roleName});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2}",
+                            objectName, relationId, roleName);
 
         boolean isNewFlag = false;
 
@@ -2739,8 +2683,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "addNewMBeanReference");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return isNewFlag;
     }
 
@@ -2772,9 +2715,8 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "removeMBeanReference",
-                new Object[] {objectName, relationId, roleName, allRolesFlag});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3}",
+                            objectName, relationId, roleName, allRolesFlag);
 
         boolean noLongerRefFlag = false;
 
@@ -2790,8 +2732,7 @@
 
             if (mbeanRefMap == null) {
                 // The MBean is no longer referenced
-                RELATION_LOGGER.exiting(RelationService.class.getName(),
-                        "removeMBeanReference");
+                RELATION_LOGGER.log(Level.TRACE, "RETURN");
                 return true;
             }
 
@@ -2824,8 +2765,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "removeMBeanReference");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return noLongerRefFlag;
     }
 
@@ -2850,9 +2790,8 @@
             }
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "updateUnregistrationListener",
-                new Object[] {newRefList, obsoleteRefList});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1}",
+                            newRefList, obsoleteRefList);
 
         // Can throw RelationServiceNotRegisteredException
         isActive();
@@ -2936,8 +2875,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "updateUnregistrationListener");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -3003,9 +2941,10 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "addRelationInt", new Object[] {relationBaseFlag, relationObj,
-                relationObjName, relationId, relationTypeName, roleList});
+        RELATION_LOGGER.log(Level.TRACE,
+                            "ENTRY {0} {1} {2} {3} {4} {5}",
+                            relationBaseFlag, relationObj, relationObjName,
+                            relationId, relationTypeName, roleList);
 
         // Can throw RelationServiceNotRegisteredException
         isActive();
@@ -3144,8 +3083,7 @@
             // OK : The Relation could not be found.
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "addRelationInt");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -3185,15 +3123,13 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "checkRoleInt", new Object[] {chkType, roleName,
-                roleValue, roleInfo, writeChkFlag});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3} {4}",
+                            chkType, roleName, roleValue, roleInfo, writeChkFlag);
 
         // Compares names
         String expName = roleInfo.getName();
         if (!(roleName.equals(expName))) {
-            RELATION_LOGGER.exiting(RelationService.class.getName(),
-                    "checkRoleInt");
+            RELATION_LOGGER.log(Level.TRACE, "RETURN");
             return Integer.valueOf(RoleStatus.NO_ROLE_WITH_NAME);
         }
 
@@ -3201,13 +3137,11 @@
         if (chkType == 1) {
             boolean isReadable = roleInfo.isReadable();
             if (!isReadable) {
-                RELATION_LOGGER.exiting(RelationService.class.getName(),
-                        "checkRoleInt");
+                RELATION_LOGGER.log(Level.TRACE, "RETURN");
                 return Integer.valueOf(RoleStatus.ROLE_NOT_READABLE);
             } else {
                 // End of check :)
-                RELATION_LOGGER.exiting(RelationService.class.getName(),
-                        "checkRoleInt");
+                RELATION_LOGGER.log(Level.TRACE, "RETURN");
                 return 0;
             }
         }
@@ -3216,8 +3150,7 @@
         if (writeChkFlag) {
             boolean isWritable = roleInfo.isWritable();
             if (!isWritable) {
-                RELATION_LOGGER.exiting(RelationService.class.getName(),
-                        "checkRoleInt");
+                RELATION_LOGGER.log(Level.TRACE, "RETURN");
                 return RoleStatus.ROLE_NOT_WRITABLE;
             }
         }
@@ -3227,16 +3160,14 @@
         // Checks minimum cardinality
         boolean chkMinFlag = roleInfo.checkMinDegree(refNbr);
         if (!chkMinFlag) {
-            RELATION_LOGGER.exiting(RelationService.class.getName(),
-                    "checkRoleInt");
+            RELATION_LOGGER.log(Level.TRACE, "RETURN");
             return RoleStatus.LESS_THAN_MIN_ROLE_DEGREE;
         }
 
         // Checks maximum cardinality
         boolean chkMaxFlag = roleInfo.checkMaxDegree(refNbr);
         if (!chkMaxFlag) {
-            RELATION_LOGGER.exiting(RelationService.class.getName(),
-                    "checkRoleInt");
+            RELATION_LOGGER.log(Level.TRACE, "RETURN");
             return RoleStatus.MORE_THAN_MAX_ROLE_DEGREE;
         }
 
@@ -3252,8 +3183,7 @@
 
             // Checks it is registered
             if (currObjName == null) {
-                RELATION_LOGGER.exiting(RelationService.class.getName(),
-                        "checkRoleInt");
+                RELATION_LOGGER.log(Level.TRACE, "RETURN");
                 return RoleStatus.REF_MBEAN_NOT_REGISTERED;
             }
 
@@ -3263,20 +3193,17 @@
                 boolean classSts = myMBeanServer.isInstanceOf(currObjName,
                                                               expClassName);
                 if (!classSts) {
-                    RELATION_LOGGER.exiting(RelationService.class.getName(),
-                            "checkRoleInt");
+                    RELATION_LOGGER.log(Level.TRACE, "RETURN");
                     return RoleStatus.REF_MBEAN_OF_INCORRECT_CLASS;
                 }
 
             } catch (InstanceNotFoundException exc) {
-                RELATION_LOGGER.exiting(RelationService.class.getName(),
-                        "checkRoleInt");
+                RELATION_LOGGER.log(Level.TRACE, "RETURN");
                 return RoleStatus.REF_MBEAN_NOT_REGISTERED;
             }
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "checkRoleInt");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return 0;
     }
 
@@ -3328,10 +3255,9 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "initializeMissingRoles", new Object[] {relationBaseFlag,
-                relationObj, relationObjName, relationId, relationTypeName,
-                roleInfoList});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3} {4} {5}",
+                            relationBaseFlag, relationObj, relationObjName,
+                            relationId, relationTypeName, roleInfoList);
 
         // Can throw RelationServiceNotRegisteredException
         isActive();
@@ -3410,8 +3336,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "initializeMissingRoles");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -3528,9 +3453,9 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "sendNotificationInt", new Object[] {intNtfType, message,
-                relationId, unregMBeanList, roleName, roleNewValue, oldValue});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3} {4} {5} {6}",
+                            intNtfType, message, relationId, unregMBeanList,
+                            roleName, roleNewValue, oldValue);
 
         // Relation type name
         // Note: do not use getRelationTypeName() as if it is a relation MBean
@@ -3616,8 +3541,7 @@
 
         sendNotification(ntf);
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "sendNotificationInt");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -3654,9 +3578,8 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationService.class.getName(),
-                "handleReferenceUnregistration",
-                new Object[] {relationId, objectName, roleNameList});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2}",
+                            relationId, objectName, roleNameList);
 
         // Can throw RelationServiceNotRegisteredException
         isActive();
@@ -3782,8 +3705,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationService.class.getName(),
-                "handleReferenceUnregistration");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 }
--- a/jdk/src/java.management/share/classes/javax/management/relation/RelationSupport.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/relation/RelationSupport.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -27,8 +27,8 @@
 
 
 
+import java.lang.System.Logger.Level;
 import java.util.ArrayList;
-
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
@@ -162,8 +162,7 @@
 
         super();
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(),
-                "RelationSupport");
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY");
 
         // Can throw InvalidRoleValueException and IllegalArgumentException
         initMembers(relationId,
@@ -172,8 +171,7 @@
                     relationTypeName,
                     list);
 
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(),
-                "RelationSupport");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
     }
 
     /**
@@ -239,8 +237,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(),
-                "RelationSupport");
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY");
 
         // Can throw InvalidRoleValueException and
         // IllegalArgumentException
@@ -250,8 +247,7 @@
                     relationTypeName,
                     list);
 
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(),
-                "RelationSupport");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
     }
 
     //
@@ -286,15 +282,14 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(),
-                "getRole", roleName);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", roleName);
 
         // Can throw RoleNotFoundException and
         // RelationServiceNotRegisteredException
         List<ObjectName> result = cast(
             getRoleInt(roleName, false, null, false));
 
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(), "getRole");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -324,12 +319,12 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(), "getRoles");
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY");
 
         // Can throw RelationServiceNotRegisteredException
         RoleResult result = getRolesInt(roleNameArray, false, null);
 
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(), "getRoles");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -346,8 +341,7 @@
     public RoleResult getAllRoles()
         throws RelationServiceNotRegisteredException {
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(),
-                "getAllRoles");
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY");
 
         RoleResult result = null;
         try {
@@ -356,7 +350,7 @@
             // OK : Invalid parameters, ignore...
         }
 
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(), "getAllRoles");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -367,8 +361,7 @@
      */
     public RoleList retrieveAllRoles() {
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(),
-                "retrieveAllRoles");
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY");
 
         RoleList result;
         synchronized(myRoleName2ValueMap) {
@@ -376,8 +369,7 @@
                 new RoleList(new ArrayList<Role>(myRoleName2ValueMap.values()));
         }
 
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(),
-                "retrieveAllRoles");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -400,8 +392,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(),
-                "getRoleCardinality", roleName);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", roleName);
 
         // Try to retrieve the role
         Role role;
@@ -426,8 +417,7 @@
 
         List<ObjectName> roleValue = role.getRoleValue();
 
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(),
-                "getRoleCardinality");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return roleValue.size();
     }
 
@@ -476,13 +466,12 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(),
-                "setRole", role);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", role);
 
         // Will return null :)
         Object result = setRoleInt(role, false, null, false);
 
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(), "setRole");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -521,12 +510,11 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(),
-                "setRoles", list);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", list);
 
         RoleResult result = setRolesInt(list, false, null);
 
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(), "setRoles");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -570,9 +558,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(),
-                "handleMBeanUnregistration",
-                new Object[]{objectName, roleName});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1}", objectName, roleName);
 
         // Can throw RoleNotFoundException, InvalidRoleValueException,
         // or RelationTypeNotFoundException
@@ -581,8 +567,7 @@
                                      false,
                                      null);
 
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(),
-                "handleMBeanUnregistration");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -594,8 +579,7 @@
      */
     public Map<ObjectName,List<String>> getReferencedMBeans() {
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(),
-                "getReferencedMBeans");
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY");
 
         Map<ObjectName,List<String>> refMBeanMap =
             new HashMap<ObjectName,List<String>>();
@@ -628,8 +612,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(),
-                "getReferencedMBeans");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return refMBeanMap;
     }
 
@@ -779,8 +762,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(),
-                "getRoleInt", roleName);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", roleName);
 
         int pbType = 0;
 
@@ -885,7 +867,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(), "getRoleInt");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -921,8 +903,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(),
-                "getRolesInt");
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY");
 
         RoleList roleList = new RoleList();
         RoleUnresolvedList roleUnresList = new RoleUnresolvedList();
@@ -966,8 +947,7 @@
         }
 
         RoleResult result = new RoleResult(roleList, roleUnresList);
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(),
-                "getRolesInt");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -991,8 +971,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(),
-                "getAllRolesInt");
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY");
 
         List<String> roleNameList;
         synchronized(myRoleName2ValueMap) {
@@ -1006,8 +985,7 @@
                                         relationServCallFlg,
                                         relationServ);
 
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(),
-                "getAllRolesInt");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -1083,9 +1061,9 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(),
-                "setRoleInt", new Object[] {aRole, relationServCallFlg,
-                relationServ, multiRoleFlg});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3}",
+                            aRole, relationServCallFlg, relationServ,
+                            multiRoleFlg);
 
         String roleName = aRole.getRoleName();
         int pbType = 0;
@@ -1244,7 +1222,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(), "setRoleInt");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -1286,9 +1264,9 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(),
-                "sendRoleUpdateNotification", new Object[] {newRole,
-                oldRoleValue, relationServCallFlg, relationServ});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3}",
+                            newRole, oldRoleValue, relationServCallFlg,
+                            relationServ);
 
         if (relationServCallFlg) {
             // Direct call to the Relation Service
@@ -1341,8 +1319,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(),
-                "sendRoleUpdateNotification");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -1383,9 +1360,9 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(),
-                "updateRelationServiceMap", new Object[] {newRole,
-                oldRoleValue, relationServCallFlg, relationServ});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3}",
+                            newRole, oldRoleValue, relationServCallFlg,
+                            relationServ);
 
         if (relationServCallFlg) {
             // Direct call to the Relation Service
@@ -1433,8 +1410,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(),
-                "updateRelationServiceMap");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -1484,9 +1460,8 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(),
-                "setRolesInt",
-                new Object[] {list, relationServCallFlg, relationServ});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2}",
+                            list, relationServCallFlg, relationServ);
 
         RoleList roleList = new RoleList();
         RoleUnresolvedList roleUnresList = new RoleUnresolvedList();
@@ -1534,7 +1509,7 @@
 
         RoleResult result = new RoleResult(roleList, roleUnresList);
 
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(), "setRolesInt");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -1578,9 +1553,9 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(),
-                "initMembers", new Object[] {relationId, relationServiceName,
-                relationServiceMBeanServer, relationTypeName, list});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3} {4}",
+                            relationId, relationServiceName,
+                            relationServiceMBeanServer, relationTypeName, list);
 
         myRelId = relationId;
         myRelServiceName = relationServiceName;
@@ -1589,7 +1564,7 @@
         // Can throw InvalidRoleValueException
         initRoleMap(list);
 
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(), "initMembers");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -1608,8 +1583,7 @@
             return;
         }
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(),
-                "initRoleMap", list);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", list);
 
         synchronized(myRoleName2ValueMap) {
 
@@ -1632,7 +1606,7 @@
             }
         }
 
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(), "initRoleMap");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -1692,9 +1666,9 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationSupport.class.getName(),
-                "handleMBeanUnregistrationInt", new Object[] {objectName,
-                roleName, relationServCallFlg, relationServ});
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3}",
+                            objectName, roleName, relationServCallFlg,
+                            relationServ);
 
         // Retrieves current role value
         Role role;
@@ -1723,8 +1697,7 @@
         Object result =
             setRoleInt(newRole, relationServCallFlg, relationServ, false);
 
-        RELATION_LOGGER.exiting(RelationSupport.class.getName(),
-                "handleMBeanUnregistrationInt");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
--- a/jdk/src/java.management/share/classes/javax/management/relation/RelationTypeSupport.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/relation/RelationTypeSupport.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2006, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -42,7 +42,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 
 /**
  * A RelationTypeSupport object implements the RelationType interface.
@@ -173,15 +173,13 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationTypeSupport.class.getName(),
-                "RelationTypeSupport", relationTypeName);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationTypeName);
 
         // Can throw InvalidRelationTypeException, ClassNotFoundException
         // and NotCompliantMBeanException
         initMembers(relationTypeName, roleInfoArray);
 
-        RELATION_LOGGER.exiting(RelationTypeSupport.class.getName(),
-                "RelationTypeSupport");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -199,13 +197,11 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationTypeSupport.class.getName(),
-                "RelationTypeSupport", relationTypeName);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationTypeName);
 
         typeName = relationTypeName;
 
-        RELATION_LOGGER.exiting(RelationTypeSupport.class.getName(),
-                "RelationTypeSupport");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -251,8 +247,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationTypeSupport.class.getName(),
-                "getRoleInfo", roleInfoName);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", roleInfoName);
 
         // No null RoleInfo allowed, so use get()
         RoleInfo result = roleName2InfoMap.get(roleInfoName);
@@ -265,8 +260,7 @@
             throw new RoleInfoNotFoundException(excMsgStrB.toString());
         }
 
-        RELATION_LOGGER.exiting(RelationTypeSupport.class.getName(),
-                "getRoleInfo");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return result;
     }
 
@@ -297,8 +291,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationTypeSupport.class.getName(),
-                "addRoleInfo", roleInfo);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", roleInfo);
 
         if (isInRelationService) {
             // Trying to update a declared relation type
@@ -319,8 +312,7 @@
 
         roleName2InfoMap.put(roleName, new RoleInfo(roleInfo));
 
-        RELATION_LOGGER.exiting(RelationTypeSupport.class.getName(),
-                "addRoleInfo");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
@@ -351,8 +343,7 @@
             throw new IllegalArgumentException(excMsg);
         }
 
-        RELATION_LOGGER.entering(RelationTypeSupport.class.getName(),
-                "initMembers", relationTypeName);
+        RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", relationTypeName);
 
         typeName = relationTypeName;
 
@@ -366,8 +357,7 @@
                                  new RoleInfo(currRoleInfo));
         }
 
-        RELATION_LOGGER.exiting(RelationTypeSupport.class.getName(),
-                "initMembers");
+        RELATION_LOGGER.log(Level.TRACE, "RETURN");
         return;
     }
 
--- a/jdk/src/java.management/share/classes/javax/management/timer/Timer.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/timer/Timer.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -33,7 +33,7 @@
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.Vector;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 
 // jmx imports
 //
@@ -221,8 +221,7 @@
      */
     public void preDeregister() throws java.lang.Exception {
 
-        TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
-                "preDeregister", "stop the timer");
+        TIMER_LOGGER.log(Level.TRACE, "stop the timer");
 
         // Stop the timer.
         //
@@ -273,8 +272,7 @@
      */
     public synchronized void start() {
 
-        TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
-                "start", "starting the timer");
+        TIMER_LOGGER.log(Level.TRACE, "starting the timer");
 
         // Start the TimerAlarmClock.
         //
@@ -323,11 +321,9 @@
             //
             isActive = true;
 
-            TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
-                    "start", "timer started");
+            TIMER_LOGGER.log(Level.TRACE, "timer started");
         } else {
-            TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
-                    "start", "the timer is already activated");
+            TIMER_LOGGER.log(Level.TRACE, "the timer is already activated");
         }
     }
 
@@ -336,8 +332,7 @@
      */
     public synchronized void stop() {
 
-        TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
-                "stop", "stopping the timer");
+        TIMER_LOGGER.log(Level.TRACE, "stopping the timer");
 
         // Stop the TimerAlarmClock.
         //
@@ -370,11 +365,9 @@
             //
             isActive = false;
 
-            TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
-                    "stop", "timer stopped");
+            TIMER_LOGGER.log(Level.TRACE, "timer stopped");
         } else {
-            TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
-                    "stop", "the timer is already deactivated");
+            TIMER_LOGGER.log(Level.TRACE, "the timer is already deactivated");
         }
     }
 
@@ -444,9 +437,8 @@
         if (currentDate.after(date)) {
 
             date.setTime(currentDate.getTime());
-            if (TIMER_LOGGER.isLoggable(Level.FINER)) {
-                TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
-                        "addNotification",
+            if (TIMER_LOGGER.isLoggable(Level.TRACE)) {
+                TIMER_LOGGER.log(Level.TRACE,
                         "update timer notification to add with:" +
                         "\n\tNotification date = " + date);
             }
@@ -486,7 +478,7 @@
         obj[ALARM_CLOCK_INDEX] = (Object)alarmClock;
         obj[FIXED_RATE_INDEX] = Boolean.valueOf(fixedRate);
 
-        if (TIMER_LOGGER.isLoggable(Level.FINER)) {
+        if (TIMER_LOGGER.isLoggable(Level.TRACE)) {
             StringBuilder strb = new StringBuilder()
             .append("adding timer notification:\n\t")
             .append("Notification source = ")
@@ -503,8 +495,7 @@
             .append(nbOccurences)
             .append("\n\tNotification executes at fixed rate = ")
             .append(fixedRate);
-            TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
-                    "addNotification", strb.toString());
+            TIMER_LOGGER.log(Level.TRACE, strb::toString);
         }
 
         timerTable.put(notifID, obj);
@@ -522,8 +513,7 @@
           }
         }
 
-        TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
-                "addNotification", "timer notification added");
+        TIMER_LOGGER.log(Level.TRACE, "timer notification added");
         return notifID;
     }
 
@@ -677,7 +667,7 @@
 
         // Remove the timer notification from the timer table.
         //
-        if (TIMER_LOGGER.isLoggable(Level.FINER)) {
+        if (TIMER_LOGGER.isLoggable(Level.TRACE)) {
             StringBuilder strb = new StringBuilder()
             .append("removing timer notification:")
             .append("\n\tNotification source = ")
@@ -694,14 +684,12 @@
             .append(obj[TIMER_NB_OCCUR_INDEX])
             .append("\n\tNotification executes at fixed rate = ")
             .append(obj[FIXED_RATE_INDEX]);
-            TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
-                    "removeNotification", strb.toString());
+            TIMER_LOGGER.log(Level.TRACE, strb::toString);
         }
 
         timerTable.remove(id);
 
-        TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
-                "removeNotification", "timer notification removed");
+        TIMER_LOGGER.log(Level.TRACE, "timer notification removed");
     }
 
     /**
@@ -752,19 +740,16 @@
         }
 
         // Remove all the timer notifications from the timer table.
-        TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
-                "removeAllNotifications", "removing all timer notifications");
+        TIMER_LOGGER.log(Level.TRACE, "removing all timer notifications");
 
         timerTable.clear();
 
-        TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
-                "removeAllNotifications", "all timer notifications removed");
+        TIMER_LOGGER.log(Level.TRACE, "all timer notifications removed");
         // Reset the counterID.
         //
         counterID = 0;
 
-        TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
-                "removeAllNotifications", "timer notification counter ID reset");
+        TIMER_LOGGER.log(Level.TRACE, "timer notification counter ID reset");
     }
 
     // GETTERS AND SETTERS
@@ -1021,7 +1006,7 @@
             while ( (currentDate.after(date)) && (timerTable.containsKey(notifID)) ) {
 
                 if (currentFlag == true) {
-                    if (TIMER_LOGGER.isLoggable(Level.FINER)) {
+                    if (TIMER_LOGGER.isLoggable(Level.TRACE)) {
                         StringBuilder strb = new StringBuilder()
                         .append("sending past timer notification:")
                         .append("\n\tNotification source = ")
@@ -1038,13 +1023,11 @@
                         .append(obj[TIMER_NB_OCCUR_INDEX])
                         .append("\n\tNotification executes at fixed rate = ")
                         .append(obj[FIXED_RATE_INDEX]);
-                        TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
-                                "sendPastNotifications", strb.toString());
+                        TIMER_LOGGER.log(Level.TRACE, strb::toString);
                     }
                     sendNotification(date, notif);
 
-                    TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
-                            "sendPastNotifications", "past timer notification sent");
+                    TIMER_LOGGER.log(Level.TRACE, "past timer notification sent");
                 }
 
                 // Update the date and the number of occurrences of the timer notification.
@@ -1107,7 +1090,7 @@
                     timer.schedule(alarmClock, alarmClock.timeout);
                   }
                 }
-                if (TIMER_LOGGER.isLoggable(Level.FINER)) {
+                if (TIMER_LOGGER.isLoggable(Level.TRACE)) {
                     TimerNotification notif = (TimerNotification)obj[TIMER_NOTIF_INDEX];
                     StringBuilder strb = new StringBuilder()
                     .append("update timer notification with:")
@@ -1125,8 +1108,7 @@
                     .append(nbOccurences)
                     .append("\n\tNotification executes at fixed rate = ")
                     .append(fixedRate);
-                    TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
-                            "updateTimerTable", strb.toString());
+                    TIMER_LOGGER.log(Level.TRACE, strb::toString);
                 }
             }
             else {
@@ -1211,7 +1193,7 @@
      */
     void sendNotification(Date timeStamp, TimerNotification notification) {
 
-        if (TIMER_LOGGER.isLoggable(Level.FINER)) {
+        if (TIMER_LOGGER.isLoggable(Level.TRACE)) {
             StringBuilder strb = new StringBuilder()
             .append("sending timer notification:")
             .append("\n\tNotification source = ")
@@ -1222,8 +1204,7 @@
             .append(notification.getNotificationID())
             .append("\n\tNotification date = ")
             .append(timeStamp);
-            TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
-                    "sendNotification", strb.toString());
+            TIMER_LOGGER.log(Level.TRACE, strb::toString);
         }
         long curSeqNumber;
         synchronized(this) {
@@ -1236,7 +1217,6 @@
             this.sendNotification((TimerNotification)notification.cloneTimerNotification());
         }
 
-        TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
-                "sendNotification", "timer notification sent");
+        TIMER_LOGGER.log(Level.TRACE, "timer notification sent");
     }
 }
--- a/jdk/src/java.management/share/classes/javax/management/timer/TimerAlarmClock.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/javax/management/timer/TimerAlarmClock.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -26,7 +26,7 @@
 package javax.management.timer;
 
 import java.util.Date;
-import java.util.logging.Level;
+import java.lang.System.Logger.Level;
 import static com.sun.jmx.defaults.JmxProperties.TIMER_LOGGER;
 
 /**
@@ -73,7 +73,7 @@
             TimerAlarmClockNotification notif = new TimerAlarmClockNotification(this);
             listener.notifyAlarmClock(notif);
         } catch (Exception e) {
-            TIMER_LOGGER.logp(Level.FINEST, Timer.class.getName(), "run",
+            TIMER_LOGGER.log(Level.TRACE,
                     "Got unexpected exception when sending a notification", e);
         }
     }
--- a/jdk/src/java.management/share/classes/module-info.java	Fri Jan 20 07:05:40 2017 -0800
+++ b/jdk/src/java.management/share/classes/module-info.java	Fri Jan 20 18:41:12 2017 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -31,7 +31,6 @@
  */
 module java.management {
     requires transitive java.rmi;
-    requires java.logging;
     requires java.naming;
 
     exports java.lang.management;
@@ -55,4 +54,3 @@
     provides javax.security.auth.spi.LoginModule
         with com.sun.jmx.remote.security.FileLoginModule;
 }
-
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/sun/management/LoggingTest/LoggingTest.java	Fri Jan 20 18:41:12 2017 +0000
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.lang.management.ManagementFactory;
+import java.util.List;
+import javax.management.MBeanServer;
+import javax.management.ObjectName;
+
+public class LoggingTest {
+
+    static class TestStream extends PrintStream {
+        final ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        private volatile boolean recording;
+        public TestStream(PrintStream wrapped) {
+            super(wrapped);
+        }
+
+        void startRecording() {
+            recording = true;
+        }
+
+        void stopRecording() {
+            recording = false;
+        }
+
+        @Override
+        public void write(int b) {
+            if (recording) {
+                bos.write(b);
+            }
+            super.write(b);
+        }
+
+        @Override
+        public void write(byte[] buf, int off, int len) {
+            if (recording) {
+                bos.write(buf, off, len);
+            }
+            super.write(buf, off, len);
+        }
+
+        @Override
+        public void write(byte[] buf) throws IOException {
+            if (recording) {
+                bos.write(buf);
+            }
+            super.write(buf);
+        }
+
+    }
+
+    public void run(TestStream ts) {
+
+        // start recording traces and trigger creation of the platform
+        // MBeanServer to produce some. This won't work if the platform
+        // MBeanServer was already initialized - so it's important to
+        // run this test in its own JVM.
+        ts.startRecording();
+        MBeanServer platform = ManagementFactory.getPlatformMBeanServer();
+        ts.stopRecording();
+        String printed = ts.bos.toString();
+        ts.bos.reset();
+
+        // Check that the Platform MBeanServer is emitting the expected
+        // log traces. This can be a bit fragile because debug traces
+        // could be changed without notice - in which case this test will
+        // need to be updated.
+        // For each registered MBean we expect to see three traces.
+        // If the messages logged by the MBeanServer change then these checks
+        // may need to be revisited.
+        List<String> checkTraces =
+                List.of("ObjectName = %s", "name = %s", "JMX.mbean.registered %s");
+
+        for (ObjectName o : platform.queryNames(ObjectName.WILDCARD, null)) {
+            String n = o.toString();
+            System.out.println("Checking log for: " + n);
+            for (String check : checkTraces) {
+                String s = String.format(check, n);
+                if (!printed.contains(s)) {
+                    throw new RuntimeException("Trace not found: " + s);
+                }
+            }
+        }
+    }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/sun/management/LoggingTest/LoggingWithJULTest.java	Fri Jan 20 18:41:12 2017 +0000
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import java.nio.file.Paths;
+
+/**
+ * @test
+ * @bug 8172971
+ * @modules java.management java.logging
+ * @summary Smoke test to check that logging in java.management works as expected.
+ * @build LoggingTest LoggingWithJULTest
+ * @run main/othervm LoggingWithJULTest
+ * @author danielfuchs
+ */
+public class LoggingWithJULTest {
+
+    public static void main(String[] args) {
+        // Replace System.err
+        LoggingTest.TestStream ts = new LoggingTest.TestStream(System.err);
+        System.setErr(ts);
+
+        // activate the javax.management traces
+        String properties = Paths.get(System.getProperty("test.src", "src"),
+                                      "logging.properties").toString();
+        System.setProperty("java.util.logging.config.file", properties);
+
+        // run the test
+        new LoggingTest().run(ts);
+    }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/sun/management/LoggingTest/LoggingWithLoggerFinderTest.java	Fri Jan 20 18:41:12 2017 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test
+ * @bug 8172971
+ * @modules java.management
+ * @summary Smoke test to check that logging in java.management is performed
+ *          through System.Logger. This test installs a LoggerFinder service
+ *          provider and verifies that it gets the traces.
+ * @build test.loggerfinder/test.loggerfinder.TestLoggerFinder LoggingTest LoggingWithLoggerFinderTest
+ * @run main/othervm --add-modules test.loggerfinder LoggingWithLoggerFinderTest
+ * @author danielfuchs
+ */
+public class LoggingWithLoggerFinderTest {
+
+    public static void main(String[] args) {
+        // Replace System.err
+        LoggingTest.TestStream ts = new LoggingTest.TestStream(System.err);
+        System.setErr(ts);
+
+        // run the test
+        new LoggingTest().run(ts);
+    }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/sun/management/LoggingTest/logging.properties	Fri Jan 20 18:41:12 2017 +0000
@@ -0,0 +1,55 @@
+############################################################
+#  	Global properties
+############################################################
+
+# "handlers" specifies a comma separated list of log Handler 
+# classes.  These handlers will be installed during VM startup.
+# Note that these classes must be on the system classpath.
+# By default we only configure a ConsoleHandler, which will only
+# show messages at the INFO and above levels.
+handlers= java.util.logging.ConsoleHandler
+
+# To also add the FileHandler, use the following line instead.
+#handlers= java.util.logging.FileHandler, java.util.logging.ConsoleHandler
+
+# Default global logging level.
+# This specifies which kinds of events are logged across
+# all loggers.  For any given facility this global level
+# can be overriden by a facility specific level
+# Note that the ConsoleHandler also has a separate level
+# setting to limit messages printed to the console.
+.level= INFO
+
+############################################################
+# Handler specific properties.
+# Describes specific configuration info for Handlers.
+############################################################
+
+# default file output is in user's home directory.
+java.util.logging.FileHandler.pattern = %h/java%u.log
+java.util.logging.FileHandler.limit = 50000
+java.util.logging.FileHandler.count = 1
+# Default number of locks FileHandler can obtain synchronously.
+# This specifies maximum number of attempts to obtain lock file by FileHandler
+# implemented by incrementing the unique field %u as per FileHandler API documentation.
+java.util.logging.FileHandler.maxLocks = 100
+java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter
+
+# Limit the message that are printed on the console to INFO and above.
+java.util.logging.ConsoleHandler.level = ALL
+java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
+
+# Example to customize the SimpleFormatter output format 
+# to print one-line log message like this:
+#     <level>: <log message> [<date/time>]
+#
+# java.util.logging.SimpleFormatter.format=%4$s: %5$s [%1$tc]%n
+
+############################################################
+# Facility specific properties.
+# Provides extra control for each logger.
+############################################################
+
+# For example, set the com.xyz.foo logger to only log SEVERE
+# messages:
+javax.management.level = ALL
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/sun/management/LoggingTest/test.loggerfinder/module-info.java	Fri Jan 20 18:41:12 2017 +0000
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+module test.loggerfinder {
+    // Install a LoggerFinder that will direct traces directly to System.err,
+    // without involving java.util.logging
+    provides java.lang.System.LoggerFinder with test.loggerfinder.TestLoggerFinder;
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/sun/management/LoggingTest/test.loggerfinder/test/loggerfinder/TestLoggerFinder.java	Fri Jan 20 18:41:12 2017 +0000
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package test.loggerfinder;
+
+import java.lang.System.Logger;
+import java.lang.System.Logger.Level;
+import java.lang.System.LoggerFinder;
+import java.lang.reflect.Module;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.Optional;
+import java.util.ResourceBundle;
+import java.util.function.Predicate;
+import java.lang.StackWalker.StackFrame;
+import java.text.MessageFormat;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
+/**
+ * A LoggerFinder that provides System.Logger which print directly
+ * on System.err, without involving java.logging.
+ * For the purpose of the test, loggers whose name start with java.management.
+ * will log all messages, and other loggers will only log level > INFO.
+ * @author danielfuchs
+ */
+public class TestLoggerFinder extends LoggerFinder {
+
+    static class TestLogger implements Logger {
+
+        final String name;
+
+        public TestLogger(String name) {
+            this.name = name;
+        }
+
+
+        @Override
+        public String getName() {
+            return name;
+        }
+
+        @Override
+        public boolean isLoggable(Level level) {
+            return name.equals("javax.management")
+                    || name.startsWith("javax.management.")
+                    || level.getSeverity() >= Level.INFO.getSeverity();
+        }
+
+        @Override
+        public void log(Level level, ResourceBundle bundle, String msg, Throwable thrown) {
+            if (!isLoggable(level)) return;
+            publish(level, bundle, msg, thrown);
+        }
+
+        @Override
+        public void log(Level level, ResourceBundle bundle, String format, Object... params) {
+            if (!isLoggable(level)) return;
+            publish(level, bundle, format, params);
+        }
+
+        static void publish(Level level, ResourceBundle bundle, String msg, Throwable thrown) {
+            StackFrame sf = new CallerFinder().get().get();
+
+            if (bundle != null && msg != null) {
+                msg = bundle.getString(msg);
+            }
+            if (msg == null) msg = "";
+            LocalDateTime ldt = LocalDateTime.now();
+            String date = DateTimeFormatter.ISO_DATE_TIME.format(ldt);
+            System.err.println(date + " "
+                    + sf.getClassName() + " " + sf.getMethodName() + "\n"
+                    + String.valueOf(level) + ": " + msg);
+            thrown.printStackTrace(System.err);
+        }
+
+        static void publish(Level level, ResourceBundle bundle, String format, Object... params) {
+            StackFrame sf = new CallerFinder().get().get();
+            if (bundle != null && format != null) {
+                format = bundle.getString(format);
+            }
+            String msg = format(format, params);
+            LocalDateTime ldt = LocalDateTime.now();
+            String date = DateTimeFormatter.ISO_DATE_TIME.format(ldt);
+            System.err.println(date + " "
+                    + sf.getClassName() + " " + sf.getMethodName() + "\n"
+                    + String.valueOf(level) + ": " + msg);
+        }
+
+        static String format(String format, Object... args) {
+            if (format == null) return "";
+            int index = 0, len = format.length();
+            while ((index = format.indexOf(index, '{')) >= 0) {
+                if (index >= len - 2) break;
+                char c = format.charAt(index+1);
+                if (c >= '0' && c <= '9') {
+                    return MessageFormat.format(format, args);
+                }
+                index++;
+            }
+            return format;
+        }
+
+    }
+
+     /*
+     * CallerFinder is a stateful predicate.
+     */
+    static final class CallerFinder implements Predicate<StackWalker.StackFrame> {
+        private static final StackWalker WALKER;
+        static {
+            PrivilegedAction<StackWalker> pa =
+                () -> StackWalker.getInstance(StackWalker.Option.RETAIN_CLASS_REFERENCE);
+            WALKER = AccessController.doPrivileged(pa);
+        }
+
+        /**
+         * Returns StackFrame of the caller's frame.
+         * @return StackFrame of the caller's frame.
+         */
+        Optional<StackWalker.StackFrame> get() {
+            return WALKER.walk((s) -> s.filter(this).findFirst());
+        }
+
+        private boolean lookingForLogger = true;
+        /**
+         * Returns true if we have found the caller's frame, false if the frame
+         * must be skipped.
+         *
+         * @param t The frame info.
+         * @return true if we have found the caller's frame, false if the frame
+         * must be skipped.
+         */
+        @Override
+        public boolean test(StackWalker.StackFrame s) {
+            // We should skip all frames until we have found the logger,
+            // because these frames could be frames introduced by e.g. custom
+            // sub classes of Handler.
+            Class<?> c = s.getDeclaringClass();
+            boolean isLogger = System.Logger.class.isAssignableFrom(c);
+            if (lookingForLogger) {
+                // Skip all frames until we have found the first logger frame.
+                lookingForLogger = c != TestLogger.class;
+                return false;
+            }
+            // Continue walking until we've found the relevant calling frame.
+            // Skips logging/logger infrastructure.
+            return !isLogger;
+        }
+    }
+
+    @Override
+    public Logger getLogger(String name, Module module) {
+        return new TestLogger(name);
+    }
+
+}