Observability
Multi-window multi-burn-rate alerting: why AND beats OR
An on-call team uses a single alert: “fire if the error rate over the past hour exceeds 1.44%.” The pager fires at 2 AM. The engineer logs in. The issue cleared itself 55 minutes ago — but the 1-hour window still contains the bad data. The engineer stays awake for nothing.
Why naive SLO alerts fail in two ways
The SRE workbook classifies six approaches to SLO alerting. Five fail in predictable ways.
Approach 1 (raw error rate > SLO threshold): fires hundreds of times per day on tiny blips. A single bad request batch triggers the page; teams learn to ignore the pager — the classic alert fatigue death spiral.
Approach 5 (single burn-rate threshold, e.g. 14.4x over 1h): better — catches real outages — but the reset is slow. After the incident is resolved, the 1-hour window still contains 55 minutes of bad data. The alert keeps firing for nearly an hour post-fix. Engineers cannot tell if their change helped.
Approach 6 (MWMBR) is the only one that balances detection latency, noise resistance, and recovery latency. It is the production default in Google, Datadog, Grafana, Splunk, Honeycomb, Sloth, and Pyrra.
The dual-window trick
The key insight: combine a long window (noise resistance) AND a short window (recovery resolution):
- Long window (e.g. 1h): confirms the burn is sustained, not a transient spike
- Short window (e.g. 5m): confirms the burn is still happening right now
The AND logic:
- If only the long window is high: the incident probably ended; the short window cleared
- If only the short window is high: a brief spike that has not yet accumulated into a sustained burn
- If both are high: a real outage that is both severe and still active — page
When the incident resolves, the short window clears within 5 minutes. The alert resets within 5 minutes instead of within 55 minutes. Detection time and reset time are both bounded.
The canonical MWMBR configuration (99.9% SLO)
| Severity | Long window | Short window | Burn rate | Budget consumed if sustained |
|---|---|---|---|---|
| Page | 1h | 5m | >14.4x | 2% in 1h — fast outage, urgent |
| Page | 6h | 30m | >6x | 5% in 6h — moderate sustained burn |
| Ticket | 3d | 6h | >1x | 10% in 3d — slow burn, needs attention |
- 14.4x burn rate = error rate of
- 1.44% (at 99.9% SLO)
- 14.4x for 1h = budget consumed
- ~2% of the 28-day budget
- 6x for 6h = budget consumed
- ~5% of the 28-day budget
- 1x for 3d = budget consumed
- ~10% of the 28-day budget
- Alert reset time (5m short window)
- <5 minutes after fix
- Alert reset time (single 1h window)
- up to 55 minutes after fix
Prometheus implementation
# Recording rule: fast-request ratio over a 1h window
record: job:slo_latency_fast:ratio_rate1h
expr: |
sum(rate(http_request_duration_seconds_bucket{le="0.2"}[1h]))
/
sum(rate(http_request_duration_seconds_count[1h]))
# Page alert: 1h AND 5m both at >14.4x burn
alert: SLOLatencyBurnFast
expr: |
(
(1 - job:slo_latency_fast:ratio_rate1h) > (14.4 * 0.001)
and
(1 - job:slo_latency_fast:ratio_rate5m) > (14.4 * 0.001)
)
labels:
severity: page
annotations:
summary: "Latency SLO burning at >14.4x over 1h AND 5m"The 14.4 * 0.001 is burn_rate × (1 − SLO) = 14.4 × 0.001 = 0.0144 — the error rate threshold corresponding to 14.4x burn at 99.9% SLO.
Why this works
The thresholds 14.4, 6, and 1 are not arbitrary. They come from solving: “what burn rate would consume X% of the budget in window W?” With a 30-day period, 2% budget in 1h: burn = (0.02 × 720h) / 1h = 14.4. With 5% budget in 6h: burn = (0.05 × 720h) / 6h = 6. With 10% budget in 3 days (72h): burn = (0.10 × 720h) / 72h = 1. These thresholds are derived from first principles, not empirical tuning — any team can recompute them for a different SLO window length.
Complete the 6h+30m page alert for the same 99.9% SLO
1/3A single-window alert fires at 14.4x burn over 1 hour. The incident resolves at 12:00. When does the alert clear?
An MWMBR alert fires when the 1h burn exceeds 14.4x AND the 5m burn exceeds 14.4x. The 1h burn is 15x and the 5m burn is 12x (just under threshold). Does the alert fire?
- 01What are the two failure modes of single-window SLO alerting?
- 02Why does the MWMBR pattern use AND between windows instead of OR?
- 03Derive the 14.4x burn rate threshold for the 1h+5m page alert at a 99.9% SLO with a 30-day window.
Naive SLO alerts fail in one of two ways: short windows are noisy and fire on every transient spike, long windows reset slowly and keep the on-call awake after the incident clears. Multi-window multi-burn-rate alerting solves both by combining a long window (noise resistance) with a short window (recovery resolution) using AND logic: the page fires only when the burn is both sustained AND currently ongoing. The canonical thresholds — 14.4x/6x/1x across 1h/6h/3d windows — derive from “what burn consumes 2%/5%/10% of the budget in each window?” At a 99.9% SLO, 14.4x means a 1.44% error rate; the 5-minute short window clears the alert within 5 minutes of fix. Hand-rolling MWMBR PromQL per service is error-prone; use Sloth or Pyrra to generate it declaratively.
- Low-traffic SLOs and burn-rate math from first principlessenior
- Iceberg SLIs, composite SLO math, and SLA vs SLOsenior
- Production SLO failures, self-observability, security, and the big picturesenior
- SLO and error budgets: instrument a journey end to endsenior
- SLO and error budgets: multiple-choice reviewsenior
- SLO and error budgets: PromQL and rule readingsenior
- SLO and error budgets: free-recall reviewsenior
appears again in167
- The journey of a request: seven stops from socket to responsejunior
- Accept and parse: from kernel queue to a typed requestmiddle
- Routing and middleware: choosing what runs, and in what ordermiddle
- Handler and response: from business logic to bytes on the wiremiddle
- Streaming and backpressure: when the client reads slower than you writesenior
- Timeouts and tail latency: budgets, deadlines, and the fan-out trapsenior
- Middleware and DI: the two patterns that shape every backendjunior
- Writing middleware: signatures, next(), and the three framework modelsmiddle
- Inversion of control: how dependencies reach a classmiddle
- DI scopes and lifecycles: singleton, request, transientmiddle
- DI as a testing seam: fakes, mocks, and the boundary that matterssenior
- DI containers in production: resolution graphs, circular deps, and when not tosenior
- Blocking vs non-blocking I/O: two ways to waitjunior
- The event loop: one thread, ordered phasesmiddle
- What blocks the loop: CPU work and sync callsmiddle
- Offloading CPU work: worker threads and the libuv poolmiddle
- Backpressure and bounded concurrencysenior
- Throughput under load: tail latency and saturationsenior
- Why pool: the cost of creating a connectionjunior
- Pool sizing: why bigger is not fastermiddle
- Acquisition and timeouts: the wait queue is the real latency dialmiddle
- Retry strategies: backoff, jitter, and thundering herdmiddle
- Observability, production failures, and global-scale designsenior
- Tasks, microtasks, and scheduler.yield()middle
- Timer accuracy, throttling, and idle workmiddle
- Node.js event loop: phases, nextTick, and loop lagsenior
- Rendering strategies: SSG, SSR, ISR, streaming, and hydrationjunior
- SSG, SSR, ISR, streaming, and RSC — how each worksmiddle
- Hydration cost: selective, progressive, islands, resumabilitymiddle
- Core Web Vitals: what LCP, INP, and CLS measurejunior
- LCP: four phases, one dominant costmiddle
- INP: input delay, processing, presentationmiddle
- Lab vs field: why the two disagree and how to use eachmiddle
- Metric tradeoffs, RUM attribution, and the CI+field loopsenior
- The full picture: URL to LCP to INP as a relay racejunior
- Eight layers traced: from the service worker to the second navigationmiddle
- Five canonical breaks: where production reliably diessenior
- The three-track method: reading traces and building a monitored systemsenior
- What an index is and how it speeds up queriesjunior
- The leading-column rule and composite index designmiddle
- Partial, expression, and covering indexesmiddle
- Index types: GIN, GiST, BRIN, Hash, Bloom, and HOT updatesmiddle
- Index-only scans, the Visibility Map, and INCLUDEsenior
- Production failure modes and the index audit playbooksenior
- Index design exercise: full-text search strategysenior
- EXPLAIN and execution plans: what the planner decides and whyjunior
- Scan types: Seq, Index, Bitmap, Index-Onlymiddle
- Join algorithms and the row-estimate cascademiddle
- pg_statistic, ANALYZE, and production observabilitymiddle
- Extended statistics: fixing correlated-column estimate failuressenior
- Plan cache, cost-constant tuning, and planner internalssenior
- Production failure modes and plan stabilitysenior
- Connection pools: amortising the cost of a Postgres backendjunior
- PgBouncer session, transaction, and statement modesmiddle
- Pool sizing: the (cores × 2) + spindles formula and the two-layer stackmiddle
- Pool exhaustion and idle-in-transaction: the 3 AM failure modemiddle
- Migrating to transaction mode: rollout playbook and PgBouncer 1.21 prepared statementsmiddle
- The Postgres process model and why raising max_connections degrades throughputsenior
- Pooler landscape 2026, serverless connection storms, and the full failure-mode taxonomysenior
- ADD COLUMN: instant in PG 11+ vs rewrite in older Postgresjunior
- The lock-queue failure mode: why instant DDL can freeze the databasemiddle
- Safe DDL patterns: NOT VALID, CONCURRENTLY, and unsafe-op fixesmiddle
- Migration failure taxonomy and production disciplinesenior
- Shard-key selection: hash, range, list, and directory strategiesmiddle
- Co-location and Citus: the invariant that makes sharding usablemiddle
- The hot-shard failure mode: detection, isolation, and durable policymiddle
- Online resharding, 2PC, and the operational cost of shardingsenior
- The seven acts: from CREATE TABLE to Citusjunior
- Acts 1–3 in depth: schema, indexes, and planner statisticsmiddle
- Acts 4–6 in depth: MVCC bloat, connection pooling, and safe migrationsmiddle
- Act 7 in depth: sharding, co-location, and the seven-tier tradeoff cascademiddle
- Observability, anti-patterns, and production triagesenior
- Bits on the wirejunior
- Latency mathmiddle
- Bufferbloat and congestionsenior
- The physical frontiersenior
- Sequence numbers and connection statemiddle
- Flow control and congestion controlmiddle
- BBR, production observability, and beyond TCPsenior
- CDN: putting content next doorjunior
- Anycast and GeoDNS: routing to the nearest edgemiddle
- Tiered cache and Cache-Controlmiddle
- Vary header and cache keysmiddle
- Stale-while-revalidate and cache stampedesenior
- Edge workers and edge-side compositionsenior
- CDN operations and observabilitysenior
- WebSocket: the HTTP upgrade handshakejunior
- WebSocket vs SSE vs long-polling: choosing the right transportmiddle
- WebSocket backpressure: when clients can''''t keep upmiddle
- Reconnection: jittered backoff, thundering herd, message resumptionsenior
- WebSocket at scale: HTTP/2 multiplexing, permessage-deflate, C10Msenior
- WebSocket in production: proxies, security, and distributed architecturesenior
- What reverse proxies dojunior
- Balancing algorithms: round-robin to power-of-two-choicesmiddle
- L4 vs L7 load balancing and client-IP preservationmiddle
- Health checks, connection draining, and slow startmiddle
- Retry storms, circuit breakers, and load sheddingsenior
- Resilient LB architecture: anycast, zone-aware routing, and observabilitysenior
- Why QUIC and not TCP+TLSjunior
- QUIC streams and head-of-line blockingjunior
- Integrated handshake and 1-RTTmiddle
- Connection IDs and network migrationmiddle
- Loss detection and congestion controlmiddle
- 0-RTT resumption and packet encryptionsenior
- Deployment tradeoffs and CPU costsenior
- DDoS: what it is and why it worksjunior
- Amplification attacks and state exhaustionmiddle
- Rate limiting: algorithms and architecturemiddle
- WAFs, firewalls, mTLS, and HSTSmiddle
- DNS cache poisoning and BGP hijackingsenior
- Defense-in-depth architecture and attack economicssenior
- The twelve layers: one URL, seven actorsjunior
- DNS, TCP, TLS in sequence: where the milliseconds gomiddle
- Critical render path and Core Web Vitalsmiddle
- Proxy intercepts and security gates: rate limiters, WAF, mTLSmiddle
- Alternate paths: QUIC 0-RTT, WebSocket upgrade, connection migrationmiddle
- Observability: distributed traces, USE/RED, and samplingsenior
- Resilience: cascading retries, circuit breakers, and error budgetssenior
- Why profile first: measure where time actually goesjunior
- Amdahl''''s law and self-time: the ceiling on every speedup you can shipmiddle
- The measurement loop: microbench, macrobench, prod profile, observer effectmiddle
- Reading flame graphs: shapes, per-language profilers, and the 60-second scanmiddle
- Statistical baselines: why one run is not a measurementmiddle
- Profiler history and microbenchmark pitfalls: Knuth to GWPsenior
- Hardware counters, cold-start profiles, and profile securitysenior
- Continuous profiling at scale: costs, CI gates, trace correlation, and anti-patternssenior
- What makes a hot path: symptom vs causejunior
- Five shapes of hotspot: CPU, alloc, cache, lock, syscallmiddle
- Reading parent and child chains: where to apply the fixmiddle
- JIT deopt, the fix-and-verify loop, and PR-time profilingmiddle
- Hardware counters and Intel TMA: sub-category diagnosissenior
- False sharing and native-bridge hot pathssenior
- Hot paths in production: security, tail latency, and tooling lineagesenior
- Memory hierarchy: why the same O(N) loop can be 17x slowerjunior
- Row-major vs column-major: access order and the 9x gapjunior
- Branch prediction and branchless codemiddle
- Hardware prefetcher, TLB, and memory-level parallelismsenior
- GC basics: what the runtime taxes you forjunior
- GC algorithms: generational, concurrent, and per-runtimemiddle
- GC tradeoffs: pause, throughput, heap — and object poolingmiddle
- GC tuning: pacing, heap shape, and allocation observabilitymiddle
- GC internals: tri-color invariant, write barriers, and per-runtime deep-divessenior
- GC in production: observability, security, edge cases, and fleet governancesenior
- N+1: one logical operation, many round-tripsjunior
- Fix families: JOIN, IN, preload, and DataLoadermiddle
- Detecting N+1: query logs, APM traces, and CI gatesmiddle
- DataLoader: batching across resolver treesmiddle
- Cross-protocol N+1: HTTP fan-out and Redis MGETmiddle
- N+1 at scale: pool exhaustion, plan changes, and denormalisationsenior
- Batching: amortize fixed cost per operationjunior
- The batching window: size and wait timemiddle
- Batching in Kafka and Postgresmiddle
- io_uring and observability of batchingmiddle
- From Nagle to io_uring: evolution of batchingmiddle
- Backpressure, failure isolation, and batch security in productionsenior
- What a bundle actually costs: download, parse, compile, executejunior
- Core Web Vitals: LCP, INP, and CLSmiddle
- Code splitting: route-level, component-level, vendor splittingmiddle
- Tree shaking and compression: removing what you don''''t usemiddle
- Third-party scripts: the silent budget killermiddle
- CI enforcement and RUM: making budgets stickmiddle
- V8 JIT pipeline, HTTP priorities, and bundle securitysenior
- The performance loop: discipline, not a projectjunior
- Classify and fix: matching bottleneck families to remediesmiddle
- Observability stack and CI gates: catching regressions before they shipmiddle
- Incident to enforcement: SLO burn to verified fix in 35 minutesmiddle
- Culture, economics, and org-scale performancesenior