Expose ClassloadingMXBean in Node Stats

Closes #12738

core/src/main/java/org/elasticsearch/monitor/jvm/JvmStats.java

@@ -44,11 +44,13 @@ public class JvmStats implements Streamable, ToXContent {
     private final static RuntimeMXBean runtimeMXBean;
     private final static MemoryMXBean memoryMXBean;
     private final static ThreadMXBean threadMXBean;
+    private final static ClassLoadingMXBean classLoadingMXBean;
 
     static {
         runtimeMXBean = ManagementFactory.getRuntimeMXBean();
         memoryMXBean = ManagementFactory.getMemoryMXBean();
         threadMXBean = ManagementFactory.getThreadMXBean();
+        classLoadingMXBean = ManagementFactory.getClassLoadingMXBean();
     }
 
     public static JvmStats jvmStats() {
@@ -114,6 +116,11 @@ public class JvmStats implements Streamable, ToXContent {
             // buffer pools are not available
         }
 
+        stats.classes = new Classes();
+        stats.classes.loadedClassCount = classLoadingMXBean.getLoadedClassCount();
+        stats.classes.totalLoadedClassCount = classLoadingMXBean.getTotalLoadedClassCount();
+        stats.classes.unloadedClassCount = classLoadingMXBean.getUnloadedClassCount();
+
         return stats;
     }
 
@@ -123,6 +130,7 @@ public class JvmStats implements Streamable, ToXContent {
     Threads threads;
     GarbageCollectors gc;
     List<BufferPool> bufferPools;
+    Classes classes;
 
     private JvmStats() {
     }
@@ -152,6 +160,14 @@ public class JvmStats implements Streamable, ToXContent {
         return gc;
     }
 
+    public List<BufferPool> getBufferPools() {
+        return bufferPools;
+    }
+
+    public Classes getClasses() {
+        return classes;
+    }
+
     @Override
     public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
         builder.startObject(Fields.JVM);
@@ -217,6 +233,14 @@ public class JvmStats implements Streamable, ToXContent {
             builder.endObject();
         }
 
+        if (classes != null) {
+            builder.startObject(Fields.CLASSES);
+            builder.field(Fields.CURRENT_LOADED_COUNT, classes.getLoadedClassCount());
+            builder.field(Fields.TOTAL_LOADED_COUNT, classes.getTotalLoadedClassCount());
+            builder.field(Fields.TOTAL_UNLOADED_COUNT, classes.getUnloadedClassCount());
+            builder.endObject();
+        }
+
         builder.endObject();
         return builder;
     }
@@ -265,6 +289,11 @@ public class JvmStats implements Streamable, ToXContent {
         static final XContentBuilderString NAME = new XContentBuilderString("name");
         static final XContentBuilderString TOTAL_CAPACITY = new XContentBuilderString("total_capacity");
         static final XContentBuilderString TOTAL_CAPACITY_IN_BYTES = new XContentBuilderString("total_capacity_in_bytes");
+
+        static final XContentBuilderString CLASSES = new XContentBuilderString("classes");
+        static final XContentBuilderString CURRENT_LOADED_COUNT = new XContentBuilderString("current_loaded_count");
+        static final XContentBuilderString TOTAL_LOADED_COUNT = new XContentBuilderString("total_loaded_count");
+        static final XContentBuilderString TOTAL_UNLOADED_COUNT = new XContentBuilderString("total_unloaded_count");
     }
 
 
@@ -629,4 +658,46 @@ public class JvmStats implements Streamable, ToXContent {
             out.writeLong(used);
         }
     }
+
+    public static class Classes implements Streamable {
+
+        long loadedClassCount;
+        long totalLoadedClassCount;
+        long unloadedClassCount;
+
+        Classes() {
+        }
+
+        public Classes(long loadedClassCount, long totalLoadedClassCount, long unloadedClassCount) {
+            this.loadedClassCount = loadedClassCount;
+            this.totalLoadedClassCount = totalLoadedClassCount;
+            this.unloadedClassCount = unloadedClassCount;
+        }
+
+        public long getLoadedClassCount() {
+            return loadedClassCount;
+        }
+
+        public long getTotalLoadedClassCount() {
+            return totalLoadedClassCount;
+        }
+
+        public long getUnloadedClassCount() {
+            return unloadedClassCount;
+        }
+
+        @Override
+        public void readFrom(StreamInput in) throws IOException {
+            loadedClassCount = in.readLong();
+            totalLoadedClassCount = in.readLong();
+            unloadedClassCount = in.readLong();
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            out.writeLong(loadedClassCount);
+            out.writeLong(totalLoadedClassCount);
+            out.writeLong(unloadedClassCount);
+        }
+    }
 }

core/src/test/java/org/elasticsearch/monitor/jvm/JvmStatsTests.java

@@ -0,0 +1,94 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.monitor.jvm;
+
+import org.elasticsearch.common.Strings;
+import org.elasticsearch.common.unit.ByteSizeValue;
+import org.elasticsearch.test.ESTestCase;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.hamcrest.Matchers.*;
+
+public class JvmStatsTests extends ESTestCase {
+
+    @Test
+    public void testJvmStats() throws IOException {
+        JvmStats stats = JvmStats.jvmStats();
+        assertNotNull(stats);
+        assertNotNull(stats.getUptime());
+        assertThat(stats.getUptime().millis(), greaterThan(0L));
+        assertThat(stats.getTimestamp(), greaterThan(0L));
+
+        // Mem
+        JvmStats.Mem mem = stats.getMem();
+        assertNotNull(mem);
+        for (ByteSizeValue heap : Arrays.asList(mem.getHeapCommitted(), mem.getHeapMax(), mem.getHeapUsed(), mem.getNonHeapCommitted())) {
+            assertNotNull(heap);
+            assertThat(heap.bytes(), greaterThanOrEqualTo(0L));
+        }
+        assertNotNull(mem.getHeapUsedPercent());
+        assertThat(mem.getHeapUsedPercent(), anyOf(equalTo((short) -1), greaterThanOrEqualTo((short) 0)));
+
+        // Threads
+        JvmStats.Threads threads = stats.getThreads();
+        assertNotNull(threads);
+        assertThat(threads.getCount(), greaterThanOrEqualTo(0));
+        assertThat(threads.getPeakCount(), greaterThanOrEqualTo(0));
+
+        // GC
+        JvmStats.GarbageCollectors gcs = stats.getGc();
+        assertNotNull(gcs);
+
+        JvmStats.GarbageCollector[] collectors = gcs.getCollectors();
+        assertNotNull(collectors);
+        assertThat(collectors.length, greaterThan(0));
+        for (JvmStats.GarbageCollector collector : collectors) {
+            assertTrue(Strings.hasText(collector.getName()));
+            assertNotNull(collector.getCollectionTime());
+            assertThat(collector.getCollectionTime().millis(), anyOf(equalTo(-1L), greaterThanOrEqualTo(0L)));
+            assertThat(collector.getCollectionCount(), anyOf(equalTo(-1L), greaterThanOrEqualTo(0L)));
+        }
+
+        // Buffer Pools
+        List<JvmStats.BufferPool> bufferPools = stats.getBufferPools();
+        if (bufferPools != null) {
+            for (JvmStats.BufferPool bufferPool : bufferPools) {
+                assertNotNull(bufferPool);
+                assertTrue(Strings.hasText(bufferPool.getName()));
+                assertThat(bufferPool.getCount(), greaterThanOrEqualTo(0L));
+                assertNotNull(bufferPool.getTotalCapacity());
+                assertThat(bufferPool.getTotalCapacity().bytes(), greaterThanOrEqualTo(0L));
+                assertNotNull(bufferPool.getUsed());
+                assertThat(bufferPool.getUsed().bytes(), anyOf(equalTo(-1L), greaterThanOrEqualTo(0L)));
+            }
+        }
+
+        // Classes
+        JvmStats.Classes classes = stats.getClasses();
+        assertNotNull(classes);
+        assertThat(classes.getLoadedClassCount(), greaterThanOrEqualTo(0L));
+        assertThat(classes.getTotalLoadedClassCount(), greaterThanOrEqualTo(0L));
+        assertThat(classes.getUnloadedClassCount(), greaterThanOrEqualTo(0L));
+    }
+}

docs/reference/cluster/nodes-stats.asciidoc

@@ -36,7 +36,7 @@ of `indices`, `os`, `process`, `jvm`, `transport`, `http`,
 
 `jvm`::
 	JVM stats, memory pool information, garbage collection, buffer
-	pools
+	pools, number of loaded/unloaded classes
 
 `os`::
 	Operating system stats, load average, cpu, mem, swap