The breaker that never opened

import java.util.*;
import java.util.function.*;

/**
 * Solution: the breaker that never opened.
 *
 * One defect, one line of configuration, and a ninety-minute outage.
 *
 * The breaker counted CONSECUTIVE failures. Against a dependency that is
 * fully dead that works — the failures arrive in an unbroken run. Against one
 * that is degraded, every other call succeeds and resets the counter, so five
 * in a row essentially never happens and the breaker stays closed while half
 * of all user requests time out.
 *
 * Total failure is the easy case. Partial failure is what a real outage looks
 * like, and it is the case consecutive counting cannot see.
 *
 * The fix is to count a failure RATE over a rolling window: "half of the last
 * twenty calls failed" opens correctly whether the dependency is dead or
 * merely sick. Every production breaker — Resilience4j, Polly, Hystrix before
 * them — is configured this way, and the option to count consecutive failures
 * mostly exists to catch total outages faster.
 *
 * Two details that matter as much as the window:
 *
 *   - The window must be FULL before the rate is judged, or the first failed
 *     call is a 100% failure rate and the breaker opens on a blip.
 *   - The window is cleared when the breaker closes, so a recovered
 *     dependency is not judged on history from before the outage.
 */
public class Solution {

    /** Fails every other call — a degraded dependency, not a dead one. */
    static class Pricing {
        int calls = 0;
        boolean down = true;

        String fetch() {
            calls++;
            if (down && calls % 2 == 1) throw new IllegalStateException("read timed out");
            return "price";
        }
    }

    static class OpenCircuitException extends RuntimeException {
        OpenCircuitException() { super("circuit is open"); }
    }

    static class Clock {
        long now = 0;
        void advance(long millis) { now += millis; }
    }

    enum State { CLOSED, OPEN, HALF_OPEN }

    static class CircuitBreaker {
        private final int threshold;
        private final long openMillis;
        private final Clock clock;
        private State state = State.CLOSED;
        private long openedAt = 0;

        /** FIX: the last N outcomes, judged as a rate rather than a run. */
        private final boolean[] window;
        private int index = 0;
        private int recorded = 0;

        CircuitBreaker(int threshold, long openMillis, Clock clock) {
            this.threshold = threshold;
            this.openMillis = openMillis;
            this.clock = clock;
            this.window = new boolean[WINDOW];
        }

        private void record(boolean failed) {
            window[index] = failed;
            index = (index + 1) % window.length;
            if (recorded < window.length) recorded++;
        }

        private void reset() {
            Arrays.fill(window, false);
            index = 0;
            recorded = 0;
        }

        /** Only judged once the window is full, so one bad call cannot trip it. */
        private boolean rateExceeded() {
            if (recorded < window.length) return false;
            int failures = 0;
            for (boolean failed : window) if (failed) failures++;
            return failures * 100 >= window.length * FAILURE_PERCENT;
        }

        State state() {
            if (state == State.OPEN && clock.now - openedAt >= openMillis) return State.HALF_OPEN;
            return state;
        }

        <T> T call(Supplier<T> action) {
            State current = state();
            if (current == State.OPEN) throw new OpenCircuitException();
            try {
                T result = action.get();
                record(false);
                // Only clear the history when the breaker actually CLOSES after
                // being open. Clearing on every success would mean the window
                // never fills, and the rate would never be judged at all.
                if (current == State.HALF_OPEN) reset();
                state = State.CLOSED;
                return result;
            } catch (RuntimeException e) {
                record(true);
                if (current == State.HALF_OPEN || rateExceeded()) {
                    state = State.OPEN;
                    openedAt = clock.now;
                    reset();
                }
                throw e;
            }
        }
    }

    static final int REQUESTS = 200;
    static final int WINDOW = 20;
    static final int FAILURE_PERCENT = 50;

    public static void main(String[] args) {
        boolean ok = true;

        Clock clock = new Clock();
        Pricing pricing = new Pricing();
        CircuitBreaker breaker = new CircuitBreaker(5, 1000, clock);

        int rejected = 0, failed = 0, succeeded = 0;
        for (int i = 0; i < REQUESTS; i++) {
            try {
                breaker.call(pricing::fetch);
                succeeded++;
            } catch (OpenCircuitException e) {
                rejected++;
            } catch (RuntimeException e) {
                failed++;
            }
        }

        System.out.println("── " + REQUESTS + " requests against a dependency failing 50% ──");
        System.out.println("  reached the dependency   : " + pricing.calls);
        System.out.println("  rejected without calling : " + rejected);
        System.out.println("  timed out                : " + failed);
        System.out.println("  succeeded                : " + succeeded);
        System.out.println("  breaker state            : " + breaker.state());
        System.out.println();

        ok &= check("the breaker opened under a 50% failure rate", rejected > 0);
        ok &= check("fewer than half the requests reached the sick dependency",
            pricing.calls < REQUESTS / 2);

        System.out.println();
        System.out.println("── after recovery ──");
        pricing.down = false;
        clock.advance(1000);
        boolean closes;
        try {
            breaker.call(pricing::fetch);
            closes = breaker.state() == State.CLOSED;
        } catch (RuntimeException e) {
            closes = false;
        }
        System.out.println("  state : " + breaker.state());
        ok &= check("the breaker closes once the dependency recovers", closes);

        System.out.println();
        System.out.println(ok ? "PASS" : "FAIL");
    }

    static boolean check(String what, boolean passed) {
        System.out.println((passed ? "  ok    " : "  FAIL  ") + what);
        return passed;
    }
}