Rate limiting

// Janela fixa: simples e com um defeito grave na virada.
// Com limite de 100/min, um cliente manda 100 as 10:00:59
// e mais 100 as 10:01:00 — 200 em dois segundos, dentro da regra.

// Token bucket: permite rajada controlada e alisa o resto.
interface Balde {
  tokens: number;
  /** ultimo instante em que reabastecemos. */
  atualizadoEm: number;
}

interface Config {
  capacidade: number;   // tamanho da rajada permitida
  porSegundo: number;   // taxa de reposicao
}

// 'agora' entra por parametro: funcao pura, testavel sem relogio.
function permitir(b: Balde, cfg: Config, agora: number, custo = 1): boolean {
  const decorrido = (agora - b.atualizadoEm) / 1000;
  b.tokens = Math.min(cfg.capacidade, b.tokens + decorrido * cfg.porSegundo);
  b.atualizadoEm = agora;

  if (b.tokens < custo) return false;
  b.tokens -= custo;
  return true;
}

// Ao recusar, diga QUANDO voltar. Sem isso o cliente vai adivinhar —
// e adivinhar errado significa todos voltando no mesmo instante.
function cabecalhos(b: Balde, cfg: Config) {
  return {
    "RateLimit-Limit": String(cfg.capacidade),
    "RateLimit-Remaining": String(Math.floor(b.tokens)),
    "Retry-After": String(Math.ceil((1 - b.tokens) / cfg.porSegundo)),
  };
}

import math

class TokenBucket:
    """Rajada ate 'capacidade', reposicao continua a 'por_segundo'."""

    def __init__(self, capacidade: int, por_segundo: float):
        self.capacidade = capacidade
        self.por_segundo = por_segundo
        self.tokens = float(capacidade)
        self.atualizado_em = 0.0

    def permitir(self, agora: float, custo: int = 1) -> bool:
        decorrido = agora - self.atualizado_em
        self.tokens = min(
            self.capacidade, self.tokens + decorrido * self.por_segundo
        )
        self.atualizado_em = agora
        if self.tokens < custo:
            return False
        self.tokens -= custo
        return True

    def retry_after(self, custo: int = 1) -> int:
        falta = max(0.0, custo - self.tokens)
        return math.ceil(falta / self.por_segundo)

# Custo por PESO, nao por requisicao: um upload de 50MB
# nao deveria valer o mesmo que um GET de 200 bytes.
balde = TokenBucket(capacidade=100, por_segundo=10)