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()});
  }
예제 #2
0
  @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();
 }
예제 #4
0
  /**
   * 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();
  }
예제 #5
0
파일: Main.java 프로젝트: ratnikov/jruby
  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));
  }
예제 #8
0
  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));
  }
예제 #10
0
  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));
  }
예제 #13
0
 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());
 }
예제 #14
0
  /**
   * @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();
  }
예제 #15
0
 /**
  * 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.");
 }
예제 #16
0
  /**
   * 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();
  }
예제 #17
0
  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;
  }
예제 #18
0
  @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;
  }
예제 #19
0
  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;
  }
예제 #20
0
  /**
   * 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();
  }