Add support for Micrometer ReactiveX#162 (ReactiveX#206)

Author: madgnome

libraries.gradle

@@ -21,6 +21,7 @@ ext {
     prometheusSimpleClientVersion = '0.0.21'
     reactorVersion = '3.1.3.RELEASE'
     reactiveStreamsVersion = '1.0.2'
+    micrometerVersion = '1.0.0'
 
     libraries = [
             // compile
@@ -67,6 +68,9 @@ ext {
             // Metrics addon
             metrics: "io.dropwizard.metrics:metrics-core:${metricsVersion}",
 
+            // Micrometers addon
+            micrometer: "io.micrometer:micrometer-core:${micrometerVersion}",
+
             // CircuitBreaker documentation
             metrics_healthcheck: "io.dropwizard.metrics:metrics-healthchecks:${metricsVersion}",
 

resilience4j-bulkhead/src/main/java/io/github/resilience4j/bulkhead/utils/MetricNames.java

@@ -0,0 +1,6 @@
+package io.github.resilience4j.bulkhead.utils;
+
+public class MetricNames {
+    public static final String DEFAULT_PREFIX = "resilience4j.bulkhead";
+    public static final String AVAILABLE_CONCURRENT_CALLS = "available_concurrent_calls";
+}

resilience4j-circuitbreaker/src/main/java/io/github/resilience4j/circuitbreaker/utils/MetricNames.java

@@ -0,0 +1,11 @@
+package io.github.resilience4j.circuitbreaker.utils;
+
+public class MetricNames {
+    public static final String DEFAULT_PREFIX = "resilience4j.circuitbreaker";
+    public static final String SUCCESSFUL = "successful";
+    public static final String FAILED = "failed";
+    public static final String NOT_PERMITTED = "not_permitted";
+    public static final String BUFFERED = "buffered";
+    public static final String BUFFERED_MAX = "buffered_max";
+    public static final String STATE = "state";
+}

resilience4j-documentation/src/docs/asciidoc/addon_guides/micrometer.adoc

@@ -0,0 +1,85 @@
+=== Micrometer Metrics exporter
+
+==== Introduction
+
+Integration with http://micrometer.io/[Micrometer].
+With this add-on you can easily add your bulkhead, circuit breaker, rate limiter, retry metrics in Micrometer `MeterRegistry`.
+
+==== Usage
+
+===== Bulkhead
+
+[source,java]
+--
+final BulkheadRegistry bulkheadRegistry = BulkheadRegistry.ofDefaults();
+final Bulkhead foo = bulkheadRegistry.bulkhead("foo");
+final Bulkhead boo = bulkheadRegistry.bulkhead("boo");
+
+// Register all bulkheads at once
+BulkheadMetrics bulkheadMetrics = BulkheadMetrics.ofBulkheadRegistry(bulkheadRegistry);
+bulkheadMetrics.bindTo(meterRegistry);
+--
+
+For each bulkhead this registry will export:
+
+* `available_concurrent_calls` - instantaneous read of the number of currently available concurrent calls `[int]`
+
+===== CircuitBreaker
+
+[source,java]
+--
+final CircuitBreakerRegistry circuitBreakerRegistry = CircuitBreakerRegistry.ofDefaults();
+final CircuitBreaker foo = circuitBreakerRegistry.circuitBreaker("foo");
+final CircuitBreaker boo = circuitBreakerRegistry.circuitBreaker("boo");
+
+// Register all circuit breakers at once
+CircuitBreakerMetrics circuitBreakerMetrics = CircuitBreakerMetrics.ofCircuitBreakerRegistry(circuitBreakerRegistry);
+circuitBreakerMetrics.bindTo(meterRegistry);
+--
+
+For each circuit breaker this registry will export:
+
+* `state` - instantaneous read of the current state where 0-CLOSED, 1-OPEN, 2-HALF-OPEN `[int]`
+* `successful` - current number of successful calls `[int]`
+* `failed` - current number of failed calls `[int]`
+* `buffered` - current number of buffered calls `[int]`
+* `buffered_max` - maximum number of buffered calls `[int]`
+* `not_permitted` - current number of not permitted calls `[int]`
+
+===== RateLimiter
+
+[source,java]
+--
+final RateLimiterRegistry rateLimiterRegistry = RateLimiterRegistry.ofDefaults();
+final RateLimiter rateLimiter = rateLimiterRegistry.rateLimiter("testLimit");
+
+// Register rate limiters at once
+RateLimiterMetrics rateLimiterMetrics = RateLimiterMetrics.ofRateLimiterRegistry(rateLimiterRegistry);
+rateLimiterMetrics.bindTo(meterRegistry);
+--
+
+For each rate limiter this registry will export:
+
+* `available_permissions` - current number of available permissions `[int]`
+* `number_of_waiting_threads` - current number of threads waiting for permission `[int]`
+
+===== Retry
+
+[source,java]
+--
+final MetricRegistry metricRegistry = new MetricRegistry();
+final RetryRegistry retryRegistry = RetryRegistry.ofDefaults();
+final Retry retry = retryRegistry.retry("testLimit");
+
+// Register all retries at once
+RetryMetrics retryMetrics = RetryMetrics.ofRetryRegistry(retryRegistry);
+retryMetrics.bindTo(meterRegistry);
+--
+
+For each retry this registry will export:
+
+* `successful_calls_without_retry` - the number of successful calls without a retry attempt `[long]`
+* `successful_calls_with_retry` - the number of successful calls after a retry attempt `[long]`
+* `failed_calls_without_retry` - the number of failed calls without a retry attempt `[long]`
+* `failed_calls_with_retry` - the number of failed calls after all retry attempts `[long]`
+

resilience4j-documentation/src/docs/asciidoc/addons_guide.adoc

@@ -8,4 +8,6 @@ include::addon_guides/retrofit.adoc[]
 
 include::addon_guides/dropwizard.adoc[]
 
-include::addon_guides/prometheus.adoc[]
+include::addon_guides/prometheus.adoc[]
+
+include::addon_guides/micrometer.adoc[]

resilience4j-metrics/src/main/java/io/github/resilience4j/metrics/BulkheadMetrics.java

@@ -26,15 +26,14 @@
 import java.util.Map;
 
 import static com.codahale.metrics.MetricRegistry.name;
+import static io.github.resilience4j.bulkhead.utils.MetricNames.AVAILABLE_CONCURRENT_CALLS;
+import static io.github.resilience4j.bulkhead.utils.MetricNames.DEFAULT_PREFIX;
 import static java.util.Objects.requireNonNull;
 
 /**
  * An adapter which exports {@link Bulkhead.Metrics} as Dropwizard Metrics Gauges.
  */
 public class BulkheadMetrics implements MetricSet {
-    private static final String DEFAULT_PREFIX = "resilience4j.bulkhead";
-    private static final String AVAILABLE_CONCURRENT_CALLS = "available_concurrent_calls";
-
     private final MetricRegistry metricRegistry = new MetricRegistry();
 
     private BulkheadMetrics(Iterable<Bulkhead> bulkheads) {

resilience4j-metrics/src/main/java/io/github/resilience4j/metrics/CircuitBreakerMetrics.java

@@ -29,21 +29,14 @@
 import java.util.Map;
 
 import static com.codahale.metrics.MetricRegistry.name;
+import static io.github.resilience4j.circuitbreaker.utils.MetricNames.*;
 import static java.util.Objects.requireNonNull;
 
 /**
  * An adapter which exports {@link CircuitBreaker.Metrics} as Dropwizard Metrics Gauges.
  */
 public class CircuitBreakerMetrics implements MetricSet {
 
-    private static final String DEFAULT_PREFIX = "resilience4j.circuitbreaker";
-    public static final String SUCCESSFUL = "successful";
-    public static final String FAILED = "failed";
-    public static final String NOT_PERMITTED = "not_permitted";
-    public static final String BUFFERED = "buffered";
-    public static final String BUFFERED_MAX = "buffered_max";
-    public static final String STATE = "state";
-
     private final MetricRegistry metricRegistry = new MetricRegistry();
 
     private CircuitBreakerMetrics(Iterable<CircuitBreaker> circuitBreakers) {

resilience4j-metrics/src/main/java/io/github/resilience4j/metrics/RateLimiterMetrics.java

@@ -29,6 +29,9 @@
 import java.util.Map;
 
 import static com.codahale.metrics.MetricRegistry.name;
+import static io.github.resilience4j.ratelimiter.utils.MetricNames.AVAILABLE_PERMISSIONS;
+import static io.github.resilience4j.ratelimiter.utils.MetricNames.DEFAULT_PREFIX;
+import static io.github.resilience4j.ratelimiter.utils.MetricNames.WAITING_THREADS;
 import static java.util.Objects.requireNonNull;
 
 /**
@@ -39,8 +42,6 @@ public class RateLimiterMetrics implements MetricSet {
     private static final String PREFIX_NULL = "Prefix must not be null";
     private static final String ITERABLE_NULL = "RateLimiters iterable must not be null";
 
-    private static final String DEFAULT_PREFIX = "resilience4j.ratelimiter";
-
     private final MetricRegistry metricRegistry = new MetricRegistry();
 
     private RateLimiterMetrics(Iterable<RateLimiter> rateLimiters) {
@@ -53,9 +54,9 @@ private RateLimiterMetrics(String prefix, Iterable<RateLimiter> rateLimiters) {
 
         rateLimiters.forEach(rateLimiter -> {
                 String name = rateLimiter.getName();
-            metricRegistry.register(name(prefix, name, "number_of_waiting_threads"),
+                metricRegistry.register(name(prefix, name, WAITING_THREADS),
                     (Gauge<Integer>) rateLimiter.getMetrics()::getNumberOfWaitingThreads);
-                metricRegistry.register(name(prefix, name, "available_permissions"),
+                metricRegistry.register(name(prefix, name, AVAILABLE_PERMISSIONS),
                     (Gauge<Integer>) rateLimiter.getMetrics()::getAvailablePermissions);
             }
         );

resilience4j-metrics/src/main/java/io/github/resilience4j/metrics/RetryMetrics.java

@@ -8,19 +8,15 @@
 import java.util.Map;
 
 import static com.codahale.metrics.MetricRegistry.name;
+import static io.github.resilience4j.retry.utils.MetricNames.*;
 import static java.util.Objects.requireNonNull;
 
 /**
  * An adapter which exports {@link Retry.Metrics} as Dropwizard Metrics Gauges.
  */
 public class RetryMetrics implements MetricSet {
 
-    public static final String SUCCESSFUL_CALLS_WITHOUT_RETRY = "successful_calls_without_retry";
-    public static final String SUCCESSFUL_CALLS_WITH_RETRY = "successful_calls_with_retry";
-    public static final String FAILED_CALLS_WITHOUT_RETRY = "failed_calls_without_retry";
-    public static final String FAILED_CALLS_WITH_RETRY = "failed_calls_with_retry";
     private final MetricRegistry metricRegistry = new MetricRegistry();
-    private static final String DEFAULT_PREFIX = "resilience4j.retry";
 
     private RetryMetrics(Iterable<Retry> retries){
         this(DEFAULT_PREFIX, retries);

resilience4j-metrics/src/test/java/io/github/resilience4j/metrics/RetryMetricsTest.java

@@ -11,6 +11,7 @@
 
 import javax.xml.ws.WebServiceException;
 
+import static io.github.resilience4j.retry.utils.MetricNames.*;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
@@ -44,10 +45,10 @@ public void shouldRegisterMetricsWithoutRetry() throws Throwable {
         // Then the helloWorldService should be invoked 1 time
         BDDMockito.then(helloWorldService).should(times(1)).returnHelloWorld();
         assertThat(metricRegistry.getMetrics()).hasSize(4);
-        assertThat(metricRegistry.getGauges().get("resilience4j.retry.testName." + RetryMetrics.SUCCESSFUL_CALLS_WITH_RETRY).getValue()).isEqualTo(0L);
-        assertThat(metricRegistry.getGauges().get("resilience4j.retry.testName." + RetryMetrics.SUCCESSFUL_CALLS_WITHOUT_RETRY).getValue()).isEqualTo(1L);
-        assertThat(metricRegistry.getGauges().get("resilience4j.retry.testName." + RetryMetrics.FAILED_CALLS_WITH_RETRY).getValue()).isEqualTo(0L);
-        assertThat(metricRegistry.getGauges().get("resilience4j.retry.testName." + RetryMetrics.FAILED_CALLS_WITHOUT_RETRY).getValue()).isEqualTo(0L);
+        assertThat(metricRegistry.getGauges().get("resilience4j.retry.testName." + SUCCESSFUL_CALLS_WITH_RETRY).getValue()).isEqualTo(0L);
+        assertThat(metricRegistry.getGauges().get("resilience4j.retry.testName." + SUCCESSFUL_CALLS_WITHOUT_RETRY).getValue()).isEqualTo(1L);
+        assertThat(metricRegistry.getGauges().get("resilience4j.retry.testName." + FAILED_CALLS_WITH_RETRY).getValue()).isEqualTo(0L);
+        assertThat(metricRegistry.getGauges().get("resilience4j.retry.testName." + FAILED_CALLS_WITHOUT_RETRY).getValue()).isEqualTo(0L);
     }
 
     @Test
@@ -74,10 +75,10 @@ public void shouldRegisterMetricsWithRetry() throws Throwable {
         // Then the helloWorldService should be invoked 1 time
         BDDMockito.then(helloWorldService).should(times(5)).returnHelloWorld();
         assertThat(metricRegistry.getMetrics()).hasSize(4);
-        assertThat(metricRegistry.getGauges().get("resilience4j.retry.testName." + RetryMetrics.SUCCESSFUL_CALLS_WITH_RETRY).getValue()).isEqualTo(1L);
-        assertThat(metricRegistry.getGauges().get("resilience4j.retry.testName." + RetryMetrics.SUCCESSFUL_CALLS_WITHOUT_RETRY).getValue()).isEqualTo(0L);
-        assertThat(metricRegistry.getGauges().get("resilience4j.retry.testName." + RetryMetrics.FAILED_CALLS_WITH_RETRY).getValue()).isEqualTo(1L);
-        assertThat(metricRegistry.getGauges().get("resilience4j.retry.testName." + RetryMetrics.FAILED_CALLS_WITHOUT_RETRY).getValue()).isEqualTo(0L);
+        assertThat(metricRegistry.getGauges().get("resilience4j.retry.testName." + SUCCESSFUL_CALLS_WITH_RETRY).getValue()).isEqualTo(1L);
+        assertThat(metricRegistry.getGauges().get("resilience4j.retry.testName." + SUCCESSFUL_CALLS_WITHOUT_RETRY).getValue()).isEqualTo(0L);
+        assertThat(metricRegistry.getGauges().get("resilience4j.retry.testName." + FAILED_CALLS_WITH_RETRY).getValue()).isEqualTo(1L);
+        assertThat(metricRegistry.getGauges().get("resilience4j.retry.testName." + FAILED_CALLS_WITHOUT_RETRY).getValue()).isEqualTo(0L);
     }
 
     @Test
@@ -97,9 +98,9 @@ public void shouldUseCustomPrefix() throws Throwable {
         // Then the helloWorldService should be invoked 1 time
         BDDMockito.then(helloWorldService).should(times(1)).returnHelloWorld();
         assertThat(metricRegistry.getMetrics()).hasSize(4);
-        assertThat(metricRegistry.getGauges().get("testPrefix.testName." + RetryMetrics.SUCCESSFUL_CALLS_WITH_RETRY).getValue()).isEqualTo(0L);
-        assertThat(metricRegistry.getGauges().get("testPrefix.testName." + RetryMetrics.SUCCESSFUL_CALLS_WITHOUT_RETRY).getValue()).isEqualTo(1L);
-        assertThat(metricRegistry.getGauges().get("testPrefix.testName." + RetryMetrics.FAILED_CALLS_WITH_RETRY).getValue()).isEqualTo(0L);
-        assertThat(metricRegistry.getGauges().get("testPrefix.testName." + RetryMetrics.FAILED_CALLS_WITHOUT_RETRY).getValue()).isEqualTo(0L);
+        assertThat(metricRegistry.getGauges().get("testPrefix.testName." + SUCCESSFUL_CALLS_WITH_RETRY).getValue()).isEqualTo(0L);
+        assertThat(metricRegistry.getGauges().get("testPrefix.testName." + SUCCESSFUL_CALLS_WITHOUT_RETRY).getValue()).isEqualTo(1L);
+        assertThat(metricRegistry.getGauges().get("testPrefix.testName." + FAILED_CALLS_WITH_RETRY).getValue()).isEqualTo(0L);
+        assertThat(metricRegistry.getGauges().get("testPrefix.testName." + FAILED_CALLS_WITHOUT_RETRY).getValue()).isEqualTo(0L);
     }
 }

resilience4j-metrics/src/test/java/io/github/resilience4j/metrics/TimerTest.java

@@ -39,6 +39,8 @@
 import java.util.function.Function;
 import java.util.function.Supplier;
 
+import static com.jayway.awaitility.Awaitility.await;
+import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
@@ -158,9 +160,12 @@ public void shouldExecuteCompletionStageSupplier() throws Throwable {
 
         assertThat(value).isEqualTo("Hello world");
 
-        assertThat(timer.getMetrics().getNumberOfTotalCalls()).isEqualTo(1);
-        assertThat(timer.getMetrics().getNumberOfSuccessfulCalls()).isEqualTo(1);
-        assertThat(timer.getMetrics().getNumberOfFailedCalls()).isEqualTo(0);
+        await().atMost(1, SECONDS)
+                .until(() -> {
+                    assertThat(timer.getMetrics().getNumberOfTotalCalls()).isEqualTo(1);
+                    assertThat(timer.getMetrics().getNumberOfSuccessfulCalls()).isEqualTo(1);
+                    assertThat(timer.getMetrics().getNumberOfFailedCalls()).isEqualTo(0);
+                });
 
         // Then the helloWorldService should be invoked 1 time
         BDDMockito.then(helloWorldService).should(times(1)).returnHelloWorld();

resilience4j-micrometer/README.adoc

@@ -0,0 +1,15 @@
+= resilience4j-micrometer
+
+Integration of bulkhead, circuit breaker, rate limiter and retry metrics with http://micrometer.io/[Micrometer].
+
+NOTE: For detailed documentation look at our *http://resilience4j.github.io/resilience4j/#_micrometer_metrics_exporter[Usage Guide]*
+
+== License
+
+Copyright 2018 Julien Hoarau
+
+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.

resilience4j-micrometer/build.gradle

@@ -0,0 +1,14 @@
+dependencies {
+    compile (libraries.micrometer)
+    compileOnly project(':resilience4j-bulkhead')
+    compileOnly project(':resilience4j-circuitbreaker')
+    compileOnly project(':resilience4j-retry')
+    compileOnly project(':resilience4j-ratelimiter')
+    testCompile project(':resilience4j-test')
+    testCompile project(':resilience4j-bulkhead')
+    testCompile project(':resilience4j-circuitbreaker')
+    testCompile project(':resilience4j-ratelimiter')
+    testCompile project(':resilience4j-retry')
+    testCompile project(':resilience4j-test')
+    testCompile project(':resilience4j-circuitbreaker')
+}

resilience4j-micrometer/src/main/java/io/github/resilience4j/micrometer/BulkheadMetrics.java

@@ -0,0 +1,46 @@
+package io.github.resilience4j.micrometer;
+
+import io.github.resilience4j.bulkhead.Bulkhead;
+import io.github.resilience4j.bulkhead.BulkheadRegistry;
+import io.micrometer.core.instrument.Gauge;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.binder.MeterBinder;
+
+import static io.github.resilience4j.bulkhead.utils.MetricNames.AVAILABLE_CONCURRENT_CALLS;
+import static io.github.resilience4j.bulkhead.utils.MetricNames.DEFAULT_PREFIX;
+import static io.github.resilience4j.micrometer.MetricUtils.getName;
+import static java.util.Objects.requireNonNull;
+
+public class BulkheadMetrics implements MeterBinder {
+
+    private final Iterable<Bulkhead> bulkheads;
+    private final String prefix;
+
+    private BulkheadMetrics(Iterable<Bulkhead> bulkheads) {
+        this(bulkheads, DEFAULT_PREFIX);
+    }
+
+    private BulkheadMetrics(Iterable<Bulkhead> bulkheads, String prefix) {
+        this.bulkheads = requireNonNull(bulkheads);
+        this.prefix = requireNonNull(prefix);
+    }
+
+    /**
+     * Creates a new instance BulkheadMetrics {@link BulkheadMetrics} with
+     * a {@link BulkheadRegistry} as a source.
+     *
+     * @param bulkheadRegistry the registry of bulkheads
+     */
+    public static BulkheadMetrics ofBulkheadRegistry(BulkheadRegistry bulkheadRegistry) {
+        return new BulkheadMetrics(bulkheadRegistry.getAllBulkheads());
+    }
+
+    @Override
+    public void bindTo(MeterRegistry registry) {
+        for (Bulkhead bulkhead : bulkheads) {
+            final String name = bulkhead.getName();
+            Gauge.builder(getName(prefix, name, AVAILABLE_CONCURRENT_CALLS), bulkhead, (cb) -> cb.getMetrics().getAvailableConcurrentCalls())
+                    .register(registry);
+        }
+    }
+}