review

Author: laurit

instrumentation/failsafe-3.0/library/src/main/java/io/opentelemetry/instrumentation/failsafe/v3_0/CircuitBreakerEventListenerBuilders.java

@@ -5,88 +5,69 @@
 
 package io.opentelemetry.instrumentation.failsafe.v3_0;
 
+import static io.opentelemetry.api.common.AttributeKey.stringKey;
+
 import dev.failsafe.CircuitBreakerConfig;
 import dev.failsafe.event.CircuitBreakerStateChangedEvent;
 import dev.failsafe.event.EventListener;
 import dev.failsafe.event.ExecutionCompletedEvent;
+import io.opentelemetry.api.common.AttributeKey;
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.metrics.LongCounter;
 
 final class CircuitBreakerEventListenerBuilders {
+  private static final AttributeKey<String> OUTCOME_KEY =
+      stringKey("failsafe.circuit_breaker.outcome");
+  private static final AttributeKey<String> STATE_KEY = stringKey("failsafe.circuit_breaker.state");
+
   private CircuitBreakerEventListenerBuilders() {}
 
   static <R> EventListener<ExecutionCompletedEvent<R>> buildInstrumentedFailureListener(
       CircuitBreakerConfig<R> userConfig,
       LongCounter executionCounter,
       Attributes commonAttributes) {
-    Attributes attributes =
-        commonAttributes.toBuilder().put("failsafe.circuit_breaker.outcome", "failure").build();
-    EventListener<ExecutionCompletedEvent<R>> failureListener = userConfig.getFailureListener();
-    return e -> {
-      executionCounter.add(1, attributes);
-      if (failureListener != null) {
-        failureListener.accept(e);
-      }
-    };
+    Attributes attributes = commonAttributes.toBuilder().put(OUTCOME_KEY, "failure").build();
+    return count(executionCounter, attributes, userConfig.getFailureListener());
   }
 
   static <R> EventListener<ExecutionCompletedEvent<R>> buildInstrumentedSuccessListener(
       CircuitBreakerConfig<R> userConfig,
       LongCounter executionCounter,
       Attributes commonAttributes) {
-    Attributes attributes =
-        commonAttributes.toBuilder().put("failsafe.circuit_breaker.outcome", "success").build();
-    EventListener<ExecutionCompletedEvent<R>> successListener = userConfig.getSuccessListener();
-    return e -> {
-      executionCounter.add(1, attributes);
-      if (successListener != null) {
-        successListener.accept(e);
-      }
-    };
+    Attributes attributes = commonAttributes.toBuilder().put(OUTCOME_KEY, "success").build();
+    return count(executionCounter, attributes, userConfig.getSuccessListener());
   }
 
   static <R> EventListener<CircuitBreakerStateChangedEvent> buildInstrumentedOpenListener(
       CircuitBreakerConfig<R> userConfig,
       LongCounter stateChangesCounter,
       Attributes commonAttributes) {
-    Attributes attributes =
-        commonAttributes.toBuilder().put("failsafe.circuit_breaker.state", "open").build();
-    EventListener<CircuitBreakerStateChangedEvent> openListener = userConfig.getOpenListener();
-    return e -> {
-      stateChangesCounter.add(1, attributes);
-      if (openListener != null) {
-        openListener.accept(e);
-      }
-    };
+    Attributes attributes = commonAttributes.toBuilder().put(STATE_KEY, "open").build();
+    return count(stateChangesCounter, attributes, userConfig.getOpenListener());
   }
 
   static <R> EventListener<CircuitBreakerStateChangedEvent> buildInstrumentedHalfOpenListener(
       CircuitBreakerConfig<R> userConfig,
       LongCounter stateChangesCounter,
       Attributes commonAttributes) {
-    Attributes attributes =
-        commonAttributes.toBuilder().put("failsafe.circuit_breaker.state", "half_open").build();
-    EventListener<CircuitBreakerStateChangedEvent> halfOpenListener =
-        userConfig.getHalfOpenListener();
-    return e -> {
-      stateChangesCounter.add(1, attributes);
-      if (halfOpenListener != null) {
-        halfOpenListener.accept(e);
-      }
-    };
+    Attributes attributes = commonAttributes.toBuilder().put(STATE_KEY, "half_open").build();
+    return count(stateChangesCounter, attributes, userConfig.getHalfOpenListener());
   }
 
   static <R> EventListener<CircuitBreakerStateChangedEvent> buildInstrumentedCloseListener(
       CircuitBreakerConfig<R> userConfig,
       LongCounter stateChangesCounter,
       Attributes commonAttributes) {
-    Attributes attributes =
-        commonAttributes.toBuilder().put("failsafe.circuit_breaker.state", "closed").build();
-    EventListener<CircuitBreakerStateChangedEvent> closedListener = userConfig.getCloseListener();
+    Attributes attributes = commonAttributes.toBuilder().put(STATE_KEY, "closed").build();
+    return count(stateChangesCounter, attributes, userConfig.getCloseListener());
+  }
+
+  private static <T> EventListener<T> count(
+      LongCounter counter, Attributes attributes, EventListener<T> delegate) {
     return e -> {
-      stateChangesCounter.add(1, attributes);
-      if (closedListener != null) {
-        closedListener.accept(e);
+      counter.add(1, attributes);
+      if (delegate != null) {
+        delegate.accept(e);
       }
     };
   }

instrumentation/failsafe-3.0/library/src/test/java/io/opentelemetry/instrumentation/failsafe/v3_0/FailsafeTelemetryTest.java

@@ -43,15 +43,7 @@ void captureCircuitBreakerMetrics() {
     for (int i = 0; i < 5; i++) {
       try {
         int temp = i;
-        Failsafe.with(instrumentedCircuitBreaker)
-            .get(
-                () -> {
-                  if (temp < 2) {
-                    return null;
-                  } else {
-                    return new Object();
-                  }
-                });
+        Failsafe.with(instrumentedCircuitBreaker).get(() -> temp < 2 ? null : new Object());
       } catch (CircuitBreakerOpenException e) {
         assertThat(i).isEqualTo(2);
       }