Exponential backoff

Exponential backoff scales the wait with the attempt number:

# delay = base × 2^(attempt - 1)
attempt 1 → base × 2^0 = base
attempt 2 → base × 2^1 = 2 × base
attempt 3 → base × 2^2 = 4 × base
attempt 4 → base × 2^3 = 8 × base

The exponent is attempt - 1, so the first attempt waits exactly the base. With a one-second base the retries land at 1s, 2s, 4s, 8s, 16s out from each failure. The delay doubles each step — a geometric series, not a linear one. Where a fixed 1s delay re-fires five times in five seconds, the exponential schedule spreads the same five attempts across thirty-one seconds of cumulative wall-clock, giving a struggling dependency exponentially more time to recover between hits.

The exponential formula is Elixir. EchoMQ.Backoff.calculate/4 is the owner; its :exponential clause computes the delay and applies jitter.

# EchoMQ.Backoff.calculate/4 — the :exponential clause (real)
def calculate(:exponential, attempt, base_delay, opts) do
  jitter = Keyword.get(opts, :jitter, 0)
  delay  = trunc(:math.pow(2, attempt - 1) * base_delay)
  apply_jitter(delay, jitter)
end

:math.pow(2, attempt - 1) is the doubling; base_delay scales it; trunc makes it an integer millisecond. The doc example is exact: calculate(:exponential, 3, 1000) returns 4000, and calculate(:exponential, 3, 1000, jitter: 0.2) returns about 4000 with the spread. The :fixed strategy is the contrast — it returns apply_jitter(base_delay, jitter), the same base every attempt, no doubling.

This is the binding distinction. The retry reschedule script (retryJob-11.lua) does not compute 2^(n-1). It re-adds the job to the delayed set at a fire-time it is given. The delay value is computed first, in EchoMQ.Backoff; the Lua only reschedules at that delay. The formula is the strategy module's; the reschedule is the script's.

The base delay sets the floor and, with it, the whole curve. A 100 ms base gives 100ms, 200ms, 400ms — tight retries for a flaky-but-fast dependency. A 5000 ms base gives 5s, 10s, 20s — patient retries for a service that takes minutes to recover. The shape is fixed (doubling); the base slides the whole series up or down. EchoMQ's default base is 1_000 ms (%{type: :exponential, delay: 1_000, jitter: 0.2}), so the default schedule is 1s, 2s, 4s, 8s out, jittered. The interactive below sweeps the base across five attempts and reads the cumulative wall-clock the curve spends.

The exponential delay is real code in echo/apps/echomq. EchoMQ.Backoff.calculate(:exponential, attempt, base_delay, opts) computes trunc(:math.pow(2, attempt - 1) × base_delay) then jitters it. The two built-in strategies are :exponential and :fixed; a custom strategy can be registered with EchoMQ.Backoff.register/2, but the doubling is the exponential clause. The delay it returns is the value passed to the reschedule — retryJob-11.lua re-adds the job to the delayed set at that fire-time. The formula and the reschedule are two functions, in two languages, with one direction of data: Elixir computes the delay, Lua reschedules at it.

# the exponential delay, attempt by attempt — base_delay = 1000 ms (real values)
calculate(:exponential, 1, 1000)  # => 1000   (1000 × 2^0)
calculate(:exponential, 2, 1000)  # => 2000   (1000 × 2^1)
calculate(:exponential, 3, 1000)  # => 4000   (1000 × 2^2)

The write that re-schedules a failed job at the exponential fire-time, the sorted set behind it, and the queue protocol EchoMQ ports.