JMX, SNMP, Java, etc...

handlers= java.util.logging.ConsoleHandler
.level=INFO

java.util.logging.FileHandler.pattern = %h/java%u.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter

java.util.logging.ConsoleHandler.level = FINEST
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

// Use FINER or FINEST for javax.management.remote.level - FINEST is
// very verbose...
//
javax.management.level=FINEST
javax.management.remote.level=FINER

/*
 * JMXTracing.java
 *
 * Created on March 2, 2006, 2:05 PM
 */

package com.sun.jmx.examples.util.tracing;
...

/**
 * Class JMXTracing
 * The JMXTracing MBean is a user friendly interface for setting up JMX 
 * traces.
 * 
 * @author dfuchs
 */
public class JMXTracing extends StandardMBean 
        implements JMXTracingMBean, MBeanRegistration {

    private final static Logger LOG = 
            Logger.getLogger(JMXTracing.class.getName());
    
    private final static ObjectName loggingMBean;
    static {
        try {
            loggingMBean = 
                    ObjectName.getInstance(LogManager.LOGGING_MXBEAN_NAME);
        } catch (MalformedObjectNameException x) {
            throw new UndeclaredThrowableException(x);
        }
    }
    
    public JMXTracing() 
        throws NotCompliantMBeanException {
        this(true,true);
    }
    
    // autostart is used in postRegister   method
    // autostop  is used in postDeregister method 
    //
    public JMXTracing(boolean autostart, boolean autostop) 
        throws NotCompliantMBeanException {
        super(JMXTracingMBean.class);
        this.autostart = autostart;
        this.autostop  = autostop;
    }
   
    ...

    // See JMXTracingMBean.java
    public String[] getLoggerNames() {
        final String[] res;
        try {
            res = (String[])
                mbeanServer.getAttribute(loggingMBean,"LoggerNames");
            Arrays.sort(res);
        } catch (RuntimeException x) {
            throw x;
        } catch (Exception x) {
            throw new UndeclaredThrowableException(x);
        }
        return res;
    }


    // See JMXTracingMBean.java
    public String[] list(String pattern) {
        
        final String[] names = getLoggerNames();
        final Set list = new TreeSet();
        for (String name : names ) {
            if (name.matches(pattern)) list.add(name);
        }
        return list.toArray(new String[list.size()]);
    }

    // See JMXTracingMBean.java
    public String[] switchTo(String pattern, String level) {
        
        final Level l = Level.parse(level);
        final String[] list = list(pattern);
        final String[] signature = { 
            "java.lang.String","java.lang.String"};
        final Set result = new TreeSet();
        
        for (String name:list) {
            try {
                mbeanServer.invoke(loggingMBean,"setLoggerLevel",new Object[] {
                    name, level
                    },signature);
                result.add(name);
            } catch (Exception x) {
                LOG.fine("Failed to switch " + name + " to " + level +": "+x);
                continue;
            }
        }
        return result.toArray(new String[result.size()]);
    }
    
    // See JMXTracingMBean.java
    public String getLoggerLevel(String loggerName)
    throws JMException {
        final String[] signature = {
            "java.lang.String"};
        
        try {
            return (String) mbeanServer.invoke(loggingMBean,"getLoggerLevel",
                new Object[] { loggerName },signature);
        } catch (RuntimeException x) {
            throw x;
        } catch (JMException x) {
            throw x;
        }
        
   }
    
    // See JMXTracingMBean.java
   public Map switchJMX(String jmxLevel, String jmxRemoteLevel) {
        final Level l1 = Level.parse(jmxLevel);
        final Level l2 = Level.parse(jmxRemoteLevel);
        final TreeMap tr = new TreeMap();
        
        for (String log : switchTo("javax.management.*",jmxLevel)) {
            try {
                tr.put(log,getLoggerLevel(log));
            } catch (Exception x) {
                LOG.fine("Failed to get level for " + log);
            }
        }
        for (String log : switchTo("javax.management.remote.*",
                jmxRemoteLevel)) {
            try {
                 tr.put(log,getLoggerLevel(log));            
            } catch (Exception x) {
                LOG.fine("Failed to get level for " + log);
            }
        }
        for (String log : switchTo("com.sun.jmx.*",jmxLevel)) {
            try {
                 tr.put(log,getLoggerLevel(log));            
            } catch (Exception x) {
                LOG.fine("Failed to get level for " + log);
            }
        }
        for (String log : switchTo("com.sun.jmx.remote.*",
                jmxRemoteLevel)) {
            try {
                 tr.put(log,getLoggerLevel(log));            
            } catch (Exception x) {
                LOG.fine("Failed to get level for " + log);
            }
        }
        return tr;
    }
    

    // See JMXTracingMBean.java
    public String[] switchAllJMX(String level) {
        final Level l1 = Level.parse(level);
        final Set res = switchJMX(level,level).keySet();
        final String[] result = res.toArray(new String[res.size()]);
        Arrays.sort(result);
        return result;
    }
    

    // See JMXTracingMBean.java
    public synchronized void setLogOnConsole(boolean on) {
        if (on && handler == null) {
            handler = new ConsoleHandler();
            handler.setLevel(Level.FINEST);
            Logger.getLogger("").addHandler(handler);
        } else if ((!on) && (handler != null)) {
            try {
                Logger.getLogger("").removeHandler(handler);
            } catch (Exception x) {
                LOG.fine("Failed to remove handler");
            }
            handler = null;
        }
    }
   
    // See JMXTracingMBean.java
    public synchronized boolean isLogOnConsole() {
        return handler!=null;
    }
    
    // See JMXTracingMBean.java
    public void enableConsoleLogging() {
        setLogOnConsole(true);
    }
    
    // See JMXTracingMBean.java
    public void disableConsoleLogging() {
        setLogOnConsole(false);
    }
    
    // See JMXTracingMBean.java
    public boolean isDebugOn() {
        return Level.FINEST.equals(LOG.getLevel());
    }
    
    // See JMXTracingMBean.java
    public void setDebugOn(boolean on) {
        if (on) LOG.setLevel(Level.FINEST);
        else LOG.setLevel(Level.INFO);
    }
        
    public ObjectName preRegister(MBeanServer server, ObjectName name) 
        throws Exception {
        if (name == null) 
            name=new ObjectName(this.getClass().getPackage().getName()+
                    ":type="+
                    this.getClass().getSimpleName());
        objectName = name;
        mbeanServer = server;
        
        if (!server.isRegistered(loggingMBean))
            throw new InstanceNotFoundException(loggingMBean.toString());
        return name;
    }

    public void postRegister(Boolean registrationDone) {
        //TODO postRegister implementation;
        if (!registrationDone.booleanValue()) return;
        if (autostart) {
            switchJMX(Level.FINEST.toString(),Level.FINER.toString());
            setDebugOn(false);
            enableConsoleLogging();
        }
    }

    public void postDeregister() {
        //TODO postDeregister implementation;
        if (autostop) {
            switchAllJMX(Level.INFO.toString());
            disableConsoleLogging();
        }
    }

    ...

    private transient MBeanServer mbeanServer;
    private transient ObjectName objectName;
    private transient ConsoleHandler handler = null;
    
    private final boolean autostart;
    private final boolean autostop;
    
    /**
     * Registers a JMXTracing MBean in the platform MBeanServer
     **/
    public static void register() throws JMException {
        ManagementFactory.getPlatformMBeanServer().
                createMBean(JMXTracing.class.getName(),null);
    }

}