Thread count and classes loaded handlers

jfr-streaming/src/main/java/io/opentelemetry/contrib/jfr/metrics/HandlerRegistry.java

@@ -8,10 +8,12 @@
 import io.opentelemetry.api.metrics.MeterProvider;
 import io.opentelemetry.contrib.jfr.metrics.internal.RecordedEventHandler;
 import io.opentelemetry.contrib.jfr.metrics.internal.ThreadGrouper;
+import io.opentelemetry.contrib.jfr.metrics.internal.classLoading.ClassesLoadedHandler;
 import io.opentelemetry.contrib.jfr.metrics.internal.container.ContainerConfigurationHandler;
 import io.opentelemetry.contrib.jfr.metrics.internal.cpu.ContextSwitchRateHandler;
 import io.opentelemetry.contrib.jfr.metrics.internal.cpu.LongLockHandler;
 import io.opentelemetry.contrib.jfr.metrics.internal.cpu.OverallCPULoadHandler;
+import io.opentelemetry.contrib.jfr.metrics.internal.cpu.ThreadCountHandler;
 import io.opentelemetry.contrib.jfr.metrics.internal.memory.G1HeapSummaryHandler;
 import io.opentelemetry.contrib.jfr.metrics.internal.memory.GCHeapSummaryHandler;
 import io.opentelemetry.contrib.jfr.metrics.internal.memory.ObjectAllocationInNewTLABHandler;
@@ -68,7 +70,9 @@ static HandlerRegistry createDefault(MeterProvider meterProvider) {
             new ContextSwitchRateHandler(),
             new OverallCPULoadHandler(),
             new ContainerConfigurationHandler(),
-            new LongLockHandler(grouper));
+            new LongLockHandler(grouper),
+            new ThreadCountHandler(),
+            new ClassesLoadedHandler());
     handlers.addAll(basicHandlers);
 
     var meter =

jfr-streaming/src/main/java/io/opentelemetry/contrib/jfr/metrics/internal/classLoading/ClassesLoadedHandler.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.contrib.jfr.metrics.internal.classLoading;
+
+import static io.opentelemetry.contrib.jfr.metrics.internal.RecordedEventHandler.defaultMeter;
+
+import io.opentelemetry.api.metrics.Meter;
+import io.opentelemetry.contrib.jfr.metrics.internal.RecordedEventHandler;
+import java.time.Duration;
+import java.util.Optional;
+import jdk.jfr.consumer.RecordedEvent;
+
+public final class ClassesLoadedHandler implements RecordedEventHandler {
+  private static final String METRIC_NAME = "process.runtime.jvm.cpu.loaded_class_count";
+  private static final String EVENT_NAME = "jdk.ClassLoadingStatistics";
+  private static final String METRIC_DESCRIPTION = "Number of loaded classes";
+
+  private volatile long value = 0;
+
+  public ClassesLoadedHandler() {
+    initializeMeter(defaultMeter());
+  }
+
+  @Override
+  public void accept(RecordedEvent ev) {
+    value = ev.getLong("loadedClassCount");
+  }
+
+  @Override
+  public String getEventName() {
+    return EVENT_NAME;
+  }
+
+  @Override
+  public void initializeMeter(Meter meter) {
+    meter
+        .gaugeBuilder(METRIC_NAME)
+        .ofLongs()
+        .setDescription(METRIC_DESCRIPTION)
+        .buildWithCallback(measurement -> measurement.record(value));
+  }
+
+  @Override
+  public Optional<Duration> getPollingDuration() {
+    return Optional.of(Duration.ofSeconds(1));
+  }
+}

jfr-streaming/src/main/java/io/opentelemetry/contrib/jfr/metrics/internal/cpu/ThreadCountHandler.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.contrib.jfr.metrics.internal.cpu;
+
+import static io.opentelemetry.contrib.jfr.metrics.internal.RecordedEventHandler.defaultMeter;
+
+import io.opentelemetry.api.metrics.Meter;
+import io.opentelemetry.contrib.jfr.metrics.internal.RecordedEventHandler;
+import java.time.Duration;
+import java.util.Optional;
+import jdk.jfr.consumer.RecordedEvent;
+
+public final class ThreadCountHandler implements RecordedEventHandler {
+  private static final String METRIC_NAME = "process.runtime.jvm.cpu.active_threads";
+  private static final String EVENT_NAME = "jdk.JavaThreadStatistics";
+  private static final String METRIC_DESCRIPTION = "Number of active threads";
+
+  private volatile long value = 0;
+
+  public ThreadCountHandler() {
+    initializeMeter(defaultMeter());
+  }
+
+  @Override
+  public void accept(RecordedEvent ev) {
+    value = ev.getLong("activeCount");
+  }
+
+  @Override
+  public String getEventName() {
+    return EVENT_NAME;
+  }
+
+  @Override
+  public void initializeMeter(Meter meter) {
+    meter
+        .gaugeBuilder(METRIC_NAME)
+        .ofLongs()
+        .setDescription(METRIC_DESCRIPTION)
+        .buildWithCallback(measurement -> measurement.record(value));
+  }
+
+  @Override
+  public Optional<Duration> getPollingDuration() {
+    return Optional.of(Duration.ofSeconds(1));
+  }
+}

jfr-streaming/src/test/java/io/opentelemetry/contrib/jfr/metrics/AbstractMetricsTest.java

@@ -22,9 +22,14 @@ public class AbstractMetricsTest {
 
   static SdkMeterProvider meterProvider;
   static InMemoryMetricReader metricReader;
+  static boolean isInitialized = false;
 
   @BeforeAll
   static void initializeOpenTelemetry() {
+    if (isInitialized) {
+      return;
+    }
+    isInitialized = true;
     metricReader = InMemoryMetricReader.create();
     meterProvider = SdkMeterProvider.builder().registerMetricReader(metricReader).build();
     GlobalOpenTelemetry.set(OpenTelemetrySdk.builder().setMeterProvider(meterProvider).build());

jfr-streaming/src/test/java/io/opentelemetry/contrib/jfr/metrics/JfrPeriodicMetricsTest.java

@@ -0,0 +1,83 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.contrib.jfr.metrics;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class JfrPeriodicMetricsTest extends AbstractMetricsTest {
+  static class Stressor {
+    private Stressor() {}
+
+    public static void execute(int numberOfThreads, Runnable task) throws Exception {
+      List<Thread> threads = new ArrayList<>();
+      for (int n = 0; n < numberOfThreads; ++n) {
+        Thread t = new Thread(task);
+        threads.add(t);
+        t.start();
+      }
+      for (Thread t : threads) {
+        t.join();
+      }
+    }
+  }
+
+  private static final int THREADS = 10;
+  private static final int MILLIS = 50;
+
+  static Object monitor = new Object();
+  private static int count = 0;
+
+  private static void doWork(Object obj) throws InterruptedException {
+    count++;
+    synchronized (obj) {
+      // Spin until everyone is at critical section. All threads must be running now.
+      while (count < THREADS) {
+        Thread.sleep(MILLIS);
+      }
+    }
+  }
+
+  @Test
+  public void shouldHaveJfrPeriodicEvents() throws Exception {
+    // This should generate some events
+
+    Runnable r =
+        () -> {
+          // create contention between threads for one lock
+          try {
+            doWork(monitor);
+          } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+          }
+        };
+    Stressor.execute(THREADS, r);
+
+    waitAndAssertMetrics(
+        metric ->
+            metric
+                .hasName("process.runtime.jvm.cpu.active_threads")
+                .hasLongGaugeSatisfying(
+                    sum ->
+                        sum.hasPointsSatisfying(
+                            point ->
+                                point.satisfies(
+                                    pointData ->
+                                        Assertions.assertTrue(pointData.getValue() >= THREADS)))),
+        metric ->
+            metric
+                .hasName("process.runtime.jvm.cpu.loaded_class_count")
+                .hasLongGaugeSatisfying(
+                    sum ->
+                        sum.hasPointsSatisfying(
+                            point ->
+                                point.satisfies(
+                                    pointData ->
+                                        Assertions.assertTrue(pointData.getValue() >= 0)))));
+  }
+}