Circuit Breaker

type Estado = "fechado" | "aberto" | "meio-aberto";

interface Config {
  /** fracao de falhas que abre o disjuntor (ex.: 0.5 = 50%). */
  limiar: number;
  /** minimo de amostras antes de julgar — evita abrir com 1 de 1. */
  minimoAmostras: number;
  /** quanto tempo fica aberto antes de sondar. */
  esperaMs: number;
}

class Disjuntor {
  private estado: Estado = "fechado";
  private falhas = 0;
  private total = 0;
  private abertoDesde = 0;

  // 'agora' entra por parametro: nada de Date.now() aqui dentro.
  permitir(agora: number): boolean {
    if (this.estado === "aberto") {
      if (agora - this.abertoDesde < this.cfg.esperaMs) return false;
      this.estado = "meio-aberto"; // hora de sondar
    }
    return true;
  }

  registrar(ok: boolean, agora: number): void {
    if (this.estado === "meio-aberto") {
      // Em teste: um erro basta para voltar a abrir.
      if (ok) this.fechar();
      else this.abrir(agora);
      return;
    }
    this.total++;
    if (!ok) this.falhas++;
    if (this.total >= this.cfg.minimoAmostras &&
        this.falhas / this.total > this.cfg.limiar) {
      this.abrir(agora);
    }
  }

  constructor(private cfg: Config) {}
  private abrir(agora: number) { this.estado = "aberto"; this.abertoDesde = agora; }
  private fechar() { this.estado = "fechado"; this.falhas = 0; this.total = 0; }
}

from dataclasses import dataclass

@dataclass
class Config:
    limiar: float = 0.5        # fracao de falhas que abre
    minimo_amostras: int = 20  # nao julga com poucos dados
    espera_s: float = 30.0     # quanto fica aberto antes de sondar

class Aberto(Exception):
    """Recusado sem chamar a dependencia — a falha vira imediata e barata."""

class Disjuntor:
    def __init__(self, cfg: Config):
        self.cfg, self.estado = cfg, "fechado"
        self.falhas = self.total = 0
        self.aberto_desde = 0.0

    def chamar(self, fn, agora: float):
        if self.estado == "aberto":
            if agora - self.aberto_desde < self.cfg.espera_s:
                raise Aberto()          # falha rapida: nao gasta prazo nem conexao
            self.estado = "meio-aberto"  # deixa UMA passar, em teste

        try:
            r = fn()
        except Exception:
            self._registrar(False, agora)
            raise
        self._registrar(True, agora)
        return r