monitor.burn-rate

def burn_rate(target_basis_points: int, total_events: int, bad_events: int) -> int

from fune.monitor.burn_rate import burn_rate  # monitor.burn-rate@^1

def _whole(value: object) -> bool:
    return isinstance(value, int) and not isinstance(value, bool)


def burn_rate(target_basis_points: int, total_events: int, bad_events: int) -> int:
    """How fast an SLO's error budget is burning, in thousandths: the window's
    error rate divided by the error rate the SLO allows. 1000 spends exactly
    the budget over the SLO period; 14400 (14.4x) spends 2% of a 30-day
    budget in one hour."""
    if not _whole(target_basis_points) or target_basis_points < 1 or target_basis_points > 9999:
        raise ValueError("targetBasisPoints must be a whole number from 1 to 9999 (10000 leaves no error budget), received %s" % (target_basis_points,))
    if not _whole(total_events) or total_events < 0:
        raise ValueError("totalEvents must be a whole number of at least 0, received %s" % (total_events,))
    if not _whole(bad_events) or bad_events < 0:
        raise ValueError("badEvents must be a whole number of at least 0, received %s" % (bad_events,))
    if bad_events > total_events:
        raise ValueError("badEvents must not exceed totalEvents: %d > %d" % (bad_events, total_events))
    # An empty window has no error rate; 0 keeps an alert quiet rather than failing it.
    if total_events == 0:
        return 0
    n = bad_events * 10000 * 1000
    d = total_events * (10000 - target_basis_points)
    return (2 * n + d) // (2 * d)

Install

fune build

With that line in your source, in a Python project (language python in fune.project), fune build resolves it and nothing else, pins them in fune.lock, downloads only the Python package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. Or pin a range in fune.project and build in one step:

fune add monitor.burn-rate

The manifest, vectors and README with only the Python implementation. Install it without the registry with fune add ./monitor.burn-rate-1.0.0-python.fune, or fetch it from a terminal with fune pull monitor.burn-rate@1.0.0:python.

The whole function, every language, is one file too: monitor.burn-rate-1.0.0.fune, 10,928 bytes, sha256 46c18382d46a5017709173ffb79dffb5064f4708ea3cbc5a92acd65d672b4ccc. It installs into a project of any language.

# fune: before monitor.burn-rate

# fune: after monitor.burn-rate

# fune: step monitor.burn-rate after <n|label>

More from the author

At 1x the budget lasts exactly the SLO period (30 days in the workbook); at 14.4x a 30-day budget is gone in 50 hours, and one hour at that rate spends 2% of it (14.4 x 1h / 720h). Budget spent in a window = burn x window / period.

Burn rate is what SLO alerts compare against a threshold: see `monitor.burn-rate-alert` for the workbook's multiwindow, multi-burn-rate rules. On its own it is the number for a dashboard ("burning at 3.2x").

## Decisions

- **Thousandths, half up.** 14.4x is `14400`. Integers keep the three languages identical. An alert that must not fire early on rounding should compare exactly, as `monitor.burn-rate-alert` does. - **An empty window is 0**, not an error: no traffic spends no budget, and a quiet night should not break the alerting. - **Exact arithmetic.** bad x 10000 x 1000 passes 2^53 below a billion bad events, so the division is exact (BigInt in TypeScript, i128 in Rust, Python's integers). The design pinned `math.round-div`; it is not used, because its integers stop at 2^53. - **It works on seconds too**: total = window seconds, bad = down seconds.

## Errors

- `targetBasisPoints must be a whole number from 1 to 9999 (10000 leaves no error budget), received X` - `totalEvents must be a whole number of at least 0, received X` - `badEvents must be a whole number of at least 0, received X` - `badEvents must not exceed totalEvents: B > T`

## Sources

Google SRE Workbook, chapter 5 "Alerting on SLOs", section "Alert on Burn Rate" (https://sre.google/workbook/alerting-on-slos/): burn rate is how fast, relative to the SLO, the service consumes the error budget; 1 consumes all of it in the 30-day window; Table 5-8 uses 14.4, 6 and 1.

Files