/** * Retrieves the value of the <code>HeapDumpPath</code> JVM option. * @return the value of the <code>HeapDumpPath</code> JVM option or <code>null</code> if the value has not been * specified. */ private static String getHeapDumpPathOption() { RuntimeMXBean runtimeMxBean = ManagementFactory.getRuntimeMXBean(); List<String> inputArguments = runtimeMxBean.getInputArguments(); String heapDumpPathOption = null; for (String argument : inputArguments) { if (argument.startsWith("-XX:HeapDumpPath=")) { heapDumpPathOption = argument; // We do not break in case the option has been specified several times. // In general it seems that JVMs use the right-most argument as the winner. } } if (heapDumpPathOption == null) return null; return heapDumpPathOption.substring(17, heapDumpPathOption.length()); }
private boolean handleStartupInfo(@NotNull List<String> args) { if (args.size() > 0 && "startup-info".equals(args.get(0))) { String jvmLocation = API.getJvmLocation(); infoln("%s", jvmLocation); RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean(); List<String> jvmArgs = bean.getInputArguments(); for (String jvmArg : jvmArgs) { infoln(jvmArg); } infoln("-classpath " + System.getProperty("java.class.path")); // print the non-JVM command line arguments // print name of the main class with its arguments, like org.ClassName param1 param2 infoln(System.getProperty("sun.java.command")); return true; } return false; }
private static synchronized boolean isDebugged() { if (debugMode == null) { debugMode = Boolean.FALSE; // check if we are debugged RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean(); List<String> args = runtime.getInputArguments(); if (args.contains(X_DEBUG_ARG)) { debugMode = Boolean.TRUE; } else if (args.contains(JDWP_DEBUG_ARG)) { debugMode = Boolean.TRUE; } else { for (String arg : args) { if (arg.startsWith(JDWP_DEBUG_ARG_PREFIX)) { debugMode = Boolean.TRUE; break; } } } } return debugMode.booleanValue(); }
private static boolean checkIfDebugged() { try { RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean(); List<String> args = runtime.getInputArguments(); for (String arg : args) { if ("-Xdebug".equals(arg)) { // NOI18N return true; } else if ("-agentlib:jdwp".equals(arg)) { // NOI18N // The idea of checking -agentlib:jdwp // is taken from org.netbeans.modules.sampler.InternalSampler return true; } else if (arg.startsWith("-agentlib:jdwp=")) { // NOI18N return true; } } } catch (SecurityException ex) { } return false; }
@Override public void testRunStarted(Description description) throws Exception { super.testRunStarted(description); Runtime.getRuntime().addShutdownHook(new Thread(() -> { running.set(Boolean.FALSE); })); new Thread(() -> { final RuntimeMXBean runtimeBean = ManagementFactory.getRuntimeMXBean(); final AtomicLong u = new AtomicLong(runtimeBean.getUptime()); while (running.get()) { try { long upTime = runtimeBean.getUptime(); if (upTime >= u.get() + 10000) { u.set(upTime); System.out.printf("Test Up Time = %.3f (s)%n", upTime / 1000d); System.out.printf("Heap Usage = %.3f (MB)%n", ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed() / 1024d / 1024d); System.out.printf("None Heap Usage = %.3f (MB)%n", ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage().getUsed() / 1024d / 1024d); System.out.println("============================="); } Thread.currentThread().sleep(10000l); } catch (InterruptedException ex) { Logger.getLogger(RedissonTestRunListener.class.getName()).log(Level.SEVERE, null, ex); } } }).start(); }
public void start() throws Exception { ConfigurableEnvironment ce = (ConfigurableEnvironment) applicationContext.getEnvironment(); RuntimeMXBean runtimeBean = ManagementFactory.getRuntimeMXBean(); String jvmName = runtimeBean.getName(); long pid = Long.valueOf(jvmName.split("@")[0]); final File tmpDir = new File(".", ".tmp_" + pid); if (tmpDir.exists()) { deleteRecursive(tmpDir); } //noinspection ResultOfMethodCallIgnored tmpDir.mkdir(); Runtime.getRuntime().addShutdownHook(new Thread(this::stop)); baseDir = tmpDir.getAbsolutePath(); PropertyResolver resolver = new SpringPropertyResolver(ce); resolver.initialize(); deployer = ResourceDeployer.newInstance(resolver, tmpDir); deployer.installRuntimeResources(); deployer.startConfigMonitoring(); }
@Override public void refresh() { if(HostInfo.isTomcat()){ webInfo = "view"; } RuntimeMXBean runtimeBean = ManagementFactory.getRuntimeMXBean(); upTime = runtimeBean.getUptime(); EnApp enApp = EnFactory.getEnApp(); enApp.refresh(); appid = nullToNA(EnFactory.getEnBase().getAppId()); appName = nullToNA(enApp.getName()); appChineseName = nullToNA(enApp.getChineseName()); appOwner = nullToNA(enApp.getOwner()); appOwnerEmail = nullToNA(enApp.getOwnerContact()); appBackup = nullToNA(enApp.getBackup()); appVersion = nullToNA(enApp.getVersion()); buildTime = nullToNA(enApp.getBuildTime()); getStatus(); }
/** * Gets the system parameters and environment parameters that were passed to the JVM on startup. * * @return The options passed to the JVM on startup. */ public static String getJvmStartupOptions() { try { final RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean(); final StringBuilder bld = new StringBuilder(); for (String s : bean.getInputArguments()) { bld.append(s).append(' '); } return bld.toString(); } catch (Throwable t) { return UNKNOWN; } }
public Substitutions(Date currentDate, int sequence) { RuntimeMXBean runtimeMx = ManagementFactory.getRuntimeMXBean(); String vmName = runtimeMx.getName(); pid = (vmName.indexOf('@') > 0) ? vmName.substring(0, vmName.indexOf('@')) : "unknown"; hostname = (vmName.indexOf('@') > 0) ? vmName.substring(vmName.indexOf('@') + 1, vmName.length()) : "unknown"; SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd"); dateFormat.setTimeZone(TimeZone.getTimeZone("UTC")); date = dateFormat.format(currentDate); SimpleDateFormat timestampFormat = new SimpleDateFormat("yyyyMMddHHmmss"); timestampFormat.setTimeZone(TimeZone.getTimeZone("UTC")); timestamp = timestampFormat.format(currentDate); hourlyTimestamp = timestamp.substring(0, 10) + "0000"; // yeah, it's a hack startupTimestamp = timestampFormat.format(new Date(runtimeMx.getStartTime())); this.sequence = String.valueOf(sequence); }
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)); }
public static long getDirectMemorySize() { RuntimeMXBean RuntimemxBean = ManagementFactory.getRuntimeMXBean(); List<String> arguments = Lists.reverse(RuntimemxBean.getInputArguments()); long multiplier = 1; //for the byte case. for (String s : arguments) { if (s.contains(MAX_DIRECT_MEMORY_PARAM)) { String memSize = s.toLowerCase(Locale.ENGLISH) .replace(MAX_DIRECT_MEMORY_PARAM.toLowerCase(Locale.ENGLISH), "").trim(); if (memSize.contains("k")) { multiplier = 1024; } else if (memSize.contains("m")) { multiplier = 1048576; } else if (memSize.contains("g")) { multiplier = 1073741824; } memSize = memSize.replaceAll("[^\\d]", ""); long retValue = Long.parseLong(memSize); return retValue * multiplier; } } return DEFAULT_SIZE; }
private Optional<Double> reportCPU(OperatingSystemMXBean operatingSystemMXBean, RuntimeMXBean runtimeMXBean) { int availableProcessors = divideByNbCores ? operatingSystemMXBean.getAvailableProcessors() : 1; long upTime = runtimeMXBean.getUptime(); long processCpuTime = operatingSystemMXBean.getProcessCpuTime(); if (lastMeasures == null || lastMeasures.availableProcessors != availableProcessors || lastMeasures.processCpuTime < 0) { lastMeasures = new Measures(availableProcessors, upTime, processCpuTime); return Optional.empty(); } long elapsedCpu = processCpuTime - lastMeasures.processCpuTime; long elapsedTime = upTime - lastMeasures.upTime; lastMeasures = new Measures(availableProcessors, upTime, processCpuTime); return Optional.of(Math.min(99D, elapsedCpu / (elapsedTime * 10000D * availableProcessors))); }
@Override protected long getLastModifiedTime() { try { URL url = ResourceUtils.getResourceAsUrl(resource); if ("file".equals(url.getProtocol())) { File file = new File(url.getFile()); return file.lastModified(); } } catch (IOException ex) { // ignore } RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean(); long startTime = runtimeMXBean.getStartTime(); // Container start time (browsers are only accurate to the second) return startTime - (startTime % 1000); }
public static void logSystemInfo() { try { OperatingSystemMXBean operatingSystemBean = ManagementFactory.getOperatingSystemMXBean(); Log.info("Operating system" + " name: " + operatingSystemBean.getName() + " version: " + operatingSystemBean.getVersion() + " architecture: " + operatingSystemBean.getArch()); RuntimeMXBean runtimeBean = ManagementFactory.getRuntimeMXBean(); Log.info("Java runtime" + " name: " + runtimeBean.getVmName() + " vendor: " + runtimeBean.getVmVendor() + " version: " + runtimeBean.getVmVersion()); MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean(); Log.info("Memory limit" + " heap: " + memoryBean.getHeapMemoryUsage().getMax() / (1024 * 1024) + "mb" + " non-heap: " + memoryBean.getNonHeapMemoryUsage().getMax() / (1024 * 1024) + "mb"); Log.info("Character encoding: " + System.getProperty("file.encoding") + " charset: " + Charset.defaultCharset()); } catch (Exception error) { Log.warning("Failed to get system info"); } }
private static Integer getProcessId() { try { // Get the current process id using a reflection hack RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean(); Field jvm = runtime.getClass().getDeclaredField("jvm"); jvm.setAccessible(true); VMManagement mgmt = (sun.management.VMManagement) jvm.get(runtime); Method pid_method = mgmt.getClass().getDeclaredMethod("getProcessId"); pid_method.setAccessible(true); Integer pid = (Integer) pid_method.invoke(mgmt); return pid; } catch(Exception ex) { return null; } }
/** * Get the java agent passed to this process and pass it to the child VMs. * This was added to support jacoco code coverage reports */ private String getAgentString() { RuntimeMXBean runtimeBean = ManagementFactory.getRuntimeMXBean(); if (runtimeBean != null) { for(String arg: runtimeBean.getInputArguments()) { if(arg.contains("-javaagent:")) { //HACK for gradle bug GRADLE-2859. Jacoco is passing a relative path //That won't work when we pass this to dunit VMs in a different //directory arg = arg.replace("-javaagent:..", "-javaagent:" + System.getProperty("user.dir") + File.separator + "src/main"); arg = arg.replace("destfile=..", "destfile=" + System.getProperty("user.dir") + File.separator + "src/main"); return arg; } } } return "-DdummyArg=true"; }
public LocatorStatusResponse initialize(final int locatorPort, final String locatorHost, final String locatorLogFile, final String locatorName) { final RuntimeMXBean runtimeBean = ManagementFactory.getRuntimeMXBean(); this.pid = identifyPid(); this.jvmArgs = runtimeBean.getInputArguments(); this.uptime = runtimeBean.getUptime(); this.classpath = runtimeBean.getClassPath(); this.gemfireVersion = GemFireVersion.getGemFireVersion(); this.javaVersion = System.getProperty("java.version"); this.workingDirectory = System.getProperty("user.dir"); this.logFile = locatorLogFile; this.host = locatorHost; this.port = locatorPort; this.name = locatorName; return this; }
private byte[] runtimeData() throws IOException { ByteArrayOutputStream bos = new ByteArrayOutputStream(); final RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean(); final Runtime rt = Runtime.getRuntime(); bos.write(runtimeMXBean.getName().getBytes(StandardCharsets.UTF_8)); bos.write(runtimeMXBean.getVmName().getBytes(StandardCharsets.UTF_8)); bos.write(runtimeMXBean.getVmVendor().getBytes(StandardCharsets.UTF_8)); bos.write(runtimeMXBean.getVmVersion().getBytes(StandardCharsets.UTF_8)); bos.write(runtimeMXBean.getClassPath().getBytes(StandardCharsets.UTF_8)); bos.write(ByteBuffer.allocate(Long.BYTES).putLong(runtimeMXBean.getStartTime()).array()); bos.write(ByteBuffer.allocate(Long.BYTES).putLong(rt.totalMemory()).array()); bos.write(ByteBuffer.allocate(Long.BYTES).putLong(rt.freeMemory()).array()); return bos.toByteArray(); }
private String applicationUptime() { RuntimeMXBean rb = ManagementFactory.getRuntimeMXBean(); long seconds = rb.getUptime() / 1000; long d = (long) Math.floor(seconds / 86400); long h = (long) Math.floor((seconds % 86400) / 3600); long m = (long) Math.floor(((seconds % 86400) % 3600) / 60); long s = (long) Math.floor(((seconds % 86400) % 3600) % 60); if (d > 0) { return String.format("%sd %sh %sm %ss", d, h, m, s); } if (h > 0) { return String.format("%sh %sm %ss", h, m, s); } if (m > 0) { return String.format("%sm %ss", m, s); } return String.format("%ss", s); }
private static void connect(String pid, String address) throws Exception { if (address == null) { throw new RuntimeException("Local connector address for " + pid + " is null"); } System.out.println("Connect to process " + pid + " via: " + address); JMXServiceURL url = new JMXServiceURL(address); JMXConnector c = JMXConnectorFactory.connect(url); MBeanServerConnection server = c.getMBeanServerConnection(); System.out.println("Connected."); RuntimeMXBean rt = newPlatformMXBeanProxy(server, RUNTIME_MXBEAN_NAME, RuntimeMXBean.class); System.out.println(rt.getName()); // close the connection c.close(); }
/** * obtain current process cpu utilization if jdk version is 1.6 by-hongqiangwei */ @SuppressWarnings("restriction") public static double getProcessCpuUtilization() { com.sun.management.OperatingSystemMXBean osMBean = (com.sun.management.OperatingSystemMXBean) ManagementFactory .getOperatingSystemMXBean(); RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean(); long processCpuTime1 = osMBean.getProcessCpuTime(); long runtime1 = runtimeMXBean.getUptime(); ThreadHelper.suspend(50); long processCpuTime2 = osMBean.getProcessCpuTime(); long runtime2 = runtimeMXBean.getUptime(); long deltaProcessTime = processCpuTime2 - processCpuTime1; long deltaRunTime = (runtime2 - runtime1) * 1000000L; int cpuNumber = Runtime.getRuntime().availableProcessors(); double cpuUtilization = (double) deltaProcessTime / (deltaRunTime * cpuNumber); return cpuUtilization; }
@Override public void sense(final MetricRecorder.Context metricContext) { RuntimeMXBean mxBean = ManagementFactory.getRuntimeMXBean(); metricContext.record(UPTIME, mxBean.getUptime(), Unit.MILLISECOND); }
static File getHeapDump() { String heapDumpPath = null; RuntimeMXBean RuntimemxBean = ManagementFactory.getRuntimeMXBean(); List<String> lst = RuntimemxBean.getInputArguments(); for (String arg : lst) { if (arg.contains("XX:HeapDumpPath")){ int index = arg.indexOf('='); heapDumpPath = arg.substring(index+1); } } if (heapDumpPath == null){ LOG.info("XX:HeapDumpPath parametter not specified"); return null; } File heapDumpFile = new File(heapDumpPath); if (heapDumpFile.exists() && heapDumpFile.canRead() && heapDumpFile.length() > 0) { return heapDumpFile; } LOG.log(Level.INFO, "heap dump was not created at {0}", heapDumpPath); LOG.log(Level.INFO, "heapdump file: exists():{0}, canRead():{1}, length:{2}",new Object[] {heapDumpFile.exists(), heapDumpFile.canRead(), heapDumpFile.length()}); // no heap dump file found - this can happen in case of OOME: unable to create new native thread // try to create heap dump dumpHeap(heapDumpFile.getAbsolutePath()); if (heapDumpFile.exists() && heapDumpFile.canRead() && heapDumpFile.length() > 0) { return heapDumpFile; } LOG.log(Level.INFO, "heap dump failed for {0}", heapDumpPath); return null; }
public JSONObject getInfo(JSONObject query, JSONObject uriParams) { JSONObject v = new JSONObject(); RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean(); v.put("boot-class-path", bean.getBootClassPath()); v.put("start-time", bean.getStartTime()); v.put("commandline", System.getProperty("sun.java.command")); return v; }
private static Integer getPid() { RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean(); String name = runtime.getName(); try { return Integer.parseInt(name.substring(0, name.indexOf('@'))); } catch (Exception e) { } return -1; }
/** * Gets the version of the JVM in the form "VM_Name - Vendor - Spec/Version". * * @return The JVM version. */ public static String getJvmVersion() { try { final RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean(); return bean.getVmName() + " - " + bean.getVmVendor() + " - " + bean.getSpecVersion() + '/' + bean.getVmVersion(); } catch (Throwable t) { return UNKNOWN; } }
/** * Gets the system parameters and environment parameters that were passed to the JVM on startup. * * @return The options passed to the JVM on startup. */ public static String[] getJvmStartupOptionsArray() { try { RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean(); List<String> options = bean.getInputArguments(); return options.toArray(new String[options.size()]); } catch (Throwable t) { return new String[0]; } }
public static JsonKeyPair uptime() { final RuntimeMXBean mgmt = ManagementFactory.getRuntimeMXBean(); return jsonPair() .add(NAME, "java -jar") .add(TIMESTAMP, mgmt.getStartTime() * 1000) .add(EVENT_TYPE, COMPLETE) .add(THREAD_ID, Thread.currentThread().getId()) .add(DURATION, mgmt.getUptime() * 1000) .add(PROCESS_ID, 0); }
/** * Log information about the currently running JVM. */ public static void logJVMInfo() { // Print out vm stats before starting up. RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean(); if (runtime != null) { LOG.info("vmName=" + runtime.getVmName() + ", vmVendor=" + runtime.getVmVendor() + ", vmVersion=" + runtime.getVmVersion()); LOG.info("vmInputArguments=" + runtime.getInputArguments()); } }
JavaVirtualMachine findCurrentJvm() throws JavaVirtualMachine.UnsupportedJavaVirtualMachineException { final RuntimeMXBean runtimeBean = getRuntimeMxBean(); final String specVendor = runtimeBean.getSpecVendor(); final String specVersion = runtimeBean.getSpecVersion(); final String vmVendor = runtimeBean.getVmVendor(); final String vmVersion = runtimeBean.getVmVersion(); logger.debug("JVM spec vendor: '%s'; spec version: '%s'; vm vendor: '%s'; vm version: '%s'", specVendor, specVersion, vmVendor, vmVersion); return JavaVirtualMachine.Supported.find(vmVendor, specVersion); }
@Test public void testStartupTimestamp() throws Exception { Substitutions subs = new Substitutions(TEST_DATE, 0); SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMddHHmmss"); formatter.setTimeZone(TimeZone.getTimeZone("UTC")); RuntimeMXBean runtimeMxBean = ManagementFactory.getRuntimeMXBean(); String expected = formatter.format(new Date(runtimeMxBean.getStartTime())); assertEquals(expected, subs.perform("{startupTimestamp}")); }