CallNotPermittedException: CircuitBreaker 'plati' is OPEN and does not permit further calls
Circuit breaker-ul din fața unei dependențe s-a deschis pentru că prea multe apeluri recente au eșuat sau au fost lente, deci respinge imediat apelurile noi o perioadă. Nu e cauza problemei, ci protecția: verifică dependența, tratează excepția cu un fallback și ajustează pragurile doar dacă sunt evident greșite.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Un circuit breaker (Resilience4j, Polly, opossum) numără rezultatele apelurilor spre o dependență. Cât timp rata de eșec sau de apeluri lente e sub prag, e CLOSED și apelurile trec. Când pragul e depășit într-o fereastră de apeluri, trece în OPEN și respinge imediat orice apel cu CallNotPermittedException, fără să mai contacteze dependența. După o pauză (waitDurationInOpenState), trece în HALF_OPEN și lasă câteva apeluri de probă; dacă reușesc, se închide.
Mesajul spune deci două lucruri: dependența (aici plati) a avut probleme recent, iar aplicația ta e protejată de a-și bloca thread-urile așteptând-o. Ce trebuie făcut: verifică starea dependenței (loguri, latență, erori), asigură-te că excepția e tratată cu un răspuns util (mesaj clar, plată reîncercată mai târziu, coadă) și nu se transformă într-un 500.
Pragurile prea agresive (fereastră de 5 apeluri, 50% eșec) pot deschide breaker-ul la câteva erori izolate; cele prea permisive nu protejează nimic.
De ce apare: cauzele frecvente
1Excepția nu e tratată
@CircuitBreaker(name = "plati")
public Rezultat plateste(Comanda c) { return client.plateste(c); }@CircuitBreaker(name = "plati", fallbackMethod = "plataAmanata")
public Rezultat plateste(Comanda c) { return client.plateste(c); }
Rezultat plataAmanata(Comanda c, CallNotPermittedException e) {
return Rezultat.inAsteptare("Plata va fi reîncercată în câteva minute.");
}Utilizatorul primește un răspuns clar, nu o eroare 500.
2Fereastră prea mică
resilience4j.circuitbreaker.instances.plati.slidingWindowSize: 5resilience4j.circuitbreaker.instances.plati.slidingWindowSize: 50
resilience4j.circuitbreaker.instances.plati.minimumNumberOfCalls: 20Câteva erori izolate nu mai deschid breaker-ul.
Repară eroarea, direct în pagină
Răspunde la cele trei întrebări despre breaker-ul deschis la serviciul de plăți.
Indiciu
Breaker-ul e un simptom: ce s-a întâmplat înainte să se deschidă?
Reparația
- q1: Rata de eșec a depășit pragul.
- q2: CLOSED → OPEN → HALF_OPEN → CLOSED.
- q3: Fals.
De ce merge
Breaker-ul deschis arată că plățile au eșuat peste prag. El protejează aplicația; cauza trebuie căutată la dependență, iar excepția tratată cu un fallback.
Alte forme ale mesajului
io.github.resilience4j.circuitbreaker.CallNotPermittedExceptionPolly.CircuitBreaker.BrokenCircuitException: The circuit is now open and is not allowing calls.Breaker is open (opossum)
Cum o eviți pe viitor
- Pune circuit breaker pe apelurile spre dependențe externe și interne importante.
- Definește un fallback pentru fiecare.
- Alertează când un breaker se deschide.
- Alege pragurile după volumul real de apeluri.
Întrebări frecvente
Cât stă breaker-ul deschis?
Cât e configurat în waitDurationInOpenState (de exemplu 30 de secunde). Apoi trimite apeluri de probă.
Breaker-ul face reîncercări?
Nu. Reîncercările (retry) sunt un mecanism separat; combinate, retry-ul trebuie să fie în interiorul breaker-ului și limitat.
Erori înrudite
Cădere în cascadă: un serviciu lent oprește și serviciile care depind de el O dependență devine lentă sau cade, iar serviciile care o apelează sincron își blochează thread-urile și conexiunile așteptând-o, apoi cad și ele, iar căderea se propagă în tot sistemul. Pune timeout-uri scurte, circuit breaker, bulkhead-uri și degradare grațioasă la fiecare apel spre altă componentă. Retry storm: reîncercările fără backoff înmulțesc traficul și țin serviciul căzut La primele erori, toți clienții reîncearcă imediat, de mai multe ori, iar serviciul deja suprasolicitat primește de câteva ori mai mult trafic și nu-și mai poate reveni. Reîncearcă doar erorile temporare, cu backoff exponențial și jitter, cu un număr mic de încercări și un buget de reîncercări. Un serviciu extern lent blochează toate thread-urile serverului (timeout prea mare) Fiecare cerere apelează sincron un serviciu extern; când acesta devine lent, thread-urile serverului stau blocate până la timeout (adesea 30–60 de secunde sau infinit), iar serverul nu mai poate servi nimic. Pune timeout-uri scurte, potrivite cu durata normală a apelului, plus circuit breaker și fallback. Învață System Design de la zero, cu exerciții la fiecare lecție
Curs System Design: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 10 lecții sunt gratuite.
