Java Code Examples for java.lang.management.ManagementFactory

public static double getProcessCpuLoad() throws Exception {

		MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
		ObjectName name = ObjectName.getInstance("java.lang:type=OperatingSystem");
		AttributeList list = mbs.getAttributes(name, new String[] { "SystemCpuLoad" });

		if (list.isEmpty())
			return Double.NaN;

		Attribute att = (Attribute) list.get(0);
		Double value = (Double) att.getValue();

		// usually takes a couple of seconds before we get real values
		if (value == -1.0)
			return Double.NaN;
		// returns a percentage value with 1 decimal point precision
		return value;
	}
 

static String buildDeadlockInfo() {
  ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
  long[] threadIds = threadBean.findMonitorDeadlockedThreads();
  if (threadIds != null && threadIds.length > 0) {
    StringWriter stringWriter = new StringWriter();
    PrintWriter out = new PrintWriter(stringWriter);
    
    ThreadInfo[] infos = threadBean.getThreadInfo(threadIds, true, true);
    for (ThreadInfo ti : infos) {
      printThreadInfo(ti, out);
      printLockInfo(ti.getLockedSynchronizers(), out);
      out.println();
    }
    
    out.close();
    return stringWriter.toString();
  } else {
    return null;
  }
}
 

private JMXConnectorServer startServer(int rmiPort) throws Exception {
    System.out.println("DEBUG: Create RMI registry on port " + rmiPort);
    LocateRegistry.createRegistry(rmiPort);

    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();

    HashMap<String,Object> env = new HashMap<String,Object>();

    JMXServiceURL url =
            new JMXServiceURL("service:jmx:rmi:///jndi/rmi://127.0.0.1:" + rmiPort + "/jmxrmi");
    JMXConnectorServer cs =
            JMXConnectorServerFactory.newJMXConnectorServer(url, env, mbs);

    cs.start();
    System.out.println("DEBUG: Started the RMI connector server");
    return cs;
}
 

@BeforeSuite
public static void setup() {
    java.lang.management.OperatingSystemMXBean bean =
            ManagementFactory.getOperatingSystemMXBean();
    if (bean instanceof OperatingSystemMXBean) {
        OperatingSystemMXBean os = (OperatingSystemMXBean)bean;
        long physicalMemorySize = os.getTotalPhysicalMemorySize() / (1024 * 1024);
        System.out.println("System memory size: " + physicalMemorySize + "M");
        // when we can get system memory size, and it's larger than 2G,
        // then we enable large array size test below,
        // else disable large array size test below.
        if (physicalMemorySize > (2 * 1024)) {
            arraySizeCollection  = new int[]{
                    SMALL_ARRAY_SIZE,
                    THRESHOLD_ARRAY_SIZE,
                    MEDIUM_ARRAY_SIZE,
                    LARGE_ARRAY_SIZE
                };
            System.out.println("System memory is large enough, add large array size test");
            return;
        }
    }
    arraySizeCollection  = new int[]{
            SMALL_ARRAY_SIZE,
            THRESHOLD_ARRAY_SIZE,
            MEDIUM_ARRAY_SIZE
        };
    System.out.println("System memory is not large enough, remove large array size test");
}
 

@Before
public void setUp() throws Exception {
    this.datasource.setDriverClassName(Driver.class.getName());
    this.datasource.setUrl("jdbc:tomcat:test");
    this.datasource.setPassword(password);
    this.datasource.setUsername(username);
    this.datasource.getConnection().close();
    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
    String domain = "tomcat.jdbc";
    Hashtable<String,String> properties = new Hashtable<String,String>();
    properties.put("type", "ConnectionPool");
    properties.put("class", this.getClass().getName());
    oname = new ObjectName(domain,properties);
    ConnectionPool pool = datasource.createPool();
    org.apache.tomcat.jdbc.pool.jmx.ConnectionPool jmxPool = new org.apache.tomcat.jdbc.pool.jmx.ConnectionPool(pool);
    mbs.registerMBean(jmxPool, oname);

}
 

/**
 * @return a list of all threads started in the JVM.
 */
public List<Thread> getAllThreads() {

    final ThreadGroup root = getRootThreadGroup();
    final ThreadMXBean thbean = ManagementFactory.getThreadMXBean();
    // get the number of all live threads
    int nAlloc = thbean.getThreadCount();
    int n = 0;
    Thread[] threads;

    do {
        nAlloc *= 2; // increase the size since more threads may have been created
        threads = new Thread[nAlloc];
        n = root.enumerate(threads, true); // get all active threads from this thread group
    } while (n == nAlloc); // stop if all active threads are enumerated

    List<Thread> res = new ArrayList<Thread>();
    for (Thread th : threads) {
        res.add(th);
    }

    return res;
}
 

public static void main(String[] args) throws Exception {
    SerializeConfig config = SerializeConfig.getGlobalInstance();
    config.put(MediaContent.class, new MediaContentSerializer());
    config.put(Media.class, new MediaSerializer());
    config.put(Image.class, new ImageSerializer());
    
    System.out.println(System.getProperty("java.vm.name") + " " + System.getProperty("java.runtime.version"));
    List<String> arguments = ManagementFactory.getRuntimeMXBean().getInputArguments();
    System.out.println(arguments);

    MediaContent content = EishayDecodeBytes.instance.getContent();
    String text = encode(content);
    System.out.println(text);
    
    for (int i = 0; i < 10; ++i) {
        perf(text);
    }
}
 

@Override
public boolean execute(CommandSender sender, String s, String[] strings)
{
    if(!testPermission(sender)) return false;
    long used = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed() / 1048576L;
    long max = Runtime.getRuntime().maxMemory() / 1048576L;

    sender.sendMessage(CloudAPI.getInstance().getPrefix() + " ");
    sender.sendMessage(CloudAPI.getInstance().getPrefix() + "§7Server: §b" + CloudAPI.getInstance().getServerId() + ":" + CloudAPI.getInstance().getUniqueId());
    sender.sendMessage(CloudAPI.getInstance().getPrefix() + "§7State§8: §b" + CloudServer.getInstance().getServerState());
    sender.sendMessage(CloudAPI.getInstance().getPrefix() + "§7Template: §b" + CloudServer.getInstance().getTemplate().getName());
    sender.sendMessage(CloudAPI.getInstance().getPrefix() + "§7Memory: §b" + used + "§7/§b" + max + "MB");
    sender.sendMessage(CloudAPI.getInstance().getPrefix() + "§7CPU-Usage internal: §b" + NetworkUtils.internalCpuUsage());
    sender.sendMessage(CloudAPI.getInstance().getPrefix() + " ");
    return false;
}
 

public static void initCodeSizeLimits(int nMaxSizeMemPoolCodeCache, int nMaxSizeMemPoolPermGen)
{
	// PJD remove ibm JMV
	List<MemoryPoolMXBean> pools = ManagementFactory.getMemoryPoolMXBeans();
	for (MemoryPoolMXBean p: pools)
	{
		if(p.getType().compareTo(MemoryType.NON_HEAP) == 0)
		{
			String cs = p.getName();
			if(cs.equalsIgnoreCase("Code Cache"))
				p.setUsageThreshold((long)nMaxSizeMemPoolCodeCache * 1024L * 1024L);
			else if(cs.equalsIgnoreCase("Perm Gen"))
				p.setUsageThreshold((long)nMaxSizeMemPoolPermGen * 1024L * 1024L);
		}
	}
}
 

/**
 * Register the MBean using our standard MBeanName format
 * "hadoop:service=<serviceName>,name=<nameName>"
 * Where the <serviceName> and <nameName> are the supplied parameters
 *    
 * @param serviceName
 * @param nameName
 * @param theMbean - the MBean to register
 * @return the named used to register the MBean
 */	
static public ObjectName registerMBean(final String serviceName, 
  							final String nameName,
  							final Object theMbean) {
  final MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
  ObjectName name = getMBeanName(serviceName, nameName);
  try {
    mbs.registerMBean(theMbean, name);
    return name;
  } catch (InstanceAlreadyExistsException ie) {
    // Ignore if instance already exists 
  } catch (Exception e) {
    e.printStackTrace();
  }
  return null;
}
 

/**
 * Returns a map of garbage collectors and their stats.
 * The first object in the array is the total count since JVM start and the
 * second is the total time (ms) since JVM start.
 * If a garbage collectors does not support the collector MXBean, then it
 * will not be represented in the map.
 * @return A non-null map of garbage collectors and their metrics. The map
 * may be empty.
 */
public static Map<String, Long[]> getGCStatst() {
  final List<GarbageCollectorMXBean> gcBeans =
      ManagementFactory.getGarbageCollectorMXBeans();
  final Map<String, Long[]> map = new HashMap<String, Long[]>(gcBeans.size());
  for (final GarbageCollectorMXBean bean : gcBeans) {
    if (!bean.isValid() || bean.getCollectionCount() < 0 ||
        bean.getCollectionTime() < 0) {
      continue;
    }

    final Long[] measurements = new Long[]{
        bean.getCollectionCount(),
        bean.getCollectionTime()
    };
    map.put(bean.getName().replace(" ", "_"), measurements);
  }
  return map;
}
 

/**
 * A debugging tool to print stack traces of most threads, as jstack does.
 * Uninteresting threads are filtered out.
 */
static void dumpTestThreads() {
    ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
    System.err.println("------ stacktrace dump start ------");
    for (ThreadInfo info : threadMXBean.dumpAllThreads(true, true)) {
        String name = info.getThreadName();
        if ("Signal Dispatcher".equals(name))
            continue;
        if ("Reference Handler".equals(name)
            && info.getLockName().startsWith("java.lang.ref.Reference$Lock"))
            continue;
        if ("Finalizer".equals(name)
            && info.getLockName().startsWith("java.lang.ref.ReferenceQueue$Lock"))
            continue;
        System.err.print(info);
    }
    System.err.println("------ stacktrace dump end ------");
}
 

private void addJvmArgsToSnooper()
{
    RuntimeMXBean runtimemxbean = ManagementFactory.getRuntimeMXBean();
    List<String> list = runtimemxbean.getInputArguments();
    int i = 0;

    for (String s : list)
    {
        if (s.startsWith("-X"))
        {
            this.addClientStat("jvm_arg[" + i++ + "]", s);
        }
    }

    this.addClientStat("jvm_args", Integer.valueOf(i));
}
 

/**
 * The maximum JVM heap size, in bytes.
 * 
 * @return The maximum JVM heap size, in bytes.
 */
public static long getMaxJvmHeapMemory() {
	long maxMemory = Runtime.getRuntime().maxMemory();

	if (maxMemory == Long.MAX_VALUE) {
		// amount of free memory unknown
		try {
			// workaround for Oracle JDK
			OperatingSystemMXBean operatingSystemMXBean = ManagementFactory.getOperatingSystemMXBean();
			Class<?> clazz = Class.forName("com.sun.management.OperatingSystemMXBean");
			Method method = clazz.getMethod("getTotalPhysicalMemorySize");
			maxMemory = (Long) method.invoke(operatingSystemMXBean) / 4;
		}
		catch (Throwable e) {
			throw new RuntimeException("Could not determine the amount of free memory.\n" +
					"Please set the maximum memory for the JVM, e.g. -Xmx512M for 512 megabytes.");
		}
	}
	
	return maxMemory;
}
 

@Override
public Object next() {
  if (!beforeFirst) {
    throw new IllegalStateException();
  }
  beforeFirst = false;
  final ThreadsInfo threadsInfo = new ThreadsInfo();

  final DrillbitEndpoint endpoint = context.getIdentity();
  threadsInfo.hostname = endpoint.getAddress();
  threadsInfo.user_port = endpoint.getUserPort();

  final ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
  threadsInfo.total_threads = threadMXBean.getPeakThreadCount();
  threadsInfo.busy_threads = threadMXBean.getThreadCount();
  return threadsInfo;
}
 

/**
 * Check if the tenured generation are currently using a parallel GC.
 */
protected static boolean isTenuredParallelGC() {
    // Currently the only parallel GC for the tenured generation is PS MarkSweep.
    List<String> parallelGCs = Arrays.asList(new String[] { "PS MarkSweep"});
    try {
        List<GarbageCollectorMXBean> beans = ManagementFactory.getGarbageCollectorMXBeans();
        for (GarbageCollectorMXBean bean : beans) {
            if (parallelGCs.contains(bean.getName())) {
                return true;
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return false;
}
 

/**
 * Factory method to create (if necessary) and return our
 * <code>MBeanServer</code> instance.
 *
 */
public synchronized MBeanServer getMBeanServer() {
	long t1 = System.currentTimeMillis();

	if (server == null) {
		if (MBeanServerFactory.findMBeanServer(null).size() > 0) {
			server = MBeanServerFactory.findMBeanServer(null).get(0);
			if (log.isDebugEnabled()) {
				log.debug("Using existing MBeanServer " + (System.currentTimeMillis() - t1));
			}
		} else {
			server = ManagementFactory.getPlatformMBeanServer();
			if (log.isDebugEnabled()) {
				log.debug("Creating MBeanServer" + (System.currentTimeMillis() - t1));
			}
		}
	}
	return (server);
}
 

/**
 * Returns a summary information about the memory pools.
 */
public static String poolSummaries() {
    // Why ? list-archive?4273859
    // How ? http://stackoverflow.com/questions/697336/how-do-i-programmatically-find-out-my-permgen-space-usage
    //       http://stackoverflow.com/questions/8356416/xxmaxpermsize-with-or-without-xxpermsize
    StringBuilder sb = new StringBuilder();
    Iterator<MemoryPoolMXBean> iter =
            ManagementFactory.getMemoryPoolMXBeans().iterator();
    while (iter.hasNext()) {
        MemoryPoolMXBean item = iter.next();
        String name = item.getName();
        MemoryType type = item.getType();
        MemoryUsage usage = item.getUsage();
        MemoryUsage peak = item.getPeakUsage();
        MemoryUsage collections = item.getCollectionUsage();
        sb.append(String.format("Memory pool name: " + name
                                + ", type: " + type
                                + ", usage: " + usage
                                + ", peak: " + peak
                                + ", collections: " + collections
                                + "\n"));
    }
    return sb.toString();
}
 

public static void main(String[] args) {
    String cmd = null;
    try {
        String pidStr = ManagementFactory.getRuntimeMXBean().getName()
                .split("@")[0];
        String osName = System.getProperty("os.name");
        if (osName.contains("Windows")) {
            cmd = "taskkill.exe /F /PID " + pidStr;
        } else {
            cmd = "kill -9 " + pidStr;
        }

        System.out.printf("executing `%s'%n", cmd);
        Runtime.getRuntime().exec(cmd);
        Thread.sleep(2000);
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.err.printf("TEST/ENV BUG: %s didn't kill JVM%n", cmd);
    System.exit(1);
}
 

@Test
public void testQueryForMemberMXBean() throws Exception {
  final Properties props = new Properties();
  props.setProperty(MCAST_PORT, "0");
  props.setProperty(LOCATORS, "");
  props.setProperty("name", getUniqueName());
  new CacheFactory(props).create();

  final MBeanServer mbeanServer = ManagementFactory.getPlatformMBeanServer();
  final ObjectName pattern = ObjectName.getInstance("GemFire:type=Member,*");

  waitForMemberMXBean(mbeanServer, pattern);

  final Set<ObjectName> mbeanNames = mbeanServer.queryNames(pattern, null);
  assertFalse(mbeanNames.isEmpty());
  assertEquals("mbeanNames=" + mbeanNames, 1, mbeanNames.size());

  final ObjectName objectName = mbeanNames.iterator().next();
  final MemberMXBean mbean = MBeanServerInvocationHandler.newProxyInstance(mbeanServer,
      objectName, MemberMXBean.class, false);

  assertNotNull(mbean);
  assertEquals(ProcessUtils.identifyPid(), mbean.getProcessId());
  assertEquals(getUniqueName(), mbean.getName());
  assertEquals(getUniqueName(), mbean.getMember());
}
 

/**
 * @param conf
 * @return The on heap size for L2 block cache.
 */
public static float getL2BlockCacheHeapPercent(Configuration conf) {
  float l2CachePercent = 0.0F;
  String bucketCacheIOEngineName = conf.get(HConstants.BUCKET_CACHE_IOENGINE_KEY, null);
  // L2 block cache can be on heap when IOEngine is "heap"
  if (bucketCacheIOEngineName != null && bucketCacheIOEngineName.startsWith("heap")) {
    float bucketCachePercentage = conf.getFloat(HConstants.BUCKET_CACHE_SIZE_KEY, 0F);
    MemoryUsage mu = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
    l2CachePercent = bucketCachePercentage < 1 ? bucketCachePercentage
        : (bucketCachePercentage * 1024 * 1024) / mu.getMax();
  }
  return l2CachePercent;
}
 

/**
 * Register the scheduler in the local MBeanServer.
 */
private void registerJMX() throws Exception {
	String jmxObjectName = resources.getJMXObjectName();
	MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
	jmxBean = new QuartzSchedulerMBeanImpl(this);
	mbs.registerMBean(jmxBean, new ObjectName(jmxObjectName));
}
 

public static void main(String[] args) {
    System.out.println("Threads");
    ThreadMXBean threadMBean = (ThreadMXBean) ManagementFactory.getThreadMXBean();

    System.out.println("Thread count = " + threadMBean.getThreadCount());
    System.out.println("Thread IDs = " + Arrays.toString(threadMBean.getAllThreadIds()));

    System.out.println(">>>>> Thread INFO");
    ThreadInfo[] threads = threadMBean.dumpAllThreads(true, true);
    for (ThreadInfo thread : threads) {
        System.out.println(thread);
    }

    System.out.println(">>>>> Thread INFO detailed");
    for (long threadId : threadMBean.getAllThreadIds()) {
        ThreadInfo threadInfo = threadMBean.getThreadInfo(threadId, 100);
        long cpuTime = threadMBean.getThreadCpuTime(threadId);
        long userTime = threadMBean.getThreadUserTime(threadId);
        long allocatedBytes = threadMBean.getThreadAllocatedBytes(threadId);
        System.out.println(threadInfo);
        System.out.println("CPU Time: " + cpuTime + ", USER time: " + userTime + ", Allocated bytes: " + allocatedBytes);
    }

    // Getting stack-traces of the current thread
    System.out.print(">> current thread: " + Thread.currentThread().getName() + "\n");
    for (StackTraceElement element : Thread.currentThread().getStackTrace()) {
        System.out.println(element);
    }
}
 

public static void main(String argv[]) {

        ThreadMXBean mbean = ManagementFactory.getThreadMXBean();
        int cnt = 0;
        long [] idArr = {0, -1, -2, (Long.MIN_VALUE + 1), Long.MIN_VALUE};

        if (mbean.isThreadCpuTimeSupported()) {
            for (int i = 0; i < idArr.length; i++) {
                try {
                    mbean.getThreadCpuTime(idArr[i]);
                    System.out.println("Test failed. IllegalArgumentException" +
                        " expected for ID = " + idArr[i]);
                } catch (IllegalArgumentException iae) {
                    cnt++;
                }
            }
            if (cnt != idArr.length) {
                throw new RuntimeException("Unexpected number of " +
                    "IllegalArgumentException = " + cnt +
                    " expected = " + idArr.length);
            }

            // CPU time for a non-existence thread
            long time = mbean.getThreadCpuTime(999999);
            if (time < 0 && time != -1) {
                throw new RuntimeException("Cpu time for thread 999999" +
                    " is invalid = " + time + " expected to be -1.");
            }
        }
        System.out.println("Test passed.");
    }
 

private void doMethodInBacktraceTestB() throws Exception {
    // Start a thread which blocks in method
    Thread t = new Thread(RedefineMethodInBacktraceTargetB::methodToRedefine);
    t.setDaemon(true);
    t.start();

    // Wait here until the new thread is in the method we want to redefine
    called.await();

    // Now redefine the class while the method is still on the stack of the new thread
    doRedefine(RedefineMethodInBacktraceTargetB.class);

    // Do thread dumps in two different ways (to exercise different code paths)
    // while the old class is still on the stack

    ThreadInfo[] tis = ManagementFactory.getThreadMXBean().dumpAllThreads(false, false);
    for(ThreadInfo ti : tis) {
        System.out.println(ti);
    }

    String[] threadPrintArgs = {};
    Object[] dcmdArgs = {threadPrintArgs};
    String[] signature = {String[].class.getName()};
    DiagnosticCommandMBean dcmd = ManagementFactoryHelper.getDiagnosticCommandMBean();
    System.out.println(dcmd.invoke("threadPrint", dcmdArgs, signature));

    // release the thread
    stop.countDown();
}
 

@Before
public void setUp() throws Exception {
    baseJMXRegistrator = new BaseJMXRegistrator(ManagementFactory.getPlatformMBeanServer());
    transactionsMBeanServer = MBeanServerFactory.createMBeanServer();
    Map<String, Map.Entry<ModuleFactory, BundleContext>> currentlyRegisteredFactories = new HashMap<>();

    ConfigTransactionLookupRegistry txLookupRegistry = new ConfigTransactionLookupRegistry(
            new TransactionIdentifier(TRANSACTION_NAME123),
        () -> baseJMXRegistrator.createTransactionJMXRegistrator(TRANSACTION_NAME123),
        currentlyRegisteredFactories);

    SearchableServiceReferenceWritableRegistry writableRegistry = ServiceReferenceRegistryImpl
            .createSRWritableRegistry(ServiceReferenceRegistryImpl.createInitialSRLookupRegistry(),
                    txLookupRegistry, currentlyRegisteredFactories);

    testedTxController = new ConfigTransactionControllerImpl(txLookupRegistry, 1, null, 1,
            currentlyRegisteredFactories, transactionsMBeanServer, ManagementFactory.getPlatformMBeanServer(),
            false, writableRegistry);
    TransactionModuleJMXRegistrator transactionModuleJMXRegistrator123 = testedTxController
            .getTxModuleJMXRegistrator();
    transactionModuleJMXRegistrator123.registerMBean(new TestingRuntimeBean(), NAME1);
    transactionModuleJMXRegistrator123.registerMBean(new TestingRuntimeBean(), NAME2);
    transactionModuleJMXRegistrator123.registerMBean(new TestingRuntimeBean(), NAME3);
    TransactionJMXRegistrator jmxRegistrator4 = baseJMXRegistrator
            .createTransactionJMXRegistrator(TRANSACTION_NAME4);
    jmxRegistrator4.createTransactionModuleJMXRegistrator().registerMBean(new TestingRuntimeBean(), NAME4);
}
 

/**
 * Register the scheduler in the local MBeanServer.
 */
private void registerJMX() throws Exception {
    String jmxObjectName = resources.getJMXObjectName();
    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
    jmxBean = new QuartzSchedulerMBeanImpl(this);
    mbs.registerMBean(jmxBean, new ObjectName(jmxObjectName));
}
 

/**
 * Get the number of opened filed descriptor for the runtime jvm.
 * If sun java, it will use the com.sun.management interfaces.
 * Otherwise, this methods implements it (linux only).  
 * @return number of open file descriptors for the jvm
 */
public long getOpenFileDescriptorCount() 
{
    Long ofdc;

    if (!ibmvendor) {
        ofdc = getOSUnixMXBeanMethod("getOpenFileDescriptorCount");
        return (ofdc != null ? ofdc.longValue () : -1);
    }
    
    try {
        //need to get the PID number of the process first
        RuntimeMXBean rtmbean = ManagementFactory.getRuntimeMXBean();
        String rtname = rtmbean.getName();
        String[] pidhost = rtname.split("@");

        //using linux bash commands to retrieve info
        Process p = Runtime.getRuntime().exec(
                new String[] { "bash", "-c",
                "ls /proc/" + pidhost[0] + "/fdinfo | wc -l" });
        InputStream in = p.getInputStream();
        BufferedReader output = new BufferedReader(
                new InputStreamReader(in));

        try {
            String openFileDesCount;
            if ((openFileDesCount = output.readLine()) != null) {
                return Long.parseLong(openFileDesCount);
            }
        } finally {
            if (output != null) {
                output.close();
            }
        }
    } catch (IOException ie) {
        LOG.warn("Not able to get the number of open file descriptors", ie);
    }
    return -1;
}
 

private static long getMemory(MemoryType type, MemoryValue memval) {
    long total = 0;
    List<MemoryPoolMXBean> memoryPoolBeans = ManagementFactory.getMemoryPoolMXBeans();
    if (memoryPoolBeans.isEmpty()) {
        return -1;
    }
    for (Iterator<MemoryPoolMXBean> iterator = memoryPoolBeans.iterator(); iterator.hasNext();) {
        MemoryPoolMXBean memoryPoolMXBean = iterator.next();
        if (memoryPoolMXBean.getType().equals(type)) {
            total += memval.getValue(memoryPoolMXBean);
        }
    }
    return total;
}
 

@PostConstruct
public void init() {
    log.debug("Registering JVM gauges");
    metricRegistry.register(PROP_METRIC_REG_JVM_MEMORY, new MemoryUsageGaugeSet());
    metricRegistry.register(PROP_METRIC_REG_JVM_GARBAGE, new GarbageCollectorMetricSet());
    metricRegistry.register(PROP_METRIC_REG_JVM_THREADS, new ThreadStatesGaugeSet());
    metricRegistry.register(PROP_METRIC_REG_JVM_FILES, new FileDescriptorRatioGauge());
    metricRegistry.register(PROP_METRIC_REG_JVM_BUFFERS, new BufferPoolMetricSet(ManagementFactory.getPlatformMBeanServer()));
    metricRegistry.register(PROP_METRIC_REG_JVM_ATTRIBUTE_SET, new JvmAttributeGaugeSet());
    if (hikariDataSource != null) {
        log.debug("Monitoring the datasource");
        hikariDataSource.setMetricRegistry(metricRegistry);
    }
    if (jHipsterProperties.getMetrics().getJmx().isEnabled()) {
        log.debug("Initializing Metrics JMX reporting");
        JmxReporter jmxReporter = JmxReporter.forRegistry(metricRegistry).build();
        jmxReporter.start();
    }
    if (jHipsterProperties.getMetrics().getLogs().isEnabled()) {
        log.info("Initializing Metrics Log reporting");
        Marker metricsMarker = MarkerFactory.getMarker("metrics");
        final Slf4jReporter reporter = Slf4jReporter.forRegistry(metricRegistry)
            .outputTo(LoggerFactory.getLogger("metrics"))
            .markWith(metricsMarker)
            .convertRatesTo(TimeUnit.SECONDS)
            .convertDurationsTo(TimeUnit.MILLISECONDS)
            .build();
        reporter.start(jHipsterProperties.getMetrics().getLogs().getReportFrequency(), TimeUnit.SECONDS);
    }
}
 

private final int doClassLoadingMXBeanTest(MBeanServerConnection mbsc) {
    int errorCount = 0 ;
    System.out.println("---- ClassLoadingMXBean") ;

    try {
        ObjectName classLoadingName =
                new ObjectName(ManagementFactory.CLASS_LOADING_MXBEAN_NAME) ;
        MBeanInfo mbInfo = mbsc.getMBeanInfo(classLoadingName);
        errorCount += checkNonEmpty(mbInfo);
        System.out.println("getMBeanInfo\t\t"
                + mbInfo);
        ClassLoadingMXBean classLoading = null;

        classLoading = JMX.newMXBeanProxy(mbsc,
                classLoadingName,
                ClassLoadingMXBean.class) ;
        System.out.println("getLoadedClassCount\t\t"
                + classLoading.getLoadedClassCount());
        System.out.println("getTotalLoadedClassCount\t\t"
                + classLoading.getTotalLoadedClassCount());
        System.out.println("getUnloadedClassCount\t\t"
                + classLoading.getUnloadedClassCount());
        System.out.println("isVerbose\t\t"
                + classLoading.isVerbose());

        System.out.println("---- OK\n") ;

    } catch (Exception e) {
        Utils.printThrowable(e, true) ;
        errorCount++ ;
        System.out.println("---- ERROR\n") ;
    }

    return errorCount ;
}
 

public String getUptime()
{
	final long uptime = ManagementFactory.getRuntimeMXBean().getUptime() / 1000;
	final long hours = uptime / 3600;
	final long mins = (uptime - (hours * 3600)) / 60;
	final long secs = ((uptime - (hours * 3600)) - (mins * 60));
	if (hours > 0)
	{
		return hours + "hrs " + mins + "mins " + secs + "secs";
	}
	return mins + "mins " + secs + "secs";
}
 

/**
 * Assert that there are no threads running whose name matches the
 * given regular expression.
 * @param regex the regex to match against
 */
public static void assertNoThreadsMatching(String regex) {
  Pattern pattern = Pattern.compile(regex);
  ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
  
  ThreadInfo[] infos = threadBean.getThreadInfo(threadBean.getAllThreadIds(), 20);
  for (ThreadInfo info : infos) {
    if (info == null) continue;
    if (pattern.matcher(info.getThreadName()).matches()) {
      Assert.fail("Leaked thread: " + info + "\n" +
          Joiner.on("\n").join(info.getStackTrace()));
    }
  }
}
 

private JMXServiceURL createServerSide() throws Exception {
    final int NINETY_SECONDS = 90;

    // We will use the platform mbean server
    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();

    JMXServiceURL url = new JMXServiceURL("rmi", null, 0);
    cs = JMXConnectorServerFactory.newJMXConnectorServer(url, null, mbs);
    cs.start();

    Utils.waitReady(cs, NINETY_SECONDS);

    JMXServiceURL addr = cs.getAddress();
    return addr;
}
 

public synchronized void registerJmx() throws SQLException {
    if (this.isJmxRegistered) {
        return;
    }
    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
    try {
        ObjectName name = new ObjectName("com.mysql.jdbc.jmx:type=LoadBalanceConnectionGroupManager");
        mbs.registerMBean(this, name);
        this.isJmxRegistered = true;
    } catch (Exception e) {
        throw SQLError.createSQLException("Unable to register load-balance management bean with JMX", null, e, null);
    }

}
 

public static void main(String[] args) throws Exception {
    List<HotSpotDiagnosticMXBean> list =
        ManagementFactory.getPlatformMXBeans(HotSpotDiagnosticMXBean.class);
    HotSpotDiagnosticMXBean mbean = list.get(0);
    checkDiagnosticOptions(mbean);

    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
    mbean = ManagementFactory.newPlatformMXBeanProxy(mbs,
                HOTSPOT_DIAGNOSTIC_MXBEAN_NAME,
                HotSpotDiagnosticMXBean.class);
    checkDiagnosticOptions(mbean);
}
 

public TransmissionPhase(MinebdConfig config, ExportProvider exportProvider) {
    super();
    this.maxUnflushedBytes = config.maxUnflushed.toBytes();
    this.minFreeSystemMem = config.minFreeSystemMem.toBytes();
    this.exportProvider = exportProvider;
    executor = new BlockingExecutor(10, 20);
    osBean = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
}
 

public static void main(String[] args) throws Exception {
    CountDownLatch prepareLatch = new CountDownLatch(2);
    AtomicInteger goLatch = new AtomicInteger(1);
    Task taskA = new Task(prepareLatch, goLatch, AnnA.class);
    Task taskB = new Task(prepareLatch, goLatch, AnnB.class);
    taskA.start();
    taskB.start();
    // wait until both threads start-up
    prepareLatch.await();
    // let them go
    goLatch.set(0);
    // obtain ThreadMXBean
    ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
    // wait for threads to finish or dead-lock
    while (taskA.isAlive() || taskB.isAlive()) {
        // attempt to join threads
        taskA.join(500L);
        taskB.join(500L);
        // detect dead-lock
        long[] deadlockedIds = threadBean.findMonitorDeadlockedThreads();
        if (deadlockedIds != null && deadlockedIds.length > 0) {
            StringBuilder sb = new StringBuilder("deadlock detected:\n\n");
            for (ThreadInfo ti : threadBean.getThreadInfo(deadlockedIds, Integer.MAX_VALUE)) {
                sb.append(ti);
            }
            throw new IllegalStateException(sb.toString());
        }
    }
}
 

@Override
public void onFinish(ITestContext ctx) {
    System.gc();
    Runtime rt = Runtime.getRuntime();
    long inMb = 1024 * 1024;
    log.info("Total memory : " + rt.totalMemory() / inMb);
    log.info("Free memory  : " + rt.freeMemory() / inMb);
    log.info("Memory usage : " + (rt.totalMemory() - rt.freeMemory()) / inMb);
    log.info("Process      : " + ManagementFactory.getRuntimeMXBean().getName());
    log.info("<<<<<<<<<<<<<<<<<<<< {} finished >>>>>>>>>>>>>>>>>>>>", ctx.getName());
}
 

public static void main(String[] args) throws Exception {
    List<HotSpotDiagnosticMXBean> list =
        ManagementFactory.getPlatformMXBeans(HotSpotDiagnosticMXBean.class);
    HotSpotDiagnosticMXBean mbean = list.get(0);
    checkVMOption(mbean);

    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
    mbean = ManagementFactory.newPlatformMXBeanProxy(mbs,
                HOTSPOT_DIAGNOSTIC_MXBEAN_NAME,
                HotSpotDiagnosticMXBean.class);
    checkVMOption(mbean);
}
 

@Test
public void test() throws Exception {
  Configuration conf = new Configuration();
  MiniDFSCluster cluster = null;

  try {
    cluster = new MiniDFSCluster.Builder(conf).build();
    cluster.waitActive();

    FSNamesystem fsn = cluster.getNameNode().namesystem;

    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
    ObjectName mxbeanName = new ObjectName(
        "Hadoop:service=NameNode,name=FSNamesystemState");

    String snapshotStats = (String) (mbs.getAttribute(mxbeanName,
        "SnapshotStats"));

    @SuppressWarnings("unchecked")
    Map<String, Object> stat = (Map<String, Object>) JSON
        .parse(snapshotStats);

    assertTrue(stat.containsKey("SnapshottableDirectories")
        && (Long) stat.get("SnapshottableDirectories") == fsn
            .getNumSnapshottableDirs());
    assertTrue(stat.containsKey("Snapshots")
        && (Long) stat.get("Snapshots") == fsn.getNumSnapshots());

    Object pendingDeletionBlocks = mbs.getAttribute(mxbeanName,
      "PendingDeletionBlocks");
    assertNotNull(pendingDeletionBlocks);
    assertTrue(pendingDeletionBlocks instanceof Long);
  } finally {
    if (cluster != null) {
      cluster.shutdown();
    }
  }
}
 

private MemoryUsage getMemoryUsage(MemoryType type) {
    if (type == MemoryType.HEAP) {
        return ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
    } else {
        return ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage();
    }
}
 

static public void unregister(ObjectName mbeanName) {
  LOG.debug("Unregistering "+ mbeanName);
  final MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
  if (mbeanName == null) {
    LOG.debug("Stacktrace: ", new Throwable());
    return;
  }
  try {
    mbs.unregisterMBean(mbeanName);
  } catch (Exception e) {
    LOG.warn("Error unregistering "+ mbeanName, e);
  }
  DefaultMetricsSystem.removeMBeanName(mbeanName);
}
 

@PostConstruct
public void init() {
    log.debug("Registering JVM gauges");
    metricRegistry.register(PROP_METRIC_REG_JVM_MEMORY, new MemoryUsageGaugeSet());
    metricRegistry.register(PROP_METRIC_REG_JVM_GARBAGE, new GarbageCollectorMetricSet());
    metricRegistry.register(PROP_METRIC_REG_JVM_THREADS, new ThreadStatesGaugeSet());
    metricRegistry.register(PROP_METRIC_REG_JVM_FILES, new FileDescriptorRatioGauge());
    metricRegistry.register(PROP_METRIC_REG_JVM_BUFFERS, new BufferPoolMetricSet(ManagementFactory.getPlatformMBeanServer()));
    if (hikariDataSource != null) {
        log.debug("Monitoring the datasource");
        hikariDataSource.setMetricRegistry(metricRegistry);
    }
    if (jHipsterProperties.getMetrics().getJmx().isEnabled()) {
        log.debug("Initializing Metrics JMX reporting");
        JmxReporter jmxReporter = JmxReporter.forRegistry(metricRegistry).build();
        jmxReporter.start();
    }
    if (jHipsterProperties.getMetrics().getLogs().isEnabled()) {
        log.info("Initializing Metrics Log reporting");
        final Slf4jReporter reporter = Slf4jReporter.forRegistry(metricRegistry)
            .outputTo(LoggerFactory.getLogger("metrics"))
            .convertRatesTo(TimeUnit.SECONDS)
            .convertDurationsTo(TimeUnit.MILLISECONDS)
            .build();
        reporter.start(jHipsterProperties.getMetrics().getLogs().getReportFrequency(), TimeUnit.SECONDS);
    }
}
 

@BeforeClass
public static void OneTimeSetUp() throws Exception {
    // Get the Platform MBean Server.
    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();

    // Register the MBeans.
    Cassandra.registerBean(mbs);
    CassandraMetrics.registerBean(mbs);
    Hadoop.registerBean(mbs);
    TomcatServlet.registerBean(mbs);
    Bool.registerBean(mbs);
}
 

@CheckForNull
private static File dumpHeap(@NonNull final String path) {
    try {
        if (heapDumper == null) {
            final Class<?> clz = Class.forName("com.sun.management.HotSpotDiagnosticMXBean");   //NOI18N
            final MBeanServer server = ManagementFactory.getPlatformMBeanServer();
            final Object bean = ManagementFactory.newPlatformMXBeanProxy(
                server,
                "com.sun.management:type=HotSpotDiagnostic",    //NOI18N
                clz);
            final Method m = clz.getDeclaredMethod("dumpHeap", String.class, Boolean.TYPE);
            heapDumper = Pair.of(bean,m);
        }
        final File folder = new File(path);
        final File[] children = folder.listFiles();
        if (children != null) {
            final String namePattern = "heapdump_"; //NOI18N
            final Set<String> names = Arrays.stream(children)
                    .map((f) -> f.getName())
                    .filter((n) -> n.startsWith(namePattern))
                    .collect(Collectors.toSet());
            int index = 1;
            while (true) {
                if (!names.contains(namePattern + index)) {
                    break;
                }
                index++;
            }
            final File file = new File(folder, namePattern + index);
            heapDumper.second().invoke(heapDumper.first(), file.getAbsolutePath(), true);
            return file;
        }
    } catch (Exception e) {
        //pass
    }
    return null;
}
 

private static void checkGcInfo(String name, GcInfo info) throws Exception {
    System.out.println("GC statistic for : " + name);
    System.out.print("GC #" + info.getId());
    System.out.print(" start:" + info.getStartTime());
    System.out.print(" end:" + info.getEndTime());
    System.out.println(" (" + info.getDuration() + "ms)");
    Map usage = info.getMemoryUsageBeforeGc();

    List pnames = new ArrayList();
    for (Iterator iter = usage.entrySet().iterator(); iter.hasNext(); ) {
        Map.Entry entry = (Map.Entry) iter.next();
        String poolname = (String) entry.getKey();
        pnames.add(poolname);
        MemoryUsage busage = (MemoryUsage) entry.getValue();
        MemoryUsage ausage = (MemoryUsage) info.getMemoryUsageAfterGc().get(poolname);
        if (ausage == null) {
            throw new RuntimeException("After Gc Memory does not exist" +
                " for " + poolname);
        }
        System.out.println("Usage for pool " + poolname);
        System.out.println("   Before GC: " + busage);
        System.out.println("   After GC: " + ausage);
    }

    // check if memory usage for all memory pools are returned
    List pools = ManagementFactory.getMemoryPoolMXBeans();
    for (Iterator iter = pools.iterator(); iter.hasNext(); ) {
        MemoryPoolMXBean p = (MemoryPoolMXBean) iter.next();
        if (!pnames.contains(p.getName())) {
            throw new RuntimeException("GcInfo does not contain " +
                "memory usage for pool " + p.getName());
        }
    }
}
 

/**
 * Serves the homepage for a list of whitelisted urls
 *
 * @param model The page model information
 * @return template path
 */
@RateLimit(limitPerMinute = 250)
@RequestMapping(value = {
        "/",
        "/News",
        "/About",
        "/Events",
        "/Events/{id}",
        "/Events/{id}/{name}",
        "/Locations",
        "/Locations/{id}",
        "/Locations/{id}/{name}",
        "/Media",
        "/Medium/{id}",
        "/Medium/{id}/{name}",
        "/Artists",
        "/Artists/{id}",
        "/Artists/{id}/{name}",
        "/Songs",
        "/Songs/{id}",
        "/Songs/{id}/{name}",
        "/Admin",
        "/login",
        "/logout",
        "/Records",
        "/Records/{name}",
        "/search",
        "/search/{name}",
        "/api"
})
public String home(final Model model) {
    model.addAttribute("profile", Optional.ofNullable(env.getProperty("envTarget")).orElse("dev"));
    model.addAttribute("version", ManagementFactory.getRuntimeMXBean().getStartTime());

    return "homepage/index";
}
 

public JMXQuery(){

        try{
             mbs = ManagementFactory.getPlatformMBeanServer();
        }catch (Throwable e){
            _logger.warn("get tomcat run info failed",e);

        }
    }
 

/**
 * Cleanup after close: unregister the ScanManagerMXBean singleton.
 * @throws java.io.IOException Cleanup failed for communication-related reasons.
 * @throws javax.management.JMException Cleanup failed for JMX-related reasons.
 */
public void cleanup() throws IOException, JMException {
    try {
        ((NotificationEmitter)proxy).
                removeNotificationListener(listener,null,null);
    } finally {
        ManagementFactory.getPlatformMBeanServer().
            unregisterMBean(ScanManager.SCAN_MANAGER_NAME);
    }
}
 

private static MemoryPoolMXBean findPool()
{
	MemoryPoolMXBean ret = null;
	for (MemoryPoolMXBean pool : ManagementFactory.getMemoryPoolMXBeans()) {
		if (pool.getType() == MemoryType.HEAP && pool.isUsageThresholdSupported()) {
			ret = pool;
		}
	}
	// we do something when we reached 99.9% of memory usage
	// when we get to this point gc was unable to recover memory.
	ret.setCollectionUsageThreshold((long) Math.floor(ret.getUsage().getMax() * 0.999));

	return (ret);
}
 

/**
 * A debugging tool to print stack traces of most threads, as jstack does.
 * Uninteresting threads are filtered out.
 */
static void dumpTestThreads() {
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        try {
            System.setSecurityManager(null);
        } catch (SecurityException giveUp) {
            return;
        }
    }

    ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
    System.err.println("------ stacktrace dump start ------");
    for (ThreadInfo info : threadMXBean.dumpAllThreads(true, true)) {
        final String name = info.getThreadName();
        String lockName;
        if ("Signal Dispatcher".equals(name))
            continue;
        if ("Reference Handler".equals(name)
            && (lockName = info.getLockName()) != null
            && lockName.startsWith("java.lang.ref.Reference$Lock"))
            continue;
        if ("Finalizer".equals(name)
            && (lockName = info.getLockName()) != null
            && lockName.startsWith("java.lang.ref.ReferenceQueue$Lock"))
            continue;
        if ("checkForWedgedTest".equals(name))
            continue;
        System.err.print(info);
    }
    System.err.println("------ stacktrace dump end ------");

    if (sm != null) System.setSecurityManager(sm);
}
 

public static void main(String[] args) throws Exception {
    List<HotSpotDiagnosticMXBean> list =
        ManagementFactory.getPlatformMXBeans(HotSpotDiagnosticMXBean.class);
    HotSpotDiagnosticMXBean mbean = list.get(0);
    checkDiagnosticOptions(mbean);

    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
    mbean = ManagementFactory.newPlatformMXBeanProxy(mbs,
                HOTSPOT_DIAGNOSTIC_MXBEAN_NAME,
                HotSpotDiagnosticMXBean.class);
    checkDiagnosticOptions(mbean);
}
 

public static String getGCStats() {
    long totalGC = 0;
    long gcTime = 0;

    for (GarbageCollectorMXBean gc : ManagementFactory.getGarbageCollectorMXBeans()) {
        long count = gc.getCollectionCount();

        if (count >= 0) {
            totalGC += count;
        }

        long time = gc.getCollectionTime();

        if (time >= 0) {
            gcTime += time;
        }
    }

    StringBuilder sb = new StringBuilder();

    sb.append(banner("memory stats"));
    sb.append("\n- total collections: " + totalGC);
    sb.append("\n- total collection time: " + formatTime(gcTime));

    Runtime runtime = Runtime.getRuntime();
    sb.append("\n- total memory: " + printMem(runtime.totalMemory()));

    return sb.toString();
}
 

public MBeanRegistry () {
    try {
        mBeanServer = ManagementFactory.getPlatformMBeanServer();        
    } catch (Error e) {
        // Account for running within IKVM and create a new MBeanServer
        // if the PlatformMBeanServer does not exist.
        mBeanServer =  MBeanServerFactory.createMBeanServer();
    }
}
 

protected void readThreadUsage(MonitorElementInstance inst) {

        ThreadMXBean tmb = ManagementFactory.getThreadMXBean();

        inst.setValue("thread_live", tmb.getThreadCount());
        inst.setValue("thread_daemon", tmb.getDaemonThreadCount());
        inst.setValue("thread_peak", tmb.getPeakThreadCount());
        inst.setValue("thread_started", tmb.getTotalStartedThreadCount());
    }
 

public static void restart(String lwjgl) throws IOException {
	StringBuilder cmd = new StringBuilder();
	cmd.append("java ");
	cmd.append("-Djava.library.path=\"" + lwjgl + "\" ");
	cmd.append("-cp \"").append(ManagementFactory.getRuntimeMXBean().getClassPath()).append("\" ");
	cmd.append(Main.class.getName()).append(" ");
	for (String arg : launch_data) {
		cmd.append(arg).append(" ");
	}
	Runtime.getRuntime().exec(cmd.toString());
	System.exit(0);
}
 

public static void premain(String agentArgs, Instrumentation inst) {
        try {
            PromagentCollectorRegistry registry = new PromagentCollectorRegistry();
            ManagementFactory.getPlatformMBeanServer().registerMBean(new Exporter(registry), new ObjectName("io.promagent:type=exporter"));
            Map<String, String> args = parseCmdline(agentArgs);
            if (args.containsKey("port")) {
                BuiltInServer.run(args.get("host"), args.get("port"), registry);
            }
            ClassLoaderCache classLoaderCache = ClassLoaderCache.getInstance();
            List<Path> hookJars = classLoaderCache.getPerDeploymentJars();
            SortedSet<HookMetadata> hookMetadata = new HookMetadataParser(hookJars).parse();
            MetricsStore metricsStore = new MetricsStore(registry);
            Delegator.init(hookMetadata, metricsStore, classLoaderCache);
            printHookMetadata(hookMetadata);

            AgentBuilder agentBuilder = new AgentBuilder.Default()
                    .with(AgentBuilder.RedefinitionStrategy.REDEFINITION)
                    .with(AgentBuilder.TypeStrategy.Default.REDEFINE);
                    // .with(AgentBuilder.Listener.StreamWriting.toSystemError()); // use this to see exceptions thrown in instrumented code
            agentBuilder = applyHooks(agentBuilder, hookMetadata, classLoaderCache);
            agentBuilder.installOn(inst);

            // TODO -- the following is an experiment supporting collectors directly (in addition to hooks)
//            io.prometheus.client.Collector jmxCollector = (io.prometheus.client.Collector) classLoaderCache.currentClassLoader().loadClass("io.promagent.collectors.JmxCollector").newInstance();
//            registry.registerNoJmx(jmxCollector);

        } catch (Throwable t) {
            t.printStackTrace();
        }
    }
 

private static void checkGcInfo(String name, GcInfo info) throws Exception {
    System.out.println("GC statistic for : " + name);
    System.out.print("GC #" + info.getId());
    System.out.print(" start:" + info.getStartTime());
    System.out.print(" end:" + info.getEndTime());
    System.out.println(" (" + info.getDuration() + "ms)");
    Map usage = info.getMemoryUsageBeforeGc();

    List pnames = new ArrayList();
    for (Iterator iter = usage.entrySet().iterator(); iter.hasNext(); ) {
        Map.Entry entry = (Map.Entry) iter.next();
        String poolname = (String) entry.getKey();
        pnames.add(poolname);
        MemoryUsage busage = (MemoryUsage) entry.getValue();
        MemoryUsage ausage = (MemoryUsage) info.getMemoryUsageAfterGc().get(poolname);
        if (ausage == null) {
            throw new RuntimeException("After Gc Memory does not exist" +
                " for " + poolname);
        }
        System.out.println("Usage for pool " + poolname);
        System.out.println("   Before GC: " + busage);
        System.out.println("   After GC: " + ausage);
    }

    // check if memory usage for all memory pools are returned
    List pools = ManagementFactory.getMemoryPoolMXBeans();
    for (Iterator iter = pools.iterator(); iter.hasNext(); ) {
        MemoryPoolMXBean p = (MemoryPoolMXBean) iter.next();
        if (!pnames.contains(p.getName())) {
            throw new RuntimeException("GcInfo does not contain " +
                "memory usage for pool " + p.getName());
        }
    }
}
 

public Status check() {
	OperatingSystemMXBean operatingSystemMXBean = ManagementFactory.getOperatingSystemMXBean();
	double load;
	try {
	    Method method = OperatingSystemMXBean.class.getMethod("getSystemLoadAverage", new Class<?>[0]);
	    load = (Double)method.invoke(operatingSystemMXBean, new Object[0]);
	} catch (Throwable e) {
	    load = -1;
	}
	int cpu = operatingSystemMXBean.getAvailableProcessors();
    return new Status(load < 0 ? Status.Level.UNKNOWN : (load < cpu ? Status.Level.OK : Status.Level.WARN), "Load: " + load + " / CPU: " + cpu);
}