Remove previous meters before registering new one (ReactiveX#821)

jihoonson · Jan 29, 2020 · e9a6a81 · e9a6a81
1 parent b07d61d
commit e9a6a81
Show file tree

Hide file tree

Showing 12 changed files with 244 additions and 14 deletions.
diff --git a/...meter/src/main/java/io/github/resilience4j/micrometer/tagged/AbstractBulkheadMetrics.java b/...meter/src/main/java/io/github/resilience4j/micrometer/tagged/AbstractBulkheadMetrics.java
@@ -38,12 +38,15 @@ protected AbstractBulkheadMetrics(MetricNames names) {
 
     protected void addMetrics(MeterRegistry meterRegistry, Bulkhead bulkhead) {
         List<Tag> customTags = mapToTagsList(bulkhead.getTags().toJavaMap());
-        addMetrics(meterRegistry, bulkhead, customTags);
+        registerMetrics(meterRegistry, bulkhead, customTags);
     }
 
-    private void addMetrics(MeterRegistry meterRegistry, Bulkhead bulkhead, List<Tag> customTags) {
-        Set<Meter.Id> idSet = new HashSet<>();
+    private void registerMetrics(
+        MeterRegistry meterRegistry, Bulkhead bulkhead, List<Tag> customTags) {
+        // Remove previous meters before register
+        removeMetrics(meterRegistry, bulkhead.getName());
 
+        Set<Meter.Id> idSet = new HashSet<>();
         idSet.add(Gauge.builder(names.getAvailableConcurrentCallsMetricName(), bulkhead,
             bh -> bh.getMetrics().getAvailableConcurrentCalls())
             .description("The number of available permissions")

diff --git a/...src/main/java/io/github/resilience4j/micrometer/tagged/AbstractCircuitBreakerMetrics.java b/...src/main/java/io/github/resilience4j/micrometer/tagged/AbstractCircuitBreakerMetrics.java
@@ -45,8 +45,11 @@ protected void addMetrics(MeterRegistry meterRegistry, CircuitBreaker circuitBre
         registerMetrics(meterRegistry, circuitBreaker, customTags);
     }
 
-    private void registerMetrics(MeterRegistry meterRegistry, CircuitBreaker circuitBreaker,
-        List<Tag> customTags) {
+    private void registerMetrics(
+        MeterRegistry meterRegistry, CircuitBreaker circuitBreaker, List<Tag> customTags) {
+        // Remove previous meters before register
+        removeMetrics(meterRegistry, circuitBreaker.getName());
+
         Set<Meter.Id> idSet = new HashSet<>();
         final CircuitBreaker.State[] states = CircuitBreaker.State.values();
         for (CircuitBreaker.State state : states) {

diff --git a/...er/src/main/java/io/github/resilience4j/micrometer/tagged/AbstractRateLimiterMetrics.java b/...er/src/main/java/io/github/resilience4j/micrometer/tagged/AbstractRateLimiterMetrics.java
@@ -42,8 +42,11 @@ protected void addMetrics(MeterRegistry meterRegistry, RateLimiter rateLimiter)
         registerMetrics(meterRegistry, rateLimiter, customTags);
     }
 
-    private void registerMetrics(MeterRegistry meterRegistry, RateLimiter rateLimiter,
-        List<Tag> customTags) {
+    private void registerMetrics(
+        MeterRegistry meterRegistry, RateLimiter rateLimiter, List<Tag> customTags) {
+        // Remove previous meters before register
+        removeMetrics(meterRegistry, rateLimiter.getName());
+
         Set<Meter.Id> idSet = new HashSet<>();
         idSet.add(Gauge.builder(names.getAvailablePermissionsMetricName(), rateLimiter,
             rl -> rl.getMetrics().getAvailablePermissions())

diff --git a/...crometer/src/main/java/io/github/resilience4j/micrometer/tagged/AbstractRetryMetrics.java b/...crometer/src/main/java/io/github/resilience4j/micrometer/tagged/AbstractRetryMetrics.java
@@ -43,6 +43,9 @@ protected void addMetrics(MeterRegistry meterRegistry, Retry retry) {
     }
 
     private void registerMetrics(MeterRegistry meterRegistry, Retry retry, List<Tag> customTags) {
+        // Remove previous meters before register
+        removeMetrics(meterRegistry, retry.getName());
+
         Set<Meter.Id> idSet = new HashSet<>();
         idSet.add(FunctionCounter.builder(names.getCallsMetricName(), retry,
             rt -> rt.getMetrics().getNumberOfSuccessfulCallsWithoutRetryAttempt())

diff --git a/...main/java/io/github/resilience4j/micrometer/tagged/AbstractThreadPoolBulkheadMetrics.java b/...main/java/io/github/resilience4j/micrometer/tagged/AbstractThreadPoolBulkheadMetrics.java
@@ -38,11 +38,14 @@ protected AbstractThreadPoolBulkheadMetrics(MetricNames names) {
 
     protected void addMetrics(MeterRegistry meterRegistry, ThreadPoolBulkhead bulkhead) {
         List<Tag> customTags = mapToTagsList(bulkhead.getTags().toJavaMap());
-        addMetrics(meterRegistry, bulkhead, customTags);
+        registerMetrics(meterRegistry, bulkhead, customTags);
     }
 
-    private void addMetrics(MeterRegistry meterRegistry, ThreadPoolBulkhead bulkhead,
-        List<Tag> customTags) {
+    private void registerMetrics(
+        MeterRegistry meterRegistry, ThreadPoolBulkhead bulkhead, List<Tag> customTags) {
+        // Remove previous meters before register
+        removeMetrics(meterRegistry, bulkhead.getName());
+
         Set<Meter.Id> idSet = new HashSet<>();
         idSet.add(Gauge.builder(names.getQueueDepthMetricName(), bulkhead,
             bh -> bh.getMetrics().getQueueDepth())

diff --git a/...er/src/main/java/io/github/resilience4j/micrometer/tagged/AbstractTimeLimiterMetrics.java b/...er/src/main/java/io/github/resilience4j/micrometer/tagged/AbstractTimeLimiterMetrics.java
@@ -40,6 +40,9 @@ protected AbstractTimeLimiterMetrics(MetricNames names) {
     }
 
     protected void addMetrics(MeterRegistry meterRegistry, TimeLimiter timeLimiter) {
+        // Remove previous meters before register
+        removeMetrics(meterRegistry, timeLimiter.getName());
+
         Counter successes = Counter.builder(names.getCallsMetricName())
             .description("The number of successful calls")
             .tag(TagNames.NAME, timeLimiter.getName())

diff --git a/...est/java/io/github/resilience4j/micrometer/tagged/TaggedBulkheadMetricsPublisherTest.java b/...est/java/io/github/resilience4j/micrometer/tagged/TaggedBulkheadMetricsPublisherTest.java
@@ -160,4 +160,41 @@ public void customMetricNamesGetApplied() {
         ));
     }
 
+    @Test
+    public void testReplaceNewMeter(){
+        Bulkhead oldOne = Bulkhead.of("backendC", BulkheadConfig.ofDefaults());
+        // add meters of old
+        taggedBulkheadMetricsPublisher.addMetrics(meterRegistry, oldOne);
+        // one success call
+        oldOne.tryAcquirePermission();
+
+        assertThat(taggedBulkheadMetricsPublisher.meterIdMap).containsKeys("backendC");
+        assertThat(taggedBulkheadMetricsPublisher.meterIdMap.get("backendC")).hasSize(2);
+        Collection<Gauge> gauges = meterRegistry
+            .get(DEFAULT_BULKHEAD_MAX_ALLOWED_CONCURRENT_CALLS_METRIC_NAME).gauges();
+        Optional<Gauge> successful = findMeterByNamesTag(gauges, oldOne.getName());
+        assertThat(successful).isPresent();
+        assertThat(successful.get().value())
+            .isEqualTo(oldOne.getMetrics().getMaxAllowedConcurrentCalls());
+
+        Bulkhead newOne = Bulkhead.of("backendC", BulkheadConfig.ofDefaults());
+
+        // add meters of new
+        taggedBulkheadMetricsPublisher.addMetrics(meterRegistry, newOne);
+        // three success call
+        newOne.tryAcquirePermission();
+        newOne.tryAcquirePermission();
+        newOne.tryAcquirePermission();
+
+        assertThat(taggedBulkheadMetricsPublisher.meterIdMap).containsKeys("backendC");
+        assertThat(taggedBulkheadMetricsPublisher.meterIdMap.get("backendC")).hasSize(2);
+        gauges = meterRegistry
+            .get(DEFAULT_BULKHEAD_MAX_ALLOWED_CONCURRENT_CALLS_METRIC_NAME).gauges();
+        successful = findMeterByNamesTag(gauges, newOne.getName());
+        assertThat(successful).isPresent();
+        assertThat(successful.get().value())
+            .isEqualTo(newOne.getMetrics().getMaxAllowedConcurrentCalls());
+
+    }
+
 }
diff --git a/...va/io/github/resilience4j/micrometer/tagged/TaggedCircuitBreakerMetricsPublisherTest.java b/...va/io/github/resilience4j/micrometer/tagged/TaggedCircuitBreakerMetricsPublisherTest.java
@@ -46,8 +46,8 @@ public class TaggedCircuitBreakerMetricsPublisherTest {
     @Before
     public void setUp() {
         meterRegistry = new SimpleMeterRegistry();
-        taggedCircuitBreakerMetricsPublisher = new TaggedCircuitBreakerMetricsPublisher(
-            meterRegistry);
+        taggedCircuitBreakerMetricsPublisher =
+            new TaggedCircuitBreakerMetricsPublisher(meterRegistry);
         circuitBreakerRegistry =
             CircuitBreakerRegistry
                 .of(CircuitBreakerConfig.ofDefaults(), taggedCircuitBreakerMetricsPublisher);
@@ -81,8 +81,7 @@ public void shouldAddMetricsForANewlyCreatedCircuitBreaker() {
         Collection<Gauge> gauges = meterRegistry.get(DEFAULT_CIRCUIT_BREAKER_BUFFERED_CALLS)
             .gauges();
 
-        Optional<Gauge> successful = MetricsTestHelper
-            .findMeterByKindAndNameTags(gauges, "successful",
+        Optional<Gauge> successful = findMeterByKindAndNameTags(gauges, "successful",
             newCircuitBreaker.getName());
         assertThat(successful).isPresent();
         assertThat(successful.get().value())
@@ -223,4 +222,38 @@ public void metricsAreRegisteredWithCustomName() {
         ));
     }
 
+    @Test
+    public void testReplaceNewMeter(){
+        CircuitBreaker oldOne = CircuitBreaker.of("backendC", CircuitBreakerConfig.ofDefaults());
+        // add meters of old
+        taggedCircuitBreakerMetricsPublisher.addMetrics(meterRegistry, oldOne);
+        // one success call
+        oldOne.onSuccess(0, TimeUnit.NANOSECONDS);
+
+        assertThat(taggedCircuitBreakerMetricsPublisher.meterIdMap).containsKeys("backendC");
+        assertThat(taggedCircuitBreakerMetricsPublisher.meterIdMap.get("backendC")).hasSize(16);
+        Collection<Gauge> gauges = meterRegistry.get(DEFAULT_CIRCUIT_BREAKER_BUFFERED_CALLS).gauges();
+        Optional<Gauge> successful = findMeterByKindAndNameTags(gauges, "successful", oldOne.getName());
+        assertThat(successful).isPresent();
+        assertThat(successful.get().value())
+            .isEqualTo(oldOne.getMetrics().getNumberOfSuccessfulCalls());
+
+        CircuitBreaker newOne = CircuitBreaker.of("backendC", CircuitBreakerConfig.ofDefaults());
+
+        // add meters of new
+        taggedCircuitBreakerMetricsPublisher.addMetrics(meterRegistry, newOne);
+        // three success call
+        newOne.onSuccess(0, TimeUnit.NANOSECONDS);
+        newOne.onSuccess(0, TimeUnit.NANOSECONDS);
+        newOne.onSuccess(0, TimeUnit.NANOSECONDS);
+
+        assertThat(taggedCircuitBreakerMetricsPublisher.meterIdMap).containsKeys("backendC");
+        assertThat(taggedCircuitBreakerMetricsPublisher.meterIdMap.get("backendC")).hasSize(16);
+        gauges = meterRegistry.get(DEFAULT_CIRCUIT_BREAKER_BUFFERED_CALLS).gauges();
+        successful = findMeterByKindAndNameTags(gauges, "successful", newOne.getName());
+        assertThat(successful).isPresent();
+        assertThat(successful.get().value())
+            .isEqualTo(newOne.getMetrics().getNumberOfSuccessfulCalls());
+
+    }
 }
diff --git a/.../java/io/github/resilience4j/micrometer/tagged/TaggedRateLimiterMetricsPublisherTest.java b/.../java/io/github/resilience4j/micrometer/tagged/TaggedRateLimiterMetricsPublisherTest.java
@@ -157,4 +157,38 @@ public void customMetricNamesGetApplied() {
             "custom_waiting_threads"
         ));
     }
+
+    @Test
+    public void testReplaceNewMeter() {
+        RateLimiter oldOne = RateLimiter.of("backendC", RateLimiterConfig.ofDefaults());
+        // add meters of old
+        taggedRateLimiterMetricsPublisher.addMetrics(meterRegistry, oldOne);
+        // one permission class
+        oldOne.acquirePermission();
+
+        assertThat(taggedRateLimiterMetricsPublisher.meterIdMap).containsKeys("backendC");
+        assertThat(taggedRateLimiterMetricsPublisher.meterIdMap.get("backendC")).hasSize(2);
+        Collection<Gauge> gauges = meterRegistry.get(DEFAULT_AVAILABLE_PERMISSIONS_METRIC_NAME)
+            .gauges();
+        Optional<Gauge> available = findMeterByNamesTag(gauges, oldOne.getName());
+        assertThat(available).isPresent();
+        assertThat(available.get().value())
+            .isEqualTo(oldOne.getMetrics().getAvailablePermissions());
+
+        RateLimiter newOne = RateLimiter.of("backendC", RateLimiterConfig.ofDefaults());
+
+        // add meters of old
+        taggedRateLimiterMetricsPublisher.addMetrics(meterRegistry, newOne);
+        // three permission call
+        newOne.acquirePermission(3);
+
+        assertThat(taggedRateLimiterMetricsPublisher.meterIdMap).containsKeys("backendC");
+        assertThat(taggedRateLimiterMetricsPublisher.meterIdMap.get("backendC")).hasSize(2);
+        gauges = meterRegistry.get(DEFAULT_AVAILABLE_PERMISSIONS_METRIC_NAME)
+            .gauges();
+        available = findMeterByNamesTag(gauges, newOne.getName());
+        assertThat(available).isPresent();
+        assertThat(available.get().value())
+            .isEqualTo(newOne.getMetrics().getAvailablePermissions());
+    }
 }
diff --git a/...c/test/java/io/github/resilience4j/micrometer/tagged/TaggedRetryMetricsPublisherTest.java b/...c/test/java/io/github/resilience4j/micrometer/tagged/TaggedRetryMetricsPublisherTest.java
@@ -177,4 +177,42 @@ public void metricsAreRegisteredWithCustomNames() {
 
         assertThat(metricNames).hasSameElementsAs(Collections.singletonList("custom_calls"));
     }
+
+    @Test
+    public void testReplaceNewMeter() {
+        Retry oldOne = Retry.of("backendC", RetryConfig.ofDefaults());
+        // add meters of old
+        taggedRetryMetricsPublisher.addMetrics(meterRegistry, oldOne);
+        // one success call
+        oldOne.executeRunnable(() -> { });
+
+        assertThat(taggedRetryMetricsPublisher.meterIdMap).containsKeys("backendC");
+        assertThat(taggedRetryMetricsPublisher.meterIdMap.get("backendC")).hasSize(4);
+        Collection<FunctionCounter> counters = meterRegistry.get(DEFAULT_RETRY_CALLS)
+            .functionCounters();
+        Optional<FunctionCounter> successfulWithoutRetry =
+            findMeterByKindAndNameTags(counters, "successful_without_retry", oldOne.getName());
+        assertThat(successfulWithoutRetry).isPresent();
+        assertThat(successfulWithoutRetry.get().count())
+            .isEqualTo(oldOne.getMetrics().getNumberOfSuccessfulCallsWithoutRetryAttempt());
+
+
+        Retry newOne = Retry.of("backendC", RetryConfig.ofDefaults());
+        // add meters of old
+        taggedRetryMetricsPublisher.addMetrics(meterRegistry, newOne);
+        // three success call
+        newOne.executeRunnable(() -> { });
+        newOne.executeRunnable(() -> { });
+        newOne.executeRunnable(() -> { });
+
+        assertThat(taggedRetryMetricsPublisher.meterIdMap).containsKeys("backendC");
+        assertThat(taggedRetryMetricsPublisher.meterIdMap.get("backendC")).hasSize(4);
+        counters = meterRegistry.get(DEFAULT_RETRY_CALLS)
+            .functionCounters();
+        successfulWithoutRetry =
+            findMeterByKindAndNameTags(counters, "successful_without_retry", newOne.getName());
+        assertThat(successfulWithoutRetry).isPresent();
+        assertThat(successfulWithoutRetry.get().count())
+            .isEqualTo(newOne.getMetrics().getNumberOfSuccessfulCallsWithoutRetryAttempt());
+    }
 }
diff --git a/...o/github/resilience4j/micrometer/tagged/TaggedThreadPoolBulkheadMetricsPublisherTest.java b/...o/github/resilience4j/micrometer/tagged/TaggedThreadPoolBulkheadMetricsPublisherTest.java
@@ -186,4 +186,41 @@ public void customMetricNamesGetApplied() {
             "resilience4j.bulkhead.thread.pool.size"
         ));
     }
+
+    @Test
+    public void testReplaceNewMeter(){
+        ThreadPoolBulkhead oldOne = ThreadPoolBulkhead.of("backendC", ThreadPoolBulkheadConfig.ofDefaults());
+        // add meters of old
+        taggedBulkheadMetricsPublisher.addMetrics(meterRegistry, oldOne);
+        // one success call
+        oldOne.executeSupplier(() -> "Bla");
+
+        assertThat(taggedBulkheadMetricsPublisher.meterIdMap).containsKeys("backendC");
+        assertThat(taggedBulkheadMetricsPublisher.meterIdMap.get("backendC")).hasSize(5);
+        Collection<Gauge> gauges = meterRegistry.get(DEFAULT_MAX_THREAD_POOL_SIZE_METRIC_NAME)
+            .gauges();
+        Optional<Gauge> successful = findMeterByNamesTag(gauges, oldOne.getName());
+        assertThat(successful).isPresent();
+        assertThat(successful.get().value())
+            .isEqualTo(oldOne.getMetrics().getMaximumThreadPoolSize());
+
+        ThreadPoolBulkhead newOne = ThreadPoolBulkhead.of("backendC", ThreadPoolBulkheadConfig.ofDefaults());
+
+        // add meters of new
+        taggedBulkheadMetricsPublisher.addMetrics(meterRegistry, newOne);
+        // three success call
+        newOne.executeSupplier(() -> "Bla");
+        newOne.executeSupplier(() -> "Bla");
+        newOne.executeSupplier(() -> "Bla");
+
+        assertThat(taggedBulkheadMetricsPublisher.meterIdMap).containsKeys("backendC");
+        assertThat(taggedBulkheadMetricsPublisher.meterIdMap.get("backendC")).hasSize(5);
+        gauges = meterRegistry.get(DEFAULT_MAX_THREAD_POOL_SIZE_METRIC_NAME)
+            .gauges();
+        successful = findMeterByNamesTag(gauges, newOne.getName());
+        assertThat(successful).isPresent();
+        assertThat(successful.get().value())
+            .isEqualTo(newOne.getMetrics().getMaximumThreadPoolSize());
+    }
+
 }
diff --git a/.../java/io/github/resilience4j/micrometer/tagged/TaggedTimeLimiterMetricsPublisherTest.java b/.../java/io/github/resilience4j/micrometer/tagged/TaggedTimeLimiterMetricsPublisherTest.java
@@ -153,4 +153,37 @@ public void customMetricNamesGetApplied() {
             "custom_calls"
         ));
     }
+
+    @Test
+    public void testReplaceNewMeter(){
+        TimeLimiter oldOne = TimeLimiter.of("backendC", TimeLimiterConfig.ofDefaults());
+        // add meters of old
+        taggedTimeLimiterMetricsPublisher.addMetrics(meterRegistry, oldOne);
+        // one success call
+        oldOne.onSuccess();
+
+        assertThat(taggedTimeLimiterMetricsPublisher.meterIdMap).containsKeys("backendC");
+        assertThat(taggedTimeLimiterMetricsPublisher.meterIdMap.get("backendC")).hasSize(3);
+        Collection<Counter> counters = meterRegistry.get(DEFAULT_TIME_LIMITER_CALLS).counters();
+        Optional<Counter> successful = findMeterByKindAndNameTags(counters, "successful",
+            oldOne.getName());
+        assertThat(successful).map(Counter::count).contains(1d);
+
+        TimeLimiter newOne = TimeLimiter.of("backendC", TimeLimiterConfig.ofDefaults());
+
+        // add meters of new
+        taggedTimeLimiterMetricsPublisher.addMetrics(meterRegistry, newOne);
+        // three success call
+        newOne.onSuccess();
+        newOne.onSuccess();
+        newOne.onSuccess();
+
+        assertThat(taggedTimeLimiterMetricsPublisher.meterIdMap).containsKeys("backendC");
+        assertThat(taggedTimeLimiterMetricsPublisher.meterIdMap.get("backendC")).hasSize(3);
+        counters = meterRegistry.get(DEFAULT_TIME_LIMITER_CALLS).counters();
+        successful = findMeterByKindAndNameTags(counters, "successful",
+            newOne.getName());
+        assertThat(successful).map(Counter::count).contains(3d);
+    }
+
 }