Skip to content

Commit 041830f

Browse files
onurkybsionurkybsi
committed
PR comments addressed
1 parent f8ab5ad commit 041830f

File tree

3 files changed

+99
-70
lines changed

3 files changed

+99
-70
lines changed

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

Lines changed: 40 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -11,83 +11,83 @@
1111
import dev.failsafe.event.ExecutionCompletedEvent;
1212
import io.opentelemetry.api.common.Attributes;
1313
import io.opentelemetry.api.metrics.LongCounter;
14-
import io.opentelemetry.api.metrics.Meter;
1514

1615
final class CircuitBreakerEventListenerBuilders {
1716
private CircuitBreakerEventListenerBuilders() {}
1817

1918
static <R> EventListener<ExecutionCompletedEvent<R>> buildInstrumentedFailureListener(
20-
CircuitBreakerConfig<R> userConfig, Meter meter, Attributes attributes) {
21-
LongCounter failureCounter =
22-
meter
23-
.counterBuilder("failsafe.circuit_breaker.failure.count")
24-
.setDescription("Count of failed circuit breaker executions.")
25-
.build();
19+
CircuitBreakerConfig<R> userConfig,
20+
LongCounter executionCounter,
21+
Attributes commonAttributes) {
22+
Attributes attributes =
23+
commonAttributes.toBuilder().put("failsafe.circuit_breaker.outcome", "failure").build();
2624
EventListener<ExecutionCompletedEvent<R>> failureListener = userConfig.getFailureListener();
2725
return e -> {
28-
failureCounter.add(1, attributes);
26+
executionCounter.add(1, attributes);
2927
if (failureListener != null) {
3028
failureListener.accept(e);
3129
}
3230
};
3331
}
3432

3533
static <R> EventListener<ExecutionCompletedEvent<R>> buildInstrumentedSuccessListener(
36-
CircuitBreakerConfig<R> userConfig, Meter meter, Attributes attributes) {
37-
LongCounter successCounter =
38-
meter
39-
.counterBuilder("failsafe.circuit_breaker.success.count")
40-
.setDescription("Count of successful circuit breaker executions.")
41-
.build();
34+
CircuitBreakerConfig<R> userConfig,
35+
LongCounter executionCounter,
36+
Attributes commonAttributes) {
37+
Attributes attributes =
38+
commonAttributes.toBuilder().put("failsafe.circuit_breaker.outcome", "success").build();
4239
EventListener<ExecutionCompletedEvent<R>> successListener = userConfig.getSuccessListener();
4340
return e -> {
44-
successCounter.add(1, attributes);
41+
executionCounter.add(1, attributes);
4542
if (successListener != null) {
4643
successListener.accept(e);
4744
}
4845
};
4946
}
5047

5148
static <R> EventListener<CircuitBreakerStateChangedEvent> buildInstrumentedOpenListener(
52-
CircuitBreakerConfig<R> userConfig, Meter meter, Attributes attributes) {
53-
LongCounter openCircuitBreakerCounter =
54-
meter
55-
.counterBuilder("failsafe.circuit_breaker.open.count")
56-
.setDescription("Count of times that circuit breaker was opened.")
57-
.build();
49+
CircuitBreakerConfig<R> userConfig,
50+
LongCounter stateChangesCounter,
51+
Attributes commonAttributes) {
52+
Attributes attributes =
53+
commonAttributes.toBuilder().put("failsafe.circuit_breaker.state", "open").build();
5854
EventListener<CircuitBreakerStateChangedEvent> openListener = userConfig.getOpenListener();
5955
return e -> {
60-
openCircuitBreakerCounter.add(1, attributes);
61-
openListener.accept(e);
56+
stateChangesCounter.add(1, attributes);
57+
if (openListener != null) {
58+
openListener.accept(e);
59+
}
6260
};
6361
}
6462

6563
static <R> EventListener<CircuitBreakerStateChangedEvent> buildInstrumentedHalfOpenListener(
66-
CircuitBreakerConfig<R> userConfig, Meter meter, Attributes attributes) {
67-
LongCounter halfOpenCircuitBreakerCounter =
68-
meter
69-
.counterBuilder("failsafe.circuit_breaker.half_open.count")
70-
.setDescription("Count of times that circuit breaker was half-opened.")
71-
.build();
64+
CircuitBreakerConfig<R> userConfig,
65+
LongCounter stateChangesCounter,
66+
Attributes commonAttributes) {
67+
Attributes attributes =
68+
commonAttributes.toBuilder().put("failsafe.circuit_breaker.state", "half_open").build();
7269
EventListener<CircuitBreakerStateChangedEvent> halfOpenListener =
7370
userConfig.getHalfOpenListener();
7471
return e -> {
75-
halfOpenCircuitBreakerCounter.add(1, attributes);
76-
halfOpenListener.accept(e);
72+
stateChangesCounter.add(1, attributes);
73+
if (halfOpenListener != null) {
74+
halfOpenListener.accept(e);
75+
}
7776
};
7877
}
7978

8079
static <R> EventListener<CircuitBreakerStateChangedEvent> buildInstrumentedCloseListener(
81-
CircuitBreakerConfig<R> userConfig, Meter meter, Attributes attributes) {
82-
LongCounter closedCircuitBreakerCounter =
83-
meter
84-
.counterBuilder("failsafe.circuit_breaker.closed.count")
85-
.setDescription("Count of times that circuit breaker was closed.")
86-
.build();
87-
EventListener<CircuitBreakerStateChangedEvent> closeListener = userConfig.getCloseListener();
80+
CircuitBreakerConfig<R> userConfig,
81+
LongCounter stateChangesCounter,
82+
Attributes commonAttributes) {
83+
Attributes attributes =
84+
commonAttributes.toBuilder().put("failsafe.circuit_breaker.state", "closed").build();
85+
EventListener<CircuitBreakerStateChangedEvent> closedListener = userConfig.getCloseListener();
8886
return e -> {
89-
closedCircuitBreakerCounter.add(1, attributes);
90-
closeListener.accept(e);
87+
stateChangesCounter.add(1, attributes);
88+
if (closedListener != null) {
89+
closedListener.accept(e);
90+
}
9191
};
9292
}
9393
}

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

Lines changed: 18 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -16,13 +16,15 @@
1616
import io.opentelemetry.api.OpenTelemetry;
1717
import io.opentelemetry.api.common.AttributeKey;
1818
import io.opentelemetry.api.common.Attributes;
19+
import io.opentelemetry.api.metrics.LongCounter;
1920
import io.opentelemetry.api.metrics.Meter;
2021

2122
/** Entrypoint for instrumenting Failsafe components. */
2223
public final class FailsafeTelemetry {
2324
private static final String INSTRUMENTATION_NAME = "io.opentelemetry.failsafe-3.0";
2425

25-
private static final AttributeKey<String> CIRCUIT_BREAKER_NAME = AttributeKey.stringKey("name");
26+
private static final AttributeKey<String> CIRCUIT_BREAKER_NAME =
27+
AttributeKey.stringKey("failsafe.circuit_breaker.name");
2628

2729
/** Returns a new {@link FailsafeTelemetry} configured with the given {@link OpenTelemetry}. */
2830
public static FailsafeTelemetry create(OpenTelemetry openTelemetry) {
@@ -47,13 +49,23 @@ public <R> CircuitBreaker<R> createCircuitBreaker(
4749
CircuitBreaker<R> delegate, String circuitBreakerName) {
4850
CircuitBreakerConfig<R> userConfig = delegate.getConfig();
4951
Meter meter = openTelemetry.getMeter(INSTRUMENTATION_NAME);
52+
LongCounter executionCounter =
53+
meter
54+
.counterBuilder("failsafe.circuit_breaker.execution.count")
55+
.setDescription("Count of circuit breaker executions.")
56+
.build();
57+
LongCounter stateChangesCounter =
58+
meter
59+
.counterBuilder("failsafe.circuit_breaker.state_changes.count")
60+
.setDescription("Count of circuit breaker state changes.")
61+
.build();
5062
Attributes attributes = Attributes.of(CIRCUIT_BREAKER_NAME, circuitBreakerName);
5163
return CircuitBreaker.builder(userConfig)
52-
.onFailure(buildInstrumentedFailureListener(userConfig, meter, attributes))
53-
.onSuccess(buildInstrumentedSuccessListener(userConfig, meter, attributes))
54-
.onOpen(buildInstrumentedOpenListener(userConfig, meter, attributes))
55-
.onHalfOpen(buildInstrumentedHalfOpenListener(userConfig, meter, attributes))
56-
.onClose(buildInstrumentedCloseListener(userConfig, meter, attributes))
64+
.onFailure(buildInstrumentedFailureListener(userConfig, executionCounter, attributes))
65+
.onSuccess(buildInstrumentedSuccessListener(userConfig, executionCounter, attributes))
66+
.onOpen(buildInstrumentedOpenListener(userConfig, stateChangesCounter, attributes))
67+
.onHalfOpen(buildInstrumentedHalfOpenListener(userConfig, stateChangesCounter, attributes))
68+
.onClose(buildInstrumentedCloseListener(userConfig, stateChangesCounter, attributes))
5769
.build();
5870
}
5971
}

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

Lines changed: 41 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -5,18 +5,19 @@
55

66
package io.opentelemetry.instrumentation.failsafe.v3_0;
77

8-
import static io.opentelemetry.api.common.AttributeKey.stringKey;
9-
import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
108
import static org.assertj.core.api.Assertions.assertThat;
9+
import static org.junit.jupiter.api.Assertions.assertEquals;
1110

1211
import dev.failsafe.CircuitBreaker;
1312
import dev.failsafe.CircuitBreakerOpenException;
1413
import dev.failsafe.Failsafe;
14+
import io.opentelemetry.api.common.Attributes;
1515
import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
1616
import io.opentelemetry.instrumentation.testing.junit.LibraryInstrumentationExtension;
17-
import io.opentelemetry.sdk.testing.assertj.MetricAssert;
17+
import io.opentelemetry.sdk.testing.assertj.LongPointAssert;
1818
import java.time.Duration;
1919
import java.util.Objects;
20+
import java.util.function.Consumer;
2021
import org.junit.jupiter.api.Test;
2122
import org.junit.jupiter.api.extension.RegisterExtension;
2223

@@ -60,29 +61,45 @@ void captureCircuitBreakerMetrics() {
6061
testing.waitAndAssertMetrics(
6162
"io.opentelemetry.failsafe-3.0",
6263
metricAssert ->
63-
assertCircuitBreakerMetric(metricAssert, "failsafe.circuit_breaker.failure.count", 2),
64-
metricAssert ->
65-
assertCircuitBreakerMetric(metricAssert, "failsafe.circuit_breaker.success.count", 3),
66-
metricAssert ->
67-
assertCircuitBreakerMetric(metricAssert, "failsafe.circuit_breaker.open.count", 1),
68-
metricAssert ->
69-
assertCircuitBreakerMetric(metricAssert, "failsafe.circuit_breaker.half_open.count", 1),
64+
metricAssert
65+
.hasName("failsafe.circuit_breaker.execution.count")
66+
.hasLongSumSatisfying(
67+
sum ->
68+
sum.isMonotonic()
69+
.hasPointsSatisfying(
70+
buildCircuitBreakerAssertion(
71+
2, "failsafe.circuit_breaker.outcome", "failure"),
72+
buildCircuitBreakerAssertion(
73+
3, "failsafe.circuit_breaker.outcome", "success"))));
74+
testing.waitAndAssertMetrics(
75+
"io.opentelemetry.failsafe-3.0",
7076
metricAssert ->
71-
assertCircuitBreakerMetric(metricAssert, "failsafe.circuit_breaker.closed.count", 1));
77+
metricAssert
78+
.hasName("failsafe.circuit_breaker.state_changes.count")
79+
.hasLongSumSatisfying(
80+
sum ->
81+
sum.isMonotonic()
82+
.hasPointsSatisfying(
83+
buildCircuitBreakerAssertion(
84+
1, "failsafe.circuit_breaker.state", "open"),
85+
buildCircuitBreakerAssertion(
86+
1, "failsafe.circuit_breaker.state", "half_open"),
87+
buildCircuitBreakerAssertion(
88+
1, "failsafe.circuit_breaker.state", "closed"))));
7289
}
7390

74-
private static void assertCircuitBreakerMetric(
75-
MetricAssert metricAssert, String counterName, long expectedValue) {
76-
metricAssert
77-
.hasName(counterName)
78-
.hasLongSumSatisfying(
79-
sum ->
80-
sum.isMonotonic()
81-
.hasPointsSatisfying(
82-
point ->
83-
point
84-
.hasValue(expectedValue)
85-
.hasAttributesSatisfyingExactly(
86-
equalTo(stringKey("name"), "testing"))));
91+
private static Consumer<LongPointAssert> buildCircuitBreakerAssertion(
92+
long expectedValue, String expectedAttributeKey, String expectedAttributeValue) {
93+
return longSumAssert ->
94+
longSumAssert
95+
.hasValue(expectedValue)
96+
.hasAttributesSatisfying(
97+
attributes ->
98+
assertEquals(
99+
Attributes.builder()
100+
.put("failsafe.circuit_breaker.name", "testing")
101+
.put(expectedAttributeKey, expectedAttributeValue)
102+
.build(),
103+
attributes));
87104
}
88105
}

0 commit comments

Comments
 (0)