Improve binders to take advantage of new function-tracking counters.

* Cache metrics
* Executor service metrics
* Fixed bugs in Prometheus in Dropwizard when registering multiple custom meters whose IDs vary only by tag values.

Author: jkschneider

micrometer-core/src/main/java/io/micrometer/core/instrument/binder/CacheMetrics.java

@@ -21,6 +21,7 @@
 import io.micrometer.core.instrument.*;
 
 import java.util.Arrays;
+import java.util.Collections;
 
 import static java.util.Collections.singletonList;
 
@@ -42,25 +43,16 @@ public CacheMetrics(String name, Iterable<Tag> tags, Cache<?, ?> cache) {
     public void bindTo(MeterRegistry registry) {
         registry.gauge(name + "_size", tags, cache, Cache::size);
 
-        registry.register(Meters.build(name + "_requests")
-                .type(Meter.Type.Counter)
-                .create(cache, (n, cacheRef) -> {
-                    CacheStats stats = cacheRef.stats();
-                    return Arrays.asList(
-                            /**
-                             * The sum of these two measurements is equal to {@link CacheStats#requestCount()}
-                             */
-                            new Measurement(n, singletonList(Tag.of("result", "hit")), stats.hitCount()),
-                            new Measurement(n, singletonList(Tag.of("result", "miss")), stats.missCount())
-                    );
-                }));
-
-        registry.gauge(name + "_evictions", tags, cache, c -> c.stats().evictionCount());
-        registry.gauge(name + "_load_duration", tags, cache, c -> c.stats().totalLoadTime());
+        registry.counter(name + "_requests", Tags.zip("result", "miss"), cache, c -> c.stats().missCount());
+        registry.counter(name + "_requests", Tags.zip("result", "hit"), cache, c -> c.stats().hitCount());
+        registry.counter(name + "_evictions", tags, cache, c -> c.stats().evictionCount());
 
         if (cache instanceof LoadingCache) {
-            registry.gauge(name + "_loads", tags, cache, c -> c.stats().loadCount());
-            registry.gauge(name + "_load_failures", tags, cache, c -> c.stats().loadExceptionCount());
+            // dividing these gives you a measure of load latency
+            registry.counter(name + "_load_duration", tags, cache, c -> c.stats().totalLoadTime());
+            registry.counter(name + "_loads", tags, cache, c -> c.stats().loadCount());
+
+            registry.counter(name + "_load_failures", tags, cache, c -> c.stats().loadExceptionCount());
         }
     }
 }

micrometer-core/src/main/java/io/micrometer/core/instrument/binder/ClassLoaderMetrics.java

@@ -26,6 +26,6 @@ public void bindTo(MeterRegistry registry) {
         ClassLoadingMXBean classLoadingBean = ManagementFactory.getClassLoadingMXBean();
 
         registry.gauge("classes_loaded", classLoadingBean, ClassLoadingMXBean::getLoadedClassCount);
-        registry.gauge("classes_unloaded", classLoadingBean, ClassLoadingMXBean::getUnloadedClassCount);
+        registry.counter("classes_unloaded", classLoadingBean, ClassLoadingMXBean::getUnloadedClassCount);
     }
 }

micrometer-core/src/main/java/io/micrometer/core/instrument/binder/ExecutorServiceMetrics.java

@@ -85,26 +85,20 @@ private void monitor(MeterRegistry registry, ThreadPoolExecutor tp) {
             return;
         }
 
-        registry.register(Meters.build(name)
-                .type(Meter.Type.Counter)
-                .tags(tags)
-                .create(tp, (n, tpRef) -> Arrays.asList(
-                        // The sum of the three lifecycle phases is monotonically increasing, though scheduled and active
-                        // can go up and down as tasks are added and completed. The sum of these three measurements
-                        // gives you the total of all tasks submitted irrespective of whether they have been completed or not.
-                        new Measurement(n, singletonList(Tag.of("lifecycle", "scheduled")), tpRef.getTaskCount()),
-                        new Measurement(n, singletonList(Tag.of("lifecycle", "completed")), tpRef.getCompletedTaskCount()),
-                        new Measurement(n, singletonList(Tag.of("lifecycle", "active")), tpRef.getActiveCount())
-                )));
+        // queued tasks = tasks - completed - active
+        registry.counter(name + "_tasks", tp, tpRef -> tpRef.getTaskCount() + tpRef.getCompletedTaskCount() + tpRef.getActiveCount());
+        registry.counter(name + "_completed", tp, ThreadPoolExecutor::getCompletedTaskCount);
 
+        registry.gauge(name + "_active", tp, ThreadPoolExecutor::getActiveCount);
         registry.gauge(name + "_queue_size", tags, tp, tpRef -> tpRef.getQueue().size());
         registry.gauge(name + "_pool_size", tags, tp, ThreadPoolExecutor::getPoolSize);
     }
 
     private void monitor(MeterRegistry registry, ForkJoinPool fj) {
-        registry.gauge(name + "_active", fj, ForkJoinPool::getActiveThreadCount);
+        registry.counter(name + "_steal_count", fj, ForkJoinPool::getStealCount);
+
         registry.gauge(name + "_queued_tasks", fj, ForkJoinPool::getQueuedTaskCount);
+        registry.gauge(name + "_active", fj, ForkJoinPool::getActiveThreadCount);
         registry.gauge(name + "_running_threads", fj, ForkJoinPool::getRunningThreadCount);
-        registry.gauge(name + "_steal_count", fj, ForkJoinPool::getStealCount);
     }
 }

micrometer-core/src/main/java/io/micrometer/core/instrument/dropwizard/DropwizardMeterRegistry.java

@@ -114,12 +114,11 @@ public LongTaskTimer longTaskTimer(String name, Iterable<Tag> tags) {
 
     @Override
     public MeterRegistry register(Meter meter) {
-        MapAccess.computeIfAbsent(meterMap, new MeterId(meter.getName(), meter.getTags()), id -> {
-            for (int i = 0; i < meter.measure().size(); i++) {
-                final int index = i;
-                registry.register(toDropwizardName(id), (Gauge<Double>) () -> meter.measure().get(index).getValue());
-            }
-            return meter;
+        meter.measure().forEach(ms -> {
+            MapAccess.computeIfAbsent(meterMap, new MeterId(ms.getName(), ms.getTags()), id -> {
+                registry.register(toDropwizardName(id), (Gauge<Double>) ms::getValue);
+                return meter;
+            });
         });
 
         return this;

micrometer-core/src/main/java/io/micrometer/core/instrument/prometheus/PrometheusDistributionSummary.java

@@ -17,6 +17,7 @@
 
 import io.micrometer.core.instrument.Meters;
 import io.micrometer.core.instrument.Tag;
+import io.micrometer.core.instrument.prometheus.internal.CustomPrometheusSummary;
 import io.micrometer.core.instrument.util.MeterId;
 import io.micrometer.core.instrument.DistributionSummary;
 import io.micrometer.core.instrument.Measurement;

micrometer-core/src/main/java/io/micrometer/core/instrument/prometheus/PrometheusLongTaskTimer.java

@@ -19,6 +19,7 @@
 import io.micrometer.core.instrument.Measurement;
 import io.micrometer.core.instrument.Meters;
 import io.micrometer.core.instrument.Tag;
+import io.micrometer.core.instrument.prometheus.internal.CustomPrometheusLongTaskTimer;
 import io.micrometer.core.instrument.util.MeterId;
 
 import java.util.List;

micrometer-core/src/main/java/io/micrometer/core/instrument/prometheus/PrometheusMeterRegistry.java

@@ -18,6 +18,9 @@
 import io.micrometer.core.instrument.*;
 import io.micrometer.core.instrument.AbstractMeterRegistry;
 import io.micrometer.core.instrument.internal.FunctionTrackingCounter;
+import io.micrometer.core.instrument.prometheus.internal.CustomPrometheusCollector;
+import io.micrometer.core.instrument.prometheus.internal.CustomPrometheusLongTaskTimer;
+import io.micrometer.core.instrument.prometheus.internal.CustomPrometheusSummary;
 import io.micrometer.core.instrument.util.MapAccess;
 import io.micrometer.core.instrument.util.MeterId;
 import io.micrometer.core.instrument.stats.hist.Histogram;
@@ -38,7 +41,6 @@
 import java.util.function.Function;
 import java.util.function.ToDoubleFunction;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 import static java.util.stream.Collectors.toList;
 import static java.util.stream.StreamSupport.stream;
@@ -188,45 +190,27 @@ public double get() {
     @Override
     public MeterRegistry register(Meter meter) {
         meterMap.computeIfAbsent(new MeterId(meter.getName(), meter.getTags()), id -> {
-            collectorMap.computeIfAbsent(meter.getName(), name -> {
-                Collector collector = new Collector() {
-                    @Override
-                    public List<MetricFamilySamples> collect() {
-                        List<MetricFamilySamples.Sample> samples = meter.measure().stream()
-                                .map(m -> {
-                                    Iterable<Tag> allTags = withCommonTags(m.getTags());
-                                    List<String> tagKeys = new ArrayList<>();
-                                    List<String> tagValues = new ArrayList<>();
-                                    for (Tag tag : allTags) {
-                                        tagKeys.add(tagFormatter.formatTagKey(tag.getKey()));
-                                        tagValues.add(tagFormatter.formatTagValue(tag.getValue()));
-                                    }
-                                    return new MetricFamilySamples.Sample(tagFormatter.formatName(m.getName()), tagKeys, tagValues, m.getValue());
-                                })
-                                .collect(toList());
-
-                        Type type = Type.UNTYPED;
-                        switch (meter.getType()) {
-                            case Counter:
-                                type = Type.COUNTER;
-                                break;
-                            case Gauge:
-                                type = Type.GAUGE;
-                                break;
-                            case DistributionSummary:
-                            case Timer:
-                                type = Type.SUMMARY;
-                                break;
-                        }
-
-                        return Collections.singletonList(new MetricFamilySamples(meter.getName(), type, " ", samples));
-                    }
-                };
+            CustomPrometheusCollector c = (CustomPrometheusCollector) collectorMap.computeIfAbsent(meter.getName(), name -> {
+                Collector.Type type = Collector.Type.UNTYPED;
+                switch (meter.getType()) {
+                    case Counter:
+                        type = Collector.Type.COUNTER;
+                        break;
+                    case Gauge:
+                        type = Collector.Type.GAUGE;
+                        break;
+                    case DistributionSummary:
+                    case Timer:
+                        type = Collector.Type.SUMMARY;
+                        break;
+                }
 
+                Collector collector = new CustomPrometheusCollector(name, type);
                 registry.register(collector);
                 return collector;
             });
 
+            c.child(meter::measure);
             return meter;
         });
 

micrometer-core/src/main/java/io/micrometer/core/instrument/prometheus/PrometheusTimer.java

@@ -18,6 +18,7 @@
 import io.micrometer.core.instrument.Clock;
 import io.micrometer.core.instrument.Measurement;
 import io.micrometer.core.instrument.AbstractTimer;
+import io.micrometer.core.instrument.prometheus.internal.CustomPrometheusSummary;
 import io.micrometer.core.instrument.util.MeterId;
 import io.micrometer.core.instrument.util.TimeUtils;
 

micrometer-core/src/main/java/io/micrometer/core/instrument/prometheus/CustomCollectorChild.java renamed to micrometer-core/src/main/java/io/micrometer/core/instrument/prometheus/internal/CustomCollectorChild.java

@@ -13,17 +13,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package io.micrometer.core.instrument.prometheus;
+package io.micrometer.core.instrument.prometheus.internal;
 
 import io.micrometer.core.instrument.Measurement;
 import io.micrometer.core.instrument.Tag;
 import io.prometheus.client.Collector;
 
 import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.atomic.AtomicLong;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
+import static java.util.stream.Collectors.toList;
+import static java.util.stream.StreamSupport.stream;
+
 public interface CustomCollectorChild {
     Stream<Collector.MetricFamilySamples.Sample> collect();
 

micrometer-core/src/main/java/io/micrometer/core/instrument/prometheus/internal/CustomPrometheusCollector.java

@@ -0,0 +1,70 @@
+/**
+ * Copyright 2017 Pivotal Software, Inc.
+ *
+ * Licensed 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 io.micrometer.core.instrument.prometheus.internal;
+
+import io.micrometer.core.instrument.Measurement;
+import io.micrometer.core.instrument.Tag;
+import io.prometheus.client.Collector;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toList;
+
+public class CustomPrometheusCollector extends Collector {
+    private final String name;
+    private final Type type;
+    private final Collection<Child> children = new ConcurrentLinkedQueue<>();
+
+    public CustomPrometheusCollector(String name, Type type) {
+        this.type = type;
+        this.name = name;
+    }
+
+    public Child child(Supplier<List<Measurement>> measurementSupplier) {
+        Child child = new Child(measurementSupplier);
+        children.add(child);
+        return child;
+    }
+
+    @Override
+    public List<MetricFamilySamples> collect() {
+        return Collections.singletonList(new MetricFamilySamples(name, type, " ", children.stream()
+                .flatMap(Child::collect).collect(toList())));
+    }
+
+    class Child implements CustomCollectorChild {
+        private final Supplier<List<Measurement>> measurementSupplier;
+
+        Child(Supplier<List<Measurement>> measurementSupplier) {
+            this.measurementSupplier = measurementSupplier;
+        }
+
+        @Override
+        public Stream<Collector.MetricFamilySamples.Sample> collect() {
+            return measurementSupplier.get().stream()
+                    .map(m -> {
+                        List<String> keys = m.getTags().stream().map(Tag::getKey).collect(toList());
+                        List<String> values = m.getTags().stream().map(Tag::getValue).collect(toList());
+                        return new MetricFamilySamples.Sample(name, keys, values, m.getValue());
+                    });
+        }
+    }
+}