Circuit Breaker

1
resilience4j:
2
  circuitbreaker:
3
    instances:
4
      creditBureau:
5
        sliding-window-type: COUNT_BASED
6
        sliding-window-size: 20
7
        minimum-number-of-calls: 10          # no verdict from 2 unlucky calls
8
        failure-rate-threshold: 50
9
        slow-call-duration-threshold: 2s     # slow counts as failing
10
        slow-call-rate-threshold: 50
11
        wait-duration-in-open-state: 30s
12
        permitted-number-of-calls-in-half-open-state: 3
13
        record-exceptions:
14
          - org.springframework.web.client.ResourceAccessException
15
          - org.springframework.web.client.HttpServerErrorException
16
        ignore-exceptions:
17
          - com.bank.loan.NoCreditHistoryException   # a business answer is not an outage
18
  retry:
19
    instances:
20
      creditBureau:
21
        max-attempts: 2
22
        wait-duration: 200ms
23
        retry-exceptions:
24
          - org.springframework.web.client.ResourceAccessException

1
@Configuration
2
class BureauHttpConfig {
3

4
    @Bean
5
    RestClient bureauRestClient(RestClient.Builder builder) {
6
        var factory = new SimpleClientHttpRequestFactory();
7
        factory.setConnectTimeout(Duration.ofMillis(500));
8
        factory.setReadTimeout(Duration.ofSeconds(2));   // matches slow-call-duration-threshold
9
        return builder.baseUrl("https://bureau.example").requestFactory(factory).build();
10
    }
11
}

1
@Component
2
class CreditBureauGateway {
3

4
    private final RestClient http;
5
    private final CircuitBreaker breaker;
6
    private final Retry retry;
7

8
    CreditBureauGateway(RestClient bureauRestClient, CircuitBreakerRegistry breakers, RetryRegistry retries) {
9
        this.http = bureauRestClient;
10
        this.breaker = breakers.circuitBreaker("creditBureau");
11
        this.retry = retries.retry("creditBureau");
12
    }
13

14
    BureauReport report(InquiryRequest request) {
15
        Supplier<BureauReport> call = () -> http.post().uri("/inquiries")
16
                // The same inquiry id on a retry lets the bureau recognise a repeated inquiry.
17
                .header("X-Inquiry-Id", request.inquiryId())
18
                .body(request)
19
                .retrieve()
20
                .body(BureauReport.class);
21

22
        return Decorators.ofSupplier(call)
23
                .withRetry(retry)                 // inner: up to 2 physical attempts
24
                .withCircuitBreaker(breaker)      // outer: records ONE logical call
25
                .withFallback(List.of(CallNotPermittedException.class, ResourceAccessException.class),
26
                        ex -> BureauReport.unavailable(request.applicationId()))
27
                .get();
28
    }
29
}

1
@Service
2
class LoanApplicationService {
3

4
    private final CreditBureauGateway bureau;
5
    private final LoanApplicationRepository applications;
6
    private final CreditPolicy policy;
7

8
    LoanApplicationService(CreditBureauGateway bureau, LoanApplicationRepository applications, CreditPolicy policy) {
9
        this.bureau = bureau;
10
        this.applications = applications;
11
        this.policy = policy;
12
    }
13

14
    @Transactional
15
    public ApplicationResult apply(LoanRequest request) {
16
        LoanApplication application = applications.save(LoanApplication.received(request));
17
        BureauReport report = bureau.report(InquiryRequest.of(application));
18

19
        // The fallback is a product decision: never reject a customer because a
20
        // dependency is down. Keep the application and decide when the score arrives.
21
        return switch (report.status()) {
22
            case AVAILABLE -> ApplicationResult.decided(application.decide(policy.evaluate(report)));
23
            case UNAVAILABLE -> ApplicationResult.pending(application.markAwaitingScore());
24
        };
25
    }
26
}

1
@Component
2
class BreakerLogging {
3

4
    private static final Logger log = LoggerFactory.getLogger(BreakerLogging.class);
5

6
    BreakerLogging(CircuitBreakerRegistry breakers) {
7
        breakers.circuitBreaker("creditBureau").getEventPublisher()
8
                .onStateTransition(event -> log.warn("credit bureau breaker {}", event.getStateTransition()))
9
                .onCallNotPermitted(event -> log.debug("credit bureau call rejected while OPEN"));
10
    }
11
}

1
class BureauBreakerTest {
2

3
    @Test
4
    void opensAfterEnoughFailuresAndThenRejectsWithoutCalling() {
5
        var breaker = CircuitBreaker.of("test", CircuitBreakerConfig.custom()
6
                .slidingWindowSize(4)
7
                .minimumNumberOfCalls(4)
8
                .failureRateThreshold(50)
9
                .build());
10
        var calls = new AtomicInteger();
11
        Supplier<String> failing = CircuitBreaker.decorateSupplier(breaker, () -> {
12
            calls.incrementAndGet();
13
            throw new ResourceAccessException("down");
14
        });
15

16
        for (int i = 0; i < 4; i++) {
17
            assertThatThrownBy(failing::get).isInstanceOf(ResourceAccessException.class);
18
        }
19
        assertThat(breaker.getState()).isEqualTo(CircuitBreaker.State.OPEN);
20

21
        assertThatThrownBy(failing::get).isInstanceOf(CallNotPermittedException.class);
22
        assertThat(calls).hasValue(4);          // the fifth call never reached the service
23
    }
24
}