diff --git a/resilience4j-circuit-breaker/README.md b/resilience4j-circuit-breaker/README.md
index 8d165f8..851b2b2 100644
--- a/resilience4j-circuit-breaker/README.md
+++ b/resilience4j-circuit-breaker/README.md
@@ -17,9 +17,9 @@ to stay independently reproducible from its own module.
| Component | Version | Notes |
|---|---|---|
-| JDK | 25 (Temurin 25.0.4.1+1) | latest LTS |
-| Spring Boot | 4.1.1 | latest GA at time of writing; 4.2.0-M1 exists but is a milestone |
-| Spring Framework | 7.0.9 | latest GA; 7.1.0-M1 exists but is a milestone |
+| JDK | 25 (Temurin 25.0.5+8) | latest LTS |
+| Spring Boot | 4.1.2 | latest GA at time of writing; 4.2.0-RC2 exists but is a release candidate |
+| Spring Framework | 7.0.10 | managed by Boot 4.1.2 |
| Resilience4j | 2.4.0 (`resilience4j-spring-boot4`) | depends internally on `resilience4j-spring6`, not a "spring7" module — see [docs/01](docs/01-two-resilience-stacks.md) |
## Quickstart
@@ -47,6 +47,13 @@ local cache); `-o` works for subsequent builds.
| `@ConcurrencyLimit` REJECT policy | same | same | [`04b`](docs/output/04b-concurrencylimit-reject.txt) |
| Resilience4j `@Bulkhead` (bounded wait) for comparison | [`R4jBulkheadService`](src/main/java/com/ankurm/resilience/r4j/R4jBulkheadService.java) | same | [`04c`](docs/output/04c-r4j-bulkhead-comparison.txt) |
| Real `/actuator/health` + `/actuator/circuitbreakers` with a breaker OPEN | [`R4jPaymentService`](src/main/java/com/ankurm/resilience/r4j/R4jPaymentService.java) | [`ActuatorHealthTest`](src/test/java/com/ankurm/resilience/r4j/ActuatorHealthTest.java) | [`05`](docs/output/05-actuator-health-tripped.txt) |
+| State transitions through the event publisher (`CLOSED -> OPEN -> HALF_OPEN -> OPEN`) | [`R4jPaymentService`](src/main/java/com/ankurm/resilience/r4j/R4jPaymentService.java) | [`StateTransitionsTest`](src/test/java/com/ankurm/resilience/r4j/StateTransitionsTest.java) | written to `target/transcripts/` by the test |
+| Testing without sleeping: force the breaker state | same | same | same |
+| Slow-call rate opens the breaker with zero failures | [`R4jSlowCallService`](src/main/java/com/ankurm/resilience/r4j/R4jSlowCallService.java) | [`LatencyAndTimeoutTest`](src/test/java/com/ankurm/resilience/r4j/LatencyAndTimeoutTest.java) | same |
+| `@TimeLimiter`, alone and combined with `@CircuitBreaker` | [`R4jTimeLimiterService`](src/main/java/com/ankurm/resilience/r4j/R4jTimeLimiterService.java) | same | same |
+| `ignoreExceptions` for business errors | [`R4jLookupService`](src/main/java/com/ankurm/resilience/r4j/R4jLookupService.java) | [`IgnoreExceptionsAndRateLimiterTest`](src/test/java/com/ankurm/resilience/r4j/IgnoreExceptionsAndRateLimiterTest.java) | same |
+| `@RateLimiter` | [`R4jRateLimiterService`](src/main/java/com/ankurm/resilience/r4j/R4jRateLimiterService.java) | same | same |
+| What happens to a call the `@TimeLimiter` gave up on; wrong or missing fallback methods; the library defaults | [`R4jBadFallbackService`](src/main/java/com/ankurm/resilience/r4j/R4jBadFallbackService.java) | [`ClaimsCheckTest`](src/test/java/com/ankurm/resilience/r4j/ClaimsCheckTest.java) | same |
## Endpoints (from `scripts/run.sh`)
diff --git a/resilience4j-circuit-breaker/pom.xml b/resilience4j-circuit-breaker/pom.xml
index f6b2dd9..7d3abea 100644
--- a/resilience4j-circuit-breaker/pom.xml
+++ b/resilience4j-circuit-breaker/pom.xml
@@ -7,7 +7,7 @@
org.springframework.boot
spring-boot-starter-parent
- 4.1.1
+ 4.1.2
diff --git a/resilience4j-circuit-breaker/src/main/java/com/ankurm/resilience/r4j/ProductNotFoundException.java b/resilience4j-circuit-breaker/src/main/java/com/ankurm/resilience/r4j/ProductNotFoundException.java
new file mode 100644
index 0000000..65fe2eb
--- /dev/null
+++ b/resilience4j-circuit-breaker/src/main/java/com/ankurm/resilience/r4j/ProductNotFoundException.java
@@ -0,0 +1,11 @@
+package com.ankurm.resilience.r4j;
+
+/**
+ * A business outcome ("no such product"), not a sign the dependency is unhealthy.
+ * The breaker instance lookupIgnored lists it under ignoreExceptions.
+ */
+public class ProductNotFoundException extends RuntimeException {
+ public ProductNotFoundException(String id) {
+ super("no product " + id);
+ }
+}
diff --git a/resilience4j-circuit-breaker/src/main/java/com/ankurm/resilience/r4j/R4jBadFallbackService.java b/resilience4j-circuit-breaker/src/main/java/com/ankurm/resilience/r4j/R4jBadFallbackService.java
new file mode 100644
index 0000000..4d45246
--- /dev/null
+++ b/resilience4j-circuit-breaker/src/main/java/com/ankurm/resilience/r4j/R4jBadFallbackService.java
@@ -0,0 +1,27 @@
+package com.ankurm.resilience.r4j;
+
+import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
+import org.springframework.stereotype.Service;
+
+/**
+ * Two deliberately wrong fallbacks: pay() names a fallback whose parameters do not match
+ * (Integer, Throwable instead of String), payMissing() names a fallback that does not exist.
+ * Used only by ClaimsCheckTest to show what each mistake looks like.
+ */
+@Service
+public class R4jBadFallbackService {
+
+ @CircuitBreaker(name = "lookupCounted", fallbackMethod = "wrong")
+ public String pay(String orderId) {
+ throw new IllegalStateException("downstream down");
+ }
+
+ @CircuitBreaker(name = "lookupCounted", fallbackMethod = "doesNotExist")
+ public String payMissing(String orderId) {
+ throw new IllegalStateException("downstream down");
+ }
+
+ private String wrong(Integer orderId, Throwable ex) {
+ return "never reached";
+ }
+}
diff --git a/resilience4j-circuit-breaker/src/main/java/com/ankurm/resilience/r4j/R4jLookupService.java b/resilience4j-circuit-breaker/src/main/java/com/ankurm/resilience/r4j/R4jLookupService.java
new file mode 100644
index 0000000..fd0a2ea
--- /dev/null
+++ b/resilience4j-circuit-breaker/src/main/java/com/ankurm/resilience/r4j/R4jLookupService.java
@@ -0,0 +1,23 @@
+package com.ankurm.resilience.r4j;
+
+import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
+import org.springframework.stereotype.Service;
+
+/**
+ * The same "not found" method behind two breakers that differ in one line of YAML:
+ * lookupCounted counts ProductNotFoundException as a failure (the default),
+ * lookupIgnored lists it under ignoreExceptions so it counts as neither success nor failure.
+ */
+@Service
+public class R4jLookupService {
+
+ @CircuitBreaker(name = "lookupCounted")
+ public String findCounted(String id) {
+ throw new ProductNotFoundException(id);
+ }
+
+ @CircuitBreaker(name = "lookupIgnored")
+ public String findIgnored(String id) {
+ throw new ProductNotFoundException(id);
+ }
+}
diff --git a/resilience4j-circuit-breaker/src/main/java/com/ankurm/resilience/r4j/R4jRateLimiterService.java b/resilience4j-circuit-breaker/src/main/java/com/ankurm/resilience/r4j/R4jRateLimiterService.java
new file mode 100644
index 0000000..b9b1483
--- /dev/null
+++ b/resilience4j-circuit-breaker/src/main/java/com/ankurm/resilience/r4j/R4jRateLimiterService.java
@@ -0,0 +1,22 @@
+package com.ankurm.resilience.r4j;
+
+import io.github.resilience4j.ratelimiter.RequestNotPermitted;
+import io.github.resilience4j.ratelimiter.annotation.RateLimiter;
+import org.springframework.stereotype.Service;
+
+/**
+ * In-process rate limiter: 3 calls per 1s period, no waiting (timeoutDuration=0).
+ * Config: resilience4j.ratelimiter.instances.searchApi.
+ */
+@Service
+public class R4jRateLimiterService {
+
+ @RateLimiter(name = "searchApi", fallbackMethod = "tooMany")
+ public String search(String q) {
+ return "results:" + q;
+ }
+
+ private String tooMany(String q, RequestNotPermitted ex) {
+ return "RATE_LIMITED:" + q;
+ }
+}
diff --git a/resilience4j-circuit-breaker/src/main/java/com/ankurm/resilience/r4j/R4jSlowCallService.java b/resilience4j-circuit-breaker/src/main/java/com/ankurm/resilience/r4j/R4jSlowCallService.java
new file mode 100644
index 0000000..081dc4b
--- /dev/null
+++ b/resilience4j-circuit-breaker/src/main/java/com/ankurm/resilience/r4j/R4jSlowCallService.java
@@ -0,0 +1,23 @@
+package com.ankurm.resilience.r4j;
+
+import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
+import org.springframework.stereotype.Service;
+
+/**
+ * A call that always SUCCEEDS but can be slow. The breaker "slowBreaker" has
+ * slowCallDurationThreshold=200ms and slowCallRateThreshold=50, so it opens on latency alone,
+ * with a failure rate of zero. Config: resilience4j.circuitbreaker.instances.slowBreaker.
+ */
+@Service
+public class R4jSlowCallService {
+
+ @CircuitBreaker(name = "slowBreaker", fallbackMethod = "fallback")
+ public String call(String id, long sleepMillis) throws InterruptedException {
+ Thread.sleep(sleepMillis);
+ return "ok:" + id;
+ }
+
+ private String fallback(String id, long sleepMillis, Throwable ex) {
+ return "FALLBACK:" + id + ":" + ex.getClass().getSimpleName();
+ }
+}
diff --git a/resilience4j-circuit-breaker/src/main/java/com/ankurm/resilience/r4j/R4jTimeLimiterService.java b/resilience4j-circuit-breaker/src/main/java/com/ankurm/resilience/r4j/R4jTimeLimiterService.java
new file mode 100644
index 0000000..44ad4b8
--- /dev/null
+++ b/resilience4j-circuit-breaker/src/main/java/com/ankurm/resilience/r4j/R4jTimeLimiterService.java
@@ -0,0 +1,61 @@
+package com.ankurm.resilience.r4j;
+
+import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
+import io.github.resilience4j.timelimiter.annotation.TimeLimiter;
+import org.springframework.stereotype.Service;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Resilience4j's TimeLimiter. It only works on methods that return a CompletableFuture
+ * (or a reactive type) because it has to be able to stop waiting for something that is still
+ * running on another thread. Config: resilience4j.timelimiter.instances.slowLookup.
+ */
+@Service
+public class R4jTimeLimiterService {
+
+ /** TimeLimiter alone: a call slower than 500ms is answered by the fallback. */
+ @TimeLimiter(name = "slowLookup", fallbackMethod = "timedOut")
+ public CompletableFuture lookup(String id, long sleepMillis) {
+ return CompletableFuture.supplyAsync(() -> slow(id, sleepMillis));
+ }
+
+ /**
+ * TimeLimiter plus CircuitBreaker: every timeout is recorded as a failure by the breaker,
+ * so a dependency that is merely slow will eventually open the circuit.
+ */
+ @CircuitBreaker(name = "timeoutBreaker", fallbackMethod = "breakerFallback")
+ @TimeLimiter(name = "slowLookup")
+ public CompletableFuture guardedLookup(String id, long sleepMillis) {
+ return CompletableFuture.supplyAsync(() -> slow(id, sleepMillis));
+ }
+
+ /** Counts how many slow calls ran all the way to the end, whether or not anyone was still waiting. */
+ private final AtomicInteger finishedWork = new AtomicInteger();
+
+ /** A method, not a public field: this bean is wrapped in a proxy, and a field read on the proxy is not the real field. */
+ public AtomicInteger finishedWork() {
+ return finishedWork;
+ }
+
+ private String slow(String id, long sleepMillis) {
+ try {
+ Thread.sleep(sleepMillis);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new IllegalStateException("interrupted", e);
+ }
+ finishedWork.incrementAndGet();
+ return "found:" + id;
+ }
+
+ private CompletableFuture timedOut(String id, long sleepMillis, TimeoutException ex) {
+ return CompletableFuture.completedFuture("TIMED_OUT:" + id);
+ }
+
+ private CompletableFuture breakerFallback(String id, long sleepMillis, Throwable ex) {
+ return CompletableFuture.completedFuture("FALLBACK:" + id + ":" + ex.getClass().getSimpleName());
+ }
+}
diff --git a/resilience4j-circuit-breaker/src/main/resources/application.yml b/resilience4j-circuit-breaker/src/main/resources/application.yml
index 419a0a7..2e51cf6 100644
--- a/resilience4j-circuit-breaker/src/main/resources/application.yml
+++ b/resilience4j-circuit-breaker/src/main/resources/application.yml
@@ -30,6 +30,46 @@ resilience4j:
automaticTransitionFromOpenToHalfOpenEnabled: true
recordExceptions:
- com.ankurm.resilience.FlakyDownstream$DownstreamUnavailableException
+ # Opens on latency alone: every call succeeds, but 2 of 4 take longer than 200ms.
+ slowBreaker:
+ slidingWindowType: COUNT_BASED
+ slidingWindowSize: 4
+ minimumNumberOfCalls: 4
+ failureRateThreshold: 50
+ slowCallDurationThreshold: 200ms
+ slowCallRateThreshold: 50
+ waitDurationInOpenState: 5s
+ # Sits behind @TimeLimiter: each timeout is one recorded failure.
+ timeoutBreaker:
+ slidingWindowType: COUNT_BASED
+ slidingWindowSize: 4
+ minimumNumberOfCalls: 4
+ failureRateThreshold: 50
+ waitDurationInOpenState: 5s
+ # Identical pair; the only difference is ignoreExceptions.
+ lookupCounted:
+ slidingWindowSize: 4
+ minimumNumberOfCalls: 4
+ failureRateThreshold: 50
+ waitDurationInOpenState: 5s
+ lookupIgnored:
+ slidingWindowSize: 4
+ minimumNumberOfCalls: 4
+ failureRateThreshold: 50
+ waitDurationInOpenState: 5s
+ ignoreExceptions:
+ - com.ankurm.resilience.r4j.ProductNotFoundException
+ timelimiter:
+ instances:
+ slowLookup:
+ timeoutDuration: 500ms
+ cancelRunningFuture: true
+ ratelimiter:
+ instances:
+ searchApi:
+ limitForPeriod: 3
+ limitRefreshPeriod: 1s
+ timeoutDuration: 0
bulkhead:
instances:
slowOp:
diff --git a/resilience4j-circuit-breaker/src/test/java/com/ankurm/resilience/Transcript.java b/resilience4j-circuit-breaker/src/test/java/com/ankurm/resilience/Transcript.java
index 5b40fda..166c99d 100644
--- a/resilience4j-circuit-breaker/src/test/java/com/ankurm/resilience/Transcript.java
+++ b/resilience4j-circuit-breaker/src/test/java/com/ankurm/resilience/Transcript.java
@@ -17,12 +17,21 @@ public final class Transcript {
private final StringBuilder buf = new StringBuilder();
private final Path outFile;
- private Transcript(String fileName) {
- this.outFile = Paths.get("docs/output", fileName);
+ private Transcript(Path outFile) {
+ this.outFile = outFile;
}
public static Transcript start(String fileName, String header) {
- Transcript t = new Transcript(fileName);
+ return begin(Paths.get("docs/output", fileName), header);
+ }
+
+ /** Same as start(), but writes under target/transcripts so a plain `mvn test` adds nothing to the source tree. */
+ public static Transcript scratch(String fileName, String header) {
+ return begin(Paths.get("target/transcripts", fileName), header);
+ }
+
+ private static Transcript begin(Path file, String header) {
+ Transcript t = new Transcript(file);
t.line(header);
t.line("=".repeat(header.length()));
return t;
diff --git a/resilience4j-circuit-breaker/src/test/java/com/ankurm/resilience/r4j/ClaimsCheckTest.java b/resilience4j-circuit-breaker/src/test/java/com/ankurm/resilience/r4j/ClaimsCheckTest.java
new file mode 100644
index 0000000..e7a1904
--- /dev/null
+++ b/resilience4j-circuit-breaker/src/test/java/com/ankurm/resilience/r4j/ClaimsCheckTest.java
@@ -0,0 +1,65 @@
+package com.ankurm.resilience.r4j;
+
+import com.ankurm.resilience.Transcript;
+import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.annotation.DirtiesContext;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/** Output: 13-abandoned-work.txt, 14-bad-fallback-signature.txt, 15-defaults.txt. */
+@SpringBootTest
+@DirtiesContext
+class ClaimsCheckTest {
+
+ @Autowired R4jTimeLimiterService timeLimited;
+ @Autowired R4jBadFallbackService bad;
+
+ @Test
+ void timeLimiterStopsWaitingButTheWorkStillFinishes() throws Exception {
+ Transcript t = Transcript.scratch("13-abandoned-work.txt", "What happens to the call the TimeLimiter gave up on?");
+ timeLimited.finishedWork().set(0);
+ String r = timeLimited.lookup("z", 1500).get();
+ t.line("caller got: " + r);
+ t.line("finished work right after timeout: " + timeLimited.finishedWork().get());
+ Thread.sleep(1500);
+ t.line("finished work 1.5s later: " + timeLimited.finishedWork().get());
+ assertThat(r).isEqualTo("TIMED_OUT:z");
+ assertThat(timeLimited.finishedWork().get()).isEqualTo(1);
+ t.save();
+ }
+
+ @Test
+ void mismatchedFallbackSignatureFailsAtCallTime() {
+ Transcript t = Transcript.scratch("14-bad-fallback-signature.txt", "Fallback whose parameters do not match the method");
+ t.line("application context started without complaint; the mistakes only show on a call");
+ t.blank();
+ Throwable mismatched = null;
+ try { bad.pay("o-1"); } catch (Throwable e) { mismatched = e; }
+ t.line("fallback exists, wrong parameters -> " + mismatched.getClass().getName() + ": " + mismatched.getMessage());
+ Throwable missing = null;
+ try { bad.payMissing("o-2"); } catch (Throwable e) { missing = e; }
+ t.line("fallback name does not exist -> " + missing.getClass().getName() + ": " + missing.getMessage());
+ assertThat(mismatched).isNotNull();
+ assertThat(missing).isNotNull();
+ t.save();
+ }
+
+ @Test
+ void printLibraryDefaults() {
+ Transcript t = Transcript.scratch("15-defaults.txt", "CircuitBreakerConfig.ofDefaults() in Resilience4j 2.4.0");
+ CircuitBreakerConfig c = CircuitBreakerConfig.ofDefaults();
+ t.line("slidingWindowType = " + c.getSlidingWindowType());
+ t.line("slidingWindowSize = " + c.getSlidingWindowSize());
+ t.line("minimumNumberOfCalls = " + c.getMinimumNumberOfCalls());
+ t.line("failureRateThreshold = " + c.getFailureRateThreshold());
+ t.line("slowCallRateThreshold = " + c.getSlowCallRateThreshold());
+ t.line("slowCallDurationThreshold = " + c.getSlowCallDurationThreshold());
+ t.line("waitIntervalFunctionInOpenState(1) = " + c.getWaitIntervalFunctionInOpenState().apply(1) + " ms");
+ t.line("permittedNumberOfCallsInHalfOpenState = " + c.getPermittedNumberOfCallsInHalfOpenState());
+ t.line("automaticTransitionFromOpenToHalfOpen = " + c.isAutomaticTransitionFromOpenToHalfOpenEnabled());
+ t.save();
+ }
+}
diff --git a/resilience4j-circuit-breaker/src/test/java/com/ankurm/resilience/r4j/IgnoreExceptionsAndRateLimiterTest.java b/resilience4j-circuit-breaker/src/test/java/com/ankurm/resilience/r4j/IgnoreExceptionsAndRateLimiterTest.java
new file mode 100644
index 0000000..3261ac5
--- /dev/null
+++ b/resilience4j-circuit-breaker/src/test/java/com/ankurm/resilience/r4j/IgnoreExceptionsAndRateLimiterTest.java
@@ -0,0 +1,55 @@
+package com.ankurm.resilience.r4j;
+
+import com.ankurm.resilience.Transcript;
+import io.github.resilience4j.circuitbreaker.CircuitBreaker;
+import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.annotation.DirtiesContext;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/** Output: 11-ignore-exceptions.txt, 12-rate-limiter.txt. */
+@SpringBootTest
+@DirtiesContext
+class IgnoreExceptionsAndRateLimiterTest {
+
+ @Autowired R4jLookupService lookup;
+ @Autowired R4jRateLimiterService limiter;
+ @Autowired CircuitBreakerRegistry registry;
+
+ @Test
+ void businessExceptionsShouldNotTripTheBreaker() {
+ Transcript t = Transcript.scratch("11-ignore-exceptions.txt",
+ "Same exception, two breakers, one line of YAML apart");
+ CircuitBreaker counted = registry.circuitBreaker("lookupCounted");
+ CircuitBreaker ignored = registry.circuitBreaker("lookupIgnored");
+ for (int i = 1; i <= 4; i++) {
+ try { lookup.findCounted("p" + i); } catch (ProductNotFoundException ignoredEx) { }
+ try { lookup.findIgnored("p" + i); } catch (ProductNotFoundException ignoredEx) { }
+ }
+ t.line("lookupCounted after 4 'not found': state=" + counted.getState()
+ + " failed=" + counted.getMetrics().getNumberOfFailedCalls());
+ t.line("lookupIgnored after 4 'not found': state=" + ignored.getState()
+ + " failed=" + ignored.getMetrics().getNumberOfFailedCalls()
+ + " buffered=" + ignored.getMetrics().getNumberOfBufferedCalls());
+ assertThat(counted.getState()).isEqualTo(CircuitBreaker.State.OPEN);
+ assertThat(ignored.getState()).isEqualTo(CircuitBreaker.State.CLOSED);
+ assertThat(ignored.getMetrics().getNumberOfBufferedCalls()).isZero();
+ t.save();
+ }
+
+ @Test
+ void rateLimiterRejectsTheFourthCallInAOneSecondWindow() throws InterruptedException {
+ Transcript t = Transcript.scratch("12-rate-limiter.txt", "limitForPeriod=3, limitRefreshPeriod=1s");
+ for (int i = 1; i <= 4; i++) {
+ t.line("call " + i + " -> " + limiter.search("q" + i));
+ }
+ Thread.sleep(1100);
+ String after = limiter.search("q5");
+ t.line("after 1.1s -> " + after);
+ assertThat(after).startsWith("results:");
+ t.save();
+ }
+}
diff --git a/resilience4j-circuit-breaker/src/test/java/com/ankurm/resilience/r4j/LatencyAndTimeoutTest.java b/resilience4j-circuit-breaker/src/test/java/com/ankurm/resilience/r4j/LatencyAndTimeoutTest.java
new file mode 100644
index 0000000..b405dda
--- /dev/null
+++ b/resilience4j-circuit-breaker/src/test/java/com/ankurm/resilience/r4j/LatencyAndTimeoutTest.java
@@ -0,0 +1,75 @@
+package com.ankurm.resilience.r4j;
+
+import com.ankurm.resilience.Transcript;
+import io.github.resilience4j.circuitbreaker.CircuitBreaker;
+import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.annotation.DirtiesContext;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Slow is a failure mode too. Output: 08-slow-call-rate.txt, 09-timelimiter.txt,
+ * 10-timelimiter-plus-breaker.txt.
+ */
+@SpringBootTest
+@DirtiesContext
+class LatencyAndTimeoutTest {
+
+ @Autowired R4jSlowCallService slow;
+ @Autowired R4jTimeLimiterService timeLimited;
+ @Autowired CircuitBreakerRegistry registry;
+
+ @Test
+ void breakerOpensOnLatencyAloneWithZeroFailures() throws Exception {
+ Transcript t = Transcript.scratch("08-slow-call-rate.txt",
+ "slowCallDurationThreshold=200ms, slowCallRateThreshold=50: opens with zero failures");
+ CircuitBreaker cb = registry.circuitBreaker("slowBreaker");
+ long[] sleeps = {10, 400, 10, 400};
+ for (int i = 0; i < sleeps.length; i++) {
+ String r = slow.call("c" + (i + 1), sleeps[i]);
+ t.line("call " + (i + 1) + " (" + sleeps[i] + "ms) -> " + r + " [state=" + cb.getState() + "]");
+ }
+ var m = cb.getMetrics();
+ t.line("failureRate=" + m.getFailureRate() + "% slowCallRate=" + m.getSlowCallRate()
+ + "% numberOfFailedCalls=" + m.getNumberOfFailedCalls()
+ + " numberOfSlowCalls=" + m.getNumberOfSlowCalls());
+ t.line("call 5 -> " + slow.call("c5", 10));
+ assertThat(m.getNumberOfFailedCalls()).isZero();
+ assertThat(cb.getState()).isEqualTo(CircuitBreaker.State.OPEN);
+ t.save();
+ }
+
+ @Test
+ void timeLimiterAnswersSlowCallsWithTheFallback() throws Exception {
+ Transcript t = Transcript.scratch("09-timelimiter.txt", "@TimeLimiter timeoutDuration=500ms");
+ long s1 = System.nanoTime();
+ String fast = timeLimited.lookup("a", 100).get();
+ t.line("100ms call -> " + fast + " (" + (System.nanoTime() - s1) / 1_000_000 / 100 * 100 + "ms bucket)");
+ long s2 = System.nanoTime();
+ String late = timeLimited.lookup("b", 2000).get();
+ long ms = (System.nanoTime() - s2) / 1_000_000;
+ t.line("2000ms call -> " + late + " (caller waited about 500ms, not 2000ms: " + (ms < 1000) + ")");
+ assertThat(fast).isEqualTo("found:a");
+ assertThat(late).isEqualTo("TIMED_OUT:b");
+ assertThat(ms).isBetween(450L, 1000L);
+ t.save();
+ }
+
+ @Test
+ void timeoutsCountAsFailuresAndEventuallyOpenTheBreaker() throws Exception {
+ Transcript t = Transcript.scratch("10-timelimiter-plus-breaker.txt",
+ "@CircuitBreaker + @TimeLimiter: timeouts are recorded as failures");
+ CircuitBreaker cb = registry.circuitBreaker("timeoutBreaker");
+ for (int i = 1; i <= 5; i++) {
+ long s = System.nanoTime();
+ String r = timeLimited.guardedLookup("k" + i, 2000).get();
+ t.line("call " + i + " -> " + r + " [state=" + cb.getState() + ", took "
+ + ((System.nanoTime() - s) / 1_000_000 < 100 ? "<100ms" : "~500ms") + "]");
+ }
+ assertThat(cb.getState()).isEqualTo(CircuitBreaker.State.OPEN);
+ t.save();
+ }
+}
diff --git a/resilience4j-circuit-breaker/src/test/java/com/ankurm/resilience/r4j/StateTransitionsTest.java b/resilience4j-circuit-breaker/src/test/java/com/ankurm/resilience/r4j/StateTransitionsTest.java
new file mode 100644
index 0000000..04f7026
--- /dev/null
+++ b/resilience4j-circuit-breaker/src/test/java/com/ankurm/resilience/r4j/StateTransitionsTest.java
@@ -0,0 +1,95 @@
+package com.ankurm.resilience.r4j;
+
+import com.ankurm.resilience.FlakyDownstream;
+import com.ankurm.resilience.Transcript;
+import io.github.resilience4j.circuitbreaker.CircuitBreaker;
+import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.annotation.DirtiesContext;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Every state transition the post draws, observed through the breaker's own event stream
+ * instead of guessed from return values. Output (under target/transcripts): 06-state-transitions.txt, 07-fast-state-tests.txt.
+ */
+@SpringBootTest
+@DirtiesContext
+class StateTransitionsTest {
+
+ @Autowired R4jPaymentService service;
+ @Autowired FlakyDownstream downstream;
+ @Autowired CircuitBreakerRegistry registry;
+
+ @Test
+ void halfOpenFailureSendsTheBreakerStraightBackToOpen() throws InterruptedException {
+ Transcript t = Transcript.scratch("06-state-transitions.txt",
+ "State transitions seen through the event publisher (downstream stays dead)");
+ CircuitBreaker cb = registry.circuitBreaker("paymentService");
+ cb.reset();
+ List transitions = new ArrayList<>();
+ cb.getEventPublisher().onStateTransition(e ->
+ transitions.add(e.getStateTransition().getFromState() + " -> " + e.getStateTransition().getToState()));
+ downstream.configure(Integer.MAX_VALUE);
+
+ for (int i = 1; i <= 5; i++) service.pay("order-" + i);
+ t.line("after 5 failing calls: state=" + cb.getState());
+ assertThat(cb.getState()).isEqualTo(CircuitBreaker.State.OPEN);
+
+ int callsBefore = downstream.callsSoFar();
+ Thread.sleep(2200); // waitDurationInOpenState=2s, automatic transition enabled
+ t.line("after waiting 2.2s (no call): state=" + cb.getState());
+ assertThat(cb.getState()).isEqualTo(CircuitBreaker.State.HALF_OPEN);
+
+ service.pay("probe-1");
+ service.pay("probe-2");
+ t.line("after 2 failing half-open probes: state=" + cb.getState()
+ + " (downstream calls during probing: " + (downstream.callsSoFar() - callsBefore) + ")");
+ assertThat(cb.getState()).isEqualTo(CircuitBreaker.State.OPEN);
+
+ t.blank();
+ t.line("transitions recorded, in order:");
+ transitions.forEach(s -> t.line(" " + s));
+ assertThat(transitions).containsExactly(
+ "CLOSED -> OPEN", "OPEN -> HALF_OPEN", "HALF_OPEN -> OPEN");
+ t.save();
+ }
+
+ @Test
+ void youCanTestFallbackWithoutSleepingByForcingTheState() {
+ Transcript t = Transcript.scratch("07-fast-state-tests.txt",
+ "Testing without sleeping: force the state, assert the behaviour");
+ CircuitBreaker cb = registry.circuitBreaker("paymentService");
+ cb.reset();
+ downstream.configure(0); // healthy downstream
+ long start = System.nanoTime();
+
+ cb.transitionToOpenState();
+ String whileOpen = service.pay("order-x");
+ t.line("OPEN -> " + whileOpen);
+ assertThat(whileOpen).startsWith("FALLBACK").contains("CallNotPermittedException");
+ assertThat(downstream.callsSoFar()).isZero();
+
+ cb.transitionToHalfOpenState();
+ String probe = service.pay("order-y");
+ t.line("HALF_OPEN -> " + probe);
+ assertThat(probe).startsWith("OK");
+
+ cb.transitionToClosedState();
+ t.line("CLOSED -> " + service.pay("order-z"));
+
+ cb.transitionToForcedOpenState();
+ t.line("FORCED_OPEN -> " + service.pay("order-w"));
+ cb.transitionToClosedState();
+
+ long ms = (System.nanoTime() - start) / 1_000_000;
+ t.line("elapsed under 1s, no Thread.sleep: " + (ms < 1000));
+ assertThat(ms).isLessThan(1000);
+ t.save();
+ }
+}