Struct Series 

struct Series {
    desc: String,
    attrs: String,
    points: Vec<(i64, Pt)>,
    dropped: usize,
    exemplars: Vec<(i64, String)>,
}

Fields

desc: String

Rendered "name":...,"unit":..., etc. Built once when the series is first seen; identical for every point in it by construction.

attrs: String

Rendered {...} attribute object.

points: Vec<(i64, Pt)>

dropped: usize

Points dropped by max_points, reported rather than hidden. A chart missing its spike because the engine quietly truncated is the failure mode this exists to prevent.

exemplars: Vec<(i64, String)>

The trace ids behind the points: (time, rendered object), rendered here because the block they were read from is unmapped before the response is written.

Implementations

impl Series

fn compact(&mut self, max: usize)

Discard all but the newest max points.

Which points a cap keeps is a correctness question, not a tuning one. Points arrive in block-scan order, so refusing them once the buffer is full kept whichever ones the directory listing happened to reach first — an arbitrary subset that the sort at render time then dressed up as a contiguous series. Newest-wins is the same rule limit already uses on the record side, and it is a window a reader can reason about.

Called at twice max, so every call throws away half of what it sorts and the amortised cost is constant per point. A bounded heap would hold exactly max at all times and pay log max on every point instead; at these sizes the occasional sort is cheaper and much less code.

ponytail: truncation, not downsampling. A chart that needs the whole range at a lower resolution needs an aggregation window — until that exists the response says dropped_points rather than pretending.