Add eventexecutor workers metric for netty (#6612)

Add a gauge to monitor the number of event executor workers, to give users context around the runtime state without having to know the Netty configuration in use at that time.

Resolves gh-6375

Signed-off-by: ttaehee <[email protected]>

Author: ttaehee

docs/modules/ROOT/pages/reference/netty.adoc

@@ -20,3 +20,21 @@ include::{include-java}/netty/NettyMetricsTests.java[tags=channelInstrumentation
 -----
 
 CAUTION: If you use lazy instrumentation, you must ensure that you do not bind metrics for the same resource multiple times, as this can have runtime drawbacks.
+
+== EventExecutor Metrics
+
+The `NettyEventExecutorMetrics` binder collects metrics from Netty's `EventExecutor` instances:
+
+.EventExecutor metrics
+|===
+|Metric |Type |Description
+
+|`eventexecutor.workers`
+|Gauge
+|The number of event executor workers
+
+|`eventexecutor.tasks.pending`
+|Gauge
+|The number of pending tasks in individual event executors
+
+|===

micrometer-core/src/main/java/io/micrometer/core/instrument/binder/netty4/NettyEventExecutorMetrics.java

@@ -21,6 +21,7 @@
 import io.micrometer.core.instrument.Tags;
 import io.micrometer.core.instrument.binder.MeterBinder;
 import io.netty.channel.EventLoop;
+import io.netty.channel.MultithreadEventLoopGroup;
 import io.netty.util.concurrent.EventExecutor;
 import io.netty.util.concurrent.SingleThreadEventExecutor;
 
@@ -77,6 +78,13 @@ public NettyEventExecutorMetrics(Iterable<EventExecutor> eventExecutors, Iterabl
 
     @Override
     public void bindTo(MeterRegistry registry) {
+        Gauge
+            .builder(NettyMeters.EVENT_EXECUTOR_WORKERS.getName(), this.eventExecutors,
+                    NettyEventExecutorMetrics::getExecutorCount)
+            .description("Number of event executor workers")
+            .tags(tags)
+            .register(registry);
+
         this.eventExecutors.forEach(eventExecutor -> {
             if (eventExecutor instanceof SingleThreadEventExecutor) {
                 SingleThreadEventExecutor singleThreadEventExecutor = (SingleThreadEventExecutor) eventExecutor;
@@ -91,4 +99,16 @@ public void bindTo(MeterRegistry registry) {
         });
     }
 
+    private static double getExecutorCount(Iterable<EventExecutor> executors) {
+        if (executors instanceof MultithreadEventLoopGroup) {
+            return ((MultithreadEventLoopGroup) executors).executorCount();
+        }
+
+        int count = 0;
+        for (EventExecutor ignored : executors) {
+            count++;
+        }
+        return count;
+    }
+
 }

micrometer-core/src/main/java/io/micrometer/core/instrument/binder/netty4/NettyMeters.java

@@ -188,6 +188,26 @@ public Meter.Type getType() {
         public KeyName[] getKeyNames() {
             return EventExecutorTasksPendingKeyNames.values();
         }
+    },
+
+    /**
+     * Number of event executor workers.
+     */
+    EVENT_EXECUTOR_WORKERS {
+        @Override
+        public String getName() {
+            return "netty.eventexecutor.workers";
+        }
+
+        @Override
+        public Meter.Type getType() {
+            return Meter.Type.GAUGE;
+        }
+
+        @Override
+        public KeyName[] getKeyNames() {
+            return new KeyName[0];
+        }
     };
 
     enum AllocatorKeyNames implements KeyName {

micrometer-core/src/test/java/io/micrometer/core/instrument/binder/netty4/NettyEventExecutorMetricsTests.java

@@ -18,18 +18,24 @@
 import io.micrometer.core.instrument.Tags;
 import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
 import io.netty.channel.EventLoop;
+import io.netty.channel.EventLoopGroup;
 import io.netty.channel.MultiThreadIoEventLoopGroup;
 import io.netty.channel.MultithreadEventLoopGroup;
 import io.netty.channel.local.LocalIoHandler;
+import io.netty.util.concurrent.DefaultThreadFactory;
+import io.netty.util.concurrent.EventExecutor;
 import io.netty.util.concurrent.SingleThreadEventExecutor;
 import org.junit.jupiter.api.Test;
 
+import java.util.Arrays;
 import java.util.LinkedHashSet;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
 
 import static io.micrometer.core.instrument.binder.netty4.NettyMeters.EVENT_EXECUTOR_TASKS_PENDING;
+import static io.micrometer.core.instrument.binder.netty4.NettyMeters.EVENT_EXECUTOR_WORKERS;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
 
 /**
  * Tests for {@link NettyEventExecutorMetrics}.
@@ -93,4 +99,56 @@ void shouldHaveCustomTags() throws Exception {
         eventExecutors.shutdownGracefully().get(5, TimeUnit.SECONDS);
     }
 
+    @Test
+    void shouldHaveWorkersMetric() throws Exception {
+        MultiThreadIoEventLoopGroup group = new MultiThreadIoEventLoopGroup(4, new DefaultThreadFactory("test-workers"),
+                LocalIoHandler.newFactory());
+        new NettyEventExecutorMetrics(group).bindTo(this.registry);
+
+        assertThat(this.registry.get(EVENT_EXECUTOR_WORKERS.getName()).gauge().value()).isEqualTo(4);
+
+        group.shutdownGracefully().get(5, TimeUnit.SECONDS);
+    }
+
+    @Test
+    void shouldHaveWorkersMetricWithCustomTags() throws Exception {
+        MultiThreadIoEventLoopGroup group = new MultiThreadIoEventLoopGroup(2, new DefaultThreadFactory("test-workers"),
+                LocalIoHandler.newFactory());
+        Tags extraTags = Tags.of("testKey", "testValue");
+        new NettyEventExecutorMetrics(group, extraTags).bindTo(this.registry);
+
+        assertThat(this.registry.get(EVENT_EXECUTOR_WORKERS.getName()).tags(extraTags).gauge().value()).isEqualTo(2);
+
+        group.shutdownGracefully().get(5, TimeUnit.SECONDS);
+    }
+
+    @Test
+    void shouldCountWorkersForGenericIterableViaFallbackPath() {
+        EventExecutor mockExecutor1 = mock(EventExecutor.class);
+        EventExecutor mockExecutor2 = mock(EventExecutor.class);
+        Iterable<EventExecutor> genericIterable = Arrays.asList(mockExecutor1, mockExecutor2);
+
+        new NettyEventExecutorMetrics(genericIterable, Tags.empty()).bindTo(this.registry);
+
+        assertThat(this.registry.get(EVENT_EXECUTOR_WORKERS.getName()).gauge().value()).isEqualTo(2.0);
+    }
+
+    @Test
+    void shouldHaveWorkersMetricForSubclassOfMultiThreadEventLoopGroup() throws Exception {
+        EventLoopGroup group = new SubclassOfMultiThreadIoEventLoopGroup(3);
+        new NettyEventExecutorMetrics(group).bindTo(this.registry);
+
+        assertThat(this.registry.get(EVENT_EXECUTOR_WORKERS.getName()).gauge().value()).isEqualTo(3.0);
+
+        group.shutdownGracefully().get(5, TimeUnit.SECONDS);
+    }
+
+    private static class SubclassOfMultiThreadIoEventLoopGroup extends MultiThreadIoEventLoopGroup {
+
+        SubclassOfMultiThreadIoEventLoopGroup(int nThreads) {
+            super(nThreads, new DefaultThreadFactory("subclass-test-workers"), LocalIoHandler.newFactory());
+        }
+
+    }
+
 }