From 0e9da44aa12ffb3e62247b8ad0e235581d44f183 Mon Sep 17 00:00:00 2001
From: Adam Weil <ajw221@gmail.com>
Date: Thu, 30 Jul 2026 01:10:12 -0400
Subject: [PATCH] feat(shred): add latency histogram metrics to Receiver

- Add ReceiverMetrics with per-method LatencyHistograms for reset,
  updateSlotRange, and processPacket
- Add ResultLatencyHistogram to telemetry lib, which flattens an
  `Error!Payload` into one series per outcome via `variant` labels
- Wire metrics through Receiver.init and observe timings around each
  method, exposing outcome-tagged series for processPacket
- Add Grafana dashboard for the shred receiver
- Make error sets explicit on shred parsing, merkle root computation,
  and ed25519 signature verification so processPacket's error set is
  nameable
---
 conformance/src/shred_parse.zig               |    2 +-
 v2/components/shred/ReceiverMetrics.zig       |   84 +
 v2/components/shred/api.zig                   |   31 +-
 v2/components/shred/component.zig             |    2 +
 v2/components/shred/receiver.zig              |   94 +-
 v2/lib/crypto/ed25519.zig                     |   12 +-
 v2/lib/solana/signature.zig                   |    6 +-
 v2/lib/telemetry.zig                          |  474 ++++
 v2/lib/telemetry/metric.zig                   |  125 +
 .../grafana/dashboards/shred_receiver.json    | 2347 +++++++++++++++++
 v2/services/shred_receiver.zig                |   25 +-
 11 files changed, 3186 insertions(+), 16 deletions(-)
 create mode 100644 v2/components/shred/ReceiverMetrics.zig
 create mode 100644 v2/metrics/grafana/dashboards/shred_receiver.json

diff --git a/conformance/src/shred_parse.zig b/conformance/src/shred_parse.zig
index 63a90ef133..3f29e497f2 100644
--- a/conformance/src/shred_parse.zig
+++ b/conformance/src/shred_parse.zig
@@ -197,7 +197,7 @@ const HarnessState = struct {
         ls.base_slot = 0;
         @memset(&ls.leaders, .ZEROES);
 
-        const receiver = try Receiver.init(allocator, IN_PROGRESS_CAPACITY, DONE_CAPACITY);
+        const receiver = try Receiver.init(allocator, IN_PROGRESS_CAPACITY, DONE_CAPACITY, .initNoop());
 
         self.* = .{
             .allocator = allocator,
diff --git a/v2/components/shred/ReceiverMetrics.zig b/v2/components/shred/ReceiverMetrics.zig
new file mode 100644
index 0000000000..84efab5c3a
--- /dev/null
+++ b/v2/components/shred/ReceiverMetrics.zig
@@ -0,0 +1,84 @@
+const std = @import("std");
+const builtin = @import("builtin");
+
+comptime {
+    _ = std.testing.refAllDecls(@This());
+}
+
+const lib = @import("lib");
+const tel = lib.telemetry;
+
+const LatencyHistogram = tel.LatencyHistogram;
+const Receiver = @import("receiver.zig").Receiver;
+
+const ReceiverMetrics = @This();
+
+reset_elapsed_ns: LatencyHistogram,
+update_slot_range_elapsed_ns: LatencyHistogram,
+process_packet_elapsed_ns: ProcessPacketElapsedHistogram,
+
+/// One latency series per `processPacket` outcome: each `NonErrorStatus` variant plus each error,
+/// flattened into `variant="<label>"` labels. `observe` takes the raw `ProcessPacketError!...`.
+const ProcessPacketElapsedHistogram = tel.ResultLatencyHistogram(
+    Receiver.ProcessPacketError!Receiver.NonErrorStatus,
+    .{ .payload_prefix = .initComptime(.{
+        .{ "fec_set_finished", "full_" },
+        .{ "fec_set_already_finished", "early_" },
+        .{ "shred_already_seen", "early_" },
+        .{ "unfinished_fec_set", "early_" },
+    }) },
+);
+
+/// Backs every series on the heap instead of in a metric region, so a test can build a `Receiver`
+/// without standing up an `Appender`. The layout is irrelevant to what these tests assert; it only
+/// has to be valid.
+pub fn initForTest(gpa: std.mem.Allocator) std.mem.Allocator.Error!ReceiverMetrics {
+    if (!builtin.is_test) @compileError("initForTest is only valid in test builds");
+    const layout: LatencyHistogram.Layout = .{
+        .min_upper_bound_ns = 512,
+        .max_upper_bound_ns = 512 << 20,
+        .bounds_per_doubling = 4,
+    };
+    const reset: LatencyHistogram = try .initForTest(gpa, layout);
+    errdefer reset.deinitForTest(gpa);
+
+    const update_slot_range: LatencyHistogram = try .initForTest(gpa, layout);
+    errdefer update_slot_range.deinitForTest(gpa);
+
+    return .{
+        .reset_elapsed_ns = reset,
+        .update_slot_range_elapsed_ns = update_slot_range,
+        .process_packet_elapsed_ns = try .initForTest(gpa, layout),
+    };
+}
+
+/// Only valid if `self` was initialized using `initForTest`.
+pub fn deinitForTest(self: ReceiverMetrics, gpa: std.mem.Allocator) void {
+    if (!builtin.is_test) @compileError("deinitForTest is only valid in test builds");
+    self.reset_elapsed_ns.deinitForTest(gpa);
+    self.update_slot_range_elapsed_ns.deinitForTest(gpa);
+    self.process_packet_elapsed_ns.deinitForTest(gpa);
+}
+
+fn initNoopLatencyHistogram() LatencyHistogram {
+    const layout: LatencyHistogram.Layout = .{
+        .min_upper_bound_ns = 1,
+        .max_upper_bound_ns = 2,
+        .bounds_per_doubling = 1,
+    };
+    const storage = struct {
+        var elements: [1 + 2 * (2 + 3)]u64 = @splat(0);
+    };
+    comptime std.debug.assert(storage.elements.len == layout.elementsFromBucketCount());
+    return .fromRaw(layout, .{ .elements = &storage.elements });
+}
+
+pub fn initNoop() ReceiverMetrics {
+    return .{
+        .reset_elapsed_ns = initNoopLatencyHistogram(),
+        .update_slot_range_elapsed_ns = initNoopLatencyHistogram(),
+        .process_packet_elapsed_ns = .{
+            .inner = .{ .histograms = @splat(initNoopLatencyHistogram()) },
+        },
+    };
+}
diff --git a/v2/components/shred/api.zig b/v2/components/shred/api.zig
index 900e0227e6..39a9a989f4 100644
--- a/v2/components/shred/api.zig
+++ b/v2/components/shred/api.zig
@@ -227,9 +227,28 @@ pub const Shred = extern struct {
     const merkle_node_size = 20;
     const merkle_root_size = 32;
 
+    pub const PacketCheckedError = error{
+        PacketUnderMinHeaderSize,
+        UnsupportedVariant,
+        PacketUnderHeaderSize,
+        DataSmallerThanHeader,
+        DataPacketUnderMinSize,
+        DataEffectiveSizeTooSmall,
+        CodeShredOverMaxSize,
+        PacketSizeUnderExpected3,
+        DataShredMarkedCompleteIsNotLastInSet,
+        BadOffset,
+        BadSlotOrParentOffset,
+        BadSlotIdx,
+        BadCodeShredIdx,
+        NoCodeOrDataCount,
+        CodeOrDataCountTooLarge,
+        SlotIndexTooHigh,
+    };
+
     // [firedancer] https://github.com/firedancer-io/firedancer/commit/7cbb71919ec9b8045c247957280e5b15d1e0cb85
     /// Makes sure that the *layout* of the Shred is valid.
-    pub fn fromPacketChecked(packet: *const Packet) !*const Shred {
+    pub fn fromPacketChecked(packet: *const Packet) PacketCheckedError!*const Shred {
         if (packet.len < min_header_size) return error.PacketUnderMinHeaderSize;
         if (!Shred.hasSupportedVariant(&packet.data)) return error.UnsupportedVariant;
 
@@ -442,8 +461,10 @@ pub const Shred = extern struct {
         @panic("unimplemented");
     }
 
+    pub const MerkleRootError = ComputeMerkleRootError;
+
     // Reconstructs the merkle root from a shred
-    pub fn merkleRoot(shred: *const Shred, out: *Hash) !void {
+    pub fn merkleRoot(shred: *const Shred, out: *Hash) MerkleRootError!void {
         const zone = tracy.Zone.init(@src(), .{ .name = "merkleRoot" });
         defer zone.deinit();
 
@@ -478,12 +499,16 @@ pub const Shred = extern struct {
         out.* = t;
     }
 
+    pub const ComputeMerkleRootError = error{
+        InvalidMerkleProof,
+    };
+
     fn computeMerkleRoot(
         shred_idx: u32,
         leaf_node: *const Hash,
         proof_nodes: []const MerkleProofNode,
         out: *Hash,
-    ) !void {
+    ) ComputeMerkleRootError!void {
         var idx = shred_idx;
         out.* = leaf_node.*;
 
diff --git a/v2/components/shred/component.zig b/v2/components/shred/component.zig
index 935c42b031..f0243c5b68 100644
--- a/v2/components/shred/component.zig
+++ b/v2/components/shred/component.zig
@@ -4,6 +4,7 @@
 
 comptime {
     if (@import("builtin").is_test) {
+        _ = @import("ReceiverMetrics.zig");
         _ = @import("receiver.zig");
         _ = @import("reed_solomon.zig");
     }
@@ -13,3 +14,4 @@ pub const api = @import("api");
 
 pub const Receiver = @import("receiver.zig").Receiver;
 pub const FecSetCtx = @import("receiver.zig").FecSetCtx;
+pub const ReceiverMetrics = @import("ReceiverMetrics.zig");
diff --git a/v2/components/shred/receiver.zig b/v2/components/shred/receiver.zig
index dd5dfb6359..85396a520e 100644
--- a/v2/components/shred/receiver.zig
+++ b/v2/components/shred/receiver.zig
@@ -18,6 +18,7 @@ const DeshreddedFecSet = api.DeshreddedFecSet;
 const DeshredRing = api.DeshredRing;
 const FecSetId = api.FecSetId;
 const Shred = api.Shred;
+const ReceiverMetrics = @import("ReceiverMetrics.zig");
 
 /// Takes in shreds, and writes out deshredded fec sets.
 /// For full docs see `services/shred_receiver.zig`.
@@ -31,6 +32,8 @@ pub const Receiver = struct {
     in_progress: InProgressSets,
     done: DoneSets,
 
+    metrics: ReceiverMetrics,
+
     /// Per-feature activation slots. A feature is enforced for shreds
     /// whose slot is `>= activation_slot`; the default `maxInt(Slot)`
     /// keeps every feature inactive.
@@ -42,6 +45,7 @@ pub const Receiver = struct {
         allocator: std.mem.Allocator,
         in_progress_capacity: u32,
         done_capacity: u32,
+        metrics: ReceiverMetrics,
     ) !Receiver {
         var in_progress: InProgressSets = try .init(allocator, in_progress_capacity);
         errdefer in_progress.deinit(allocator);
@@ -56,6 +60,8 @@ pub const Receiver = struct {
             .root_slot = 0,
             .max_slot = std.math.maxInt(Slot),
             .features = .{},
+
+            .metrics = metrics,
         };
     }
 
@@ -69,6 +75,9 @@ pub const Receiver = struct {
     /// (e.g. the conformance shred-parse harness, which runs one fixture per
     /// invocation and must not leak state between them).
     pub fn reset(self: *Receiver) void {
+        const method_obs = self.metrics.reset_elapsed_ns.observer();
+        defer method_obs.observe();
+
         self.in_progress.reset();
         self.done.reset();
         self.root_slot = 0;
@@ -77,14 +86,43 @@ pub const Receiver = struct {
     }
 
     pub fn updateSlotRange(self: *Receiver, root_slot: Slot, max_slot: Slot) void {
+        const method_obs = self.metrics.update_slot_range_elapsed_ns.observer();
+        defer method_obs.observe();
+
+        self.updateSlotRangeImpl(root_slot, max_slot);
+    }
+
+    fn updateSlotRangeImpl(self: *Receiver, root_slot: Slot, max_slot: Slot) void {
         self.root_slot = root_slot;
         self.max_slot = max_slot;
 
         // TODO: this is where we would add code to prune entries outside of the new range.
     }
 
-    // TODO: report return values to observability
-    // TODO: report back equivocating shreds, so that we can construct and send out duplicate proofs
+    pub const ProcessPacketError = error{
+        ShredOlderThanRoot,
+        ShredTooNew,
+        ShredVersionMismatch,
+        FecSetIndexTooHigh,
+        SlotIndexTooHigh,
+        BadDataShredCount,
+        BadCodeShredCount,
+        BadCodeShredIdx,
+        UnexpectedDataCompleteShred,
+        InvalidFecSetIdx,
+        ShredIdxTooLarge,
+        MerkleCountTooLarge,
+        VariantMismatchFromFecSet,
+        MismatchedMerkleRoot,
+        EquivocationDifferentHashForSameFecSetId,
+        EquivocationMatchingFecSetWithDifferentSignatureAlreadyInProgress,
+        UnknownLeader,
+    } || (Shred.PacketCheckedError ||
+        std.fmt.BufPrintError ||
+        Shred.ComputeMerkleRootError ||
+        lib.crypto.ed25519.VerifySignatureError ||
+        InProgressSets.CreateFecSetCtxError);
+
     pub fn processPacket(
         state: *Receiver,
         leader_schedule: *const lib.solana.LeaderSchedule,
@@ -92,10 +130,36 @@ pub const Receiver = struct {
         packet: *const Packet,
         deshred_writer: *DeshredRing.Iterator(.writer),
         logger: lib.telemetry.Logger("processPacket"),
-    ) !NonErrorStatus {
+    ) ProcessPacketError!NonErrorStatus {
         const zone = tracy.Zone.init(@src(), .{ .name = "processPacket" });
         defer zone.deinit();
 
+        const method_obs = state.metrics.process_packet_elapsed_ns.observer();
+
+        const result = state.processPacketImpl(
+            leader_schedule,
+            network_shred_version,
+            packet,
+            deshred_writer,
+            logger,
+            zone,
+        );
+
+        method_obs.observe(result);
+        return result;
+    }
+
+    // TODO: report return values to observability
+    // TODO: report back equivocating shreds, so that we can construct and send out duplicate proofs
+    fn processPacketImpl(
+        state: *Receiver,
+        leader_schedule: *const lib.solana.LeaderSchedule,
+        network_shred_version: u16,
+        packet: *const Packet,
+        deshred_writer: *DeshredRing.Iterator(.writer),
+        logger: lib.telemetry.Logger("processPacket"),
+        zone: tracy.Zone,
+    ) ProcessPacketError!NonErrorStatus {
         // check that the shred variant is supported and the header is valid
         const shred = try Shred.fromPacketChecked(packet);
 
@@ -579,12 +643,14 @@ const InProgressSets = struct {
         return self.signature_map.getAdapted(signature, map_ctx);
     }
 
+    pub const CreateFecSetCtxError = error{};
+
     // returns undefined memory, which must be immediately set by the caller
     fn createFecSetCtx(
         self: *InProgressSets,
         id: FecSetId,
         signature: *const Signature,
-    ) !*FecSetCtx {
+    ) CreateFecSetCtxError!*FecSetCtx {
         const map_ctx = self.mapContext();
 
         self.assertCounts();
@@ -756,7 +822,10 @@ fn signTestDataPacket(packet: *Packet, keypair: *const lib.crypto.KeyPair) !void
 test "shred.receiver: empty packet" {
     const allocator = std.testing.allocator;
 
-    var receiver: Receiver = try .init(allocator, 1, 1);
+    const metrics: ReceiverMetrics = try .initForTest(allocator);
+    defer metrics.deinitForTest(allocator);
+
+    var receiver: Receiver = try .init(allocator, 1, 1, metrics);
     defer receiver.deinit(allocator);
 
     var packet: Packet = undefined;
@@ -780,7 +849,10 @@ test "shred.receiver: empty packet" {
 test "shred.receiver: shred version mismatch" {
     const allocator = std.testing.allocator;
 
-    var receiver: Receiver = try .init(allocator, 1, 1);
+    const metrics: ReceiverMetrics = try .initForTest(allocator);
+    defer metrics.deinitForTest(allocator);
+
+    var receiver: Receiver = try .init(allocator, 1, 1, metrics);
     defer receiver.deinit(allocator);
 
     var packet: Packet = undefined;
@@ -804,7 +876,10 @@ test "shred.receiver: shred version mismatch" {
 test "shred.receiver: one shred (unfinished fec set)" {
     const allocator = std.testing.allocator;
 
-    var receiver: Receiver = try .init(allocator, 1, 1);
+    const metrics: ReceiverMetrics = try .initForTest(allocator);
+    defer metrics.deinitForTest(allocator);
+
+    var receiver: Receiver = try .init(allocator, 1, 1, metrics);
     defer receiver.deinit(allocator);
 
     const std_keypair = try std.crypto.sign.Ed25519.KeyPair.generateDeterministic(@splat(1));
@@ -839,7 +914,10 @@ test "shred.receiver: one shred (unfinished fec set)" {
 test "shred.receiver: duplicate shred" {
     const allocator = std.testing.allocator;
 
-    var receiver: Receiver = try .init(allocator, 1, 1);
+    const metrics: ReceiverMetrics = try .initForTest(allocator);
+    defer metrics.deinitForTest(allocator);
+
+    var receiver: Receiver = try .init(allocator, 1, 1, metrics);
     defer receiver.deinit(allocator);
 
     const std_keypair = try std.crypto.sign.Ed25519.KeyPair.generateDeterministic(@splat(1));
diff --git a/v2/lib/crypto/ed25519.zig b/v2/lib/crypto/ed25519.zig
index 40d05bfecb..cf9759dc19 100644
--- a/v2/lib/crypto/ed25519.zig
+++ b/v2/lib/crypto/ed25519.zig
@@ -126,6 +126,12 @@ pub fn verifyBatchOverSingleMessage(
     }
 }
 
+pub const VerifySignatureError = error{
+    InvalidSignature,
+} || (std.crypto.errors.NonCanonicalError ||
+    std.crypto.errors.EncodingError ||
+    AffineLowOrderError);
+
 /// See the doc-comment above `verifyBatchOverSingleMessage` for further detail,
 /// but this is that same thing, just for single messages, and with the ability to toggle
 /// between `verify` and `verify_strict` semantics (used in ed25519 precompile).
@@ -134,7 +140,7 @@ pub fn verifySignature(
     pubkey: *const Pubkey,
     message: []const u8,
     strict: bool,
-) !void {
+) VerifySignatureError!void {
     const s = signature.s;
     const r = signature.r;
     try Edwards25519.scalar.rejectNonCanonical(s);
@@ -166,6 +172,8 @@ pub fn affineEqual(a: Edwards25519, b: Edwards25519) bool {
     return x1.equivalent(a.x) and y1.equivalent(a.y);
 }
 
+pub const AffineLowOrderError = error{WeakPublicKey};
+
 /// Determines whether `a` is of small order (in the torision subgroup E[8]), but with the
 /// assumption that `a.Z == 1`.
 ///
@@ -189,7 +197,7 @@ pub fn affineEqual(a: Edwards25519, b: Edwards25519) bool {
 /// just checking a single coordinate of the point is enough to determine if it's in the blacklist,
 /// meaning we only need 4 equivalence checks to cover all of the pairs.
 ///
-pub fn affineLowOrder(a: Edwards25519) !void {
+pub fn affineLowOrder(a: Edwards25519) AffineLowOrderError!void {
     // y coordinate of points 5 and 6
     const y0: Edwards25519.Fe = .{ .limbs = .{
         0x4d3d706a17c7,
diff --git a/v2/lib/solana/signature.zig b/v2/lib/solana/signature.zig
index a743cdcc3d..10a258370e 100644
--- a/v2/lib/solana/signature.zig
+++ b/v2/lib/solana/signature.zig
@@ -33,7 +33,11 @@ pub const Signature = extern struct {
         return .{ .r = signature.r, .s = signature.s };
     }
 
-    pub fn verify(self: *const Signature, pubkey: *const Pubkey, message: []const u8) !void {
+    pub fn verify(
+        self: *const Signature,
+        pubkey: *const Pubkey,
+        message: []const u8,
+    ) ed25519.VerifySignatureError!void {
         const zone = tracy.Zone.init(@src(), .{ .name = "Sig.verify" });
         defer zone.deinit();
 
diff --git a/v2/lib/telemetry.zig b/v2/lib/telemetry.zig
index ef1f407f68..b72a8bbc61 100644
--- a/v2/lib/telemetry.zig
+++ b/v2/lib/telemetry.zig
@@ -1605,6 +1605,343 @@ pub fn LatencyObserver(comptime kind: metric.HistogramKind, comptime V: ?type) t
     };
 }
 
+/// Presentation-only config for `ResultLatencyHistogram` labels. Whether flattening happens at all is
+/// decided by the `Result` type (an `error_union`/`error_set` flattens; anything else is rejected),
+/// so this struct only tunes the label *text*, never the shape.
+pub const ResultLatencyHistogramLabelConfig = struct {
+    /// Optional per-payload-variant label prefix, distinguishing e.g. a `full_` from an `early_`
+    /// completion of the same variant. Keyed by the payload field's original (pre-snake_case) name.
+    /// Both halves are checked at comptime: every key must name a payload variant, and every value
+    /// must end in `_`. A key that matches nothing is a typo, and a typo here is invisible at
+    /// runtime — the series is still recorded, just under the unprefixed name.
+    payload_prefix: std.StaticStringMap([]const u8) = .{},
+};
+
+/// Backstop on how many series one `ResultLatencyHistogram` may claim. Not a budget — a `Result` anywhere
+/// near this is an error set that grew by accident, not a decision. Every outcome costs a full
+/// `LatencyHistogram` out of the single fixed `histogram_data` region the whole process shares, and
+/// a flattened `Result` is the one metric whose width is set by a type someone else can widen:
+/// adding a `try` to a callee adds a series here, with no diff to the metrics code.
+///
+/// The cost is worth knowing before raising this. On a 1024ns..2MiB-ns window at 4 bounds per
+/// doubling — the shred receiver's — one series is 100 u64 words, so 43 outcomes already claim
+/// ~4.3k of the 12,288 words `init/main.zig` hands the whole process. At this ceiling one metric
+/// would take over half of it.
+const result_histogram_max_series = 64;
+
+/// A `VariantHistogram(LabelEnum, .latency)` fronted by a `Result`-aware `observe`. Hand it the raw
+/// `Error!Payload` (or error-set) value and it records into the matching per-outcome latency series
+/// — the flattening/naming a `Result` needs (which a bare `VariantHistogram` can't express) lives
+/// here, while all storage, registration, and exposition are delegated to the inner
+/// `VariantHistogram`. The label enum is synthesized internally; callers never name it.
+///
+/// Register it like any other metric field: `metric.Appender.appendFields` detects the type and
+/// routes it through `appendResultLatencyHistogram`, which needs the same `.layout` a `LatencyHistogram`
+/// does. One series per outcome is registered up front, so the error set decides how much of the
+/// shared histogram region this metric claims — see `result_histogram_max_series`.
+pub fn ResultLatencyHistogram(comptime ResultT: type, comptime config: ResultLatencyHistogramLabelConfig) type {
+    return struct {
+        inner: Inner,
+        const ResultLatencyHistogramSelf = @This();
+
+        /// One entry per exposed series: the `variant="<label>"` string paired with the runtime
+        /// discriminant that selects it. `ResultLatencyHistogram` derives both its label enum and its `observe`
+        /// dispatch from the same slot list, so the two can never disagree.
+        const ResultSlot = struct {
+            label: [:0]const u8,
+            origin: Origin,
+
+            const Origin = union(enum) {
+                /// Active payload variant selects this slot; the `usize` indexes `std.meta.fields(Payload)`.
+                payload: usize,
+                /// This error value (matched by `@errorName`) selects this slot.
+                err: [:0]const u8,
+            };
+        };
+
+        /// The original `Error!Payload` (or error-set) type this histogram observes. Retaining it is
+        /// what lets `observe` accept a raw result instead of a pre-mapped tag.
+        pub const Result = ResultT;
+        pub const label_config = config;
+        pub const slots = flattenResult(ResultT, config);
+        pub const LabelEnum = ResultLabelEnum(slots);
+        pub const Inner = VariantHistogram(LabelEnum, .latency);
+
+        const PayloadT = switch (@typeInfo(Result)) {
+            .error_union => |eu| eu.payload,
+            else => void,
+        };
+        const ErrorSetT = switch (@typeInfo(Result)) {
+            .error_union => |eu| eu.error_set,
+            .error_set => Result,
+            else => void,
+        };
+
+        comptime {
+            // `observe` reaches `inner.histograms` by raw slot index, while registration filled that
+            // array through `Inner.Indexer`. Those are the same slot only because `LabelEnum` is
+            // dense and in slot order, which is this type's whole correctness argument — assert it
+            // rather than assume it.
+            for (0..slots.len) |i| std.debug.assert(Inner.Indexer.indexOf(@enumFromInt(i)) == i);
+        }
+
+        /// Builds every series on the heap, outside any metric region, so a test can hold a metrics
+        /// struct without standing up an `Appender`. See `LatencyHistogram.initForTest`.
+        pub fn initForTest(
+            gpa: std.mem.Allocator,
+            layout: LatencyHistogram.Layout,
+        ) std.mem.Allocator.Error!ResultLatencyHistogramSelf {
+            return .{ .inner = try initVariantForTest(LabelEnum, .latency, gpa, layout) };
+        }
+
+        /// Only valid if `self` was initialized using `initForTest`.
+        pub fn deinitForTest(self: ResultLatencyHistogramSelf, gpa: std.mem.Allocator) void {
+            deinitVariantForTest(self.inner, gpa);
+        }
+
+        /// Records `ns` into the series selected by `result`. Indexes the inner histogram array
+        /// directly with a runtime slot index, so — unlike `VariantHistogram.observe` — it needs no
+        /// comptime-known tag.
+        pub fn observe(self: *const ResultLatencyHistogramSelf, result: Result, ns: u64) void {
+            self.inner.histograms[indexOf(result)].observe(ns);
+        }
+
+        pub fn observer(self: *const ResultLatencyHistogramSelf) ResultLatencyObserver(ResultLatencyHistogramSelf) {
+            return .init(self);
+        }
+
+        /// The individual histogram handle registered for one outcome, for operations beyond
+        /// `observe` (e.g. snapshotting a single outcome's distribution). Mirrors
+        /// `VariantHistogram.get`; `label` is the flattened name, not the original variant.
+        pub fn get(self: *const ResultLatencyHistogramSelf, comptime label: LabelEnum) LatencyHistogram {
+            return self.inner.get(label);
+        }
+
+        /// Runtime value -> slot index. Every arm resolves through `slots`, so this cannot drift
+        /// from the labels the inner `VariantHistogram` registered.
+        fn indexOf(result: Result) usize {
+            return switch (@typeInfo(Result)) {
+                .error_union => if (result) |payload| payloadIndex(payload) else |err| errIndex(err),
+                .error_set => errIndex(result),
+                else => comptime unreachable,
+            };
+        }
+
+        fn payloadIndex(payload: PayloadT) usize {
+            return switch (@typeInfo(PayloadT)) {
+                .@"union" => switch (payload) {
+                    inline else => |_, tag| comptime slotForPayload(@tagName(tag)),
+                },
+                .@"enum" => switch (payload) {
+                    inline else => |tag| comptime slotForPayload(@tagName(tag)),
+                },
+                else => comptime unreachable,
+            };
+        }
+
+        fn errIndex(err: ErrorSetT) usize {
+            return switch (err) {
+                inline else => |e| comptime slotForErr(@errorName(e)),
+            };
+        }
+
+        /// Resolves through `slots` rather than returning `fieldIndex` directly. Payload slots are
+        /// currently emitted first and in field order, so the two always agree and the scan is an
+        /// identity — it is here so that a change to slot ordering stays a compile error rather than
+        /// a silent relabelling.
+        fn slotForPayload(comptime name: []const u8) usize {
+            @setEvalBranchQuota(1000 + slots.len * 200);
+            const want = std.meta.fieldIndex(PayloadT, name).?;
+            for (slots, 0..) |slot, i| switch (slot.origin) {
+                .payload => |idx| if (idx == want) return i,
+                .err => {},
+            };
+            @compileError("ResultLatencyHistogram: no slot for payload variant `" ++ name ++ "`");
+        }
+
+        fn slotForErr(comptime name: []const u8) usize {
+            @setEvalBranchQuota(1000 + slots.len * 200);
+            for (slots, 0..) |slot, i| switch (slot.origin) {
+                .err => |ename| if (std.mem.eql(u8, ename, name)) return i,
+                .payload => {},
+            };
+            @compileError("ResultLatencyHistogram: no slot for error `" ++ name ++ "`");
+        }
+
+        /// The single comptime pass over `Result`. Payload variants come first, in field order, then
+        /// the errors; each error label is `err_`-prefixed unless it already is.
+        ///
+        /// Error order is whatever `@typeInfo` reports, which is Zig's own — not the order they were
+        /// declared in, and not stable against unrelated code that mentions the same errors. Nothing
+        /// depends on it: `slotForErr` matches by name, and a series is identified in the exposition
+        /// by its label text. Only the slot a given error lands in can move between builds.
+        fn flattenResult(comptime Res: type, comptime cfg: ResultLatencyHistogramLabelConfig) []const ResultSlot {
+            comptime {
+                const info = @typeInfo(Res);
+                const payload_names: []const [:0]const u8 = switch (info) {
+                    .error_union => |eu| switch (@typeInfo(eu.payload)) {
+                        // A bare `union` is accepted by `fieldNames` but has no tag to dispatch on,
+                        // and would fail much later, inside `observe`, pointing here instead of at
+                        // the caller's type.
+                        .@"union" => |u| if (u.tag_type == null) @compileError(
+                            "ResultLatencyHistogram payload `" ++ @typeName(eu.payload) ++
+                                "` is an untagged union; it has no tag to select a series with. " ++
+                                "Make it a `union(enum)`.",
+                        ) else std.meta.fieldNames(eu.payload),
+                        .@"enum" => std.meta.fieldNames(eu.payload),
+                        else => @compileError(
+                            "ResultLatencyHistogram payload must be a tagged union or enum; got " ++
+                                @typeName(eu.payload),
+                        ),
+                    },
+                    .error_set => &.{},
+                    else => @compileError(
+                        "ResultLatencyHistogram requires an error union (`E!P`) or error set; got " ++
+                            @typeName(Res) ++ ". For a plain enum/union, use VariantHistogram directly.",
+                    ),
+                };
+                const ErrSet = switch (info) {
+                    .error_union => |eu| eu.error_set,
+                    .error_set => Res,
+                    else => unreachable,
+                };
+                const err_fields = @typeInfo(ErrSet).error_set orelse @compileError(
+                    "ResultLatencyHistogram needs a concrete error set, and `" ++ @typeName(ErrSet) ++
+                        "` has none to enumerate. Every error becomes its own registered series, " ++
+                        "so the set has to be nameable: declare one " ++
+                        "(`pub const FooError = error{...}`) and return `FooError!Payload`.",
+                );
+
+                for (cfg.payload_prefix.keys(), cfg.payload_prefix.values()) |key, prefix| {
+                    for (payload_names) |name| {
+                        if (std.mem.eql(u8, name, key)) break;
+                    } else @compileError(
+                        "ResultLatencyHistogram: payload_prefix key `" ++ key ++
+                            "` names no payload variant of " ++ @typeName(Res) ++ ".",
+                    );
+                    if (prefix.len == 0 or prefix[prefix.len - 1] != '_') @compileError(
+                        "ResultLatencyHistogram: payload_prefix value `" ++ prefix ++ "` (for `" ++ key ++
+                            "`) must end in `_`, so it reads as one label segment.",
+                    );
+                }
+
+                const count = payload_names.len + err_fields.len;
+                if (count > result_histogram_max_series) @compileError(std.fmt.comptimePrint(
+                    "ResultLatencyHistogram: {s} flattens to {d} outcomes, over the {d}-series cap. Each " ++
+                        "one claims a full LatencyHistogram from the shared histogram region; an " ++
+                        "error set this wide is usually one that grew by accident. Narrow the set, " ++
+                        "or raise `result_histogram_max_series` deliberately.\n",
+                    .{ @typeName(Res), count, result_histogram_max_series },
+                ));
+                @setEvalBranchQuota(1000 + err_fields.len * 500 + count * count * 10);
+
+                var res_slots: [count]ResultSlot = undefined;
+                for (payload_names, 0..) |name, i| {
+                    const prefix = cfg.payload_prefix.get(name) orelse "";
+                    res_slots[i] = .{ .label = snakeCase(prefix, name), .origin = .{ .payload = i } };
+                }
+                for (err_fields, payload_names.len..) |field, i| {
+                    // Decided on the snake_cased spelling, not the raw name: error names are
+                    // conventionally PascalCase, so testing `ErrFoo` against a snake_case prefix
+                    // would prefix it a second time.
+                    const prefix =
+                        if (std.mem.startsWith(u8, snakeCase("", field.name), "err_")) "" else "err_";
+                    res_slots[i] = .{ .label = snakeCase(prefix, field.name), .origin = .{ .err = field.name } };
+                }
+
+                for (res_slots, 0..) |a, i| for (res_slots[i + 1 ..]) |b| {
+                    if (std.mem.eql(u8, a.label, b.label)) {
+                        // Payload slots all precede error slots, so an `.err` on the left means both
+                        // are errors.
+                        const advice = switch (a.origin) {
+                            .payload => switch (b.origin) {
+                                .payload => "Two payload variants snake_case to one spelling. " ++
+                                    "Rename one.",
+                                .err => "A payload variant collides with a flattened error. " ++
+                                    "Rename the payload variant, or give it a `payload_prefix`.",
+                            },
+                            .err => "Two errors snake_case to one spelling. Rename one.",
+                        };
+                        @compileError(
+                            "ResultLatencyHistogram label collision in " ++ @typeName(Result) ++ ": `" ++
+                                a.label ++ "` names two outcomes. " ++ advice,
+                        );
+                    }
+                };
+
+                const frozen = res_slots;
+                return &frozen;
+            }
+        }
+
+        fn ResultLabelEnum(comptime res_slots: []const ResultSlot) type {
+            comptime {
+                var fields: [res_slots.len]std.builtin.Type.EnumField = undefined;
+                for (res_slots, 0..) |slot, i| fields[i] = .{ .name = slot.label, .value = i };
+                const frozen = fields;
+                return @Type(.{ .@"enum" = .{
+                    .tag_type = std.math.IntFittingRange(0, @max(1, res_slots.len) - 1),
+                    .fields = &frozen,
+                    .decls = &.{},
+                    .is_exhaustive = true,
+                } });
+            }
+        }
+
+        fn snakeCase(comptime prefix: []const u8, comptime name: []const u8) [:0]const u8 {
+            comptime {
+                std.debug.assert(prefix.len == 0 or prefix[prefix.len - 1] == '_');
+                // The function puts an underscore only before an uppercase character, and never before two
+                // uppercase characters in sequence. Thus, at worst, every second character gets one:
+                // `aAaA` -> `a_aa_a`. Twice the length is a sufficient over-allocation.
+                var buf: [prefix.len + name.len * 2:0]u8 = undefined;
+                @memcpy(buf[0..prefix.len], prefix);
+                var len = prefix.len;
+
+                for (name, 0..) |char, i| {
+                    if (std.ascii.isUpper(char) and i > 0) {
+                        const starts_word = !std.ascii.isUpper(name[i - 1]);
+                        const ends_acronym = i + 1 < name.len and std.ascii.isLower(name[i + 1]);
+                        if (starts_word or ends_acronym) {
+                            buf[len] = '_';
+                            len += 1;
+                        }
+                    }
+                    buf[len] = std.ascii.toLower(char);
+                    len += 1;
+                }
+                buf[len] = 0;
+
+                const frozen = buf;
+                return frozen[0..len :0];
+            }
+        }
+    };
+}
+
+/// Times an operation and records the elapsed nanoseconds into the `ResultLatencyHistogram` series chosen
+/// by the operation's result. Mirrors `LatencyObserver`, but `observe` takes the raw `Result`.
+pub fn ResultLatencyObserver(comptime RH: type) type {
+    return struct {
+        hist: *const RH,
+        start_ns: u64,
+        const ResultLatencyObserverSelf = @This();
+
+        pub fn init(hist: *const RH) ResultLatencyObserverSelf {
+            return .{ .hist = hist, .start_ns = clock.monotonic(.ns) };
+        }
+
+        /// Nanoseconds since construction; saturating so a non-monotonic clock can't underflow.
+        pub fn elapsedNs(self: ResultLatencyObserverSelf) u64 {
+            return clock.monotonic(.ns) -| self.start_ns;
+        }
+
+        pub fn observe(self: ResultLatencyObserverSelf, result: RH.Result) void {
+            self.hist.observe(result, self.elapsedNs());
+        }
+    };
+}
+
 fn initBuckets(
     comptime len: usize,
     upper_bounds: *const [len]f64,
@@ -2246,3 +2583,140 @@ test "latency observer: a plain histogram observes through the same ns contract"
     try std.testing.expect(snap.sum >= @as(f64, @floatFromInt(before)));
     try std.testing.expect(snap.sum <= @as(f64, @floatFromInt(after)));
 }
+
+// Deliberately awkward spellings: a payload variant carrying a struct, one that needs a prefix to
+// stay distinct, an error whose name starts an acronym, and one already spelled `err_`.
+const ResultTestStatus = union(enum) {
+    unfinished_fec_set: struct { received: u8 },
+    fec_set_finished,
+    shred_already_seen,
+};
+const ResultTestError = error{ ShredTooNew, IOFailure, err_already_prefixed };
+const ResultTestHistogram = ResultLatencyHistogram(ResultTestError!ResultTestStatus, .{
+    .payload_prefix = .initComptime(.{
+        .{ "fec_set_finished", "full_" },
+        .{ "shred_already_seen", "early_" },
+    }),
+});
+
+/// Asserts a `ResultLatencyHistogram` exposes exactly these labels, in any order. `expectEqualSlices` is
+/// wrong for the error half: `@typeInfo` reports an error set in Zig's order, not the declaration's,
+/// and unrelated code mentioning the same errors can change it. The spellings are the contract.
+fn expectLabels(comptime Rh: type, want: []const []const u8) !void {
+    const names = std.meta.fieldNames(Rh.LabelEnum);
+    try std.testing.expectEqual(want.len, names.len);
+    for (want) |w| {
+        for (names) |got| {
+            if (std.mem.eql(u8, got, w)) break;
+        } else {
+            std.debug.print("ResultLatencyHistogram has no label `{s}`\n", .{w});
+            return error.TestExpectedEqual;
+        }
+    }
+}
+
+test "result histogram: flattens payloads then errors into one label per outcome" {
+    // Payload variants keep field order and take their configured prefix.
+    try std.testing.expectEqualSlices([]const u8, &.{
+        "unfinished_fec_set",
+        "full_fec_set_finished",
+        "early_shred_already_seen",
+    }, std.meta.fieldNames(ResultTestHistogram.LabelEnum)[0..3]);
+
+    // Then one label per error: snake_cased, `err_`-prefixed unless the name already is.
+    // `IOFailure` is the acronym case — the boundary falls before the last capital, not between
+    // every pair.
+    try expectLabels(ResultTestHistogram, &.{
+        "unfinished_fec_set",
+        "full_fec_set_finished",
+        "early_shred_already_seen",
+        "err_shred_too_new",
+        "err_io_failure",
+        "err_already_prefixed",
+    });
+}
+
+test "result histogram: a runtime result records into its own series" {
+    const gpa = std.testing.allocator;
+
+    const rh: ResultTestHistogram = try .initForTest(gpa, observer_test_layout);
+    defer rh.deinitForTest(gpa);
+
+    // Runtime values, not comptime literals: `observe` takes the raw result, and this is what
+    // exercises the slot dispatch. A mis-ordered mapping passes a literal-only suite and fails here.
+    const results: []const ResultTestError!ResultTestStatus = &.{
+        .{ .unfinished_fec_set = .{ .received = 3 } },
+        .fec_set_finished,
+        .fec_set_finished,
+        error.IOFailure,
+        error.err_already_prefixed,
+    };
+    for (results) |result| rh.observe(result, 700);
+
+    inline for (.{
+        .{ .unfinished_fec_set, 1 },
+        .{ .full_fec_set_finished, 2 },
+        .{ .early_shred_already_seen, 0 },
+        .{ .err_shred_too_new, 0 },
+        .{ .err_io_failure, 1 },
+        .{ .err_already_prefixed, 1 },
+    }) |case| {
+        var snap = rh.get(case[0]).swapOutSnapshot();
+        defer snap.release();
+        try std.testing.expectEqual(@as(u63, case[1]), snap.count);
+    }
+}
+
+test "result histogram: the observer files a span by its outcome" {
+    const gpa = std.testing.allocator;
+
+    const rh: ResultTestHistogram = try .initForTest(gpa, observer_test_layout);
+    defer rh.deinitForTest(gpa);
+
+    // The span opens before the outcome is known, which is the whole point: no comptime tag is
+    // needed at the end, just the result the operation returned.
+    const obs = rh.observer();
+    const before = obs.elapsedNs();
+    var result: ResultTestError!ResultTestStatus = .fec_set_finished;
+    _ = &result;
+    obs.observe(result);
+    const after = obs.elapsedNs();
+
+    var snap = rh.get(.full_fec_set_finished).swapOutSnapshot();
+    defer snap.release();
+    try std.testing.expectEqual(@as(u63, 1), snap.count);
+    try std.testing.expect(snap.sum >= before);
+    try std.testing.expect(snap.sum <= after);
+}
+
+test "result histogram: a bare error set flattens to errors alone" {
+    const gpa = std.testing.allocator;
+    const Rh = ResultLatencyHistogram(ResultTestError, .{});
+
+    try expectLabels(Rh, &.{ "err_shred_too_new", "err_io_failure", "err_already_prefixed" });
+
+    const rh: Rh = try .initForTest(gpa, observer_test_layout);
+    defer rh.deinitForTest(gpa);
+
+    rh.observe(error.ShredTooNew, 700);
+
+    var snap = rh.get(.err_shred_too_new).swapOutSnapshot();
+    defer snap.release();
+    try std.testing.expectEqual(@as(u63, 1), snap.count);
+}
+
+test "result histogram: an enum payload flattens like a union one" {
+    const gpa = std.testing.allocator;
+    const Rh = ResultLatencyHistogram(ResultTestError!enum { hit, miss }, .{});
+
+    const rh: Rh = try .initForTest(gpa, observer_test_layout);
+    defer rh.deinitForTest(gpa);
+
+    var outcome: @typeInfo(Rh.Result).error_union.payload = .miss;
+    _ = &outcome;
+    rh.observe(outcome, 700);
+
+    var snap = rh.get(.miss).swapOutSnapshot();
+    defer snap.release();
+    try std.testing.expectEqual(@as(u63, 1), snap.count);
+}
diff --git a/v2/lib/telemetry/metric.zig b/v2/lib/telemetry/metric.zig
index 042d92ceb8..e0fbc69c84 100644
--- a/v2/lib/telemetry/metric.zig
+++ b/v2/lib/telemetry/metric.zig
@@ -297,6 +297,20 @@ pub const Appender = struct {
         return vh;
     }
 
+    /// Registers one latency series per outcome of `Result` (its payload variants plus its errors,
+    /// flattened per `config`) and returns a `ResultLatencyHistogram` that observes raw `Result` values.
+    /// Storage/registration reuse `appendVariantHistogram` over the synthesized label enum.
+    pub fn appendResultLatencyHistogram(
+        self: Appender,
+        comptime name: []const u8,
+        comptime Result: type,
+        comptime config: tel.ResultLatencyHistogramLabelConfig,
+        comptime layout: tel.LatencyHistogram.Layout,
+    ) tel.ResultLatencyHistogram(Result, config) {
+        const Rh = tel.ResultLatencyHistogram(Result, config);
+        return .{ .inner = self.appendVariantHistogram(name, Rh.LabelEnum, .latency, layout) };
+    }
+
     pub fn appendFields(
         self: Appender,
         comptime S: type,
@@ -333,6 +347,16 @@ pub const Appender = struct {
                 else => blk: {
                     if (isVariantCounter(s_field.type)) {
                         break :blk self.appendVariantCounter(id_name, s_field.type.Value);
+                    } else if (maybeResultLatencyHistogram(s_field.type)) {
+                        break :blk self.appendResultLatencyHistogram(
+                            id_name,
+                            s_field.type.Result,
+                            s_field.type.label_config,
+                            field_config.layout orelse @compileError(std.fmt.comptimePrint(
+                                "ResultLatencyHistogram metric '{s}' requires a `.layout`.\n",
+                                .{s_field.name},
+                            )),
+                        );
                     } else if (maybeVariantHistogram(s_field.type)) |hist_kind| {
                         break :blk self.appendVariantHistogram(
                             id_name,
@@ -470,6 +494,7 @@ pub fn FieldConfigs(comptime S: type) type {
             tel.LatencyHistogram => FieldConfigLatencyHistogram,
             else => blk: {
                 if (isVariantCounter(s_field.type)) break :blk FieldConfigBasic;
+                if (maybeResultLatencyHistogram(s_field.type)) break :blk FieldConfigLatencyHistogram;
                 if (maybeVariantHistogram(s_field.type)) |kind| break :blk kind.FieldConfigType();
                 @compileError("Unsupported: " ++ @typeName(s_field.type));
             },
@@ -506,6 +531,17 @@ inline fn isVariantCounter(comptime S: type) bool {
     }
 }
 
+inline fn maybeResultLatencyHistogram(comptime S: type) bool {
+    comptime {
+        if (@typeInfo(S) != .@"struct") return false;
+        if (!@hasDecl(S, "Result") or @TypeOf(S.Result) != type) return false;
+        if (!@hasDecl(S, "label_config") or @TypeOf(S.label_config) != tel.ResultLatencyHistogramLabelConfig) return false;
+        // Reconstruct-and-compare, exactly like maybeVariantHistogram: relies on Zig memoizing the
+        // generic instantiation so re-passing the stored (Result, label_config) yields the same type.
+        return tel.ResultLatencyHistogram(S.Result, S.label_config) == S;
+    }
+}
+
 inline fn maybeVariantHistogram(comptime S: type) ?HistogramKind {
     comptime {
         if (!@hasDecl(S, "Value")) return null;
@@ -793,3 +829,92 @@ test "variant histogram: appendFields registers latency and bounds variants" {
     try std.testing.expectEqual(@as(usize, 2), latency_series); // get, put
     try std.testing.expectEqual(@as(usize, 2), sizes_series); // ok, err
 }
+
+/// Snapshots the single `ResultLatencyHistogram` series whose flattened label is `label` and asserts its
+/// observation count.
+fn expectResultSeriesCount(rh: anytype, comptime label: []const u8, expected: u63) !void {
+    var snap = rh.get(@field(@TypeOf(rh).LabelEnum, label)).swapOutSnapshot();
+    defer snap.release();
+    try std.testing.expectEqual(expected, snap.count);
+}
+
+test "result histogram: observe dispatches a runtime result to its own series" {
+    const gpa = std.testing.allocator;
+    const E = error{ Boom, Splat };
+    const P = union(enum) { ok, retry: u8 };
+    const Result = E!P;
+
+    const region, const buf = try testRegion(gpa);
+    defer gpa.free(buf);
+
+    const rh = region.metricAppender().appendResultLatencyHistogram(
+        "op_elapsed_ns",
+        Result,
+        .{},
+        .{ .min_upper_bound_ns = 512, .max_upper_bound_ns = 512 << 4, .bounds_per_doubling = 4 },
+    );
+
+    // Runtime values, not comptime literals: this is the only thing that exercises `indexOf`. A
+    // `comptime`-constrained or mis-ordered mapping would fail here but pass a literal-only suite.
+    const results = [_]Result{ .ok, .{ .retry = 3 }, error.Boom, error.Splat, .ok };
+    for (results) |result| rh.observe(result, 700);
+
+    // Each outcome landed in exactly its own series — payloads and errors both.
+    try expectResultSeriesCount(rh, "ok", 2);
+    try expectResultSeriesCount(rh, "retry", 1);
+    try expectResultSeriesCount(rh, "err_boom", 1);
+    try expectResultSeriesCount(rh, "err_splat", 1);
+
+    // The registered metric carries one labeled series per outcome.
+    var metrics = try testCollect(gpa, region);
+    defer metrics.deinit(gpa);
+    var seen: usize = 0;
+    for (metrics.keys(), metrics.values()) |id, any| {
+        if (!std.mem.eql(u8, id.name, "op_elapsed_ns")) continue;
+        seen += 1;
+        try std.testing.expectEqual(@as(usize, 1), id.label_count);
+        try std.testing.expectEqual(Kind.latency_histogram, std.meta.activeTag(any));
+    }
+    try std.testing.expectEqual(@as(usize, 4), seen); // ok, retry, err_boom, err_splat
+}
+
+test "result histogram: appendFields detects and registers a ResultLatencyHistogram field" {
+    const gpa = std.testing.allocator;
+    const E = error{ Boom, Splat };
+    const P = union(enum) { ok, retry: u8 };
+    const Metrics = struct {
+        op_elapsed_ns: tel.ResultLatencyHistogram(E!P, .{}),
+    };
+
+    const region, const buf = try testRegion(gpa);
+    defer gpa.free(buf);
+
+    const m = region.metricAppender().appendFields(Metrics, .{
+        .prefix = "svc",
+        .fields = .{
+            .op_elapsed_ns = .{ .layout = .{
+                .min_upper_bound_ns = 512,
+                .max_upper_bound_ns = 512 << 4,
+                .bounds_per_doubling = 4,
+            } },
+        },
+    });
+
+    // Runtime result through the appendFields-registered handle.
+    var pick_err = true;
+    _ = &pick_err;
+    var result: E!P = .ok;
+    if (pick_err) result = error.Splat;
+    m.op_elapsed_ns.observe(result, 700);
+
+    try expectResultSeriesCount(m.op_elapsed_ns, "err_splat", 1);
+    try expectResultSeriesCount(m.op_elapsed_ns, "ok", 0);
+
+    var metrics = try testCollect(gpa, region);
+    defer metrics.deinit(gpa);
+    var series: usize = 0;
+    for (metrics.keys()) |id| {
+        if (std.mem.eql(u8, id.name, "svc_op_elapsed_ns")) series += 1;
+    }
+    try std.testing.expectEqual(@as(usize, 4), series); // ok, retry, err_boom, err_splat
+}
diff --git a/v2/metrics/grafana/dashboards/shred_receiver.json b/v2/metrics/grafana/dashboards/shred_receiver.json
new file mode 100644
index 0000000000..2d05a34caa
--- /dev/null
+++ b/v2/metrics/grafana/dashboards/shred_receiver.json
@@ -0,0 +1,2347 @@
+{
+  "apiVersion": "dashboard.grafana.app/v2",
+  "kind": "Dashboard",
+  "metadata": {
+    "name": "sig-shred-receiver"
+  },
+  "spec": {
+    "annotations": [],
+    "cursorSync": "Crosshair",
+    "elements": {
+      "panel-1": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_count(rate(shred_receiver_process_packet_elapsed_ns{variant=\"full_fec_set_finished\"}[$__rate_interval]))",
+                        "range": false
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "A"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "Rate of packets that ran processPacket to its last line, completing a FEC set (Reed-Solomon reconstruction plus the deshredded write).",
+          "id": 1,
+          "links": [],
+          "title": "FEC Sets Completed",
+          "vizConfig": {
+            "group": "stat",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {
+                  "color": {
+                    "mode": "thresholds"
+                  },
+                  "unit": "ops"
+                },
+                "overrides": []
+              },
+              "options": {}
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-10": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "sum(rate(shred_receiver_process_packet_elapsed_ns{variant=\"full_fec_set_finished\"}[$__rate_interval]))",
+                        "format": "heatmap",
+                        "legendFormat": "{{le}}",
+                        "range": true
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "A"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "Latency distribution for packets that completed a full FEC set. The only outcome that reaches the end of processPacketImpl, so the only one whose observation covers the whole function.",
+          "id": 10,
+          "links": [],
+          "title": "full_fec_set_finished",
+          "vizConfig": {
+            "group": "heatmap",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {},
+                "overrides": []
+              },
+              "options": {
+                "calculate": false,
+                "cellValues": {
+                  "unit": "pps"
+                },
+                "color": {
+                  "exponent": 0.5,
+                  "fill": "dark-orange",
+                  "mode": "scheme",
+                  "reverse": false,
+                  "scale": "exponential",
+                  "scheme": "Spectral",
+                  "steps": 128
+                },
+                "filterValues": {
+                  "le": 1e-09
+                },
+                "tooltip": {
+                  "mode": "single",
+                  "showColorScale": true,
+                  "yHistogram": true
+                },
+                "yAxis": {
+                  "unit": "ns"
+                }
+              }
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-11": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "sum(rate(shred_receiver_process_packet_elapsed_ns{variant=~\"early_fec_set_already_finished\"}[$__rate_interval]))",
+                        "format": "heatmap",
+                        "legendFormat": "{{le}}",
+                        "range": true
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "A"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "Latency distribution for shreds dropped because their FEC set was already reconstructed. Returns before any merkle-root computation.",
+          "id": 11,
+          "links": [],
+          "title": "early_fec_set_already_finished",
+          "vizConfig": {
+            "group": "heatmap",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {},
+                "overrides": []
+              },
+              "options": {
+                "calculate": false,
+                "cellValues": {
+                  "unit": "pps"
+                },
+                "color": {
+                  "exponent": 0.5,
+                  "fill": "dark-orange",
+                  "mode": "scheme",
+                  "reverse": false,
+                  "scale": "exponential",
+                  "scheme": "Spectral",
+                  "steps": 128
+                },
+                "filterValues": {
+                  "le": 1e-09
+                },
+                "tooltip": {
+                  "mode": "single",
+                  "showColorScale": true,
+                  "yHistogram": true
+                },
+                "yAxis": {
+                  "unit": "ns"
+                }
+              }
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-12": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "sum(rate(shred_receiver_process_packet_elapsed_ns{variant=~\"early_shred_already_seen\"}[$__rate_interval]))",
+                        "format": "heatmap",
+                        "legendFormat": "{{le}}",
+                        "range": true
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "A"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "Latency distribution for shreds whose index was already received. Returns after the merkle-root check on an existing set, or after full signature verification on a new one.",
+          "id": 12,
+          "links": [],
+          "title": "early_shred_already_seen",
+          "vizConfig": {
+            "group": "heatmap",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {},
+                "overrides": []
+              },
+              "options": {
+                "calculate": false,
+                "cellValues": {
+                  "unit": "pps"
+                },
+                "color": {
+                  "exponent": 0.5,
+                  "fill": "dark-orange",
+                  "mode": "scheme",
+                  "reverse": false,
+                  "scale": "exponential",
+                  "scheme": "Spectral",
+                  "steps": 128
+                },
+                "filterValues": {
+                  "le": 1e-09
+                },
+                "tooltip": {
+                  "mode": "single",
+                  "showColorScale": true,
+                  "yHistogram": true
+                },
+                "yAxis": {
+                  "unit": "ns"
+                }
+              }
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-13": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "sum(rate(shred_receiver_process_packet_elapsed_ns{variant=~\"early_unfinished_fec_set\"}[$__rate_interval]))",
+                        "format": "heatmap",
+                        "legendFormat": "{{le}}",
+                        "range": true
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "A"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "Latency distribution for shreds accepted into an in-progress FEC set that is not yet complete. The normal accumulate path: 31 of every 32 accepted shreds take it.",
+          "id": 13,
+          "links": [],
+          "title": "early_unfinished_fec_set",
+          "vizConfig": {
+            "group": "heatmap",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {},
+                "overrides": []
+              },
+              "options": {
+                "calculate": false,
+                "cellValues": {
+                  "unit": "pps"
+                },
+                "color": {
+                  "exponent": 0.5,
+                  "fill": "dark-orange",
+                  "mode": "scheme",
+                  "reverse": false,
+                  "scale": "exponential",
+                  "scheme": "Spectral",
+                  "steps": 128
+                },
+                "filterValues": {
+                  "le": 1e-09
+                },
+                "tooltip": {
+                  "mode": "single",
+                  "showColorScale": true,
+                  "yHistogram": true
+                },
+                "yAxis": {
+                  "unit": "ns"
+                }
+              }
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-14": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "sum(rate(shred_receiver_process_packet_elapsed_ns{variant=~\"err_.*\"}[$__rate_interval]))",
+                        "format": "heatmap",
+                        "legendFormat": "{{le}}",
+                        "range": true
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "A"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "Latency distribution across all err_* outcomes combined.",
+          "id": 14,
+          "links": [],
+          "title": "err returns",
+          "vizConfig": {
+            "group": "heatmap",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {},
+                "overrides": []
+              },
+              "options": {
+                "calculate": false,
+                "cellValues": {
+                  "unit": "pps"
+                },
+                "color": {
+                  "exponent": 0.5,
+                  "fill": "dark-orange",
+                  "mode": "scheme",
+                  "reverse": false,
+                  "scale": "exponential",
+                  "scheme": "Spectral",
+                  "steps": 128
+                },
+                "filterValues": {
+                  "le": 1e-09
+                },
+                "tooltip": {
+                  "mode": "single",
+                  "showColorScale": true,
+                  "yHistogram": true
+                },
+                "yAxis": {
+                  "unit": "ns"
+                }
+              }
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-15": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_quantile(0.99, sum(rate(shred_receiver_process_packet_elapsed_ns[$__rate_interval])) by (variant)) > 0",
+                        "legendFormat": "{{variant}}",
+                        "range": true
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "C"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "p99 per-packet processing latency, one series per processPacket return value. Each outcome exits at a different depth in the function, so the series measure different amounts of work and are not comparable to one another.",
+          "id": 15,
+          "links": [],
+          "title": "Process Packet Latency by Return (p99)",
+          "vizConfig": {
+            "group": "timeseries",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {
+                  "custom": {
+                    "axisLabel": "time / packet",
+                    "axisPlacement": "right"
+                  },
+                  "unit": "ns"
+                },
+                "overrides": []
+              },
+              "options": {
+                "legend": {
+                  "calcs": [
+                    "lastNotNull"
+                  ],
+                  "displayMode": "table",
+                  "placement": "right",
+                  "showLegend": true,
+                  "sortBy": "Last *",
+                  "sortDesc": true,
+                  "width": 250
+                },
+                "tooltip": {
+                  "mode": "multi",
+                  "sort": "desc"
+                }
+              }
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-16": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_quantile(0.95, sum(rate(shred_receiver_process_packet_elapsed_ns[$__rate_interval])) by (variant)) > 0",
+                        "legendFormat": "{{variant}}",
+                        "range": true
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "C"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "p95 per-packet processing latency, one series per processPacket return value. Each outcome exits at a different depth in the function, so the series measure different amounts of work and are not comparable to one another.",
+          "id": 16,
+          "links": [],
+          "title": "Process Packet Latency by Return (p95)",
+          "vizConfig": {
+            "group": "timeseries",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {
+                  "custom": {
+                    "axisLabel": "time / packet",
+                    "axisPlacement": "right"
+                  },
+                  "unit": "ns"
+                },
+                "overrides": []
+              },
+              "options": {
+                "legend": {
+                  "calcs": [
+                    "lastNotNull"
+                  ],
+                  "displayMode": "table",
+                  "placement": "right",
+                  "showLegend": true,
+                  "sortBy": "Last *",
+                  "sortDesc": true,
+                  "width": 250
+                },
+                "tooltip": {
+                  "mode": "multi",
+                  "sort": "desc"
+                }
+              }
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-17": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_quantile(0.75, sum(rate(shred_receiver_process_packet_elapsed_ns[$__rate_interval])) by (variant)) > 0",
+                        "legendFormat": "{{variant}}",
+                        "range": true
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "C"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "p75 per-packet processing latency, one series per processPacket return value. Each outcome exits at a different depth in the function, so the series measure different amounts of work and are not comparable to one another.",
+          "id": 17,
+          "links": [],
+          "title": "Process Packet Latency by Return (p75)",
+          "vizConfig": {
+            "group": "timeseries",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {
+                  "custom": {
+                    "axisLabel": "time / packet",
+                    "axisPlacement": "right"
+                  },
+                  "unit": "ns"
+                },
+                "overrides": []
+              },
+              "options": {
+                "legend": {
+                  "calcs": [
+                    "lastNotNull"
+                  ],
+                  "displayMode": "table",
+                  "placement": "right",
+                  "showLegend": true,
+                  "sortBy": "Last *",
+                  "sortDesc": true,
+                  "width": 250
+                },
+                "tooltip": {
+                  "mode": "multi",
+                  "sort": "desc"
+                }
+              }
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-18": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_quantile(0.50, sum(rate(shred_receiver_process_packet_elapsed_ns[$__rate_interval])) by (variant)) > 0",
+                        "legendFormat": "{{variant}}",
+                        "range": true
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "C"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "p50 per-packet processing latency, one series per processPacket return value. Each outcome exits at a different depth in the function, so the series measure different amounts of work and are not comparable to one another.",
+          "id": 18,
+          "links": [],
+          "title": "Process Packet Latency by Return (p50)",
+          "vizConfig": {
+            "group": "timeseries",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {
+                  "custom": {
+                    "axisLabel": "time / packet",
+                    "axisPlacement": "right"
+                  },
+                  "unit": "ns"
+                },
+                "overrides": []
+              },
+              "options": {
+                "legend": {
+                  "calcs": [
+                    "lastNotNull"
+                  ],
+                  "displayMode": "table",
+                  "placement": "right",
+                  "showLegend": true,
+                  "sortBy": "Last *",
+                  "sortDesc": true,
+                  "width": 250
+                },
+                "tooltip": {
+                  "mode": "multi",
+                  "sort": "desc"
+                }
+              }
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-19": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_quantile(0.99, sum(rate(shred_receiver_process_packet_elapsed_ns[$__rate_interval]))) > 0",
+                        "legendFormat": "p99",
+                        "range": true
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "C"
+                  }
+                },
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_quantile(0.95, sum(rate(shred_receiver_process_packet_elapsed_ns[$__rate_interval]))) > 0",
+                        "legendFormat": "p95",
+                        "range": true
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "A"
+                  }
+                },
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_quantile(0.90, sum(rate(shred_receiver_process_packet_elapsed_ns[$__rate_interval]))) > 0",
+                        "legendFormat": "p90",
+                        "range": true
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "B"
+                  }
+                },
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_quantile(0.75, sum(rate(shred_receiver_process_packet_elapsed_ns[$__rate_interval]))) > 0",
+                        "legendFormat": "p75",
+                        "range": true
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "D"
+                  }
+                },
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_quantile(0.50, sum(rate(shred_receiver_process_packet_elapsed_ns[$__rate_interval]))) > 0",
+                        "legendFormat": "p50",
+                        "range": true
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "E"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "Per-packet processing latency percentiles across all outcomes combined. Cheap rejections dominate by volume, so read this alongside the by-return panels rather than instead of them.",
+          "id": 19,
+          "links": [],
+          "title": "Tail Latencies",
+          "vizConfig": {
+            "group": "timeseries",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {
+                  "custom": {
+                    "axisLabel": "time / packet",
+                    "axisPlacement": "right"
+                  },
+                  "unit": "ns"
+                },
+                "overrides": []
+              },
+              "options": {
+                "legend": {
+                  "calcs": [
+                    "lastNotNull"
+                  ],
+                  "displayMode": "table",
+                  "placement": "right",
+                  "showLegend": true,
+                  "sortBy": "Last *",
+                  "sortDesc": true,
+                  "width": 250
+                },
+                "tooltip": {
+                  "mode": "multi",
+                  "sort": "desc"
+                }
+              }
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-2": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "sum(histogram_count(rate(shred_receiver_process_packet_elapsed_ns{variant=~\"err_.*\"}[$__rate_interval])))",
+                        "range": false
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "A"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "Rate of packets rejected by a validity, signature, or equivocation check (all err_* outcomes).",
+          "id": 2,
+          "links": [],
+          "title": "Packets Rejected",
+          "vizConfig": {
+            "group": "stat",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {
+                  "color": {
+                    "mode": "thresholds"
+                  },
+                  "unit": "pps"
+                },
+                "overrides": []
+              },
+              "options": {}
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-20": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_avg(rate(shred_receiver_process_packet_elapsed_ns[$__rate_interval])) > 0",
+                        "legendFormat": "{{variant}}",
+                        "range": true
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "C"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "Mean per-packet processing latency, split by return value.",
+          "id": 20,
+          "links": [],
+          "title": "Average by Return",
+          "vizConfig": {
+            "group": "timeseries",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {
+                  "custom": {
+                    "axisLabel": "time / packet",
+                    "axisPlacement": "right"
+                  },
+                  "unit": "ns"
+                },
+                "overrides": []
+              },
+              "options": {
+                "legend": {
+                  "calcs": [
+                    "lastNotNull"
+                  ],
+                  "displayMode": "table",
+                  "placement": "right",
+                  "showLegend": true,
+                  "sortBy": "Last *",
+                  "sortDesc": true,
+                  "width": 250
+                },
+                "tooltip": {
+                  "mode": "multi",
+                  "sort": "desc"
+                }
+              }
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-3": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_quantile(0.99, sum(rate(shred_receiver_process_packet_elapsed_ns[$__rate_interval])))",
+                        "range": false
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "A"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "99th percentile per-packet processing time across all outcomes combined.",
+          "id": 3,
+          "links": [],
+          "title": "Processing Latency p99",
+          "vizConfig": {
+            "group": "stat",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {
+                  "color": {
+                    "mode": "thresholds"
+                  },
+                  "unit": "ns"
+                },
+                "overrides": []
+              },
+              "options": {}
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-5": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "sum(histogram_count(rate(shred_receiver_process_packet_elapsed_ns[$__rate_interval]))) by (variant) > 0",
+                        "legendFormat": "{{variant}}",
+                        "range": true
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "B"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "Packets/sec for every processPacket outcome. Series that are not currently occurring are filtered out by the `> 0`.",
+          "id": 5,
+          "links": [],
+          "title": "Throughput by Outcome",
+          "vizConfig": {
+            "group": "timeseries",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {
+                  "custom": {
+                    "axisLabel": "packets / sec",
+                    "axisPlacement": "right",
+                    "fillOpacity": 25,
+                    "stacking": {
+                      "group": "A",
+                      "mode": "none"
+                    }
+                  },
+                  "unit": "pps"
+                },
+                "overrides": []
+              },
+              "options": {
+                "legend": {
+                  "calcs": [
+                    "lastNotNull"
+                  ],
+                  "displayMode": "table",
+                  "placement": "right",
+                  "showLegend": true,
+                  "sortBy": "Last *",
+                  "sortDesc": true,
+                  "width": 250
+                },
+                "tooltip": {
+                  "mode": "multi",
+                  "sort": "desc"
+                }
+              }
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-6": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "sum(rate(shred_receiver_process_packet_elapsed_ns[$__rate_interval]))",
+                        "format": "heatmap",
+                        "legendFormat": "{{le}}",
+                        "range": true
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "A"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "Distribution of per-packet processing latency over time, across all outcomes combined.",
+          "id": 6,
+          "links": [],
+          "title": "Latency Distribution",
+          "vizConfig": {
+            "group": "heatmap",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {},
+                "overrides": []
+              },
+              "options": {
+                "calculate": false,
+                "cellValues": {
+                  "unit": "pps"
+                },
+                "color": {
+                  "exponent": 0.5,
+                  "fill": "dark-orange",
+                  "mode": "scheme",
+                  "reverse": false,
+                  "scale": "exponential",
+                  "scheme": "Spectral",
+                  "steps": 128
+                },
+                "filterValues": {
+                  "le": 1e-09
+                },
+                "tooltip": {
+                  "mode": "single",
+                  "showColorScale": true,
+                  "yHistogram": true
+                },
+                "yAxis": {
+                  "unit": "ns"
+                }
+              }
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-7": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "sum by (variant) (histogram_count(rate(shred_receiver_process_packet_elapsed_ns{variant=~\"err_.*\"}[$__rate_interval]))) > 0",
+                        "legendFormat": "{{variant}}",
+                        "range": false
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "A"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "Current rate of each rejection outcome (err_* variants); only outcomes actively occurring are shown.",
+          "id": 7,
+          "links": [],
+          "title": "Rejection Reasons",
+          "vizConfig": {
+            "group": "bargauge",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {
+                  "color": {
+                    "mode": "continuous-GrYlRd"
+                  },
+                  "unit": "pps"
+                },
+                "overrides": []
+              },
+              "options": {
+                "displayMode": "gradient",
+                "legend": {
+                  "showLegend": false
+                },
+                "orientation": "horizontal",
+                "reduceOptions": {
+                  "calcs": [
+                    "lastNotNull"
+                  ],
+                  "fields": "",
+                  "values": false
+                },
+                "sortBy": "Value",
+                "sortDescending": true,
+                "valueMode": "color"
+              }
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-21": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "sum(rate(shred_receiver_reset_elapsed_ns[$__rate_interval]))",
+                        "range": true,
+                        "format": "heatmap",
+                        "legendFormat": "{{le}}"
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "A"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "Distribution of Receiver.reset latency over time, from the shred_receiver_reset_elapsed_ns native histogram buckets.",
+          "id": 21,
+          "links": [],
+          "title": "Latency Distribution",
+          "vizConfig": {
+            "group": "heatmap",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {},
+                "overrides": []
+              },
+              "options": {
+                "calculate": false,
+                "cellValues": {
+                  "unit": "pps"
+                },
+                "color": {
+                  "exponent": 0.5,
+                  "fill": "dark-orange",
+                  "mode": "scheme",
+                  "reverse": false,
+                  "scale": "exponential",
+                  "scheme": "Spectral",
+                  "steps": 128
+                },
+                "filterValues": {
+                  "le": 1e-09
+                },
+                "tooltip": {
+                  "mode": "single",
+                  "showColorScale": true,
+                  "yHistogram": true
+                },
+                "yAxis": {
+                  "unit": "ns"
+                }
+              }
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-22": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_quantile(0.99, sum(rate(shred_receiver_reset_elapsed_ns[$__rate_interval]))) > 0",
+                        "range": true,
+                        "legendFormat": "p99"
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "A"
+                  }
+                },
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_quantile(0.95, sum(rate(shred_receiver_reset_elapsed_ns[$__rate_interval]))) > 0",
+                        "range": true,
+                        "legendFormat": "p95"
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "B"
+                  }
+                },
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_quantile(0.9, sum(rate(shred_receiver_reset_elapsed_ns[$__rate_interval]))) > 0",
+                        "range": true,
+                        "legendFormat": "p90"
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "C"
+                  }
+                },
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_quantile(0.75, sum(rate(shred_receiver_reset_elapsed_ns[$__rate_interval]))) > 0",
+                        "range": true,
+                        "legendFormat": "p75"
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "D"
+                  }
+                },
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_quantile(0.5, sum(rate(shred_receiver_reset_elapsed_ns[$__rate_interval]))) > 0",
+                        "range": true,
+                        "legendFormat": "p50"
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "E"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "Receiver.reset latency percentiles, from the shred_receiver_reset_elapsed_ns native histogram.",
+          "id": 22,
+          "links": [],
+          "title": "Tail Latencies",
+          "vizConfig": {
+            "group": "timeseries",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {
+                  "custom": {
+                    "axisLabel": "time / reset",
+                    "axisPlacement": "right"
+                  },
+                  "unit": "ns"
+                },
+                "overrides": []
+              },
+              "options": {
+                "legend": {
+                  "calcs": [
+                    "lastNotNull"
+                  ],
+                  "displayMode": "table",
+                  "placement": "right",
+                  "showLegend": true,
+                  "sortBy": "Last *",
+                  "sortDesc": true,
+                  "width": 250
+                },
+                "tooltip": {
+                  "mode": "multi",
+                  "sort": "desc"
+                }
+              }
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-23": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_avg(rate(shred_receiver_reset_elapsed_ns[$__rate_interval])) > 0",
+                        "range": true,
+                        "legendFormat": "mean"
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "A"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "Mean Receiver.reset latency, from the shred_receiver_reset_elapsed_ns native histogram.",
+          "id": 23,
+          "links": [],
+          "title": "Average",
+          "vizConfig": {
+            "group": "timeseries",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {
+                  "custom": {
+                    "axisLabel": "time / reset",
+                    "axisPlacement": "right"
+                  },
+                  "unit": "ns"
+                },
+                "overrides": []
+              },
+              "options": {
+                "legend": {
+                  "calcs": [
+                    "lastNotNull"
+                  ],
+                  "displayMode": "table",
+                  "placement": "right",
+                  "showLegend": true,
+                  "sortBy": "Last *",
+                  "sortDesc": true,
+                  "width": 250
+                },
+                "tooltip": {
+                  "mode": "multi",
+                  "sort": "desc"
+                }
+              }
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-24": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "sum(rate(shred_receiver_update_slot_range_elapsed_ns[$__rate_interval]))",
+                        "range": true,
+                        "format": "heatmap",
+                        "legendFormat": "{{le}}"
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "A"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "Distribution of Receiver.updateSlotRange latency over time, from the shred_receiver_update_slot_range_elapsed_ns native histogram buckets.",
+          "id": 24,
+          "links": [],
+          "title": "Latency Distribution",
+          "vizConfig": {
+            "group": "heatmap",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {},
+                "overrides": []
+              },
+              "options": {
+                "calculate": false,
+                "cellValues": {
+                  "unit": "pps"
+                },
+                "color": {
+                  "exponent": 0.5,
+                  "fill": "dark-orange",
+                  "mode": "scheme",
+                  "reverse": false,
+                  "scale": "exponential",
+                  "scheme": "Spectral",
+                  "steps": 128
+                },
+                "filterValues": {
+                  "le": 1e-09
+                },
+                "tooltip": {
+                  "mode": "single",
+                  "showColorScale": true,
+                  "yHistogram": true
+                },
+                "yAxis": {
+                  "unit": "ns"
+                }
+              }
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-25": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_quantile(0.99, sum(rate(shred_receiver_update_slot_range_elapsed_ns[$__rate_interval]))) > 0",
+                        "range": true,
+                        "legendFormat": "p99"
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "A"
+                  }
+                },
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_quantile(0.95, sum(rate(shred_receiver_update_slot_range_elapsed_ns[$__rate_interval]))) > 0",
+                        "range": true,
+                        "legendFormat": "p95"
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "B"
+                  }
+                },
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_quantile(0.9, sum(rate(shred_receiver_update_slot_range_elapsed_ns[$__rate_interval]))) > 0",
+                        "range": true,
+                        "legendFormat": "p90"
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "C"
+                  }
+                },
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_quantile(0.75, sum(rate(shred_receiver_update_slot_range_elapsed_ns[$__rate_interval]))) > 0",
+                        "range": true,
+                        "legendFormat": "p75"
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "D"
+                  }
+                },
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_quantile(0.5, sum(rate(shred_receiver_update_slot_range_elapsed_ns[$__rate_interval]))) > 0",
+                        "range": true,
+                        "legendFormat": "p50"
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "E"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "Receiver.updateSlotRange latency percentiles, from the shred_receiver_update_slot_range_elapsed_ns native histogram.",
+          "id": 25,
+          "links": [],
+          "title": "Tail Latencies",
+          "vizConfig": {
+            "group": "timeseries",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {
+                  "custom": {
+                    "axisLabel": "time / update",
+                    "axisPlacement": "right"
+                  },
+                  "unit": "ns"
+                },
+                "overrides": []
+              },
+              "options": {
+                "legend": {
+                  "calcs": [
+                    "lastNotNull"
+                  ],
+                  "displayMode": "table",
+                  "placement": "right",
+                  "showLegend": true,
+                  "sortBy": "Last *",
+                  "sortDesc": true,
+                  "width": 250
+                },
+                "tooltip": {
+                  "mode": "multi",
+                  "sort": "desc"
+                }
+              }
+            },
+            "version": "13.1.0"
+          }
+        }
+      },
+      "panel-26": {
+        "kind": "Panel",
+        "spec": {
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "hidden": false,
+                    "query": {
+                      "datasource": {
+                        "name": "PBFA97CFB590B2093"
+                      },
+                      "group": "prometheus",
+                      "kind": "DataQuery",
+                      "spec": {
+                        "expr": "histogram_avg(rate(shred_receiver_update_slot_range_elapsed_ns[$__rate_interval])) > 0",
+                        "range": true,
+                        "legendFormat": "mean"
+                      },
+                      "version": "v0"
+                    },
+                    "refId": "A"
+                  }
+                }
+              ],
+              "queryOptions": {},
+              "transformations": []
+            }
+          },
+          "description": "Mean Receiver.updateSlotRange latency, from the shred_receiver_update_slot_range_elapsed_ns native histogram.",
+          "id": 26,
+          "links": [],
+          "title": "Average",
+          "vizConfig": {
+            "group": "timeseries",
+            "kind": "VizConfig",
+            "spec": {
+              "fieldConfig": {
+                "defaults": {
+                  "custom": {
+                    "axisLabel": "time / update",
+                    "axisPlacement": "right"
+                  },
+                  "unit": "ns"
+                },
+                "overrides": []
+              },
+              "options": {
+                "legend": {
+                  "calcs": [
+                    "lastNotNull"
+                  ],
+                  "displayMode": "table",
+                  "placement": "right",
+                  "showLegend": true,
+                  "sortBy": "Last *",
+                  "sortDesc": true,
+                  "width": 250
+                },
+                "tooltip": {
+                  "mode": "multi",
+                  "sort": "desc"
+                }
+              }
+            },
+            "version": "13.1.0"
+          }
+        }
+      }
+    },
+    "layout": {
+      "kind": "TabsLayout",
+      "spec": {
+        "tabs": [
+          {
+            "kind": "TabsLayoutTab",
+            "spec": {
+              "layout": {
+                "kind": "GridLayout",
+                "spec": {
+                  "items": [
+                    {
+                      "kind": "GridLayoutItem",
+                      "spec": {
+                        "element": {
+                          "kind": "ElementReference",
+                          "name": "panel-1"
+                        },
+                        "height": 4,
+                        "width": 8,
+                        "x": 0,
+                        "y": 0
+                      }
+                    },
+                    {
+                      "kind": "GridLayoutItem",
+                      "spec": {
+                        "element": {
+                          "kind": "ElementReference",
+                          "name": "panel-2"
+                        },
+                        "height": 4,
+                        "width": 8,
+                        "x": 8,
+                        "y": 0
+                      }
+                    },
+                    {
+                      "kind": "GridLayoutItem",
+                      "spec": {
+                        "element": {
+                          "kind": "ElementReference",
+                          "name": "panel-3"
+                        },
+                        "height": 4,
+                        "width": 8,
+                        "x": 16,
+                        "y": 0
+                      }
+                    },
+                    {
+                      "kind": "GridLayoutItem",
+                      "spec": {
+                        "element": {
+                          "kind": "ElementReference",
+                          "name": "panel-7"
+                        },
+                        "height": 8,
+                        "width": 12,
+                        "x": 0,
+                        "y": 4
+                      }
+                    },
+                    {
+                      "kind": "GridLayoutItem",
+                      "spec": {
+                        "element": {
+                          "kind": "ElementReference",
+                          "name": "panel-5"
+                        },
+                        "height": 8,
+                        "width": 12,
+                        "x": 12,
+                        "y": 4
+                      }
+                    }
+                  ]
+                }
+              },
+              "title": "Overview"
+            }
+          },
+          {
+            "kind": "TabsLayoutTab",
+            "spec": {
+              "layout": {
+                "kind": "RowsLayout",
+                "spec": {
+                  "rows": [
+                    {
+                      "kind": "RowsLayoutRow",
+                      "spec": {
+                        "collapse": false,
+                        "layout": {
+                          "kind": "RowsLayout",
+                          "spec": {
+                            "rows": [
+                              {
+                                "kind": "RowsLayoutRow",
+                                "spec": {
+                                  "collapse": false,
+                                  "layout": {
+                                    "kind": "GridLayout",
+                                    "spec": {
+                                      "items": [
+                                        {
+                                          "kind": "GridLayoutItem",
+                                          "spec": {
+                                            "element": {
+                                              "kind": "ElementReference",
+                                              "name": "panel-6"
+                                            },
+                                            "height": 8,
+                                            "width": 24,
+                                            "x": 0,
+                                            "y": 0
+                                          }
+                                        },
+                                        {
+                                          "kind": "GridLayoutItem",
+                                          "spec": {
+                                            "element": {
+                                              "kind": "ElementReference",
+                                              "name": "panel-19"
+                                            },
+                                            "height": 8,
+                                            "width": 12,
+                                            "x": 0,
+                                            "y": 8
+                                          }
+                                        },
+                                        {
+                                          "kind": "GridLayoutItem",
+                                          "spec": {
+                                            "element": {
+                                              "kind": "ElementReference",
+                                              "name": "panel-20"
+                                            },
+                                            "height": 8,
+                                            "width": 12,
+                                            "x": 12,
+                                            "y": 8
+                                          }
+                                        }
+                                      ]
+                                    }
+                                  },
+                                  "title": "Overview"
+                                }
+                              },
+                              {
+                                "kind": "RowsLayoutRow",
+                                "spec": {
+                                  "collapse": true,
+                                  "layout": {
+                                    "kind": "GridLayout",
+                                    "spec": {
+                                      "items": [
+                                        {
+                                          "kind": "GridLayoutItem",
+                                          "spec": {
+                                            "element": {
+                                              "kind": "ElementReference",
+                                              "name": "panel-15"
+                                            },
+                                            "height": 10,
+                                            "width": 12,
+                                            "x": 0,
+                                            "y": 0
+                                          }
+                                        },
+                                        {
+                                          "kind": "GridLayoutItem",
+                                          "spec": {
+                                            "element": {
+                                              "kind": "ElementReference",
+                                              "name": "panel-16"
+                                            },
+                                            "height": 10,
+                                            "width": 12,
+                                            "x": 12,
+                                            "y": 0
+                                          }
+                                        },
+                                        {
+                                          "kind": "GridLayoutItem",
+                                          "spec": {
+                                            "element": {
+                                              "kind": "ElementReference",
+                                              "name": "panel-17"
+                                            },
+                                            "height": 9,
+                                            "width": 12,
+                                            "x": 0,
+                                            "y": 10
+                                          }
+                                        },
+                                        {
+                                          "kind": "GridLayoutItem",
+                                          "spec": {
+                                            "element": {
+                                              "kind": "ElementReference",
+                                              "name": "panel-18"
+                                            },
+                                            "height": 9,
+                                            "width": 12,
+                                            "x": 12,
+                                            "y": 10
+                                          }
+                                        }
+                                      ]
+                                    }
+                                  },
+                                  "title": "Tail Latencies by Return"
+                                }
+                              },
+                              {
+                                "kind": "RowsLayoutRow",
+                                "spec": {
+                                  "collapse": true,
+                                  "layout": {
+                                    "kind": "GridLayout",
+                                    "spec": {
+                                      "items": [
+                                        {
+                                          "kind": "GridLayoutItem",
+                                          "spec": {
+                                            "element": {
+                                              "kind": "ElementReference",
+                                              "name": "panel-10"
+                                            },
+                                            "height": 8,
+                                            "width": 12,
+                                            "x": 0,
+                                            "y": 0
+                                          }
+                                        },
+                                        {
+                                          "kind": "GridLayoutItem",
+                                          "spec": {
+                                            "element": {
+                                              "kind": "ElementReference",
+                                              "name": "panel-11"
+                                            },
+                                            "height": 8,
+                                            "width": 12,
+                                            "x": 12,
+                                            "y": 0
+                                          }
+                                        },
+                                        {
+                                          "kind": "GridLayoutItem",
+                                          "spec": {
+                                            "element": {
+                                              "kind": "ElementReference",
+                                              "name": "panel-12"
+                                            },
+                                            "height": 8,
+                                            "width": 12,
+                                            "x": 0,
+                                            "y": 8
+                                          }
+                                        },
+                                        {
+                                          "kind": "GridLayoutItem",
+                                          "spec": {
+                                            "element": {
+                                              "kind": "ElementReference",
+                                              "name": "panel-13"
+                                            },
+                                            "height": 8,
+                                            "width": 12,
+                                            "x": 12,
+                                            "y": 8
+                                          }
+                                        },
+                                        {
+                                          "kind": "GridLayoutItem",
+                                          "spec": {
+                                            "element": {
+                                              "kind": "ElementReference",
+                                              "name": "panel-14"
+                                            },
+                                            "height": 8,
+                                            "width": 12,
+                                            "x": 0,
+                                            "y": 16
+                                          }
+                                        }
+                                      ]
+                                    }
+                                  },
+                                  "title": "Heatmaps by Return"
+                                }
+                              }
+                            ]
+                          }
+                        },
+                        "title": "processPacket"
+                      }
+                    },
+                    {
+                      "kind": "RowsLayoutRow",
+                      "spec": {
+                        "collapse": true,
+                        "layout": {
+                          "kind": "RowsLayout",
+                          "spec": {
+                            "rows": [
+                              {
+                                "kind": "RowsLayoutRow",
+                                "spec": {
+                                  "collapse": false,
+                                  "layout": {
+                                    "kind": "GridLayout",
+                                    "spec": {
+                                      "items": [
+                                        {
+                                          "kind": "GridLayoutItem",
+                                          "spec": {
+                                            "element": {
+                                              "kind": "ElementReference",
+                                              "name": "panel-21"
+                                            },
+                                            "height": 8,
+                                            "width": 24,
+                                            "x": 0,
+                                            "y": 0
+                                          }
+                                        },
+                                        {
+                                          "kind": "GridLayoutItem",
+                                          "spec": {
+                                            "element": {
+                                              "kind": "ElementReference",
+                                              "name": "panel-22"
+                                            },
+                                            "height": 8,
+                                            "width": 12,
+                                            "x": 0,
+                                            "y": 8
+                                          }
+                                        },
+                                        {
+                                          "kind": "GridLayoutItem",
+                                          "spec": {
+                                            "element": {
+                                              "kind": "ElementReference",
+                                              "name": "panel-23"
+                                            },
+                                            "height": 8,
+                                            "width": 12,
+                                            "x": 12,
+                                            "y": 8
+                                          }
+                                        }
+                                      ]
+                                    }
+                                  },
+                                  "title": "Overview"
+                                }
+                              }
+                            ]
+                          }
+                        },
+                        "title": "reset"
+                      }
+                    },
+                    {
+                      "kind": "RowsLayoutRow",
+                      "spec": {
+                        "collapse": true,
+                        "layout": {
+                          "kind": "RowsLayout",
+                          "spec": {
+                            "rows": [
+                              {
+                                "kind": "RowsLayoutRow",
+                                "spec": {
+                                  "collapse": false,
+                                  "layout": {
+                                    "kind": "GridLayout",
+                                    "spec": {
+                                      "items": [
+                                        {
+                                          "kind": "GridLayoutItem",
+                                          "spec": {
+                                            "element": {
+                                              "kind": "ElementReference",
+                                              "name": "panel-24"
+                                            },
+                                            "height": 8,
+                                            "width": 24,
+                                            "x": 0,
+                                            "y": 0
+                                          }
+                                        },
+                                        {
+                                          "kind": "GridLayoutItem",
+                                          "spec": {
+                                            "element": {
+                                              "kind": "ElementReference",
+                                              "name": "panel-25"
+                                            },
+                                            "height": 8,
+                                            "width": 12,
+                                            "x": 0,
+                                            "y": 8
+                                          }
+                                        },
+                                        {
+                                          "kind": "GridLayoutItem",
+                                          "spec": {
+                                            "element": {
+                                              "kind": "ElementReference",
+                                              "name": "panel-26"
+                                            },
+                                            "height": 8,
+                                            "width": 12,
+                                            "x": 12,
+                                            "y": 8
+                                          }
+                                        }
+                                      ]
+                                    }
+                                  },
+                                  "title": "Overview"
+                                }
+                              }
+                            ]
+                          }
+                        },
+                        "title": "updateSlotRange"
+                      }
+                    }
+                  ]
+                }
+              },
+              "title": "Latencies"
+            }
+          }
+        ]
+      }
+    },
+    "links": [],
+    "tags": [
+      "sig",
+      "shred"
+    ],
+    "timeSettings": {
+      "from": "now-3h",
+      "timezone": "browser",
+      "to": "now"
+    },
+    "title": "Shred Receiver",
+    "variables": []
+  }
+}
diff --git a/v2/services/shred_receiver.zig b/v2/services/shred_receiver.zig
index b0d7bc52ab..04c6d65c56 100644
--- a/v2/services/shred_receiver.zig
+++ b/v2/services/shred_receiver.zig
@@ -79,10 +79,33 @@ pub fn serviceMain(runner: lib.runner.Connection, ro: ReadOnly, rw: ReadWrite) !
     const allocator = fba.allocator();
 
     const logger = rw.tel.acquireLogger(@tagName(name), "main");
+    const metrics = rw.tel.metricAppender().appendFields(shred.ReceiverMetrics, .{
+        .prefix = @tagName(name),
+        .fields = .{
+            // 512ns - 2.048us, 1 bound = 1 bucket
+            .reset_elapsed_ns = .{ .layout = .{
+                .min_upper_bound_ns = std.math.floorPowerOfTwo(u64, std.time.ns_per_us),
+                .max_upper_bound_ns = std.math.floorPowerOfTwo(u64, 3 * std.time.ns_per_us),
+                .bounds_per_doubling = 1,
+            } },
+            // 512ns - 2.048us, 1 bound = 1 bucket
+            .update_slot_range_elapsed_ns = .{ .layout = .{
+                .min_upper_bound_ns = std.math.floorPowerOfTwo(u64, std.time.ns_per_us),
+                .max_upper_bound_ns = std.math.floorPowerOfTwo(u64, 3 * std.time.ns_per_us),
+                .bounds_per_doubling = 1,
+            } },
+            // 1.024ns - 2.097152ms, 2 bounds = 1 bucket
+            .process_packet_elapsed_ns = .{ .layout = .{
+                .min_upper_bound_ns = std.math.floorPowerOfTwo(u64, 2 * std.time.ns_per_us),
+                .max_upper_bound_ns = std.math.floorPowerOfTwo(u64, 3 * std.time.ns_per_ms),
+                .bounds_per_doubling = 2,
+            } },
+        },
+    });
     rw.tel.signalReady();
     logger.info().logf("Waiting for shreds on port {}", .{rw.tvu_socket.port});
 
-    var receiver: Receiver = try .init(allocator, max_in_progress, max_done);
+    var receiver: Receiver = try .init(allocator, max_in_progress, max_done, metrics);
     defer receiver.deinit(allocator);
 
     var packet_iter = rw.tvu_socket.recv.get(.reader);