subc-daemon 0.49.3

Embeddable subc daemon: bootstrap, module supervision, and opaque-byte splice routing.
Documentation
//! Bounded, body-free attribution of channel-zero requests.

use std::collections::BTreeMap;
use std::time::{Duration, Instant};

use serde_json::{json, Value};

const WINDOW: Duration = Duration::from_secs(60);
const MAX_PAIRS: usize = 256;
const TOP_PAIRS: usize = 32;
const MAX_LABEL_BYTES: usize = 256;

pub(super) struct ControlUsage {
    started: Instant,
    pairs: BTreeMap<(String, String), u64>,
    total: u64,
    overflow: u64,
}

impl Default for ControlUsage {
    fn default() -> Self {
        Self {
            started: Instant::now(),
            pairs: BTreeMap::new(),
            total: 0,
            overflow: 0,
        }
    }
}

impl ControlUsage {
    fn advance(&mut self, now: Instant) {
        if now.duration_since(self.started) >= WINDOW {
            self.started = now;
            self.pairs.clear();
            self.total = 0;
            self.overflow = 0;
        }
    }

    pub(super) fn record(&mut self, op: &str, principal: &str) {
        self.record_at(op, principal, Instant::now());
    }

    fn record_at(&mut self, op: &str, principal: &str, now: Instant) {
        self.advance(now);
        self.total = self.total.saturating_add(1);
        // Unknown operations and principals cannot grow diagnostics without bound.
        if op.len() > MAX_LABEL_BYTES || principal.len() > MAX_LABEL_BYTES {
            self.overflow = self.overflow.saturating_add(1);
            return;
        }
        let key = (op.to_owned(), principal.to_owned());
        if let Some(count) = self.pairs.get_mut(&key) {
            *count = count.saturating_add(1);
        } else if self.pairs.len() < MAX_PAIRS {
            self.pairs.insert(key, 1);
        } else {
            self.overflow = self.overflow.saturating_add(1);
        }
    }

    pub(super) fn snapshot(&mut self) -> Value {
        self.snapshot_at(Instant::now())
    }

    fn snapshot_at(&mut self, now: Instant) -> Value {
        self.advance(now);
        let mut pairs: Vec<_> = self.pairs.iter().collect();
        pairs.sort_by(|(a_key, a_count), (b_key, b_count)| {
            b_count.cmp(a_count).then_with(|| a_key.cmp(b_key))
        });
        let top: Vec<_> = pairs
            .into_iter()
            .take(TOP_PAIRS)
            .map(|((op, principal), count)| {
                json!({"op": op, "principal": principal, "requests": count})
            })
            .collect();
        json!({
            "window_ms": WINDOW.as_millis() as u64,
            "elapsed_ms": now.duration_since(self.started).as_millis() as u64,
            "requests": self.total,
            "overflow_requests": self.overflow,
            "tracked_pairs": self.pairs.len(),
            "top": top,
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn control_usage_counts_principals_and_resets_without_a_timer() {
        let mut usage = ControlUsage::default();
        let now = usage.started;
        usage.record_at("catalog.list", "reserved:provider", now);
        usage.record_at("catalog.list", "direct", now);
        usage.record_at("catalog.list", "reserved:provider", now);
        usage.record_at("config.desktop_review", "direct", now);
        let snapshot = usage.snapshot_at(now + Duration::from_secs(2));
        assert_eq!(snapshot["requests"], 4);
        assert_eq!(snapshot["top"][0]["principal"], "reserved:provider");
        assert_eq!(snapshot["top"][0]["requests"], 2);
        assert_eq!(snapshot["elapsed_ms"], 2000);
        let reset = usage.snapshot_at(now + WINDOW);
        assert_eq!(reset["requests"], 0);
        assert_eq!(reset["top"], json!([]));
    }

    #[test]
    fn control_usage_bounds_storage_output_and_labels() {
        let mut usage = ControlUsage::default();
        let now = usage.started;
        for index in 0..MAX_PAIRS + 10 {
            usage.record_at("catalog.list", &format!("reserved:provider-{index}"), now);
        }
        usage.record_at(&"x".repeat(MAX_LABEL_BYTES + 1), "direct", now);
        let snapshot = usage.snapshot_at(now);
        assert_eq!(snapshot["tracked_pairs"], MAX_PAIRS);
        assert_eq!(snapshot["top"].as_array().unwrap().len(), TOP_PAIRS);
        assert_eq!(snapshot["overflow_requests"], 11);
        assert_eq!(snapshot["requests"], MAX_PAIRS + 11);
    }
}