Declarative client and circuitbreaker retry won't trigger for 404 responses

[kevgilmore]

When using the Declarative client with circuitbreaker, a 404 response returns a Mono.empty() instead of throwing an exception. This prevents the circuitbreaker retry being triggered.

Example client

@Client("my-client")
public interface RcsCapabilityClient {
    String PATH = "/internal/v1/something";

    @Get(PATH)
    @CircuitBreaker(attempts = "${my-client-circuitBreaker.attempts}",
            delay = "${my-client-clients.circuitBreaker.delay}",
            maxDelay = "${my-client-clients.circuitBreaker.maxDelay}",
            reset = "${my-client-clients.circuitBreaker.reset}",
            predicate = MyClientRetryPredicate.class)
    Mono<SomeCustomResponse> getSomething();
}

And the predicate class:

public class MyClientRetryPredicate implements RetryPredicate {
    @Override
    public boolean test(Throwable t) {
        if (t instanceof HttpClientResponseException e) {
            return switch (e.getStatus()) {
                case UNPROCESSABLE_ENTITY, BAD_REQUEST, GATEWAY_TIMEOUT, OK -> false;
                default -> true;
            };
        }

        if (t instanceof ResponseClosedException) {
            return true;
        }
        if (t instanceof HttpClientException hce) {
            return !(hce.getCause() instanceof CodecException);
        }
        return true;
    }
}

build.gradle

api("io.micronaut.reactor:micronaut-reactor-http-client")

I tried to override this behaviour with a custom error decoder and a global exception handler, but it didn't work. How can I make the client throw an exception on a 404 response so that the circuit breaker can retry?

[graemerocher]

Micronaut implements the same semantics as OpenFeign which doesn't regard 404 as retryable status code since it isn't an error

[kevgilmore]

OpenFeign can be configured to treat 404 status codes as retryable though. Micronaut cannot, which is my point. The methods to do it in Micronaut are not working.

❌ custom error decoder

@Singleton
public class CustomErrorDecoder implements HttpClientErrorDecoder {

    @Override
    public Exception decode(HttpResponse<?> response, HttpClientException exception) { //doesn't exist
        if (response.getStatus().getCode() == 404) {
            return new HttpClientResponseException("Resource not found", response);
        }
        // Default behavior for other status codes
        return new HttpClientResponseException(response.getStatus().getReason(), response);
    }
}

❌ global exception handler

@Produces
@Singleton
@Requires(classes = {HttpClientResponseException.class, ExceptionHandler.class})
public class CustomHttpClientResponseExceptionHandler implements ExceptionHandler<HttpClientResponseException, HttpResponse<?>> {

    @Override
    public HttpResponse<?> handle(HttpRequest request, HttpClientResponseException exception) {
        if (exception.getStatus().getCode() == 404) {
            return HttpResponse.notFound("Resource not found");
        }
        return HttpResponse.status(exception.getStatus(), exception.getMessage());
    }
}

[graemerocher]

probably because 404 is never treated as an error. Would require a similar configuration change to feign.

[kevgilmore]

Thanks, but that was the predicate method above no? Which doesn't work.

I'm unable to find a solution so am in the process of migrating services to use imperative method on ReactorHttpClient instead which seems to work with the predicate method above.

Any thoughts/views on why none of the solutions (3) are working for the declarative http @Client?

[graemerocher]

the predicate applies to exceptions and as I said 404 is not an exceptional condition