use std::path::PathBuf;
use anyhow::{Context, Result};
use serde::Deserialize;
use crate::model::{SiteKey, SitePolicy, SiteStats, Unit};
use crate::profile::Profile;
fn parse_name(name: &str) -> Option<(PathBuf, u32, u32)> {
let rest = name
.strip_prefix("auto:")
.or_else(|| name.strip_prefix("manual:"))?;
let col_sep = rest.rfind(':')?;
let col: u32 = rest[col_sep + 1..].parse().ok()?;
let rest = &rest[..col_sep];
let line_sep = rest.rfind(':')?;
let line: u32 = rest[line_sep + 1..].parse().ok()?;
let path_str = &rest[..line_sep];
let file: PathBuf = path_str.split('/').collect();
Some((file, line, col))
}
#[derive(Debug, Deserialize)]
struct Dump {
#[allow(dead_code)]
version: u32,
stats: Vec<Entry>,
}
#[derive(Debug, Deserialize)]
struct Entry {
#[allow(dead_code)]
name: String,
file: PathBuf,
line: u32,
column: u32,
creation_count: u64,
samples: Vec<usize>,
#[serde(default)]
policy: Option<SitePolicy>,
}
pub struct CaptrackProfile {
file: PathBuf,
}
impl CaptrackProfile {
pub fn new(file: impl Into<PathBuf>) -> Self {
Self { file: file.into() }
}
}
impl Profile for CaptrackProfile {
fn sites(&self) -> Result<Vec<SiteStats>> {
let raw = std::fs::read_to_string(&self.file)
.with_context(|| format!("read captrack dump {}", self.file.display()))?;
let dump: Dump = serde_json::from_str(&raw)
.with_context(|| format!("parse captrack dump {}", self.file.display()))?;
Ok(dump.stats.into_iter().map(entry_to_site_stats).collect())
}
}
fn entry_to_site_stats(e: Entry) -> SiteStats {
let key = if let Some((orig_file, orig_line, orig_col)) = parse_name(&e.name) {
SiteKey {
file: orig_file,
line: orig_line,
col: orig_col,
}
} else {
SiteKey {
file: e.file,
line: e.line,
col: e.column,
}
};
if let Some(s) = ::captrack::SampleStats::from_samples(&e.samples) {
SiteStats {
key,
unit: Unit::Elements,
peak: s.max,
p50: s.median,
p95: s.p95,
count: e.creation_count,
mean: Some(s.mean),
p99: Some(s.p99),
policy: e.policy,
}
} else {
SiteStats {
key,
unit: Unit::Elements,
peak: 0,
p50: 0,
p95: 0,
count: e.creation_count,
mean: None,
p99: None,
policy: e.policy,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::path::Path;
#[test]
fn parses_sample_fixture() {
let fixture = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("tests")
.join("fixtures")
.join("captrack-dump.sample.json");
let p = CaptrackProfile::new(fixture);
let stats = p.sites().expect("parse must succeed");
assert_eq!(stats.len(), 2);
let hot = stats
.iter()
.find(|s| s.key.file == *"crates/engine/src/write.rs")
.expect("hot entry exists");
assert_eq!(hot.unit, Unit::Elements);
assert_eq!(hot.key.line, 142);
assert_eq!(hot.key.col, 17);
assert_eq!(hot.peak, 1024);
assert_eq!(hot.count, 1234);
assert_eq!(hot.p50, 64);
assert_eq!(hot.p95, 1024);
assert_eq!(
hot.p99,
Some(1024),
"p99 must be Some for non-empty samples"
);
assert!(
(hot.mean.expect("mean must be Some for non-empty samples") - 180.8).abs() < 1e-9,
"mean should be 180.8, got {:?}",
hot.mean
);
assert_eq!(
hot.policy,
Some(crate::model::SitePolicy {
cap_from: Some(crate::model::CapFrom::Median),
cap_mul: Some(2.0),
cap_round: Some(crate::model::CapRound::Pow2),
}),
"loader must carry the per-site policy from the dump JSON"
);
let cold = stats
.iter()
.find(|s| s.key.file == *"crates/engine/src/cold.rs")
.expect("cold entry exists");
assert_eq!(cold.peak, 0);
assert_eq!(cold.count, 1);
assert_eq!(cold.mean, None, "mean must be None for empty samples");
assert_eq!(cold.p99, None, "p99 must be None for empty samples");
assert_eq!(
cold.policy, None,
"entry without a policy field loads as None"
);
}
#[test]
fn parse_name_extracts_original_location() {
let result = parse_name("auto:crates/shamir-wal/src/wal_segment.rs:212:27");
assert!(result.is_some(), "must parse auto: prefix");
let (file, line, col) = result.unwrap();
let expected: std::path::PathBuf =
"crates/shamir-wal/src/wal_segment.rs".split('/').collect();
assert_eq!(file, expected, "file must use OS separator");
assert_eq!(line, 212);
assert_eq!(col, 27);
let result2 = parse_name("manual:src/lib.rs:10:5");
assert!(result2.is_some());
let (f2, l2, c2) = result2.unwrap();
let exp2: std::path::PathBuf = "src/lib.rs".split('/').collect();
assert_eq!(f2, exp2);
assert_eq!(l2, 10);
assert_eq!(c2, 5);
assert!(
parse_name("engine/write_batch").is_none(),
"bare name must return None"
);
assert!(parse_name("").is_none(), "empty string must return None");
}
}