Function eval_histogram_quantile

nodedb/src/control/promql/evaluator/call.rs:334–386

(ctx: &EvalContext, args: &[Expr])

}

fn eval_histogram_quantile(ctx: &EvalContext, args: &[Expr]) -> Result<Value, PromqlError> {
    if args.len() < 2 {
        return Err(PromqlError::WrongArgCount {
            func: "histogram_quantile".to_string(),
            expected: 2,
            got: args.len(),
        });
    }
    let Value::Scalar(phi, _) = eval(ctx, &args[0])? else {
        return Err(PromqlError::TypeError {
            context: "histogram_quantile".to_string(),
            detail: "first arg must be scalar".to_string(),
        });
    };
    let val = eval(ctx, &args[1])?;
    let Value::Vector(samples) = val else {
        return Err(PromqlError::TypeError {
            context: "histogram_quantile".to_string(),
            detail: "second arg must be instant vector".to_string(),
        });
    };

    // Group by labels excluding "le".
    let mut groups: std::collections::BTreeMap<String, Vec<(f64, f64)>> =
        std::collections::BTreeMap::new();
    let mut group_labels_map: std::collections::BTreeMap<String, Labels> =
        std::collections::BTreeMap::new();

    for s in &samples {
        let le_str = s.labels.get("le").cloned().unwrap_or_default();
        let le: f64 = le_str.parse().unwrap_or(f64::INFINITY);
        let mut key_labels = s.labels.clone();
        key_labels.remove("le");
        key_labels.remove("__name__");
        let key = super::helpers::labels_key(&key_labels);
        group_labels_map.entry(key.clone()).or_insert(key_labels);
        groups.entry(key).or_default().push((le, s.value));
    }

    let mut result = Vec::new();
    for (key, mut buckets) in groups {
        buckets.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal));
        let quantile_val = histogram_quantile_from_buckets(phi, &buckets);
        if let Some(labels) = group_labels_map.get(&key) {
            result.push(InstantSample {
                labels: labels.clone(),
                value: quantile_val,
                timestamp_ms: ctx.timestamp_ms,
            });
        }
    }
    Ok(Value::Vector(result))
}

/// Compute quantile from sorted histogram buckets (le, count) pairs.
fn histogram_quantile_from_buckets(phi: f64, buckets: &[(f64, f64)]) -> f64 {