diff --git a/config/checkstyle/checkstyle-suppressions.xml b/config/checkstyle/checkstyle-suppressions.xml
index 195bc4a363..e9ad4648d1 100644
--- a/config/checkstyle/checkstyle-suppressions.xml
+++ b/config/checkstyle/checkstyle-suppressions.xml
@@ -5,9 +5,11 @@
+
+
diff --git a/implementations/micrometer-registry-health/build.gradle b/implementations/micrometer-registry-health/build.gradle
index 7ad798c7c0..87666526bc 100644
--- a/implementations/micrometer-registry-health/build.gradle
+++ b/implementations/micrometer-registry-health/build.gradle
@@ -1,5 +1,6 @@
dependencies {
api project(':micrometer-core')
+ api project(':micrometer-binders')
implementation 'org.slf4j:slf4j-api'
diff --git a/implementations/micrometer-registry-health/src/main/java/io/micrometer/health/objectives/JvmServiceLevelObjectives.java b/implementations/micrometer-registry-health/src/main/java/io/micrometer/health/objectives/JvmServiceLevelObjectives.java
index 9b180ec9ca..e5a43f442b 100644
--- a/implementations/micrometer-registry-health/src/main/java/io/micrometer/health/objectives/JvmServiceLevelObjectives.java
+++ b/implementations/micrometer-registry-health/src/main/java/io/micrometer/health/objectives/JvmServiceLevelObjectives.java
@@ -15,9 +15,9 @@
*/
package io.micrometer.health.objectives;
-import io.micrometer.core.instrument.binder.jvm.JvmGcMetrics;
-import io.micrometer.core.instrument.binder.jvm.JvmHeapPressureMetrics;
-import io.micrometer.core.instrument.binder.jvm.JvmMemoryMetrics;
+import io.micrometer.binder.jvm.JvmGcMetrics;
+import io.micrometer.binder.jvm.JvmHeapPressureMetrics;
+import io.micrometer.binder.jvm.JvmMemoryMetrics;
import io.micrometer.health.ServiceLevelObjective;
import java.time.Duration;
diff --git a/implementations/micrometer-registry-health/src/main/java/io/micrometer/health/objectives/OperatingSystemServiceLevelObjectives.java b/implementations/micrometer-registry-health/src/main/java/io/micrometer/health/objectives/OperatingSystemServiceLevelObjectives.java
index 2a849ddf9d..15f92db524 100644
--- a/implementations/micrometer-registry-health/src/main/java/io/micrometer/health/objectives/OperatingSystemServiceLevelObjectives.java
+++ b/implementations/micrometer-registry-health/src/main/java/io/micrometer/health/objectives/OperatingSystemServiceLevelObjectives.java
@@ -15,7 +15,7 @@
*/
package io.micrometer.health.objectives;
-import io.micrometer.core.instrument.binder.system.FileDescriptorMetrics;
+import io.micrometer.binder.system.FileDescriptorMetrics;
import io.micrometer.health.ServiceLevelObjective;
/**
diff --git a/implementations/micrometer-registry-health/src/test/java/io/micrometer/health/HealthMeterRegistryTest.java b/implementations/micrometer-registry-health/src/test/java/io/micrometer/health/HealthMeterRegistryTest.java
index 9de4871ee8..6f8ad86d85 100644
--- a/implementations/micrometer-registry-health/src/test/java/io/micrometer/health/HealthMeterRegistryTest.java
+++ b/implementations/micrometer-registry-health/src/test/java/io/micrometer/health/HealthMeterRegistryTest.java
@@ -18,7 +18,7 @@
import io.micrometer.core.instrument.Meter;
import io.micrometer.core.instrument.MockClock;
import io.micrometer.core.instrument.Timer;
-import io.micrometer.core.instrument.binder.jvm.JvmMemoryMetrics;
+import io.micrometer.binder.jvm.JvmMemoryMetrics;
import io.micrometer.core.instrument.config.MeterFilter;
import io.micrometer.health.objectives.JvmServiceLevelObjectives;
import org.junit.jupiter.api.Test;
diff --git a/implementations/micrometer-registry-statsd/build.gradle b/implementations/micrometer-registry-statsd/build.gradle
index 0fd0573087..3fafd8f40a 100644
--- a/implementations/micrometer-registry-statsd/build.gradle
+++ b/implementations/micrometer-registry-statsd/build.gradle
@@ -4,6 +4,7 @@ plugins {
dependencies {
api project(':micrometer-core')
+ api project(':micrometer-binders')
implementation 'io.projectreactor:reactor-core'
implementation('io.projectreactor.netty:reactor-netty-core') {
diff --git a/implementations/micrometer-registry-statsd/src/main/java/io/micrometer/statsd/internal/LogbackMetricsSuppressingFluxSink.java b/implementations/micrometer-registry-statsd/src/main/java/io/micrometer/statsd/internal/LogbackMetricsSuppressingFluxSink.java
index 335bcff32a..c8a8b32b81 100644
--- a/implementations/micrometer-registry-statsd/src/main/java/io/micrometer/statsd/internal/LogbackMetricsSuppressingFluxSink.java
+++ b/implementations/micrometer-registry-statsd/src/main/java/io/micrometer/statsd/internal/LogbackMetricsSuppressingFluxSink.java
@@ -17,7 +17,7 @@
import java.util.function.LongConsumer;
-import io.micrometer.core.instrument.binder.logging.LogbackMetrics;
+import io.micrometer.binder.logging.LogbackMetrics;
import reactor.core.Disposable;
import reactor.core.publisher.FluxSink;
import reactor.util.context.Context;
diff --git a/implementations/micrometer-registry-statsd/src/test/java/io/micrometer/statsd/StatsdMeterRegistryTest.java b/implementations/micrometer-registry-statsd/src/test/java/io/micrometer/statsd/StatsdMeterRegistryTest.java
index 64ef66bb21..b4b419444b 100644
--- a/implementations/micrometer-registry-statsd/src/test/java/io/micrometer/statsd/StatsdMeterRegistryTest.java
+++ b/implementations/micrometer-registry-statsd/src/test/java/io/micrometer/statsd/StatsdMeterRegistryTest.java
@@ -19,7 +19,7 @@
import ch.qos.logback.classic.Logger;
import io.micrometer.core.Issue;
import io.micrometer.core.instrument.*;
-import io.micrometer.core.instrument.binder.logging.LogbackMetrics;
+import io.micrometer.binder.logging.LogbackMetrics;
import io.micrometer.core.instrument.config.NamingConvention;
import io.micrometer.core.lang.Nullable;
import org.junit.jupiter.api.AfterEach;
diff --git a/micrometer-binders/build.gradle b/micrometer-binders/build.gradle
new file mode 100644
index 0000000000..450393da47
--- /dev/null
+++ b/micrometer-binders/build.gradle
@@ -0,0 +1,149 @@
+plugins {
+ id 'idea'
+}
+
+dependencies {
+ // TODO(anuraaga): HdrHistogram is exposed in the micrometer API but probably shouldn't be
+ api 'org.hdrhistogram:HdrHistogram'
+ implementation('org.latencyutils:LatencyUtils') {
+ exclude group: 'org.hdrhistogram', module: 'HdrHistogram'
+ }
+
+ api project(':micrometer-core')
+
+ // cache monitoring
+ optionalApi 'com.google.guava:guava'
+ optionalApi 'com.github.ben-manes.caffeine:caffeine'
+ optionalApi 'net.sf.ehcache:ehcache'
+ optionalApi 'javax.cache:cache-api'
+ optionalApi 'com.hazelcast:hazelcast'
+ optionalApi 'org.hibernate:hibernate-entitymanager'
+
+ // server runtime monitoring
+ optionalApi 'org.eclipse.jetty:jetty-server'
+ optionalApi 'org.eclipse.jetty:jetty-client'
+ optionalApi 'org.apache.tomcat.embed:tomcat-embed-core'
+ optionalApi 'org.glassfish.jersey.core:jersey-server'
+ optionalApi 'io.grpc:grpc-api'
+
+ // apache httpcomponents monitoring
+ optionalApi 'org.apache.httpcomponents:httpclient'
+ optionalApi 'org.apache.httpcomponents:httpasyncclient'
+
+ // hystrix monitoring
+ // TODO: Mark deprecated in 1.9 in old code
+ // TODO: Make it noop in 1.9 in new code and in 2.0
+ // TODO: Marked for removal in 2.1.0?
+ optionalApi 'com.netflix.hystrix:hystrix-core'
+
+ // log monitoring
+ optionalApi 'ch.qos.logback:logback-classic'
+ optionalApi 'org.apache.logging.log4j:log4j-core'
+
+ // @Timed AOP
+ optionalApi 'com.squareup.okhttp3:okhttp'
+
+ optionalApi 'org.mongodb:mongodb-driver-sync'
+
+ optionalApi 'org.jooq:jooq'
+
+ optionalApi 'org.apache.kafka:kafka-clients'
+ optionalApi 'org.apache.kafka:kafka-streams'
+
+ testImplementation 'io.projectreactor:reactor-test'
+
+ // JUnit 5
+ testImplementation 'org.junit.jupiter:junit-jupiter'
+ testImplementation 'com.tngtech.archunit:archunit-junit5'
+
+ // Eclipse still needs this (as of 4.7.1a)
+ testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
+
+ testImplementation 'org.mockito:mockito-inline'
+
+ testImplementation 'org.hsqldb:hsqldb'
+
+ // dependency injection tests
+ testImplementation 'javax.inject:javax.inject'
+ testImplementation 'org.springframework:spring-context'
+ testImplementation 'com.google.inject:guice'
+
+ testImplementation 'com.h2database:h2'
+
+ // Uncomment these if you are interested in testing injection with dagger in MeterRegistryInjectionTest
+// testImplementation 'com.google.dagger:dagger'
+// testAnnotationProcessor 'com.google.dagger:dagger-compiler'
+
+ testImplementation 'org.assertj:assertj-core'
+ testImplementation 'org.awaitility:awaitility'
+
+ testImplementation 'org.ehcache:ehcache'
+
+ testImplementation 'org.apache.kafka:kafka-clients'
+
+ testImplementation 'org.apache.commons:commons-pool2:2.+'
+
+ testImplementation 'org.glassfish.jersey.test-framework.providers:jersey-test-framework-provider-inmemory'
+ testRuntimeOnly 'org.glassfish.jersey.inject:jersey-hk2'
+
+ testImplementation 'ru.lanwen.wiremock:wiremock-junit5'
+ testImplementation 'com.github.tomakehurst:wiremock-jre8-standalone'
+
+ // Log4j2 Async dependency
+ testImplementation 'com.lmax:disruptor:3.4.+'
+
+ // Kafka binder IT dependencies
+ testImplementation 'org.testcontainers:testcontainers'
+ testImplementation 'org.testcontainers:junit-jupiter'
+ testImplementation 'org.testcontainers:kafka'
+
+ // Postgres Binder IT dependencies
+ testImplementation 'org.testcontainers:postgresql'
+ testImplementation 'org.postgresql:postgresql'
+
+ testImplementation 'org.testcontainers:mongodb'
+}
+
+task shenandoahTest(type: Test) {
+ // set heap size for the test JVM(s)
+ maxHeapSize = "1500m"
+
+ useJUnitPlatform {
+ includeTags 'gc'
+ }
+
+ jvmArgs '-XX:+UseShenandoahGC'
+}
+
+task zgcTest(type: Test) {
+ // set heap size for the test JVM(s)
+ maxHeapSize = "1500m"
+
+ useJUnitPlatform {
+ includeTags 'gc'
+ }
+
+ jvmArgs '-XX:+UseZGC'
+}
+
+task openj9BalancedTest(type: Test) {
+ // set heap size for the test JVM(s)
+ maxHeapSize = "1500m"
+
+ useJUnitPlatform {
+ includeTags 'gc'
+ }
+
+ jvmArgs '-Xgcpolicy:balanced'
+}
+
+task openj9ConcurrentScavengeTest(type: Test) {
+ // set heap size for the test JVM(s)
+ maxHeapSize = "1500m"
+
+ useJUnitPlatform {
+ includeTags 'gc'
+ }
+
+ jvmArgs '-Xgc:concurrentScavenge'
+}
diff --git a/micrometer-binders/src/main/java/io/micrometer/binder/cache/CacheMeterBinder.java b/micrometer-binders/src/main/java/io/micrometer/binder/cache/CacheMeterBinder.java
new file mode 100644
index 0000000000..46c52d716d
--- /dev/null
+++ b/micrometer-binders/src/main/java/io/micrometer/binder/cache/CacheMeterBinder.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright 2017 VMware, 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
+ *
+ * https://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.binder.cache;
+
+import java.lang.ref.WeakReference;
+
+import io.micrometer.core.instrument.FunctionCounter;
+import io.micrometer.core.instrument.Gauge;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.Tag;
+import io.micrometer.core.instrument.Tags;
+import io.micrometer.core.instrument.binder.MeterBinder;
+import io.micrometer.core.lang.NonNullApi;
+import io.micrometer.core.lang.NonNullFields;
+import io.micrometer.core.lang.Nullable;
+
+/**
+ * A common base class for cache metrics that ensures that all caches are instrumented
+ * with the same basic set of metrics while allowing for additional detail that is specific
+ * to an individual implementation.
+ *
+ * Having this common base set of metrics ensures that you can reason about basic cache performance
+ * in a dimensional slice that spans different cache implementations in your application.
+ *
+ * @author Jon Schneider
+ */
+@NonNullApi
+@NonNullFields
+public abstract class CacheMeterBinder implements MeterBinder {
+ private final WeakReference cacheRef;
+ private final Iterable tags;
+
+ public CacheMeterBinder(C cache, String cacheName, Iterable tags) {
+ this.tags = Tags.concat(tags, "cache", cacheName);
+ this.cacheRef = new WeakReference<>(cache);
+ }
+
+ @Nullable
+ protected C getCache() {
+ return cacheRef.get();
+ }
+
+ @Override
+ public final void bindTo(MeterRegistry registry) {
+ C cache = getCache();
+ if (size() != null) {
+ Gauge.builder("cache.size", cache,
+ c -> {
+ Long size = size();
+ return size == null ? 0 : size;
+ })
+ .tags(tags)
+ .description("The number of entries in this cache. This may be an approximation, depending on the type of cache.")
+ .register(registry);
+ }
+
+ if (missCount() != null) {
+ FunctionCounter.builder("cache.gets", cache,
+ c -> {
+ Long misses = missCount();
+ return misses == null ? 0 : misses;
+ })
+ .tags(tags).tag("result", "miss")
+ .description("the number of times cache lookup methods have returned an uncached (newly loaded) value, or null")
+ .register(registry);
+ }
+
+ FunctionCounter.builder("cache.gets", cache, c -> hitCount())
+ .tags(tags).tag("result", "hit")
+ .description("The number of times cache lookup methods have returned a cached value.")
+ .register(registry);
+
+ FunctionCounter.builder("cache.puts", cache, c -> putCount())
+ .tags(tags)
+ .description("The number of entries added to the cache")
+ .register(registry);
+
+ if (evictionCount() != null) {
+ FunctionCounter.builder("cache.evictions", cache,
+ c -> {
+ Long evictions = evictionCount();
+ return evictions == null ? 0 : evictions;
+ })
+ .tags(tags)
+ .description("cache evictions")
+ .register(registry);
+ }
+
+ bindImplementationSpecificMetrics(registry);
+ }
+
+ /**
+ * MOST cache implementations provide a means of retrieving the number of entries. Even if
+ *
+ * @return Total number of cache entries. This value may go up or down with puts, removes, and evictions. Returns
+ * {@code null} if the cache implementation does not provide a way to track cache size.
+ */
+ @Nullable
+ protected abstract Long size();
+
+ /**
+ * @return Get requests that resulted in a "hit" against an existing cache entry. Monotonically increasing hit count.
+ */
+ protected abstract long hitCount();
+
+ /**
+ * @return Get requests that resulted in a "miss", or didn't match an existing cache entry. Monotonically increasing count.
+ * Returns {@code null} if the cache implementation does not provide a way to track miss count, especially in distributed
+ * caches.
+ */
+ @Nullable
+ protected abstract Long missCount();
+
+ /**
+ * @return Total number of entries that have been evicted from the cache. Monotonically increasing eviction count.
+ * Returns {@code null} if the cache implementation does not support eviction, or does not provide a way to track
+ * the eviction count.
+ */
+ @Nullable
+ protected abstract Long evictionCount();
+
+ /**
+ * The put mechanism is unimportant - this count applies to entries added to the cache according to a pre-defined
+ * load function such as exists in Guava/Caffeine caches as well as manual puts.
+ *
+ * Note that Guava/Caffeine caches don't count manual puts.
+ *
+ * @return Total number of entries added to the cache. Monotonically increasing count.
+ */
+ protected abstract long putCount();
+
+ /**
+ * Bind detailed metrics that are particular to the cache implementation, e.g. load duration for
+ * Caffeine caches, heap and disk size for EhCache caches. These metrics are above and beyond the
+ * basic set of metrics that is common to all caches.
+ *
+ * @param registry The registry to bind metrics to.
+ */
+ protected abstract void bindImplementationSpecificMetrics(MeterRegistry registry);
+
+ protected Iterable getTagsWithCacheName() {
+ return tags;
+ }
+}
diff --git a/micrometer-binders/src/main/java/io/micrometer/binder/cache/CaffeineCacheMetrics.java b/micrometer-binders/src/main/java/io/micrometer/binder/cache/CaffeineCacheMetrics.java
new file mode 100644
index 0000000000..39e121de95
--- /dev/null
+++ b/micrometer-binders/src/main/java/io/micrometer/binder/cache/CaffeineCacheMetrics.java
@@ -0,0 +1,210 @@
+/*
+ * Copyright 2017 VMware, 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
+ *
+ * https://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.binder.cache;
+
+import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
+import java.util.function.ToLongFunction;
+
+import com.github.benmanes.caffeine.cache.AsyncCache;
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import com.github.benmanes.caffeine.cache.LoadingCache;
+import com.github.benmanes.caffeine.cache.stats.CacheStats;
+import io.micrometer.core.instrument.FunctionCounter;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.Tag;
+import io.micrometer.core.instrument.Tags;
+import io.micrometer.core.instrument.TimeGauge;
+import io.micrometer.core.lang.NonNullApi;
+import io.micrometer.core.lang.NonNullFields;
+import io.micrometer.core.lang.Nullable;
+
+/**
+ * Collect metrics from Caffeine's {@link Cache}. {@link CaffeineStatsCounter} is an
+ * alternative that can collect more detailed statistics.
+ *
+ * Note that {@code recordStats()} is required to gather non-zero statistics:
+ *
+ *
+ * @author Clint Checketts
+ * @see CaffeineStatsCounter
+ */
+@NonNullApi
+@NonNullFields
+public class CaffeineCacheMetrics> extends CacheMeterBinder {
+
+ /**
+ * Creates a new {@link CaffeineCacheMetrics} instance.
+ *
+ * @param cache The cache to be instrumented. You must call {@link Caffeine#recordStats()} prior to building the cache
+ * for metrics to be recorded.
+ * @param cacheName Will be used to tag metrics with "cache".
+ * @param tags tags to apply to all recorded metrics.
+ */
+ public CaffeineCacheMetrics(C cache, String cacheName, Iterable tags) {
+ super(cache, cacheName, tags);
+ }
+
+ /**
+ * Record metrics on a Caffeine cache. You must call {@link Caffeine#recordStats()} prior to building the cache
+ * for metrics to be recorded.
+ *
+ * @param registry The registry to bind metrics to.
+ * @param cache The cache to instrument.
+ * @param cacheName Will be used to tag metrics with "cache".
+ * @param tags Tags to apply to all recorded metrics. Must be an even number of arguments representing key/value pairs of tags.
+ * @param Cache key type.
+ * @param Cache value type.
+ * @param The cache type.
+ * @return The instrumented cache, unchanged. The original cache is not wrapped or proxied in any way.
+ */
+ public static > C monitor(MeterRegistry registry, C cache, String cacheName, String... tags) {
+ return monitor(registry, cache, cacheName, Tags.of(tags));
+ }
+
+ /**
+ * Record metrics on a Caffeine cache. You must call {@link Caffeine#recordStats()} prior to building the cache
+ * for metrics to be recorded.
+ *
+ * @param registry The registry to bind metrics to.
+ * @param cache The cache to instrument.
+ * @param cacheName Will be used to tag metrics with "cache".
+ * @param tags Tags to apply to all recorded metrics.
+ * @param Cache key type.
+ * @param Cache value type.
+ * @param The cache type.
+ * @return The instrumented cache, unchanged. The original cache is not wrapped or proxied in any way.
+ * @see CacheStats
+ */
+ public static > C monitor(MeterRegistry registry, C cache, String cacheName, Iterable tags) {
+ new CaffeineCacheMetrics<>(cache, cacheName, tags).bindTo(registry);
+ return cache;
+ }
+
+ /**
+ * Record metrics on a Caffeine cache. You must call {@link Caffeine#recordStats()} prior to building the cache
+ * for metrics to be recorded.
+ *
+ * @param registry The registry to bind metrics to.
+ * @param cache The cache to instrument.
+ * @param cacheName Will be used to tag metrics with "cache".
+ * @param tags Tags to apply to all recorded metrics. Must be an even number of arguments representing key/value pairs of tags.
+ * @param Cache key type.
+ * @param Cache value type.
+ * @param The cache type.
+ * @return The instrumented cache, unchanged. The original cache is not wrapped or proxied in any way.
+ */
+ public static > C monitor(MeterRegistry registry, C cache, String cacheName, String... tags) {
+ return monitor(registry, cache, cacheName, Tags.of(tags));
+ }
+
+ /**
+ * Record metrics on a Caffeine cache. You must call {@link Caffeine#recordStats()} prior to building the cache
+ * for metrics to be recorded.
+ *
+ * @param registry The registry to bind metrics to.
+ * @param cache The cache to instrument.
+ * @param cacheName Will be used to tag metrics with "cache".
+ * @param tags Tags to apply to all recorded metrics.
+ * @param Cache key type.
+ * @param Cache value type.
+ * @param The cache type.
+ * @return The instrumented cache, unchanged. The original cache is not wrapped or proxied in any way.
+ * @see CacheStats
+ */
+ public static > C monitor(MeterRegistry registry, C cache, String cacheName, Iterable tags) {
+ monitor(registry, cache.synchronous(), cacheName, tags);
+ return cache;
+ }
+
+ @Override
+ protected Long size() {
+ return getOrDefault(Cache::estimatedSize, null);
+ }
+
+ @Override
+ protected long hitCount() {
+ return getOrDefault(c -> c.stats().hitCount(), 0L);
+ }
+
+ @Override
+ protected Long missCount() {
+ return getOrDefault(c -> c.stats().missCount(), null);
+ }
+
+ @Override
+ protected Long evictionCount() {
+ return getOrDefault(c -> c.stats().evictionCount(), null);
+ }
+
+ @Override
+ protected long putCount() {
+ return getOrDefault(c -> c.stats().loadCount(), 0L);
+ }
+
+ @Override
+ protected void bindImplementationSpecificMetrics(MeterRegistry registry) {
+ C cache = getCache();
+ FunctionCounter.builder("cache.eviction.weight", cache, c -> c.stats().evictionWeight())
+ .tags(getTagsWithCacheName())
+ .description("The sum of weights of evicted entries. This total does not include manual invalidations.")
+ .register(registry);
+
+ if (cache instanceof LoadingCache) {
+ // dividing these gives you a measure of load latency
+ TimeGauge.builder("cache.load.duration", cache, TimeUnit.NANOSECONDS, c -> c.stats().totalLoadTime())
+ .tags(getTagsWithCacheName())
+ .description("The time the cache has spent loading new values")
+ .register(registry);
+
+ FunctionCounter.builder("cache.load", cache, c -> c.stats().loadSuccessCount())
+ .tags(getTagsWithCacheName())
+ .tags("result", "success")
+ .description("The number of times cache lookup methods have successfully loaded a new value")
+ .register(registry);
+
+ FunctionCounter.builder("cache.load", cache, c -> c.stats().loadFailureCount())
+ .tags(getTagsWithCacheName())
+ .tags("result", "failure")
+ .description("The number of times {@link Cache} lookup methods failed to load a new value, either " +
+ "because no value was found or an exception was thrown while loading")
+ .register(registry);
+ }
+ }
+
+ @Nullable
+ private Long getOrDefault(Function function, @Nullable Long defaultValue) {
+ C cache = getCache();
+ if (cache != null) {
+ return function.apply(cache);
+ }
+
+ return defaultValue;
+ }
+
+ private long getOrDefault(ToLongFunction function, long defaultValue) {
+ C cache = getCache();
+ if (cache != null) {
+ return function.applyAsLong(cache);
+ }
+
+ return defaultValue;
+ }
+}
diff --git a/micrometer-binders/src/main/java/io/micrometer/binder/cache/CaffeineStatsCounter.java b/micrometer-binders/src/main/java/io/micrometer/binder/cache/CaffeineStatsCounter.java
new file mode 100644
index 0000000000..bff2027c9c
--- /dev/null
+++ b/micrometer-binders/src/main/java/io/micrometer/binder/cache/CaffeineStatsCounter.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright 2021 VMware, 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
+ *
+ * https://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.binder.cache;
+
+import java.util.Arrays;
+import java.util.EnumMap;
+import java.util.concurrent.TimeUnit;
+
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.RemovalCause;
+import com.github.benmanes.caffeine.cache.stats.CacheStats;
+import com.github.benmanes.caffeine.cache.stats.StatsCounter;
+import io.micrometer.core.instrument.Counter;
+import io.micrometer.core.instrument.DistributionSummary;
+import io.micrometer.core.instrument.Gauge;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.Tag;
+import io.micrometer.core.instrument.Tags;
+import io.micrometer.core.instrument.Timer;
+import io.micrometer.core.lang.NonNullApi;
+import io.micrometer.core.lang.NonNullFields;
+
+import static java.util.Objects.requireNonNull;
+
+/**
+ * A {@link StatsCounter} instrumented with Micrometer. This will provide more detailed metrics than using
+ * {@link CaffeineCacheMetrics}.
+ *
+ * Note that this doesn't instrument the cache's size by default. Use {@link #registerSizeMetric(Cache)} to do so after
+ * the cache has been built.
+ *
+ * Use {@link com.github.benmanes.caffeine.cache.Caffeine#recordStats} to supply this class to the cache builder:
+ *
+ *
+ * @author Ben Manes
+ * @author John Karp
+ * @author Johnny Lim
+ * @see CaffeineCacheMetrics
+ * @since 1.7.0
+ */
+@NonNullApi
+@NonNullFields
+public final class CaffeineStatsCounter implements StatsCounter {
+
+ private final MeterRegistry registry;
+ private final Tags tags;
+
+ private final Counter hitCount;
+ private final Counter missCount;
+ private final Timer loadSuccesses;
+ private final Timer loadFailures;
+ private final EnumMap evictionMetrics;
+
+ /**
+ * Constructs an instance for use by a single cache.
+ *
+ * @param registry the registry of metric instances
+ * @param cacheName will be used to tag metrics with "cache".
+ */
+ public CaffeineStatsCounter(MeterRegistry registry, String cacheName) {
+ this(registry, cacheName, Tags.empty());
+ }
+
+ /**
+ * Constructs an instance for use by a single cache.
+ *
+ * @param registry the registry of metric instances
+ * @param cacheName will be used to tag metrics with "cache".
+ * @param extraTags tags to apply to all recorded metrics.
+ */
+ public CaffeineStatsCounter(MeterRegistry registry, String cacheName, Iterable extraTags) {
+ requireNonNull(registry);
+ requireNonNull(cacheName);
+ requireNonNull(extraTags);
+ this.registry = registry;
+ this.tags = Tags.concat(extraTags, "cache", cacheName);
+
+ hitCount = Counter.builder("cache.gets").tag("result", "hit").tags(tags)
+ .description("The number of times cache lookup methods have returned a cached value.")
+ .register(registry);
+ missCount = Counter.builder("cache.gets").tag("result", "miss").tags(tags)
+ .description("The number of times cache lookup methods have returned an uncached (newly loaded) value.")
+ .register(registry);
+ loadSuccesses = Timer.builder("cache.loads").tag("result", "success").tags(tags)
+ .description("Successful cache loads.").register(registry);
+ loadFailures = Timer.builder("cache.loads").tag("result", "failure").tags(tags)
+ .description("Failed cache loads.").register(registry);
+
+ evictionMetrics = new EnumMap<>(RemovalCause.class);
+ Arrays.stream(RemovalCause.values()).forEach(cause -> evictionMetrics.put(
+ cause,
+ DistributionSummary.builder("cache.evictions").tag("cause", cause.name()).tags(tags)
+ .description("Entries evicted from cache.").register(registry)));
+ }
+
+ /**
+ * Register a gauge for the size of the given cache.
+ *
+ * @param cache cache to register a gauge for its size
+ */
+ public void registerSizeMetric(Cache cache) {
+ Gauge.builder("cache.size", cache, Cache::estimatedSize).tags(tags)
+ .description("The approximate number of entries in this cache.")
+ .register(registry);
+ }
+
+ @Override
+ public void recordHits(int count) {
+ hitCount.increment(count);
+ }
+
+ @Override
+ public void recordMisses(int count) {
+ missCount.increment(count);
+ }
+
+ @Override
+ public void recordLoadSuccess(long loadTime) {
+ loadSuccesses.record(loadTime, TimeUnit.NANOSECONDS);
+ }
+
+ @Override
+ public void recordLoadFailure(long loadTime) {
+ loadFailures.record(loadTime, TimeUnit.NANOSECONDS);
+ }
+
+ @SuppressWarnings("deprecation")
+ public void recordEviction() {
+ }
+
+ @Override
+ public void recordEviction(int weight, RemovalCause cause) {
+ evictionMetrics.get(cause).record(weight);
+ }
+
+ @Override
+ public CacheStats snapshot() {
+ return CacheStats.of(
+ (long) hitCount.count(),
+ (long) missCount.count(),
+ loadSuccesses.count(),
+ loadFailures.count(),
+ (long) loadSuccesses.totalTime(TimeUnit.NANOSECONDS)
+ + (long) loadFailures.totalTime(TimeUnit.NANOSECONDS),
+ evictionMetrics.values().stream().mapToLong(DistributionSummary::count).sum(),
+ (long) evictionMetrics.values().stream().mapToDouble(DistributionSummary::totalAmount).sum()
+ );
+ }
+
+ @Override
+ public String toString() {
+ return snapshot().toString();
+ }
+}
diff --git a/micrometer-binders/src/main/java/io/micrometer/binder/cache/EhCache2Metrics.java b/micrometer-binders/src/main/java/io/micrometer/binder/cache/EhCache2Metrics.java
new file mode 100644
index 0000000000..0f39b30ff4
--- /dev/null
+++ b/micrometer-binders/src/main/java/io/micrometer/binder/cache/EhCache2Metrics.java
@@ -0,0 +1,233 @@
+/*
+ * Copyright 2017 VMware, 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
+ *
+ * https://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.binder.cache;
+
+import java.util.function.Function;
+import java.util.function.ToLongFunction;
+
+import io.micrometer.core.instrument.FunctionCounter;
+import io.micrometer.core.instrument.Gauge;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.Tag;
+import io.micrometer.core.instrument.Tags;
+import io.micrometer.core.instrument.binder.BaseUnits;
+import io.micrometer.core.lang.NonNullApi;
+import io.micrometer.core.lang.NonNullFields;
+import io.micrometer.core.lang.Nullable;
+import net.sf.ehcache.Ehcache;
+import net.sf.ehcache.statistics.StatisticsGateway;
+
+/**
+ * Collect metrics on EhCache caches, including detailed metrics on transactions and storage space.
+ *
+ * @author Jon Schneider
+ */
+@NonNullApi
+@NonNullFields
+public class EhCache2Metrics extends CacheMeterBinder {
+
+ public EhCache2Metrics(Ehcache cache, Iterable tags) {
+ super(cache, cache.getName(), tags);
+ }
+
+ /**
+ * Record metrics on an EhCache cache.
+ *
+ * @param registry The registry to bind metrics to.
+ * @param cache The cache to instrument.
+ * @param tags Tags to apply to all recorded metrics. Must be an even number of arguments representing key/value pairs of tags.
+ * @return The instrumented cache, unchanged. The original cache is not wrapped or proxied in any way.
+ */
+ public static Ehcache monitor(MeterRegistry registry, Ehcache cache, String... tags) {
+ return monitor(registry, cache, Tags.of(tags));
+ }
+
+ /**
+ * Record metrics on an EhCache cache.
+ *
+ * @param registry The registry to bind metrics to.
+ * @param cache The cache to instrument.
+ * @param tags Tags to apply to all recorded metrics.
+ * @return The instrumented cache, unchanged. The original cache is not wrapped or proxied in any way.
+ */
+ public static Ehcache monitor(MeterRegistry registry, Ehcache cache, Iterable tags) {
+ new EhCache2Metrics(cache, tags).bindTo(registry);
+ return cache;
+ }
+
+ @Override
+ protected Long size() {
+ return getOrDefault(StatisticsGateway::getSize, null);
+ }
+
+ @Override
+ protected long hitCount() {
+ return getOrDefault(StatisticsGateway::cacheHitCount, 0L);
+ }
+
+ @Override
+ protected Long missCount() {
+ return getOrDefault(StatisticsGateway::cacheMissCount, null);
+ }
+
+ @Override
+ protected Long evictionCount() {
+ return getOrDefault(StatisticsGateway::cacheEvictedCount, null);
+ }
+
+ @Override
+ protected long putCount() {
+ return getOrDefault(StatisticsGateway::cachePutCount, 0L);
+ }
+
+ @Override
+ protected void bindImplementationSpecificMetrics(MeterRegistry registry) {
+ StatisticsGateway stats = getStats();
+ Gauge.builder("cache.remoteSize", stats, StatisticsGateway::getRemoteSize)
+ .tags(getTagsWithCacheName())
+ .description("The number of entries held remotely in this cache")
+ .register(registry);
+
+ FunctionCounter.builder("cache.removals", stats, StatisticsGateway::cacheRemoveCount)
+ .tags(getTagsWithCacheName())
+ .description("Cache removals")
+ .register(registry);
+
+ FunctionCounter.builder("cache.puts.added", stats, StatisticsGateway::cachePutAddedCount)
+ .tags(getTagsWithCacheName()).tags("result", "added")
+ .description("Cache puts resulting in a new key/value pair")
+ .register(registry);
+
+ FunctionCounter.builder("cache.puts.added", stats, StatisticsGateway::cachePutUpdatedCount)
+ .tags(getTagsWithCacheName()).tags("result", "updated")
+ .description("Cache puts resulting in an updated value")
+ .register(registry);
+
+ missMetrics(registry);
+ commitTransactionMetrics(registry);
+ rollbackTransactionMetrics(registry);
+ recoveryTransactionMetrics(registry);
+
+ Gauge.builder("cache.local.offheap.size", stats, StatisticsGateway::getLocalOffHeapSizeInBytes)
+ .tags(getTagsWithCacheName())
+ .description("Local off-heap size")
+ .baseUnit(BaseUnits.BYTES)
+ .register(registry);
+
+ Gauge.builder("cache.local.heap.size", stats, StatisticsGateway::getLocalHeapSizeInBytes)
+ .tags(getTagsWithCacheName())
+ .description("Local heap size")
+ .baseUnit(BaseUnits.BYTES)
+ .register(registry);
+
+ Gauge.builder("cache.local.disk.size", stats, StatisticsGateway::getLocalDiskSizeInBytes)
+ .tags(getTagsWithCacheName())
+ .description("Local disk size")
+ .baseUnit(BaseUnits.BYTES)
+ .register(registry);
+ }
+
+ @Nullable
+ private StatisticsGateway getStats() {
+ Ehcache cache = getCache();
+ return cache != null ? cache.getStatistics() : null;
+ }
+
+ private void missMetrics(MeterRegistry registry) {
+ StatisticsGateway stats = getStats();
+ FunctionCounter.builder("cache.misses", stats, StatisticsGateway::cacheMissExpiredCount)
+ .tags(getTagsWithCacheName())
+ .tags("reason", "expired")
+ .description("The number of times cache lookup methods have not returned a value, due to expiry")
+ .register(registry);
+
+ FunctionCounter.builder("cache.misses", stats, StatisticsGateway::cacheMissNotFoundCount)
+ .tags(getTagsWithCacheName())
+ .tags("reason", "notFound")
+ .description("The number of times cache lookup methods have not returned a value, because the key was not found")
+ .register(registry);
+ }
+
+ private void commitTransactionMetrics(MeterRegistry registry) {
+ StatisticsGateway stats = getStats();
+ FunctionCounter.builder("cache.xa.commits", stats, StatisticsGateway::xaCommitReadOnlyCount)
+ .tags(getTagsWithCacheName())
+ .tags("result", "readOnly")
+ .description("Transaction commits that had a read-only result")
+ .register(registry);
+
+ FunctionCounter.builder("cache.xa.commits", stats, StatisticsGateway::xaCommitExceptionCount)
+ .tags(getTagsWithCacheName())
+ .tags("result", "exception")
+ .description("Transaction commits that failed")
+ .register(registry);
+
+ FunctionCounter.builder("cache.xa.commits", stats, StatisticsGateway::xaCommitCommittedCount)
+ .tags(getTagsWithCacheName())
+ .tags("result", "committed")
+ .description("Transaction commits that failed")
+ .register(registry);
+ }
+
+ private void rollbackTransactionMetrics(MeterRegistry registry) {
+ StatisticsGateway stats = getStats();
+ FunctionCounter.builder("cache.xa.rollbacks", stats, StatisticsGateway::xaRollbackExceptionCount)
+ .tags(getTagsWithCacheName())
+ .tags("result", "exception")
+ .description("Transaction rollbacks that failed")
+ .register(registry);
+
+ FunctionCounter.builder("cache.xa.rollbacks", stats, StatisticsGateway::xaRollbackSuccessCount)
+ .tags(getTagsWithCacheName())
+ .tags("result", "success")
+ .description("Transaction rollbacks that failed")
+ .register(registry);
+ }
+
+ private void recoveryTransactionMetrics(MeterRegistry registry) {
+ StatisticsGateway stats = getStats();
+ FunctionCounter.builder("cache.xa.recoveries", stats, StatisticsGateway::xaRecoveryNothingCount)
+ .tags(getTagsWithCacheName())
+ .tags("result", "nothing")
+ .description("Recovery transactions that recovered nothing")
+ .register(registry);
+
+ FunctionCounter.builder("cache.xa.recoveries", stats, StatisticsGateway::xaRecoveryRecoveredCount)
+ .tags(getTagsWithCacheName())
+ .tags("result", "success")
+ .description("Successful recovery transaction")
+ .register(registry);
+ }
+
+ @Nullable
+ private Long getOrDefault(Function function, @Nullable Long defaultValue) {
+ StatisticsGateway ref = getStats();
+ if (ref != null) {
+ return function.apply(ref);
+ }
+
+ return defaultValue;
+ }
+
+ private long getOrDefault(ToLongFunction function, long defaultValue) {
+ StatisticsGateway ref = getStats();
+ if (ref != null) {
+ return function.applyAsLong(ref);
+ }
+
+ return defaultValue;
+ }
+}
diff --git a/micrometer-binders/src/main/java/io/micrometer/binder/cache/GuavaCacheMetrics.java b/micrometer-binders/src/main/java/io/micrometer/binder/cache/GuavaCacheMetrics.java
new file mode 100644
index 0000000000..357baac0f2
--- /dev/null
+++ b/micrometer-binders/src/main/java/io/micrometer/binder/cache/GuavaCacheMetrics.java
@@ -0,0 +1,146 @@
+/*
+ * Copyright 2017 VMware, 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
+ *
+ * https://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.binder.cache;
+
+import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
+import java.util.function.ToLongFunction;
+
+import com.google.common.cache.Cache;
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.LoadingCache;
+import io.micrometer.core.instrument.FunctionCounter;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.Tag;
+import io.micrometer.core.instrument.Tags;
+import io.micrometer.core.instrument.TimeGauge;
+import io.micrometer.core.lang.NonNullApi;
+import io.micrometer.core.lang.NonNullFields;
+import io.micrometer.core.lang.Nullable;
+
+/**
+ * @author Jon Schneider
+ */
+@NonNullApi
+@NonNullFields
+public class GuavaCacheMetrics> extends CacheMeterBinder {
+ /**
+ * Record metrics on a Guava cache. You must call {@link CacheBuilder#recordStats()} prior to building the cache
+ * for metrics to be recorded.
+ *
+ * @param registry The registry to bind metrics to.
+ * @param cache The cache to instrument.
+ * @param cacheName Will be used to tag metrics with "cache".
+ * @param tags Tags to apply to all recorded metrics. Must be an even number of arguments representing key/value pairs of tags.
+ * @param Cache key type.
+ * @param Cache value type.
+ * @param The cache type.
+ * @return The instrumented cache, unchanged. The original cache is not wrapped or proxied in any way.
+ * @see com.google.common.cache.CacheStats
+ */
+ public static > C monitor(MeterRegistry registry, C cache, String cacheName, String... tags) {
+ return monitor(registry, cache, cacheName, Tags.of(tags));
+ }
+
+ /**
+ * Record metrics on a Guava cache. You must call {@link CacheBuilder#recordStats()} prior to building the cache
+ * for metrics to be recorded.
+ *
+ * @param registry The registry to bind metrics to.
+ * @param cache The cache to instrument.
+ * @param cacheName The name prefix of the metrics.
+ * @param tags Tags to apply to all recorded metrics.
+ * @param Cache key type.
+ * @param Cache value type.
+ * @param The cache type.
+ * @return The instrumented cache, unchanged. The original cache is not wrapped or proxied in any way.
+ * @see com.google.common.cache.CacheStats
+ */
+ public static > C monitor(MeterRegistry registry, C cache, String cacheName, Iterable tags) {
+ new GuavaCacheMetrics<>(cache, cacheName, tags).bindTo(registry);
+ return cache;
+ }
+
+ public GuavaCacheMetrics(C cache, String cacheName, Iterable tags) {
+ super(cache, cacheName, tags);
+ }
+
+ @Override
+ protected Long size() {
+ return getOrDefault(Cache::size, null);
+ }
+
+ @Override
+ protected long hitCount() {
+ return getOrDefault(c -> c.stats().hitCount(), 0L);
+ }
+
+ @Override
+ protected Long missCount() {
+ return getOrDefault(c -> c.stats().missCount(), null);
+ }
+
+ @Override
+ protected Long evictionCount() {
+ return getOrDefault(c -> c.stats().evictionCount(), null);
+ }
+
+ @Override
+ protected long putCount() {
+ return getOrDefault(c -> c.stats().loadCount(), 0L);
+ }
+
+ @Override
+ protected void bindImplementationSpecificMetrics(MeterRegistry registry) {
+ C cache = getCache();
+ if (cache instanceof LoadingCache) {
+ // dividing these gives you a measure of load latency
+ TimeGauge.builder("cache.load.duration", cache, TimeUnit.NANOSECONDS, c -> c.stats().totalLoadTime())
+ .tags(getTagsWithCacheName())
+ .description("The time the cache has spent loading new values")
+ .register(registry);
+
+ FunctionCounter.builder("cache.load", cache, c -> c.stats().loadSuccessCount())
+ .tags(getTagsWithCacheName()).tags("result", "success")
+ .description("The number of times cache lookup methods have successfully loaded a new value")
+ .register(registry);
+
+ FunctionCounter.builder("cache.load", cache, c -> c.stats().loadExceptionCount())
+ .tags(getTagsWithCacheName()).tags("result", "failure")
+ .description("The number of times cache lookup methods threw an exception while loading a new value")
+ .register(registry);
+ }
+ }
+
+ @Nullable
+ private Long getOrDefault(Function, Long> function, @Nullable Long defaultValue) {
+ C ref = getCache();
+ if (ref != null) {
+ return function.apply(ref);
+ }
+
+ return defaultValue;
+ }
+
+ private long getOrDefault(ToLongFunction> function, long defaultValue) {
+ C ref = getCache();
+ if (ref != null) {
+ return function.applyAsLong(ref);
+ }
+
+ return defaultValue;
+ }
+}
diff --git a/micrometer-binders/src/main/java/io/micrometer/binder/cache/HazelcastCacheMetrics.java b/micrometer-binders/src/main/java/io/micrometer/binder/cache/HazelcastCacheMetrics.java
new file mode 100644
index 0000000000..e270df5cf2
--- /dev/null
+++ b/micrometer-binders/src/main/java/io/micrometer/binder/cache/HazelcastCacheMetrics.java
@@ -0,0 +1,218 @@
+/*
+ * Copyright 2017 VMware, 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
+ *
+ * https://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.binder.cache;
+
+import java.util.concurrent.TimeUnit;
+import java.util.function.ToDoubleFunction;
+import java.util.function.ToLongFunction;
+
+import io.micrometer.core.instrument.FunctionCounter;
+import io.micrometer.core.instrument.FunctionTimer;
+import io.micrometer.core.instrument.Gauge;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.Tag;
+import io.micrometer.core.instrument.Tags;
+import io.micrometer.core.instrument.binder.BaseUnits;
+import io.micrometer.binder.cache.HazelcastIMapAdapter.LocalMapStats;
+import io.micrometer.core.lang.NonNullApi;
+import io.micrometer.core.lang.NonNullFields;
+import io.micrometer.core.lang.Nullable;
+
+/**
+ * Collect metrics on Hazelcast caches, including detailed metrics on storage space, near cache usage, and timings.
+ *
+ * @author Jon Schneider
+ */
+@NonNullApi
+@NonNullFields
+public class HazelcastCacheMetrics extends CacheMeterBinder