public String func_71487_a() { RuntimeMXBean runtimemxbean = ManagementFactory.getRuntimeMXBean(); List list = runtimemxbean.getInputArguments(); int i = 0; StringBuilder stringbuilder = new StringBuilder(); Iterator iterator = list.iterator(); do { if (!iterator.hasNext()) { break; } String s = (String) iterator.next(); if (s.startsWith("-X")) { if (i++ > 0) { stringbuilder.append(" "); } stringbuilder.append(s); } } while (true); return String.format( "%d total; %s", new Object[] {Integer.valueOf(i), stringbuilder.toString()}); }
@RequestMapping("/loadRuntimeInfo") @ResponseBody public JSONObject doLoadRuntimeInfo(HttpServletRequest request) { try { String app = request.getParameter("app"); RuntimeMXBean mBean = JMConnManager.getRuntimeMBean(app); ClassLoadingMXBean cBean = JMConnManager.getClassMbean(app); Map<String, String> props = mBean.getSystemProperties(); DateFormat format = DateFormat.getInstance(); List<String> input = mBean.getInputArguments(); Date date = new Date(mBean.getStartTime()); TreeMap<String, Object> data = new TreeMap<String, Object>(); data.put("apppid", mBean.getName()); data.put("startparam", input.toString()); data.put("starttime", format.format(date)); data.put("classLoadedNow", cBean.getLoadedClassCount()); data.put("classUnloadedAll", cBean.getUnloadedClassCount()); data.put("classLoadedAll", cBean.getTotalLoadedClassCount()); data.putAll(props); JSONObject json = new JSONObject(true); json.putAll(data); return json; } catch (IOException e) { throw new RuntimeException(e); } }
private String getVMArguments() { final StringBuilder result = new StringBuilder(1024); final RuntimeMXBean rmBean = ManagementFactory.getRuntimeMXBean(); final List<String> inputArguments = rmBean.getInputArguments(); for (String arg : inputArguments) { result.append(arg).append(" "); } return result.toString(); }
/** * Create the JVM information * * @return */ private JsonValue getJVMInformation() { JsonObject report = JsonValueBuilder.jsonValue(); // Arguments List<String> arguments = runtimeMxBean.getInputArguments(); JsonArray argumentsJson = report.array(JVM_ARGUMENTS_LABEL); for (String argument : arguments) { argumentsJson.add(argument); } // some useful jvm properties JsonObject propertiesJson = JsonValueBuilder.jsonValue(); propertiesJson.put("java.vm.info", System.getProperty("java.vm.info")); propertiesJson.put("java.vm.name", System.getProperty("java.vm.info")); propertiesJson.put( "java.vm.specification.name", System.getProperty("java.vm.specification.name")); propertiesJson.put( "java.vm.specification.vendor", System.getProperty("java.vm.specification.vendor")); propertiesJson.put( "java.vm.specification.version", System.getProperty("java.vm.specification.version")); propertiesJson.put("java.vm.vendor", System.getProperty("java.vm.vendor")); propertiesJson.put("java.vm.version", System.getProperty("java.vm.version")); report.put(JVM_PROPERTIES_LABEL, propertiesJson.build().asMap()); report.put(JVM_JAVA_VERSION_LABEL, System.getProperty("java.version")); // Memory JsonObject memoryJson = JsonValueBuilder.jsonValue(); memoryJson.put(JVM_UNIT_MEMORY_LABEL, FileSizeUnit.MB); // Getting the runtime reference from system Runtime runtime = Runtime.getRuntime(); // Print used memory memoryJson.put( JVM_USED_MEMORY_LABEL, FileSizeUnit.B.toMB(runtime.totalMemory() - runtime.freeMemory())); // Print free memory memoryJson.put(JVM_FREE_MEMORY_LABEL, FileSizeUnit.B.toMB(runtime.freeMemory())); // Print total available memory memoryJson.put(JVM_TOTAL_MEMORY_LABEL, FileSizeUnit.B.toMB(runtime.totalMemory())); // Print Maximum available memory memoryJson.put(JVM_MAX_MEMORY_LABEL, FileSizeUnit.B.toMB(runtime.maxMemory())); // GNU systems don't support the "sun.arch.data.model" property, so we print both memoryJson.put(JVM_BIT_SIZE_GNU_LABEL, System.getProperty("sun.arch.data.model")); memoryJson.put(JVM_BIT_SIZE_LABEL, System.getProperty("os.arch")); report.put(JVM_MEMORY_LABEL, memoryJson.build().asMap()); return report.build(); }
private String getRuntimeFlagValue(String prefix) { RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean(); for (String param : runtime.getInputArguments()) { if (param.startsWith(prefix)) { return param.substring(prefix.length()).toUpperCase(); } } return null; }
private void writeSystemProperties() { try { Properties properties = System.getProperties(); int maxKeyLength = 1; List<String> keys = new ArrayList<String>(); for (Map.Entry<Object, Object> entry : properties.entrySet()) { Object objKey = entry.getKey(); Object objValue = entry.getValue(); // Filter out any bad non-String keys or values in system properties if (objKey instanceof String && objValue instanceof String) { String key = (String) objKey; keys.add(key); maxKeyLength = Math.max(maxKeyLength, key.length()); } } String inputArguments = null; try { RuntimeMXBean mxbean = ManagementFactory.getRuntimeMXBean(); inputArguments = mxbean.getInputArguments().toString(); } catch (SecurityException se) { inputArguments = "unknown"; } String nl = System.getProperty("line.separator"); StringBuffer data = new StringBuffer(); data.append("All Java System Properties for this Terracotta instance:"); data.append(nl); data.append("========================================================================"); data.append(nl); data.append("JVM arguments: " + inputArguments); data.append(nl); String[] sortedKeys = keys.toArray(new String[keys.size()]); Arrays.sort(sortedKeys); for (String key : sortedKeys) { data.append(key); for (int i = 0; i < maxKeyLength - key.length(); i++) { data.append(' '); } data.append(" : "); data.append(properties.get(key)); data.append(nl); } data.append("========================================================================"); getLogger(TCLoggingLog4J.class).info(data.toString()); } catch (Throwable t) { // don't let exceptions here be fatal t.printStackTrace(); } }
private void g() { RuntimeMXBean localRuntimeMXBean = ManagementFactory.getRuntimeMXBean(); List localList = localRuntimeMXBean.getInputArguments(); int i = 0; for (String str : localList) { if (str.startsWith("-X")) { a("jvm_arg[" + i++ + "]", str); } } a("jvm_args", Integer.valueOf(i)); }
private void func_76467_g() { RuntimeMXBean var1 = ManagementFactory.getRuntimeMXBean(); List var2 = var1.getInputArguments(); int var3 = 0; Iterator var4 = var2.iterator(); while (var4.hasNext()) { String var5 = (String) var4.next(); if (var5.startsWith("-X")) { this.func_76472_a("jvm_arg[" + var3++ + "]", var5); } } this.func_76472_a("jvm_args", Integer.valueOf(var3)); }
private void addJvmArgsToSnooper() { RuntimeMXBean runtimemxbean = ManagementFactory.getRuntimeMXBean(); List list = runtimemxbean.getInputArguments(); int i = 0; Iterator iterator = list.iterator(); while (iterator.hasNext()) { String s = (String) iterator.next(); if (s.startsWith("-X")) { this.addClientStat("jvm_arg[" + i++ + "]", s); } } this.addClientStat("jvm_args", Integer.valueOf(i)); }
public Map<String, String> getProperties() { Map<String, String> map = new TreeMap<String, String>(); RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean(); List<String> aList = runtimeMXBean.getInputArguments(); String parameters = ""; for (int i = 0; i < aList.size(); i++) { parameters = parameters + " " + aList.get(i); } map.put("params", parameters); map.put("name", runtimeMXBean.getVmName()); map.put("vendor", runtimeMXBean.getVmVendor()); map.put("version", runtimeMXBean.getVmVersion()); map.put("specification", runtimeMXBean.getSpecVersion()); map.put("uptime", DurationFormatUtils.formatDurationHMS(runtimeMXBean.getUptime())); Date date = new Date(runtimeMXBean.getStartTime()); SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss"); map.put("start time", sdf.format(date)); MemoryMXBean memory = ManagementFactory.getMemoryMXBean(); MemoryUsage heap = memory.getHeapMemoryUsage(); map.put( "memory. (heap)", readableFileSize(heap.getUsed()) + "/" + readableFileSize(heap.getCommitted()) + " min:" + readableFileSize(heap.getInit()) + " max:" + readableFileSize(heap.getMax())); MemoryUsage nonheap = memory.getNonHeapMemoryUsage(); map.put( "memory (non heap)", readableFileSize(nonheap.getUsed()) + "/" + readableFileSize(nonheap.getCommitted()) + " min:" + readableFileSize(nonheap.getInit()) + " max:" + readableFileSize(nonheap.getMax())); return map; }
public JvmRuntimeMXBean(RuntimeMXBean runtimeMXBean) { this.bootClassPath = runtimeMXBean.getBootClassPath(); this.classPath = runtimeMXBean.getClassPath(); this.inputArguments = runtimeMXBean.getInputArguments(); this.libraryPath = runtimeMXBean.getLibraryPath(); this.managementSpecVersion = runtimeMXBean.getManagementSpecVersion(); this.name = runtimeMXBean.getName(); this.specName = runtimeMXBean.getSpecName(); this.specVendor = runtimeMXBean.getSpecVendor(); this.specVersion = runtimeMXBean.getSpecVersion(); this.startTime = runtimeMXBean.getStartTime(); this.systemProperties = runtimeMXBean.getSystemProperties(); this.upTime = runtimeMXBean.getUptime(); this.vmName = runtimeMXBean.getVmName(); this.vmVendor = runtimeMXBean.getVmVendor(); this.vmVersion = runtimeMXBean.getVmVersion(); this.bootClassPathSupported = runtimeMXBean.isBootClassPathSupported(); }
private void addJvmArgsToSnooper() { RuntimeMXBean runtimemxbean = ManagementFactory.getRuntimeMXBean(); List list = runtimemxbean.getInputArguments(); int i = 0; Iterator iterator = list.iterator(); do { if (!iterator.hasNext()) { break; } String s = (String) iterator.next(); if (s.startsWith("-X")) { addData((new StringBuilder()).append("jvm_arg[").append(i++).append("]").toString(), s); } } while (true); addData("jvm_args", Integer.valueOf(i)); }
public static void main(String[] args) { RuntimeMXBean vmBean = ManagementFactory.getRuntimeMXBean(); System.out.println("Bean: " + vmBean); boolean bootClassPath = vmBean.isBootClassPathSupported(); System.out.println("Boot Class Path Supported: " + bootClassPath); if (bootClassPath) System.out.println("Boot Class Path: " + vmBean.getBootClassPath()); System.out.println("Class Path: " + vmBean.getClassPath()); System.out.println("Input Arguments: " + vmBean.getInputArguments()); System.out.println("Library Path: " + vmBean.getLibraryPath()); System.out.println("Management Spec. Version: " + vmBean.getManagementSpecVersion()); System.out.println("Name: " + vmBean.getName()); System.out.println("Spec Name: " + vmBean.getSpecName()); System.out.println("Spec Vendor: " + vmBean.getSpecVendor()); System.out.println("Spec Version: " + vmBean.getSpecVersion()); System.out.println("Start Time: " + new Date(vmBean.getStartTime())); System.out.println("System Properties: " + vmBean.getSystemProperties()); System.out.println("Uptime: " + vmBean.getUptime() + "ms"); System.out.println("VM Name: " + vmBean.getVmName()); System.out.println("VM Vendor: " + vmBean.getVmVendor()); System.out.println("VM Version: " + vmBean.getVmVersion()); }
/** * @param args the command line arguments: must be -url <jmx-url>, or -port <port-number> [-host * <host-or-ip], or -pid <pid>, or -help */ public static void main(String[] args) throws Exception { // Parse arguments. final ConnectionArgs cArgs = new ConnectionArgs(args); // Get target's URL final JMXServiceURL target = cArgs.getJMXServiceURL(); // Connect to target (assuming no security) final JMXConnector connector = JMXConnectorFactory.connect(target); // Get an MBeanServerConnection on the remote VM. final MBeanServerConnection remote = connector.getMBeanServerConnection(); final RuntimeMXBean remoteRuntime = ManagementFactory.newPlatformMXBeanProxy( remote, ManagementFactory.RUNTIME_MXBEAN_NAME, RuntimeMXBean.class); System.out.println("Target VM is: " + remoteRuntime.getName()); System.out.println("Started since: " + remoteRuntime.getUptime()); System.out.println("With Classpath: " + remoteRuntime.getClassPath()); System.out.println("And args: " + remoteRuntime.getInputArguments()); connector.close(); }
/** * Code to help figure if our approximation of object heap sizes is close enough. See hbase-900. * Fills memstores then waits so user can heap dump and bring up resultant hprof in something like * jprofiler which allows you get 'deep size' on objects. * * @param args main args */ public static void main(String[] args) { RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean(); LOG.info( "vmName=" + runtime.getVmName() + ", vmVendor=" + runtime.getVmVendor() + ", vmVersion=" + runtime.getVmVersion()); LOG.info("vmInputArguments=" + runtime.getInputArguments()); DefaultMemStore memstore1 = new DefaultMemStore(); // TODO: x32 vs x64 long size = 0; final int count = 10000; byte[] fam = Bytes.toBytes("col"); byte[] qf = Bytes.toBytes("umn"); byte[] empty = new byte[0]; for (int i = 0; i < count; i++) { // Give each its own ts size += memstore1.add(new KeyValue(Bytes.toBytes(i), fam, qf, i, empty)); } LOG.info("memstore1 estimated size=" + size); for (int i = 0; i < count; i++) { size += memstore1.add(new KeyValue(Bytes.toBytes(i), fam, qf, i, empty)); } LOG.info("memstore1 estimated size (2nd loading of same data)=" + size); // Make a variably sized memstore. DefaultMemStore memstore2 = new DefaultMemStore(); for (int i = 0; i < count; i++) { size += memstore2.add(new KeyValue(Bytes.toBytes(i), fam, qf, i, new byte[i])); } LOG.info("memstore2 estimated size=" + size); final int seconds = 30; LOG.info("Waiting " + seconds + " seconds while heap dump is taken"); LOG.info("Exiting."); }
/** * Builds an XML report of the timings to be uploaded for parsing. * * @param sender Who to report to */ static void reportTimings(CommandSource sender) { Platform platform = SpongeImpl.getGame().getPlatform(); JsonObjectBuilder builder = JSONUtil.objectBuilder() // Get some basic system details about the server .add( "version", platform .getImplementation() .getVersion() .orElse(platform.getMinecraftVersion().getName() + "-DEV")) .add("maxplayers", SpongeImpl.getGame().getServer().getMaxPlayers()) .add("start", TimingsManager.timingStart / 1000) .add("end", System.currentTimeMillis() / 1000) .add("sampletime", (System.currentTimeMillis() - TimingsManager.timingStart) / 1000); if (!TimingsManager.privacy) { builder .add("server", getServerName()) .add("motd", SpongeImpl.getGame().getServer().getMotd().toPlain()) .add("online-mode", SpongeImpl.getGame().getServer().getOnlineMode()) .add("icon", MinecraftServer.getServer().getServerStatusResponse().getFavicon()); } final Runtime runtime = Runtime.getRuntime(); RuntimeMXBean runtimeBean = ManagementFactory.getRuntimeMXBean(); builder.add( "system", JSONUtil.objectBuilder() .add("timingcost", getCost()) .add("name", System.getProperty("os.name")) .add("version", System.getProperty("os.version")) .add("jvmversion", System.getProperty("java.version")) .add("arch", System.getProperty("os.arch")) .add("maxmem", runtime.maxMemory()) .add("cpu", runtime.availableProcessors()) .add("runtime", ManagementFactory.getRuntimeMXBean().getUptime()) .add("flags", RUNTIME_FLAG_JOINER.join(runtimeBean.getInputArguments())) .add( "gc", JSONUtil.mapArrayToObject( ManagementFactory.getGarbageCollectorMXBeans(), (input) -> { return JSONUtil.singleObjectPair( input.getName(), JSONUtil.arrayOf(input.getCollectionCount(), input.getCollectionTime())); }))); Set<BlockType> blockTypeSet = Sets.newHashSet(); Set<EntityType> entityTypeSet = Sets.newHashSet(); int size = HISTORY.size(); TimingHistory[] history = new TimingHistory[size + 1]; int i = 0; for (TimingHistory timingHistory : HISTORY) { blockTypeSet.addAll(timingHistory.blockTypeSet); entityTypeSet.addAll(timingHistory.entityTypeSet); history[i++] = timingHistory; } history[i] = new TimingHistory(); // Current snapshot blockTypeSet.addAll(history[i].blockTypeSet); entityTypeSet.addAll(history[i].entityTypeSet); JsonObjectBuilder handlersBuilder = JSONUtil.objectBuilder(); for (TimingIdentifier.TimingGroup group : TimingIdentifier.GROUP_MAP.values()) { for (TimingHandler id : group.handlers) { if (!id.timed && !id.isSpecial()) { continue; } handlersBuilder.add(id.id, JSONUtil.arrayOf(group.id, id.name)); } } builder.add( "idmap", JSONUtil.objectBuilder() .add( "groups", JSONUtil.mapArrayToObject( TimingIdentifier.GROUP_MAP.values(), (group) -> { return JSONUtil.singleObjectPair(group.id, group.name); })) .add("handlers", handlersBuilder) .add( "worlds", JSONUtil.mapArrayToObject( TimingHistory.worldMap.entrySet(), (entry) -> { return JSONUtil.singleObjectPair(entry.getValue(), entry.getKey()); })) .add( "tileentity", JSONUtil.mapArrayToObject( blockTypeSet, (blockType) -> { return JSONUtil.singleObjectPair( Block.getIdFromBlock((Block) blockType), blockType.getId()); })) .add( "entity", JSONUtil.mapArrayToObject( entityTypeSet, (entityType) -> { return JSONUtil.singleObjectPair( ((SpongeEntityType) entityType).entityTypeId, entityType.getId()); }))); // Information about loaded plugins builder.add( "plugins", JSONUtil.mapArrayToObject( SpongeImpl.getGame().getPluginManager().getPlugins(), (plugin) -> { return JSONUtil.objectBuilder() .add( plugin.getId(), JSONUtil.objectBuilder() .add("version", plugin.getVersion().orElse("")) .add("description", plugin.getDescription().orElse("")) .add("website", plugin.getUrl().orElse("")) .add("authors", AUTHOR_LIST_JOINER.join(plugin.getAuthors()))) .build(); })); // Information on the users Config builder.add( "config", JSONUtil.objectBuilder() .add("sponge", serializeConfigNode(SpongeImpl.getGlobalConfig().getRootNode()))); new TimingsExport(sender, builder.build(), history).start(); }
static { RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean(); MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean(); // returns the <process id>@<host> long pid; String xPid = runtimeMXBean.getName(); try { xPid = xPid.split("@")[0]; pid = Long.parseLong(xPid); } catch (Exception e) { pid = -1; } JvmInfo info = new JvmInfo(); info.pid = pid; info.startTime = runtimeMXBean.getStartTime(); info.version = System.getProperty("java.version"); info.vmName = runtimeMXBean.getVmName(); info.vmVendor = runtimeMXBean.getVmVendor(); info.vmVersion = runtimeMXBean.getVmVersion(); info.mem = new Mem(); info.mem.heapInit = memoryMXBean.getHeapMemoryUsage().getInit() < 0 ? 0 : memoryMXBean.getHeapMemoryUsage().getInit(); info.mem.heapMax = memoryMXBean.getHeapMemoryUsage().getMax() < 0 ? 0 : memoryMXBean.getHeapMemoryUsage().getMax(); info.mem.nonHeapInit = memoryMXBean.getNonHeapMemoryUsage().getInit() < 0 ? 0 : memoryMXBean.getNonHeapMemoryUsage().getInit(); info.mem.nonHeapMax = memoryMXBean.getNonHeapMemoryUsage().getMax() < 0 ? 0 : memoryMXBean.getNonHeapMemoryUsage().getMax(); try { Class<?> vmClass = Class.forName("sun.misc.VM"); info.mem.directMemoryMax = (Long) vmClass.getMethod("maxDirectMemory").invoke(null); } catch (Exception t) { // ignore } info.inputArguments = runtimeMXBean .getInputArguments() .toArray(new String[runtimeMXBean.getInputArguments().size()]); try { info.bootClassPath = runtimeMXBean.getBootClassPath(); } catch (UnsupportedOperationException e) { // oracle java 9 info.bootClassPath = System.getProperty("sun.boot.class.path"); if (info.bootClassPath == null) { // something else info.bootClassPath = "<unknown>"; } } info.classPath = runtimeMXBean.getClassPath(); info.systemProperties = Collections.unmodifiableMap(runtimeMXBean.getSystemProperties()); List<GarbageCollectorMXBean> gcMxBeans = ManagementFactory.getGarbageCollectorMXBeans(); info.gcCollectors = new String[gcMxBeans.size()]; for (int i = 0; i < gcMxBeans.size(); i++) { GarbageCollectorMXBean gcMxBean = gcMxBeans.get(i); info.gcCollectors[i] = gcMxBean.getName(); } List<MemoryPoolMXBean> memoryPoolMXBeans = ManagementFactory.getMemoryPoolMXBeans(); info.memoryPools = new String[memoryPoolMXBeans.size()]; for (int i = 0; i < memoryPoolMXBeans.size(); i++) { MemoryPoolMXBean memoryPoolMXBean = memoryPoolMXBeans.get(i); info.memoryPools[i] = memoryPoolMXBean.getName(); } try { @SuppressWarnings("unchecked") Class<? extends PlatformManagedObject> clazz = (Class<? extends PlatformManagedObject>) Class.forName("com.sun.management.HotSpotDiagnosticMXBean"); Class<?> vmOptionClazz = Class.forName("com.sun.management.VMOption"); PlatformManagedObject hotSpotDiagnosticMXBean = ManagementFactory.getPlatformMXBean(clazz); Method vmOptionMethod = clazz.getMethod("getVMOption", String.class); Method valueMethod = vmOptionClazz.getMethod("getValue"); try { Object onError = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "OnError"); info.onError = (String) valueMethod.invoke(onError); } catch (Exception ignored) { } try { Object onOutOfMemoryError = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "OnOutOfMemoryError"); info.onOutOfMemoryError = (String) valueMethod.invoke(onOutOfMemoryError); } catch (Exception ignored) { } try { Object useCompressedOopsVmOption = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "UseCompressedOops"); info.useCompressedOops = (String) valueMethod.invoke(useCompressedOopsVmOption); } catch (Exception ignored) { } try { Object useG1GCVmOption = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "UseG1GC"); info.useG1GC = (String) valueMethod.invoke(useG1GCVmOption); } catch (Exception ignored) { } try { Object initialHeapSizeVmOption = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "InitialHeapSize"); info.configuredInitialHeapSize = Long.parseLong((String) valueMethod.invoke(initialHeapSizeVmOption)); } catch (Exception ignored) { } try { Object maxHeapSizeVmOption = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "MaxHeapSize"); info.configuredMaxHeapSize = Long.parseLong((String) valueMethod.invoke(maxHeapSizeVmOption)); } catch (Exception ignored) { } } catch (Exception ignored) { } INSTANCE = info; }
@Override public List<Attribute> getMonitorData() { ArrayList<Attribute> attrs = new ArrayList<>(13); attrs.add(createAttribute("javaVersion", System.getProperty("java.version"))); attrs.add(createAttribute("javaVendor", System.getProperty("java.vendor"))); attrs.add(createAttribute("jvmVersion", System.getProperty("java.vm.version"))); attrs.add(createAttribute("jvmVendor", System.getProperty("java.vm.vendor"))); attrs.add(createAttribute("javaHome", System.getProperty("java.home"))); attrs.add(createAttribute("classPath", System.getProperty("java.class.path"))); attrs.add(createAttribute("workingDirectory", System.getProperty("user.dir"))); String osInfo = System.getProperty("os.name") + " " + System.getProperty("os.version") + " " + System.getProperty("os.arch"); attrs.add(createAttribute("operatingSystem", osInfo)); String sunOsArchDataModel = System.getProperty("sun.arch.data.model"); if (sunOsArchDataModel != null) { String jvmArch = sunOsArchDataModel; if (!sunOsArchDataModel.toLowerCase().equals("unknown")) { jvmArch += "-bit"; } attrs.add(createAttribute("jvmArchitecture", jvmArch)); } else { attrs.add(createAttribute("jvmArchitecture", "unknown")); } try { attrs.add(createAttribute("systemName", InetAddress.getLocalHost().getCanonicalHostName())); } catch (Exception e) { logger.traceException(e); } Runtime runtime = Runtime.getRuntime(); attrs.add(createAttribute("availableCPUs", runtime.availableProcessors())); attrs.add(createAttribute("maxMemory", runtime.maxMemory())); attrs.add(createAttribute("usedMemory", runtime.totalMemory())); attrs.add(createAttribute("freeUsedMemory", runtime.freeMemory())); String installPath = DirectoryServer.getServerRoot(); if (installPath != null) { attrs.add(createAttribute("installPath", installPath)); } String instancePath = DirectoryServer.getInstanceRoot(); if (instancePath != null) { attrs.add(createAttribute("instancePath", instancePath)); } // Get the JVM input arguments. RuntimeMXBean rtBean = ManagementFactory.getRuntimeMXBean(); List<String> jvmArguments = rtBean.getInputArguments(); if (jvmArguments != null && !jvmArguments.isEmpty()) { StringBuilder argList = new StringBuilder(); for (String jvmArg : jvmArguments) { if (argList.length() > 0) { argList.append(" "); } argList.append("\""); argList.append(jvmArg); argList.append("\""); } attrs.add(createAttribute("jvmArguments", argList.toString())); } // Get the list of supported SSL protocols and ciphers. Collection<String> supportedTlsProtocols; Collection<String> supportedTlsCiphers; try { final SSLContext context = SSLContext.getDefault(); final SSLParameters parameters = context.getSupportedSSLParameters(); supportedTlsProtocols = Arrays.asList(parameters.getProtocols()); supportedTlsCiphers = Arrays.asList(parameters.getCipherSuites()); } catch (Exception e) { // A default SSL context should always be available. supportedTlsProtocols = Collections.emptyList(); supportedTlsCiphers = Collections.emptyList(); } addAttribute(attrs, ATTR_SUPPORTED_TLS_PROTOCOLS, supportedTlsProtocols); addAttribute(attrs, ATTR_SUPPORTED_TLS_CIPHERS, supportedTlsCiphers); return attrs; }
synchronized Result formatSummary() { Result result = new Result(); ProxyClient proxyClient = vmPanel.getProxyClient(); if (proxyClient.isDead()) { return null; } buf = new StringBuilder(); append("<table cellpadding=1>"); try { RuntimeMXBean rmBean = proxyClient.getRuntimeMXBean(); CompilationMXBean cmpMBean = proxyClient.getCompilationMXBean(); ThreadMXBean tmBean = proxyClient.getThreadMXBean(); MemoryMXBean memoryBean = proxyClient.getMemoryMXBean(); ClassLoadingMXBean clMBean = proxyClient.getClassLoadingMXBean(); OperatingSystemMXBean osMBean = proxyClient.getOperatingSystemMXBean(); com.sun.management.OperatingSystemMXBean sunOSMBean = proxyClient.getSunOperatingSystemMXBean(); append("<tr><td colspan=4>"); append("<center><b>" + Messages.SUMMARY_TAB_TAB_NAME + "</b></center>"); String dateTime = headerDateTimeFormat.format(System.currentTimeMillis()); append("<center>" + dateTime + "</center>"); append(newDivider); { // VM info append(newLeftTable); append(Messages.CONNECTION_NAME, vmPanel.getDisplayName()); append( Messages.VIRTUAL_MACHINE, Resources.format( Messages.SUMMARY_TAB_VM_VERSION, rmBean.getVmName(), rmBean.getVmVersion())); append(Messages.VENDOR, rmBean.getVmVendor()); append(Messages.NAME, rmBean.getName()); append(endTable); append(newRightTable); result.upTime = rmBean.getUptime(); append(Messages.UPTIME, formatTime(result.upTime)); if (sunOSMBean != null) { result.processCpuTime = sunOSMBean.getProcessCpuTime(); append(Messages.PROCESS_CPU_TIME, formatNanoTime(result.processCpuTime)); } if (cmpMBean != null) { append(Messages.JIT_COMPILER, cmpMBean.getName()); append( Messages.TOTAL_COMPILE_TIME, cmpMBean.isCompilationTimeMonitoringSupported() ? formatTime(cmpMBean.getTotalCompilationTime()) : Messages.UNAVAILABLE); } else { append(Messages.JIT_COMPILER, Messages.UNAVAILABLE); } append(endTable); } append(newDivider); { // Threads and Classes append(newLeftTable); int tlCount = tmBean.getThreadCount(); int tdCount = tmBean.getDaemonThreadCount(); int tpCount = tmBean.getPeakThreadCount(); long ttCount = tmBean.getTotalStartedThreadCount(); String[] strings1 = formatLongs( tlCount, tpCount, tdCount, ttCount); append(Messages.LIVE_THREADS, strings1[0]); append(Messages.PEAK, strings1[1]); append(Messages.DAEMON_THREADS, strings1[2]); append(Messages.TOTAL_THREADS_STARTED, strings1[3]); append(endTable); append(newRightTable); long clCount = clMBean.getLoadedClassCount(); long cuCount = clMBean.getUnloadedClassCount(); long ctCount = clMBean.getTotalLoadedClassCount(); String[] strings2 = formatLongs(clCount, cuCount, ctCount); append(Messages.CURRENT_CLASSES_LOADED, strings2[0]); append(Messages.TOTAL_CLASSES_LOADED, strings2[2]); append(Messages.TOTAL_CLASSES_UNLOADED, strings2[1]); append(null, ""); append(endTable); } append(newDivider); { // Memory MemoryUsage u = memoryBean.getHeapMemoryUsage(); append(newLeftTable); String[] strings1 = formatKByteStrings(u.getUsed(), u.getMax()); append(Messages.CURRENT_HEAP_SIZE, strings1[0]); append(Messages.MAXIMUM_HEAP_SIZE, strings1[1]); append(endTable); append(newRightTable); String[] strings2 = formatKByteStrings(u.getCommitted()); append(Messages.COMMITTED_MEMORY, strings2[0]); append( Messages.SUMMARY_TAB_PENDING_FINALIZATION_LABEL, Messages.SUMMARY_TAB_PENDING_FINALIZATION_VALUE, memoryBean.getObjectPendingFinalizationCount()); append(endTable); append(newTable); Collection<GarbageCollectorMXBean> garbageCollectors = proxyClient.getGarbageCollectorMXBeans(); for (GarbageCollectorMXBean garbageCollectorMBean : garbageCollectors) { String gcName = garbageCollectorMBean.getName(); long gcCount = garbageCollectorMBean.getCollectionCount(); long gcTime = garbageCollectorMBean.getCollectionTime(); append( Messages.GARBAGE_COLLECTOR, Resources.format( Messages.GC_INFO, gcName, gcCount, (gcTime >= 0) ? formatTime(gcTime) : Messages.UNAVAILABLE), 4); } append(endTable); } append(newDivider); { // Operating System info append(newLeftTable); String osName = osMBean.getName(); String osVersion = osMBean.getVersion(); String osArch = osMBean.getArch(); result.nCPUs = osMBean.getAvailableProcessors(); append(Messages.OPERATING_SYSTEM, osName + " " + osVersion); append(Messages.ARCHITECTURE, osArch); append(Messages.NUMBER_OF_PROCESSORS, result.nCPUs + ""); if (pathSeparator == null) { // Must use separator of remote OS, not File.pathSeparator // from this local VM. In the future, consider using // RuntimeMXBean to get the remote system property. pathSeparator = osName.startsWith("Windows ") ? ";" : ":"; } if (sunOSMBean != null) { String[] kbStrings1 = formatKByteStrings(sunOSMBean.getCommittedVirtualMemorySize()); String[] kbStrings2 = formatKByteStrings( sunOSMBean.getTotalPhysicalMemorySize(), sunOSMBean.getFreePhysicalMemorySize(), sunOSMBean.getTotalSwapSpaceSize(), sunOSMBean.getFreeSwapSpaceSize()); append(Messages.COMMITTED_VIRTUAL_MEMORY, kbStrings1[0]); append(endTable); append(newRightTable); append(Messages.TOTAL_PHYSICAL_MEMORY, kbStrings2[0]); append(Messages.FREE_PHYSICAL_MEMORY, kbStrings2[1]); append(Messages.TOTAL_SWAP_SPACE, kbStrings2[2]); append(Messages.FREE_SWAP_SPACE, kbStrings2[3]); } append(endTable); } append(newDivider); { // VM arguments and paths append(newTable); String args = ""; java.util.List<String> inputArguments = rmBean.getInputArguments(); for (String arg : inputArguments) { args += arg + " "; } append(Messages.VM_ARGUMENTS, args, 4); append(Messages.CLASS_PATH, rmBean.getClassPath(), 4); append(Messages.LIBRARY_PATH, rmBean.getLibraryPath(), 4); append( Messages.BOOT_CLASS_PATH, rmBean.isBootClassPathSupported() ? rmBean.getBootClassPath() : Messages.UNAVAILABLE, 4); append(endTable); } } catch (IOException e) { if (JConsole.isDebug()) { e.printStackTrace(); } proxyClient.markAsDead(); return null; } catch (UndeclaredThrowableException e) { if (JConsole.isDebug()) { e.printStackTrace(); } proxyClient.markAsDead(); return null; } append("</table>"); result.timeStamp = System.currentTimeMillis(); result.summary = buf.toString(); return result; }
/** * Retrieve a JVM information text formatted using the given StringManager. * * @param requestedSm the StringManager to use * @return the formatted JVM information text */ private static String getVMInfo(StringManager requestedSm) { StringBuilder sb = new StringBuilder(); synchronized (timeformat) { sb.append(timeformat.format(new Date())); } sb.append(CRLF); sb.append(requestedSm.getString("diagnostics.vmInfoRuntime")); sb.append(":" + CRLF); sb.append(INDENT1 + "vmName: " + runtimeMXBean.getVmName() + CRLF); sb.append(INDENT1 + "vmVersion: " + runtimeMXBean.getVmVersion() + CRLF); sb.append(INDENT1 + "vmVendor: " + runtimeMXBean.getVmVendor() + CRLF); sb.append(INDENT1 + "specName: " + runtimeMXBean.getSpecName() + CRLF); sb.append(INDENT1 + "specVersion: " + runtimeMXBean.getSpecVersion() + CRLF); sb.append(INDENT1 + "specVendor: " + runtimeMXBean.getSpecVendor() + CRLF); sb.append( INDENT1 + "managementSpecVersion: " + runtimeMXBean.getManagementSpecVersion() + CRLF); sb.append(INDENT1 + "name: " + runtimeMXBean.getName() + CRLF); sb.append(INDENT1 + "startTime: " + runtimeMXBean.getStartTime() + CRLF); sb.append(INDENT1 + "uptime: " + runtimeMXBean.getUptime() + CRLF); sb.append( INDENT1 + "isBootClassPathSupported: " + runtimeMXBean.isBootClassPathSupported() + CRLF); sb.append(CRLF); sb.append(requestedSm.getString("diagnostics.vmInfoOs")); sb.append(":" + CRLF); sb.append(INDENT1 + "name: " + operatingSystemMXBean.getName() + CRLF); sb.append(INDENT1 + "version: " + operatingSystemMXBean.getVersion() + CRLF); sb.append(INDENT1 + "architecture: " + operatingSystemMXBean.getArch() + CRLF); sb.append( INDENT1 + "availableProcessors: " + operatingSystemMXBean.getAvailableProcessors() + CRLF); sb.append( INDENT1 + "systemLoadAverage: " + operatingSystemMXBean.getSystemLoadAverage() + CRLF); sb.append(CRLF); sb.append(requestedSm.getString("diagnostics.vmInfoThreadMxBean")); sb.append(":" + CRLF); sb.append( INDENT1 + "isCurrentThreadCpuTimeSupported: " + threadMXBean.isCurrentThreadCpuTimeSupported() + CRLF); sb.append( INDENT1 + "isThreadCpuTimeSupported: " + threadMXBean.isThreadCpuTimeSupported() + CRLF); sb.append(INDENT1 + "isThreadCpuTimeEnabled: " + threadMXBean.isThreadCpuTimeEnabled() + CRLF); sb.append( INDENT1 + "isObjectMonitorUsageSupported: " + threadMXBean.isObjectMonitorUsageSupported() + CRLF); sb.append( INDENT1 + "isSynchronizerUsageSupported: " + threadMXBean.isSynchronizerUsageSupported() + CRLF); sb.append( INDENT1 + "isThreadContentionMonitoringSupported: " + threadMXBean.isThreadContentionMonitoringSupported() + CRLF); sb.append( INDENT1 + "isThreadContentionMonitoringEnabled: " + threadMXBean.isThreadContentionMonitoringEnabled() + CRLF); sb.append(CRLF); sb.append(requestedSm.getString("diagnostics.vmInfoThreadCounts")); sb.append(":" + CRLF); sb.append(INDENT1 + "daemon: " + threadMXBean.getDaemonThreadCount() + CRLF); sb.append(INDENT1 + "total: " + threadMXBean.getThreadCount() + CRLF); sb.append(INDENT1 + "peak: " + threadMXBean.getPeakThreadCount() + CRLF); sb.append(INDENT1 + "totalStarted: " + threadMXBean.getTotalStartedThreadCount() + CRLF); sb.append(CRLF); sb.append(requestedSm.getString("diagnostics.vmInfoStartup")); sb.append(":" + CRLF); for (String arg : runtimeMXBean.getInputArguments()) { sb.append(INDENT1 + arg + CRLF); } sb.append(CRLF); sb.append(requestedSm.getString("diagnostics.vmInfoPath")); sb.append(":" + CRLF); sb.append(INDENT1 + "bootClassPath: " + runtimeMXBean.getBootClassPath() + CRLF); sb.append(INDENT1 + "classPath: " + runtimeMXBean.getClassPath() + CRLF); sb.append(INDENT1 + "libraryPath: " + runtimeMXBean.getLibraryPath() + CRLF); sb.append(CRLF); sb.append(requestedSm.getString("diagnostics.vmInfoClassLoading")); sb.append(":" + CRLF); sb.append(INDENT1 + "loaded: " + classLoadingMXBean.getLoadedClassCount() + CRLF); sb.append(INDENT1 + "unloaded: " + classLoadingMXBean.getUnloadedClassCount() + CRLF); sb.append(INDENT1 + "totalLoaded: " + classLoadingMXBean.getTotalLoadedClassCount() + CRLF); sb.append(INDENT1 + "isVerbose: " + classLoadingMXBean.isVerbose() + CRLF); sb.append(CRLF); sb.append(requestedSm.getString("diagnostics.vmInfoClassCompilation")); sb.append(":" + CRLF); sb.append(INDENT1 + "name: " + compilationMXBean.getName() + CRLF); sb.append( INDENT1 + "totalCompilationTime: " + compilationMXBean.getTotalCompilationTime() + CRLF); sb.append( INDENT1 + "isCompilationTimeMonitoringSupported: " + compilationMXBean.isCompilationTimeMonitoringSupported() + CRLF); sb.append(CRLF); for (MemoryManagerMXBean mbean : memoryManagerMXBeans) { sb.append(requestedSm.getString("diagnostics.vmInfoMemoryManagers", mbean.getName())); sb.append(":" + CRLF); sb.append(INDENT1 + "isValid: " + mbean.isValid() + CRLF); sb.append(INDENT1 + "mbean.getMemoryPoolNames: " + CRLF); String[] names = mbean.getMemoryPoolNames(); Arrays.sort(names); for (String name : names) { sb.append(INDENT2 + name + CRLF); } sb.append(CRLF); } for (GarbageCollectorMXBean mbean : garbageCollectorMXBeans) { sb.append(requestedSm.getString("diagnostics.vmInfoGarbageCollectors", mbean.getName())); sb.append(":" + CRLF); sb.append(INDENT1 + "isValid: " + mbean.isValid() + CRLF); sb.append(INDENT1 + "mbean.getMemoryPoolNames: " + CRLF); String[] names = mbean.getMemoryPoolNames(); Arrays.sort(names); for (String name : names) { sb.append(INDENT2 + name + CRLF); } sb.append(INDENT1 + "getCollectionCount: " + mbean.getCollectionCount() + CRLF); sb.append(INDENT1 + "getCollectionTime: " + mbean.getCollectionTime() + CRLF); sb.append(CRLF); } sb.append(requestedSm.getString("diagnostics.vmInfoMemory")); sb.append(":" + CRLF); sb.append(INDENT1 + "isVerbose: " + memoryMXBean.isVerbose() + CRLF); sb.append( INDENT1 + "getObjectPendingFinalizationCount: " + memoryMXBean.getObjectPendingFinalizationCount() + CRLF); sb.append(formatMemoryUsage("heap", memoryMXBean.getHeapMemoryUsage())); sb.append(formatMemoryUsage("non-heap", memoryMXBean.getNonHeapMemoryUsage())); sb.append(CRLF); for (MemoryPoolMXBean mbean : memoryPoolMXBeans) { sb.append(requestedSm.getString("diagnostics.vmInfoMemoryPools", mbean.getName())); sb.append(":" + CRLF); sb.append(INDENT1 + "isValid: " + mbean.isValid() + CRLF); sb.append(INDENT1 + "getType: " + mbean.getType() + CRLF); sb.append(INDENT1 + "mbean.getMemoryManagerNames: " + CRLF); String[] names = mbean.getMemoryManagerNames(); Arrays.sort(names); for (String name : names) { sb.append(INDENT2 + name + CRLF); } sb.append(INDENT1 + "isUsageThresholdSupported: " + mbean.isUsageThresholdSupported() + CRLF); try { sb.append(INDENT1 + "isUsageThresholdExceeded: " + mbean.isUsageThresholdExceeded() + CRLF); } catch (UnsupportedOperationException ex) { // IGNORE } sb.append( INDENT1 + "isCollectionUsageThresholdSupported: " + mbean.isCollectionUsageThresholdSupported() + CRLF); try { sb.append( INDENT1 + "isCollectionUsageThresholdExceeded: " + mbean.isCollectionUsageThresholdExceeded() + CRLF); } catch (UnsupportedOperationException ex) { // IGNORE } try { sb.append(INDENT1 + "getUsageThreshold: " + mbean.getUsageThreshold() + CRLF); } catch (UnsupportedOperationException ex) { // IGNORE } try { sb.append(INDENT1 + "getUsageThresholdCount: " + mbean.getUsageThresholdCount() + CRLF); } catch (UnsupportedOperationException ex) { // IGNORE } try { sb.append( INDENT1 + "getCollectionUsageThreshold: " + mbean.getCollectionUsageThreshold() + CRLF); } catch (UnsupportedOperationException ex) { // IGNORE } try { sb.append( INDENT1 + "getCollectionUsageThresholdCount: " + mbean.getCollectionUsageThresholdCount() + CRLF); } catch (UnsupportedOperationException ex) { // IGNORE } sb.append(formatMemoryUsage("current", mbean.getUsage())); sb.append(formatMemoryUsage("collection", mbean.getCollectionUsage())); sb.append(formatMemoryUsage("peak", mbean.getPeakUsage())); sb.append(CRLF); } sb.append(requestedSm.getString("diagnostics.vmInfoSystem")); sb.append(":" + CRLF); Map<String, String> props = runtimeMXBean.getSystemProperties(); ArrayList<String> keys = new ArrayList<String>(props.keySet()); Collections.sort(keys); for (String prop : keys) { sb.append(INDENT1 + prop + ": " + props.get(prop) + CRLF); } sb.append(CRLF); sb.append(requestedSm.getString("diagnostics.vmInfoLogger")); sb.append(":" + CRLF); List<String> loggers = loggingMXBean.getLoggerNames(); Collections.sort(loggers); for (String logger : loggers) { sb.append( INDENT1 + logger + ": level=" + loggingMXBean.getLoggerLevel(logger) + ", parent=" + loggingMXBean.getParentLoggerName(logger) + CRLF); } sb.append(CRLF); return sb.toString(); }