Circuit Breaker, ou le disjoncteur qui coupe pour laisser revenirCircuit Breaker, or the switch that cuts to let things come back

Le service n'est pas lent — il est mort. À quoi bon continuer d'appeler ?The service isn't slow — it's dead. Why keep calling at all?

Le #1 a réglé le hoquet : un échec passager, on le re-tente, espacé, désynchronisé. Mais le retry a un angle mort — la panne franche et durable. Quand le service d'en face est vraiment mort (un crash, une base saturée, un déploiement qui a mal tourné), chaque requête paie le plein tarif de l'échec : tout le timeout, toutes les tentatives, pour un échec qu'on connaissait d'avance. On gaspille nos propres ressources sur des appels condamnés, on remplit nos pools d'attentes inutiles — et notre service tombe à son tour, à cause d'une dépendance morte. Pire : en continuant de marteler le service à terre, on l'empêche de se relever. Le réflexe : un disjoncteur. Après trop d'échecs d'affilée, il s'ouvre et cesse d'appeler — il échoue immédiatement, sans même essayer —, laisse le service respirer un temps, puis teste prudemment s'il est revenu.Issue #1 settled the hiccup: a passing failure, you re-attempt it, spaced, desynchronized. But the retry has a blind spot — the hard, lasting outage. When the service across is truly dead (a crash, a saturated database, a botched deploy), every request pays the full price of failure: the whole timeout, every attempt, for a failure you knew in advance. You waste your own resources on doomed calls, fill your pools with useless waits — and your service falls in turn, because of a dead dependency. Worse: by hammering the downed service, you keep it from recovering. The reflex: a circuit breaker. After too many failures in a row, it opens and stops calling — it fails immediately, without even trying —, lets the service breathe a while, then cautiously tests whether it's back.

# le #1 nous a appris à retenter le transitoire. mais que se passe-t-il
# quand billing n'est pas en hoquet — quand il est franchement MORT, plusieurs minutes ?
def charge(order_id, amount):
    return retry(                                    # ✓ parfait contre un hoquet d'1s
        lambda: billing.charge(amount, idempotency_key=order_id, timeout=2.0),
        max_tries=4, backoff=expo_jitter,
    )
# billing est down. chaque requête : 4 × 2s de timeout + 1 + 2 + 4s de backoff ≈ 15 à 18s,
# pour un échec GARANTI qu'on connaissait dès la première tentative.
# pire : on continue de marteler un service à terre, et on l'empêche de se relever.
# le retry soigne le transitoire. il est impuissant — et nuisible — face à la panne franche.

Marteler un mort coûte trois fois : on se ruine, on entraîne les autres, on l'achève.Hammering a corpse costs thrice: you ruin yourself, drag others down, finish it off.

Sans disjoncteur, face à une panne durable, le retry seul a trois coûts qui s'enchaînent. D'abord chaque requête paie le plein tarif de l'échec — tout le timeout, toutes les tentatives — pour un verdict connu d'avance : on brûle du temps et des ressources en pure perte. Ensuite ces appels condamnés s'accumulent dans nos pools, qui se remplissent d'attentes inutiles : notre propre service ralentit, puis tombe, et la panne d'une dépendance en bout de chaîne remonte jusqu'à nous — c'est la défaillance en cascade. Enfin, en continuant de frapper le service à terre, on l'empêche de redémarrer : il a besoin de silence pour se relever, on lui envoie une tempête. Trois manières de transformer la panne d'un seul service en panne de tout le système.Without a breaker, facing a lasting outage, the retry alone has three costs that chain together. First, every request pays the full price of failure — the whole timeout, every attempt — for a verdict known in advance: you burn time and resources for nothing. Then these doomed calls pile up in your pools, which fill with useless waits: your own service slows, then falls, and a dependency's outage at the chain's end surges back to you — that's cascading failure. Finally, by hitting the downed service, you keep it from restarting: it needs silence to recover, you send it a storm. Three ways to turn one service's outage into the whole system's.

# billing est mort depuis 5 minutes. à chaque commande :
def checkout(order):
    reserve_stock(order)                 # ✓ ok
    status = charge(order.id, order.total)   # 💥 retry × 4 × timeout 2s ≈ 8s d'attente…
    #                                          …pour un échec qu'on connaissait à la 1re ms
    notify(order)
# 200 commandes/min × 8s bloquées = le pool de checkout sature en moins d'une minute.
# checkout tombe → le panier tombe → la home tombe. billing a éternué, tout le site est par terre.
# et billing, qu'on bombarde de retries, n'a jamais le silence pour redémarrer.

Fermé, ouvert, demi-ouvert — la boucle qui s'ouvre puis se répare seule.Closed, open, half-open — the loop that opens, then heals itself.

Le disjoncteur est une petite machine à états — trois états, des transitions pilotées par un compteur d'échecs. L'animation la fait tourner : on part fermé (le courant passe), le service tombe et les échecs montent jusqu'au seuil, le disjoncteur s'ouvre et coupe tout, il laisse le service respirer le temps d'un cooldown, puis teste le retour avec un seul appel en demi-ouvert, et se referme dès que ce test réussit. Suis le compteur d'échecs et l'état du service en aval : c'est leur danse qui décide quand couper et quand rouvrir.The breaker is a small state machine — three states, transitions driven by a failure counter. The animation runs it: we start closed (current flows), the service falls and failures climb to the threshold, the breaker opens and cuts everything, it lets the service breathe for a cooldown, then tests the return with a single call in half-open, and closes again as soon as that test succeeds. Follow the failure counter and the downstream service's state: it's their dance that decides when to cut and when to reopen.

class CircuitBreaker:
    def __init__(self, threshold=5, cooldown=30):
        self.state, self.fails, self.opened_at = "closed", 0, None

    def call(self, fn):
        if self.state == "open":
            if now() - self.opened_at < self.cooldown:▸ à toiyour turn — ouvert, cooldown pas écoulé — que fait-on de l'appel ?open, cooldown not elapsed — what happens to the call? · cliquer pour révélerclick to reveal            self.state = "half"                  # cooldown fini → on teste

        try:
            result = fn()                        # fermé ou demi-ouvert : on tente▸ à toiyour turn — succès — quel état, quel compteur ?success — which state, which counter? · cliquer pour révélerclick to reveal            return result
        except Transient:
            self.fails += 1▸ à toiyour turn — échec en demi-ouvert, ou seuil atteint — quelle transition ?failure in half-open, or threshold reached — which transition? · cliquer pour révélerclick to reveal            raise

Ce qui précède se lit ; ce qui suit se constate. Les quatre presets sont des réglages déjà cassés — un clic, et tu vois la faute se produire. Puis pousse les curseurs toi-même pendant que ça tourne : la simulation ne repart pas de zéro, elle encaisse ton nouveau réglage en marche. La règle du jeu : fais tomber la p99 sans jeter une seule requête de plus sur le service à terre.What comes before is read; what comes next is witnessed. The four presets are settings already broken — one click and you watch the mistake happen. Then push the sliders yourself while it runs: the simulation doesn't restart, it absorbs your new setting on the fly. The rule of the game: bring p99 down without throwing a single extra request at the downed service.

Pas de disjoncteur, ou un disjoncteur qui ne se referme jamais.No breaker, or a breaker that never closes again.

Deux échecs symétriques encadrent le bon usage. À gauche, l'absence : on s'en remet au seul retry, et face à une panne durable on retente sans relâche, requête après requête — chacune paie le plein timeout, les pools saturent, la cascade monte. À droite, le faux ami : un disjoncteur présent mais mal réglé, qui annule son propre effet. Un seuil si haut qu'il ne saute jamais protège aussi peu que pas de disjoncteur du tout. Un cooldown d'une heure prive le système d'un service revenu en trente secondes. Et sans demi-ouvert, une fois ouvert il ne se referme jamais seul : on a transformé une panne de deux minutes en panne permanente, de nos propres mains. Bascule le toggle : repère l'acharnement sans garde-fou, et le garde-fou qui se retourne en panne.Two symmetric failures frame correct use. On the left, the absence: you rely on the retry alone, and against a lasting outage you retry relentlessly, request after request — each one pays the full timeout, pools saturate, the cascade climbs. On the right, the false friend: a breaker present but mistuned, that cancels its own effect. A threshold so high it never trips protects as little as no breaker at all. A one-hour cooldown deprives the system of a service back in thirty seconds. And without half-open, once open it never closes by itself: you've turned a two-minute outage into a permanent one, by your own hand. Flip the toggle: spot the hammering with no guardrail, and the guardrail that turns into an outage.

# disjoncteur AUTOUR de l'appel, retry À L'INTÉRIEUR — deux étages pour deux durées d'échec
breaker = CircuitBreaker(threshold=5, cooldown=30)   # 5 échecs d'affilée → on ouvre 30s

def charge(order_id, amount):
    try:
        return breaker.call(lambda: retry(           # retry = le hoquet · breaker = la panne
            lambda: billing.charge(amount, idempotency_key=order_id, timeout=2.0),
            max_tries=3, backoff=expo_jitter,
        ))
    except CircuitOpen:
        return queue_for_later(order_id, amount)      # ouvert → fallback : on diffère, sans bloquer
# panne franche : au 5e échec le circuit s'ouvre. les requêtes suivantes échouent en <1ms,
# nos pools restent libres, billing a 30s de silence pour redémarrer. au bout des 30s,
# UN appel test sonde le retour ; s'il passe, on referme. l'échec reste local et borné.

Insister sur un mort, ou couper pour le laisser revenir.Insisting on a corpse, or cutting to let it come back.

Quand ne pas mettre de disjoncteurWhen not to add a breaker

Le disjoncteur a un loyer : un état partagé à maintenir, trois réglages à accorder, et le risque de couper un service sain s'il est mal réglé. On appelle sans disjoncteur — et c'est correct — quand :The breaker has rent: a shared state to maintain, three settings to tune, and the risk of cutting a healthy service if mistuned. You call without a breaker — and that's fine — when:

• l'appel est local, en mémoire : il n'y a pas de dépendance qui puisse « mourir plusieurs minutes » à isoler. Un disjoncteur autour d'un appel de fonction protège d'une panne qui ne peut pas arriver — c'est de la cérémonie (YAGNI, Vol 0 #3).the call is local, in-memory: there's no dependency that can 'die for several minutes' to isolate. A breaker around a function call guards against an outage that can't happen — pure ceremony (YAGNI, Vol 0 #3).
• l'échec est déjà rapide et sans effet de bord : si l'appel échoue en quelques millisecondes sans bloquer de ressource ni se propager, il n'y a ni attente à borner ni cascade à craindre. Le disjoncteur protège d'un coût qui n'existe pas.the failure is already fast and side-effect-free: if the call fails in a few milliseconds without tying up a resource or propagating, there's no wait to bound and no cascade to fear. The breaker guards against a cost that doesn't exist.
• les appels sont trop rares pour qu'un seuil ait un sens : un job qui s'exécute une fois par heure n'accumulera jamais « cinq échecs d'affilée » de façon significative. Le compteur n'a pas de quoi se nourrir ; un simple retry avec alerte suffit.the calls are too rare for a threshold to mean anything: a job running once an hour will never meaningfully accumulate 'five failures in a row'. The counter has nothing to feed on; a simple retry with an alert is enough.

Le réflexe n'est donc pas « mets un disjoncteur sur chaque appel » : c'est « cette dépendance peut-elle rester durablement morte, et son agonie peut-elle me faire tomber ? Alors un disjoncteur, accordé à son rythme de panne, avec un fallback pour l'état ouvert. Sinon, le retry seul suffit. »So the reflex isn't 'put a breaker on every call': it's 'can this dependency stay durably dead, and can its agony topple me? Then a breaker, tuned to its failure rhythm, with a fallback for the open state. Otherwise, the retry alone is enough.'

Mot de l'éditeurFrom the editor

Le #1 traitait l'échec passager ; ce numéro traite l'échec qui dure. C'est la même question — « l'autre côté ne répond pas » — mais une autre échelle de temps, et donc un autre geste. Le retry insiste parce qu'il parie sur le retour imminent ; le disjoncteur renonce, justement parce qu'insister contre une panne durable se retourne en panne. La leçon profonde du couple, c'est que la résilience n'est pas une vertu unique : c'est un dosage entre persévérer et abandonner, accordé à la durée probable de l'échec. Trop d'insistance noie le système et achève le service ; trop d'abandon coupe un service qui revenait. Le disjoncteur encode ce dosage dans une machine à trois états qui sait, seule, quand couper et quand retenter.Issue #1 handled the passing failure; this one handles the lasting one. It's the same question — 'the other side doesn't answer' — but another time scale, and so another gesture. The retry insists because it bets on imminent return; the breaker gives up, precisely because insisting against a lasting outage turns into an outage. The pair's deep lesson is that resilience isn't a single virtue: it's a dosage between persevering and giving up, tuned to the failure's likely duration. Too much insistence drowns the system and finishes the service; too much surrender cuts a service that was coming back. The breaker encodes that dosage into a three-state machine that knows, on its own, when to cut and when to retry.

Restent deux fils que ces deux numéros ont noués sans les serrer. Le premier : le disjoncteur, comme la State machine du Vol 3, est une machine à états — trois états, des transitions gardées, des états illégaux rendus impossibles. La résilience, sous le capot, c'est de la modélisation d'états. Le second nous emmène au #3. On a installé le retry, et on a vu son ombre revenir à chaque chapitre : rejouer un appel, c'est risquer de l'exécuter deux fois. C'est l'autre moitié de la question du volume — « ou répond deux fois ? ». Le #3 la regarde en face : « exactly-once » n'existe pas sur un réseau. On conçoit pour le « au moins une fois », avec l'idempotence pour que rejouer ne duplique rien, et la Saga pour rattraper, par compensation, ce qui ne tient plus dans une transaction unique. Le fil rouge du volume tient toujours : le réseau oublie, répète et tarde — et on code en le sachant.Two threads remain that these two issues tied without tightening. The first: the breaker, like Vol 3's State machine, is a state machine — three states, guarded transitions, illegal states made impossible. Resilience, under the hood, is state modeling. The second takes us to #3. We installed the retry, and watched its shadow return every chapter: replaying a call risks running it twice. That's the volume's other half — 'or answers twice?'. Issue #3 faces it head-on: 'exactly-once' doesn't exist on a network. You design for 'at least once', with idempotency so replaying duplicates nothing, and the Saga to catch, by compensation, what no longer fits in a single transaction. The volume's through-line holds: the network forgets, repeats and lags — and you code knowing it.

Les voisins que ce numéro débloqueThe neighbors this issue unlocks

• Bulkhead — la cloison étanche, empruntée à la coque des navires. On cloisonne les ressources par dépendance — un pool de connexions dédié à chacune — pour qu'un service lent ne noie pas le pool commun et n'emporte pas les appels vers les services sains. Là où le disjoncteur coupe une dépendance morte, le bulkhead empêche une dépendance malade de contaminer les autres : la panne reste dans son caisson.the watertight compartment, borrowed from ships' hulls. You partition resources per dependency — a dedicated connection pool for each — so a slow service doesn't drown the shared pool and take down calls to healthy services. Where the breaker cuts a dead dependency, the bulkhead stops a sick dependency from contaminating the others: the outage stays in its compartment.
• Rate limiter — le garde-fou de l'entrée. Plutôt que d'accepter tout le trafic et de s'écrouler sous la charge, on borne le débit : au-delà d'un seuil, on refuse (ou on diffère) à la porte. Le disjoncteur protège de ce qu'on appelle ; le rate limiter protège de ce qui nous appelle. Ensemble, ils bornent la pression dans les deux sens.the entrance guardrail. Rather than accept all traffic and collapse under load, you bound the throughput: past a threshold, you refuse (or defer) at the door. The breaker protects from what you call; the rate limiter protects from what calls you. Together, they bound pressure in both directions.
• Fallback — l'issue de l'état ouvert. Quand le disjoncteur a coupé, l'appel doit rendre quelque chose : une valeur par défaut, une réponse en cache, une mise en file pour plus tard. Le fallback transforme « le service est mort » en dégradation gracieuse plutôt qu'en erreur brutale — c'est lui qui fait la différence entre un système qui s'effondre et un système qui rétrécit ses fonctions sans tomber.the open state's outcome. When the breaker has cut, the call must return something: a default value, a cached response, a queue for later. The fallback turns 'the service is dead' into graceful degradation rather than a brutal error — it's what separates a system that collapses from one that shrinks its features without falling.

Le kata — écris-le, ne le relis pasThe kata — write it, don't reread it

# test_circuit_breaker.py — la spec EST le harnais : fais-le passer au vert.
# trois états, un seuil, un cooldown, un demi-ouvert. sans lib, sans framework.

def test_ferme_laisse_passer():
    b = CircuitBreaker(threshold=3, cooldown=30)
    assert b.call(lambda: "ok") == "ok"          # au repos, transparent

def test_s_ouvre_au_seuil():
    b = CircuitBreaker(threshold=3, cooldown=30)
    for _ in range(3):
        with raises(Transient): b.call(dead)     # 3 échecs d'affilée…
    with raises(CircuitOpen): b.call(dead)       # …le 4e échoue SANS appeler

def test_ouvert_n_appelle_jamais():
    b = breaker_ouvert(threshold=3, cooldown=30)
    sonde = compteur_d_appels(dead)
    with raises(CircuitOpen): b.call(sonde)
    assert sonde.count == 0                      # zéro requête vers le service

def test_demi_ouvert_referme_sur_succes():
    b = breaker_ouvert(threshold=3, cooldown=30)
    avance_le_temps(31)                          # cooldown écoulé
    assert b.call(lambda: "ok") == "ok"          # UN appel test passe…
    assert b.state == "closed"                   # …et referme le circuit

def test_test_rate_rouvre_aussitot():
    b = breaker_ouvert(threshold=3, cooldown=30)
    avance_le_temps(31)
    with raises(Transient): b.call(dead)         # le test échoue…
    with raises(CircuitOpen): b.call(dead)       # …on rouvre, pas de 2e chance

def test_succes_remet_le_compteur_a_zero():
    b = CircuitBreaker(threshold=3, cooldown=30)
    for _ in range(2):
        with raises(Transient): b.call(dead)     # 2 échecs…
    b.call(lambda: "ok")                         # …un succès intercalé…
    with raises(Transient): b.call(dead)         # …puis un 3e échec : le circuit
    assert b.state == "closed"                   # reste FERMÉ. consécutifs = consécutifs.