Proposal: Retry lifecycle and/or attempt methods

[johnmanko]

Retry doesn't have any way to call a side method for lifecycle stage or retry attempt. I think it could be a good idea. Right now the only solution seems to be the aspect (AOP) approach.

Consider the following. There is a fallback if all retries fail, but what if I want enhanced logging or notifications if retries occur, including the context surrounding failures/successes?

@ApplicationScoped
public class FaultToleranceBean {

   @Retry(maxRetries = 2)
   @Fallback(fallbackMethod = "doWorkFallback")
   public Result doWork() {
      return callServiceA(); // This service usually works but sometimes
                             // throws a RuntimeException
   }

   private Result doWorkFallback() {
      return Result.emptyResult();
   }
}

What if we had something like the following:

@ApplicationScoped
public class FaultToleranceBean {

   @Retry(maxRetries = 2,
      onRetryMethod="logRetryIsOccurring",
      onRetrySuccessMethod="logRetrySuccess"
  )
   public Result doWork() {
      return callServiceA(); // This service usually works but sometimes
                             // throws a RuntimeException
   }

   private void logRetryIsOccurring(RetryContext context) {

   }
   private void logRetrySuccess(RetryContext context) {

   }
}

RetryContext could contain information like incoming data, the retry count, previous context (if any) etc.

Alternatively, using annotations:

• @OnRetryStart
• @OnRetryComplete
• @OnRetryFailure
• @OnRetrySuccess

Thoughts?

[Ladicek]

In SmallRye Fault Tolerance, we have @BeforeRetry to call a method before any retry attempt happens (but not before the initial attempt). See https://smallrye.io/docs/smallrye-fault-tolerance/6.7.0/reference/retry.html#_before_retry_actions for more info.

[johnmanko]

In looking at SmallRye, I came up with the following solution if one wants to do any logging (this is from a quarkus app).

The documentation states

Note that the before retry action must fast and non-blocking (i.e., it must not do any IO or long-running computations) and must not throw an exception.

I guess the only solution is to just fire an event to handle any workload or IO activity.

@ApplicationScoped
public class EventLogger {
    
    
    public void logEvent(@ObservesAsync LogEvent<Throwable> event) {
        
        String message = String.format("%s (%s.%s)", event.getMessage(), event.getSourceClass(), event.getSourceMethod());
        
        Logger.getLogger(event.getSourceClass()).logp(
                event.getLevel(), 
                event.getSourceClass(),
                event.getSourceMethod(),
                message,
                event.getThrowable());

        
    }
    
}

@Path("/coffee")
public class CoffeeResource {

    private static final Logger LOGGER = Logger.getLogger(CoffeeResource.class);

    @Inject
    CoffeeRepositoryService coffeeRepository;
    
    @Inject
    private Event<LogEvent<Throwable>> logger;

    private AtomicLong counter = new AtomicLong(0);

    @GET
    @Retry(maxRetries = 4)
    @BeforeRetry(MyBeforeRetry.class)
    public List<Coffee> coffees() {
        final Long invocationNumber = counter.getAndIncrement();

        maybeFail(String.format("CoffeeResource#coffees() invocation #%d failed", invocationNumber));

        LOGGER.infof("CoffeeResource#coffees() invocation #%d returning successfully", invocationNumber);
        return coffeeRepository.getAllCoffees();
    }
    
    private void maybeFail(String failureLogMessage) {
        if (new Random().nextBoolean()) {
            LOGGER.error(failureLogMessage);
            throw new RuntimeException("Resource failure.");
        }
    }
    

    public static class MyBeforeRetry implements BeforeRetryHandler {
    
        @Inject
        private Event<LogEvent<Throwable>> logger;
        
        public void handle(ExecutionContext context) {
            Method m = context.getMethod();
            logger.fireAsync(new LogEvent<>(Level.WARNING, 
                    "Retry happening from BeforeRetryHandler", 
                    context.getFailure(), 
                    m.getDeclaringClass().getName(), 
                    m.getName()));
        }
    }
}

The only information that's not available is the retry count. I don't have a use case for needing it, but it would be nice if additional information about the retry was available from ExecutionContext.

[Ladicek]

You're firing a synchronous event, which means all observers are notified synchronously. That doesn't help :-) IMHO, logging in the before retry handler is fine, hopefully the actual logger is asynchronous.

[johnmanko]

Ah, yes, you're correct. Was trying to write that from memory. I think it's .fireAsync and @ObservesAsync, IIRC.

To your point, though, logging (file) IO is fine? So the "IO" stated in the docs is "network IO" (which I presume could include network FS)? I just want to nail down the meaning.

[Ladicek]

Yes, fireAsync and @ObservesAsync would be a lot better :-)

By "logging is fine", I meant it is such a tiny IO operation it doesn't matter. And probably not even that, if the logger is asynchronous (and the IO happens on another thread). I don't specifically distinguish file IO and network IO, for example sending a tiny request in a fire-and-forget fashion should be fine too. The before retry handler just has to be fast.

[johnmanko]

Good to know. Thank you for that info.