Class RetryUtil

src/main/java/se/devrandom/heimdall/util/RetryUtil.java:33–172

Utility class for executing operations with retry logic and exponential backoff. Only retries transient errors (network issues, 5xx errors, S3 throttling). Does not retry client errors (4xx) or application-level failures.

 * Does not retry client errors (4xx) or application-level failures.
 */
public class RetryUtil {
    private static final Logger log = LoggerFactory.getLogger(RetryUtil.class);

    /**
     * Executes the given operation with retry logic and exponential backoff.
     *
     * @param operation      The operation to execute
     * @param maxAttempts    Maximum number of attempts (e.g., 3)
     * @param initialDelayMs Initial delay in milliseconds (e.g., 1000 for 1 second)
     * @param operationName  Name of the operation for logging purposes
     * @param <T>            Return type of the operation
     * @return The result from the operation
     * @throws Exception if all retry attempts are exhausted or a non-retryable error occurs
     */
    public static <T> T executeWithRetry(
            Callable<T> operation,
            int maxAttempts,
            long initialDelayMs,
            String operationName) throws Exception {

        Exception lastException = null;

        for (int attempt = 1; attempt <= maxAttempts; attempt++) {
            try {
                return operation.call();
            } catch (Exception e) {
                lastException = e;

                // Check if we've exhausted all attempts
                if (attempt == maxAttempts) {
                    log.error("{} failed after {} attempts", operationName, maxAttempts, e);
                    throw e;
                }

                // Check if error is retryable
                if (!isRetryable(e)) {
                    log.error("{} failed with non-retryable error: {}",
                        operationName, e.getClass().getSimpleName(), e);
                    throw e;
                }

                // Calculate exponential backoff delay: 1s, 2s, 4s, 8s, ...
                long delayMs = initialDelayMs * (1L << (attempt - 1));

                log.warn("{} attempt {}/{} failed, retrying in {}ms: {}",
                    operationName, attempt, maxAttempts, delayMs, e.getMessage());

                // Wait before retrying
                try {
                    Thread.sleep(delayMs);
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    throw new RuntimeException("Retry interrupted", ie);
                }
            }
        }

        // Should not reach here, but throw last exception just in case