로깅·재시도 AOP

package board.resilience;

public record OperationLog(
        String operation,
        String outcome,
        long elapsedNanos,
        String traceId
) {
    public OperationLog {
        if (operation.isBlank() || outcome.isBlank() || elapsedNanos < 0) {
            throw new IllegalArgumentException("invalid operation log");
        }
    }

    public static OperationLog success(
            String operation,
            long started,
            String traceId
    ) {
        return new OperationLog(
                operation, "success",
                System.nanoTime() - started, traceId);
    }
}

package board.resilience;

import java.time.Duration;
import java.util.Objects;

public final class RetryExecutor {
    public <T> T execute(
            int maximumAttempts,
            Duration remainingBudget,
            Attempt<T> target
    ) {
        Objects.requireNonNull(target);
        if (maximumAttempts < 1 || remainingBudget.isNegative()
                || remainingBudget.isZero()) {
            throw new IllegalArgumentException("invalid retry budget");
        }
        TransientStoreFailure last = null;
        for (int attempt = 1; attempt <= maximumAttempts; attempt++) {
            try {
                return target.call(attempt);
            } catch (TransientStoreFailure failure) {
                last = failure;
            }
        }
        throw last;
    }

    @FunctionalInterface
    public interface Attempt<T> {
        T call(int attempt);
    }

    public static final class TransientStoreFailure extends RuntimeException {
        public TransientStoreFailure(String message) { super(message); }
    }

    public static void main(String[] args) {
        var retry = new RetryExecutor();
        long id = retry.execute(3, Duration.ofSeconds(1), attempt -> {
            System.out.println("attempt=" + attempt);
            if (attempt < 3) throw new TransientStoreFailure("temporary");
            return 41L;
        });
        System.out.println("id=" + id);
    }
}

attempt=1
attempt=2
attempt=3
id=41

implementation 'org.springframework:spring-context'
implementation 'org.springframework:spring-aop'
implementation 'org.aspectj:aspectjweaver'

package board.resilience;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.ArrayList;
import java.util.List;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.junit.jupiter.api.Test;
import org.springframework.aop.support.AopUtils;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.core.annotation.Order;
import board.resilience.RetryExecutor.TransientStoreFailure;

public final class RetryProxyTest {
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Observed { String value(); }

    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface RetryTransient { int maximumAttempts(); }

    public static final class Events {
        private final List<String> values = new ArrayList<>();
        void add(String value) { values.add(value); }
        List<String> snapshot() { return List.copyOf(values); }
    }

    @Aspect
    @Order(10)
    public static final class LogAspect {
        private final Events events;
        public LogAspect(Events events) { this.events = events; }

        @Around(value = "execution(public * board.resilience..*(..)) && "
                + "@annotation(operation)", argNames = "operation")
        public Object observe(ProceedingJoinPoint point, Observed operation)
                throws Throwable {
            events.add("log:begin:" + operation.value());
            try {
                Object result = point.proceed();
                events.add("log:success");
                return result;
            } catch (Throwable failure) {
                events.add("log:failure");
                throw failure;
            } finally {
                events.add("log:end");
            }
        }
    }

    @Aspect
    @Order(20)
    public static final class LimitedRetryAspect {
        private final Events events;
        public LimitedRetryAspect(Events events) { this.events = events; }

        @Around(value = "execution(public * board.resilience..*(..)) && "
                + "@annotation(retry)", argNames = "retry")
        public Object retry(ProceedingJoinPoint point, RetryTransient retry)
                throws Throwable {
            int maximum = retry.maximumAttempts();
            if (maximum < 1) {
                throw new IllegalArgumentException("maximumAttempts must be positive");
            }
            for (int attempt = 1; attempt <= maximum; attempt++) {
                events.add("retry:" + attempt);
                try {
                    return point.proceed();
                } catch (TransientStoreFailure failure) {
                    if (attempt == maximum) throw failure;
                }
            }
            throw new IllegalStateException("unreachable retry state");
        }
    }

    public static class ReportService {
        private final Events events;
        private int calls;
        private int transientFailures;
        private boolean invalid;
        private TransientStoreFailure lastFailure;
        private final IllegalArgumentException validationFailure =
                new IllegalArgumentException("invalid report range");

        public ReportService(Events events) { this.events = events; }
        public void plan(int transientFailures, boolean invalid) {
            this.transientFailures = transientFailures;
            this.invalid = invalid;
        }
        public int calls() { return calls; }
        public TransientStoreFailure lastFailure() { return lastFailure; }
        public IllegalArgumentException validationFailure() { return validationFailure; }

        @Observed("post.weekly")
        @RetryTransient(maximumAttempts = 3)
        public int load() {
            events.add("target:" + ++calls);
            if (invalid) throw validationFailure;
            if (calls <= transientFailures) {
                lastFailure = new TransientStoreFailure("temporary store failure");
                throw lastFailure;
            }
            return 12;
        }
    }

    @Configuration(proxyBeanMethods = false)
    @EnableAspectJAutoProxy(proxyTargetClass = true)
    public static class Config {
        @Bean Events events() { return new Events(); }
        @Bean LogAspect logAspect(Events events) { return new LogAspect(events); }
        @Bean LimitedRetryAspect retryAspect(Events events) {
            return new LimitedRetryAspect(events);
        }
        @Bean ReportService reportService(Events events) {
            return new ReportService(events);
        }
    }

    @Test
    void logWrapsLimitedRetry() {
        verifyCase(0, false, 1, List.of(
                "log:begin:post.weekly", "retry:1", "target:1",
                "log:success", "log:end"));
        verifyCase(2, false, 3, List.of(
                "log:begin:post.weekly", "retry:1", "target:1",
                "retry:2", "target:2", "retry:3", "target:3",
                "log:success", "log:end"));
        verifyCase(3, false, 3, List.of(
                "log:begin:post.weekly", "retry:1", "target:1",
                "retry:2", "target:2", "retry:3", "target:3",
                "log:failure", "log:end"));
        verifyCase(0, true, 1, List.of(
                "log:begin:post.weekly", "retry:1", "target:1",
                "log:failure", "log:end"));
    }

    private static void verifyCase(int failures, boolean invalid, int calls,
                                   List<String> expected) {
        try (var context = new AnnotationConfigApplicationContext(Config.class)) {
            ReportService report = context.getBean(ReportService.class);
            assertTrue(AopUtils.isAopProxy(report));
            report.plan(failures, invalid);
            if (invalid) {
                var failure = assertThrows(IllegalArgumentException.class, report::load);
                assertSame(report.validationFailure(), failure);
            } else if (failures >= 3) {
                var failure = assertThrows(TransientStoreFailure.class, report::load);
                assertSame(report.lastFailure(), failure);
            } else {
                assertEquals(12, report.load());
            }
            assertEquals(calls, report.calls());
            assertEquals(expected, context.getBean(Events.class).snapshot());
        }
    }
}

./gradlew test --tests board.resilience.RetryProxyTest

log:begin:post.weekly
retry:1
target:1
retry:2
target:2
retry:3
target:3
log:success
log:end