← the depth behind redis-patterns R8 · Production Operations
The Proof · pillar VI
The system holds,
and it can show you
A bus is only as good as the evidence it can produce about itself.
The Proof is the closing pillar, and it does one thing: it makes the whole system accountable
to itself. EchoMQ produces three kinds of evidence: two are code, and the third is a named
frontier. Conformance (EchoMQ.Conformance) is the bus contract written as
runnable scenarios: each drives the public surface against a live server and asserts the
externally visible verdict, so the protocol is proven, not asserted — and any runtime that
speaks the wire must pass the same set. Telemetry & the read plane
(EchoMQ.Meter + EchoMQ.Metrics) is how the running system answers
how it is doing without being asked to change — the lifecycle metered the standard
:telemetry way at zero cost when absent, and a pure-read plane that observes and never
mutates. The benchmark is the named frontier: throughput under load, named here so the picture is
whole, never invented so the page stays honest. It is all real code, except the benchmark,
which has no module in the code and is named as exactly that.
Three concerns, one question
The question the Proof answers is simple: can you trust the bus? It answers in three registers — the contract is proven by running it, the running system reports on itself, and performance under load is the named frontier, with no module behind it. Two are code; the third is greyed, because a depth course names the frontier and teaches only what runs. The suite runs through EchoMQ’s connector: on its default wire 4 it proves the scripts, and on wire 6 a pinned job subset proves the native verbs. Pick a concern to read what it is, the surface beneath it, and whether it runs today.
Three kinds of evidence · pick a concern
Two concerns are code and one is named: the contract is run, the system reports, and the benchmark is honest about having no surface.
The modules
Two modules of evidence in code, the benchmark named as the frontier, then a workshop that folds them. Each
module grounds in the real echo/apps/echo_mq code — the conformance suite, and
the telemetry surface and read plane. The benchmark is a card without a page: a depth course names the frontier
and never fabricates a surface.
The conformance suite
The bus contract written as scenarios: each drives the public surface against a live server and asserts the externally visible verdict.
Telemetry & the read plane
Two ways the running system reports on itself: the lifecycle metered via :telemetry, and a pure-read plane over the as-built sets.
Benchmark — the frontier
Throughput and latency under load — the placement story the {q} hashtag exists for. No benchmark module in the code; named here, never invented.
Workshop
Prove it on a live queue: run the suite, attach a meter and watch the events flow, then read the plane — the system holds, meters itself, reports honestly.
Redis Patterns Applied
This is the depth behind two Redis Patterns Applied chapters that door here. R2 · Coordination — the atomicity the conformance suite proves: the single-owner claim, the fence read before any work, the kind law, the stale-token refusal are each a named scenario asserting an externally visible verdict.
R8 · Production Operations — running the tier: telemetry is how you see the bus working without changing it, and the read plane is how you answer counts, state, and the rate-gate without mutating a thing. There the pattern is the door; here is the evidence it holds.
The manuscript
Proof is where the four libraries become accountable as one. The conformance suite asserts the contract the whole umbrella stands on — one write down, one read up, the branded id the thread through all of it. That composition is narrated in the Branded Component System manuscript, where the libraries come together: The Branded Component System · Together.
The rest of the system
The Proof is the closing reading of the shared substrate. The Queue distributes work over the wire; the Bus broadcasts signals and keeps a replayable log; the Cache serves reads in front of it; the Protocol below them all is the keyspace every key is born to. Proof is the pillar that shows the whole of it holds.
The Protocol
The substrate the suite asserts against: the braced keyspace, the record, the Lua layer, the branded-id gate.
The Queue
Distribute work: the lifecycle, jobs, lanes, the consumer, batches, flows.
The Bus
Broadcast signals: fire-and-forget events plus a retained, replayable log.
The Cache
Serve reads: cache-aside, single-flight, coherence on the Bus.
Every chapter is ready to read: the Protocol, the Queue, the Bus, the Cache and the Proof. The benchmark is the one named frontier, and it has no page.
References
Sources
- Beck — Test-Driven Development — the verdict-asserting scenario as the contract: the test states the externally visible truth the suite proves.
- Elixir — the :telemetry library — the standard metering surface the Meter re-roots under
[:emq, …], opt-in at zero cost when the dep is absent. - Erlang/OTP — :telemetry.execute/3 — the emit the guarded
function_exportedcheck fences, so the bus carries no telemetry dependency edge. - Valkey — ZCARD — the per-state cardinality the read plane's
get_countsanswers over the four sorted sets.
Related in this course
- The Queue — distribute work; the first pillar the suite proves whole.
- The Bus — broadcast signals; the second pillar over the same wire.
- The Cache — serve reads; cache-aside in front of the bus.
- The Protocol — the keyspace and branded-id gate every scenario asserts against.
- Overview — the chapter that frames the three pillars.
- The Branded Component System · Together — the manuscript chapter the Proof shows holds.