Percentiles

use quantiles.qweruse quantile_add, quantile_get from quantiles      // Quillo 0.6: only these

tdigest = "1"

// Response-time percentiles for a status page, kept in memory as requests come in.////   quillo run quantiles.qwe      then open http://localhost:8080/latencyuse "quantiles.qwer"// Each API request adds its time; here, 10,000 made-up timings: most fast, a few slow.route GET /latency {    quantile_reset("api")    quantile_add("api", range(1, 10001) | map((i) => i % 100 == 0 ? 900 + i % 7 : 20 + i % 61))?    { summary: quantile_summary("api"), p999: quantile_get("api", 0.999), slower_than: quantile_rank("api", 85.0) }}route GET /order-values = {    added: quantile_add("orders", [12.5, 40, 22, 99.9, 15, 18, 250, 31])?,    median: quantile_get("orders", 0.5),    empty: quantile_summary("nothing").p50,}

//! Streaming percentiles kept in memory by name, shared by all requests: p50, p95 and p99 of response times, order values or queue waits, with a t-digest that stays small however many values come in.//! version: 1.0.0//!//! [dependencies]//! tdigest = "1"use serde_json::{json, Value};use std::collections::HashMap;use std::sync::Mutex;use tdigest::TDigest;static DIGESTS: Mutex<Option<HashMap<String, TDigest>>> = Mutex::new(None);fn round(x: f64) -> f64 {    (x * 1000.0).round() / 1000.0}/// Adds `values` (up to 100,000 a call; numbers that are not finite are skipped) to the digest `name`, made on first use (up to 1,000 names, about 10 KB each). Gives how many values it holds.pub fn quantile_add(name: &str, values: Vec<f64>) -> Result<i64, String> {    if values.len() > 100_000 {        return Err("up to 100,000 values a call".into());    }    let mut g = DIGESTS.lock().unwrap_or_else(|e| e.into_inner());    let all = g.get_or_insert_with(HashMap::new);    if !all.contains_key(name) && all.len() >= 1000 {        return Err("up to 1,000 digests: quantile_reset old ones".into());    }    let d = all.entry(name.to_string()).or_insert_with(|| TDigest::new_with_size(200));    d.extend_values(values.into_iter().filter(|v| v.is_finite()));    d.flush();    Ok(d.count() as i64)}/// The value below which a share `q` (0 to 1) of the values lie: 0.5 is the median, 0.99 the 99th percentile. Null when the digest is empty or unknown. Exact at the ends, within a fraction of a percent in between.pub fn quantile_get(name: &str, q: f64) -> Option<f64> {    let g = DIGESTS.lock().unwrap_or_else(|e| e.into_inner());    g.as_ref()?.get(name)?.estimate_quantile(q.clamp(0.0, 1.0)).map(round)}/// The usual figures of digest `name`: `{ count, min, max, mean, p50, p90, p95, p99 }`, for a dashboard. Nulls when empty.pub fn quantile_summary(name: &str) -> Value {    let g = DIGESTS.lock().unwrap_or_else(|e| e.into_inner());    let Some(d) = g.as_ref().and_then(|a| a.get(name)) else {        return json!({ "count": 0, "min": null, "max": null, "mean": null, "p50": null, "p90": null, "p95": null, "p99": null });    };    let q = |x: f64| d.estimate_quantile(x).map(round);    json!({ "count": d.count() as i64, "min": d.min(), "max": d.max(), "mean": d.mean().map(round), "p50": q(0.5), "p90": q(0.9), "p95": q(0.95), "p99": q(0.99) })}/// The share of values in digest `name` below `value`, 0 to 1: "this request was slower than 97% of them". Null when empty.pub fn quantile_rank(name: &str, value: f64) -> Option<f64> {    let g = DIGESTS.lock().unwrap_or_else(|e| e.into_inner());    g.as_ref()?.get(name)?.estimate_rank(value).map(round)}/// Forgets digest `name`, to start a new period or free its memory.pub fn quantile_reset(name: &str) {    if let Some(a) = DIGESTS.lock().unwrap_or_else(|e| e.into_inner()).as_mut() {        a.remove(name);    }}