558 lines
19 KiB
Rust
558 lines
19 KiB
Rust
use mtp::common::unix_time_millis;
|
|
use serde::{Deserialize, Serialize};
|
|
use std::path::Path;
|
|
use std::time::{Duration, SystemTime, UNIX_EPOCH};
|
|
|
|
fn now_epoch_secs() -> u64 {
|
|
SystemTime::now()
|
|
.duration_since(UNIX_EPOCH)
|
|
.unwrap_or_default()
|
|
.as_secs()
|
|
}
|
|
fn now_epoch_millis() -> u64 {
|
|
unix_time_millis().unwrap_or_default()
|
|
}
|
|
|
|
fn generate_session_id() -> String {
|
|
let ts = now_epoch_secs();
|
|
let rand_part: u32 = rand::random();
|
|
format!("{ts}-{rand_part:08x}")
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Persisted data types
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
|
pub struct PipeResult {
|
|
pub size: usize,
|
|
pub iteration: usize,
|
|
pub total_ms: f64,
|
|
pub data_only_ms: f64,
|
|
pub bytes_matched: bool,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
|
pub struct ClientSessionRecord {
|
|
pub session_id: String,
|
|
pub timestamp: u64,
|
|
pub auth_method: String,
|
|
pub auth_duration_ms: f64,
|
|
pub error: Option<String>,
|
|
pub message_roundtrip_ms: f64,
|
|
pub pipe_results: Vec<PipeResult>,
|
|
pub total_pipe_bytes: u64,
|
|
pub overall_pipe_avg_total_ms: f64,
|
|
pub overall_pipe_avg_data_ms: f64,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
|
pub struct ClientAggregateStats {
|
|
pub total_sessions: u64,
|
|
pub auth_failures: u64,
|
|
pub avg_auth_duration_ms: f64,
|
|
pub avg_message_roundtrip_ms: f64,
|
|
pub avg_pipe_total_ms: f64,
|
|
pub avg_pipe_data_ms: f64,
|
|
pub total_pipe_bytes: u64,
|
|
pub avg_pipe_throughput_mbps: f64,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct ClientOverview {
|
|
pub total_sessions: u64,
|
|
pub aggregate: ClientAggregateStats,
|
|
pub sessions: Vec<ClientSessionRecord>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
|
pub struct ClientMetricsFile {
|
|
pub sessions: Vec<ClientSessionRecord>,
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Live metrics state
|
|
// ---------------------------------------------------------------------------
|
|
|
|
pub struct ClientMetrics {
|
|
sessions: Vec<ClientSessionRecord>,
|
|
}
|
|
|
|
impl ClientMetrics {
|
|
#[cfg(test)]
|
|
pub fn new() -> Self {
|
|
Self {
|
|
sessions: Vec::new(),
|
|
}
|
|
}
|
|
|
|
pub fn load(path: &str) -> Self {
|
|
let file = std::fs::read_to_string(path)
|
|
.ok()
|
|
.and_then(|s| serde_json::from_str::<ClientMetricsFile>(&s).ok());
|
|
|
|
Self {
|
|
sessions: file.map(|f| f.sessions).unwrap_or_default(),
|
|
}
|
|
}
|
|
|
|
pub fn save(&self, path: &str) {
|
|
let data = ClientMetricsFile {
|
|
sessions: self.sessions.clone(),
|
|
};
|
|
if let Some(parent) = Path::new(path).parent() {
|
|
let _ = std::fs::create_dir_all(parent);
|
|
}
|
|
let json = serde_json::to_string_pretty(&data).unwrap_or_default();
|
|
let _ = std::fs::write(path, json);
|
|
}
|
|
|
|
pub fn record_session(&mut self, record: ClientSessionRecord) {
|
|
self.sessions.push(record);
|
|
}
|
|
|
|
pub fn build_overview(&self, overview_path: &str) {
|
|
let total = self.sessions.len() as u64;
|
|
|
|
if total == 0 {
|
|
let overview = ClientOverview {
|
|
total_sessions: 0,
|
|
aggregate: ClientAggregateStats::default(),
|
|
sessions: Vec::new(),
|
|
};
|
|
if let Some(parent) = Path::new(overview_path).parent() {
|
|
let _ = std::fs::create_dir_all(parent);
|
|
}
|
|
let json = serde_json::to_string_pretty(&overview).unwrap_or_default();
|
|
let _ = std::fs::write(overview_path, json);
|
|
return;
|
|
}
|
|
|
|
let mut auth_sum: f64 = 0.0;
|
|
let mut msg_sum: f64 = 0.0;
|
|
let mut pipe_total_sum: f64 = 0.0;
|
|
let mut pipe_data_sum: f64 = 0.0;
|
|
let mut total_pipe_bytes: u64 = 0;
|
|
let mut total_pipe_duration_secs: f64 = 0.0;
|
|
let mut auth_failures: u64 = 0;
|
|
let mut success_count: u64 = 0;
|
|
|
|
for s in &self.sessions {
|
|
if s.error.is_some() {
|
|
auth_failures += 1;
|
|
} else {
|
|
success_count += 1;
|
|
auth_sum += s.auth_duration_ms;
|
|
msg_sum += s.message_roundtrip_ms;
|
|
pipe_total_sum += s.overall_pipe_avg_total_ms;
|
|
pipe_data_sum += s.overall_pipe_avg_data_ms;
|
|
total_pipe_bytes += s.total_pipe_bytes;
|
|
for pr in &s.pipe_results {
|
|
total_pipe_duration_secs += pr.total_ms / 1000.0;
|
|
}
|
|
}
|
|
}
|
|
|
|
let divisor = if success_count > 0 { success_count } else { 1 };
|
|
|
|
let aggregate = ClientAggregateStats {
|
|
total_sessions: total,
|
|
auth_failures,
|
|
avg_auth_duration_ms: auth_sum / divisor as f64,
|
|
avg_message_roundtrip_ms: msg_sum / divisor as f64,
|
|
avg_pipe_total_ms: pipe_total_sum / divisor as f64,
|
|
avg_pipe_data_ms: pipe_data_sum / divisor as f64,
|
|
total_pipe_bytes,
|
|
avg_pipe_throughput_mbps: if total_pipe_duration_secs > 0.0 {
|
|
(total_pipe_bytes as f64 / 1_048_576.0) / total_pipe_duration_secs
|
|
} else {
|
|
0.0
|
|
},
|
|
};
|
|
|
|
let overview = ClientOverview {
|
|
total_sessions: total,
|
|
aggregate,
|
|
sessions: self.sessions.clone(),
|
|
};
|
|
|
|
if let Some(parent) = Path::new(overview_path).parent() {
|
|
let _ = std::fs::create_dir_all(parent);
|
|
}
|
|
let json = serde_json::to_string_pretty(&overview).unwrap_or_default();
|
|
let _ = std::fs::write(overview_path, json);
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Builder for constructing a session record piece by piece
|
|
// ---------------------------------------------------------------------------
|
|
|
|
pub struct SessionBuilder {
|
|
session_id: String,
|
|
timestamp: u64,
|
|
auth_method: String,
|
|
auth_duration_ms: f64,
|
|
error: Option<String>,
|
|
message_roundtrip_ms: f64,
|
|
pipe_results: Vec<PipeResult>,
|
|
}
|
|
|
|
impl SessionBuilder {
|
|
pub fn new(auth_method: &str, auth_duration: Duration) -> Self {
|
|
Self {
|
|
session_id: generate_session_id(),
|
|
timestamp: now_epoch_millis(),
|
|
auth_method: auth_method.to_string(),
|
|
auth_duration_ms: auth_duration.as_secs_f64() * 1000.0,
|
|
error: None,
|
|
message_roundtrip_ms: 0.0,
|
|
pipe_results: Vec::new(),
|
|
}
|
|
}
|
|
|
|
pub fn set_error(&mut self, error: String) {
|
|
self.error = Some(error);
|
|
}
|
|
|
|
pub fn set_message_roundtrip(&mut self, duration: Duration) {
|
|
self.message_roundtrip_ms = duration.as_secs_f64() * 1000.0;
|
|
}
|
|
|
|
pub fn add_pipe_result(&mut self, result: PipeResult) {
|
|
self.pipe_results.push(result);
|
|
}
|
|
|
|
pub fn build(self) -> ClientSessionRecord {
|
|
let total_pipe_bytes: u64 = self.pipe_results.iter().map(|r| r.size as u64).sum();
|
|
|
|
let overall_pipe_avg_total_ms = if self.pipe_results.is_empty() {
|
|
0.0
|
|
} else {
|
|
self.pipe_results.iter().map(|r| r.total_ms).sum::<f64>()
|
|
/ self.pipe_results.len() as f64
|
|
};
|
|
|
|
let overall_pipe_avg_data_ms = if self.pipe_results.is_empty() {
|
|
0.0
|
|
} else {
|
|
self.pipe_results
|
|
.iter()
|
|
.map(|r| r.data_only_ms)
|
|
.sum::<f64>()
|
|
/ self.pipe_results.len() as f64
|
|
};
|
|
|
|
ClientSessionRecord {
|
|
session_id: self.session_id,
|
|
timestamp: self.timestamp,
|
|
auth_method: self.auth_method,
|
|
auth_duration_ms: self.auth_duration_ms,
|
|
error: self.error,
|
|
message_roundtrip_ms: self.message_roundtrip_ms,
|
|
pipe_results: self.pipe_results,
|
|
total_pipe_bytes,
|
|
overall_pipe_avg_total_ms,
|
|
overall_pipe_avg_data_ms,
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Tests
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use std::time::Duration;
|
|
|
|
fn tmp_path(name: &str) -> String {
|
|
let dir = std::env::temp_dir().join("mtp_client_metrics_test");
|
|
let _ = std::fs::create_dir_all(&dir);
|
|
dir.join(name).to_str().unwrap().to_string()
|
|
}
|
|
|
|
#[test]
|
|
fn test_pipe_result_roundtrip() {
|
|
let pr = PipeResult {
|
|
size: 1024,
|
|
iteration: 0,
|
|
total_ms: 5.5,
|
|
data_only_ms: 3.2,
|
|
bytes_matched: true,
|
|
};
|
|
let json = serde_json::to_string(&pr).unwrap();
|
|
let decoded: PipeResult = serde_json::from_str(&json).unwrap();
|
|
assert_eq!(pr, decoded);
|
|
}
|
|
|
|
#[test]
|
|
fn test_client_session_roundtrip() {
|
|
let record = ClientSessionRecord {
|
|
session_id: "test-session".into(),
|
|
timestamp: 12345,
|
|
auth_method: "connect".into(),
|
|
auth_duration_ms: 42.5,
|
|
error: None,
|
|
message_roundtrip_ms: 10.3,
|
|
pipe_results: vec![
|
|
PipeResult {
|
|
size: 64,
|
|
iteration: 0,
|
|
total_ms: 1.0,
|
|
data_only_ms: 0.5,
|
|
bytes_matched: true,
|
|
},
|
|
PipeResult {
|
|
size: 256,
|
|
iteration: 0,
|
|
total_ms: 2.0,
|
|
data_only_ms: 1.0,
|
|
bytes_matched: true,
|
|
},
|
|
],
|
|
total_pipe_bytes: 320,
|
|
overall_pipe_avg_total_ms: 1.5,
|
|
overall_pipe_avg_data_ms: 0.75,
|
|
};
|
|
|
|
let json = serde_json::to_string(&record).unwrap();
|
|
let decoded: ClientSessionRecord = serde_json::from_str(&json).unwrap();
|
|
assert_eq!(record, decoded);
|
|
}
|
|
|
|
#[test]
|
|
fn test_client_metrics_load_missing() {
|
|
let metrics = ClientMetrics::load("/nonexistent/path.json");
|
|
assert!(metrics.sessions.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn test_multiple_client_sessions() {
|
|
let path = tmp_path("multi_session.json");
|
|
let mut metrics = ClientMetrics::load(&path);
|
|
|
|
for i in 0..3 {
|
|
let mut builder = SessionBuilder::new("connect", Duration::from_millis(10 + i));
|
|
builder.set_message_roundtrip(Duration::from_millis(5 + i));
|
|
builder.add_pipe_result(PipeResult {
|
|
size: 64,
|
|
iteration: 0,
|
|
total_ms: 1.0 + i as f64,
|
|
data_only_ms: 0.5 + i as f64 * 0.5,
|
|
bytes_matched: true,
|
|
});
|
|
metrics.record_session(builder.build());
|
|
}
|
|
|
|
metrics.save(&path);
|
|
|
|
let metrics2 = ClientMetrics::load(&path);
|
|
assert_eq!(metrics2.sessions.len(), 3);
|
|
assert_eq!(metrics2.sessions[0].auth_method, "connect");
|
|
assert_eq!(metrics2.sessions[1].pipe_results[0].size, 64);
|
|
|
|
let _ = std::fs::remove_file(&path);
|
|
}
|
|
|
|
#[test]
|
|
fn test_client_overview_stats() {
|
|
let mut metrics = ClientMetrics::new();
|
|
|
|
for i in 0..4 {
|
|
let mut builder = SessionBuilder::new("connect", Duration::from_millis(20));
|
|
builder.set_message_roundtrip(Duration::from_millis(10 + i as u64));
|
|
builder.add_pipe_result(PipeResult {
|
|
size: 256,
|
|
iteration: 0,
|
|
total_ms: 2.0,
|
|
data_only_ms: 1.0,
|
|
bytes_matched: true,
|
|
});
|
|
metrics.record_session(builder.build());
|
|
}
|
|
|
|
let overview_path = tmp_path("client_overview.json");
|
|
metrics.build_overview(&overview_path);
|
|
|
|
let json = std::fs::read_to_string(&overview_path).unwrap();
|
|
let overview: ClientOverview = serde_json::from_str(&json).unwrap();
|
|
|
|
assert_eq!(overview.total_sessions, 4);
|
|
assert_eq!(overview.aggregate.avg_auth_duration_ms, 20.0);
|
|
assert_eq!(overview.aggregate.avg_message_roundtrip_ms, 11.5);
|
|
assert_eq!(overview.aggregate.avg_pipe_total_ms, 2.0);
|
|
assert_eq!(overview.aggregate.avg_pipe_data_ms, 1.0);
|
|
assert_eq!(overview.aggregate.total_pipe_bytes, 1024);
|
|
assert!(overview.aggregate.avg_pipe_throughput_mbps > 0.0);
|
|
assert_eq!(overview.sessions.len(), 4);
|
|
|
|
let _ = std::fs::remove_file(&overview_path);
|
|
}
|
|
|
|
#[test]
|
|
fn test_client_overview_empty() {
|
|
let metrics = ClientMetrics::new();
|
|
let overview_path = tmp_path("client_empty_overview.json");
|
|
metrics.build_overview(&overview_path);
|
|
|
|
let json = std::fs::read_to_string(&overview_path).unwrap();
|
|
let overview: ClientOverview = serde_json::from_str(&json).unwrap();
|
|
assert_eq!(overview.total_sessions, 0);
|
|
assert!(overview.sessions.is_empty());
|
|
|
|
let _ = std::fs::remove_file(&overview_path);
|
|
}
|
|
|
|
#[test]
|
|
fn test_auth_failure_recording() {
|
|
let path = tmp_path("auth_failure.json");
|
|
let overview_path = tmp_path("auth_failure_overview.json");
|
|
|
|
let mut metrics = ClientMetrics::load(&path);
|
|
|
|
// Successful session
|
|
let mut b1 = SessionBuilder::new("connect", Duration::from_millis(42));
|
|
b1.set_message_roundtrip(Duration::from_millis(10));
|
|
metrics.record_session(b1.build());
|
|
|
|
// Failed auth session
|
|
let mut b2 = SessionBuilder::new("connect", Duration::from_millis(5000));
|
|
b2.set_error("authentication timed out".into());
|
|
metrics.record_session(b2.build());
|
|
|
|
// Another successful session
|
|
let mut b3 = SessionBuilder::new("register", Duration::from_millis(100));
|
|
b3.set_message_roundtrip(Duration::from_millis(8));
|
|
metrics.record_session(b3.build());
|
|
|
|
metrics.save(&path);
|
|
let metrics2 = ClientMetrics::load(&path);
|
|
assert_eq!(metrics2.sessions.len(), 3);
|
|
assert!(metrics2.sessions[0].error.is_none());
|
|
assert_eq!(
|
|
metrics2.sessions[1].error.as_deref(),
|
|
Some("authentication timed out")
|
|
);
|
|
assert!(metrics2.sessions[2].error.is_none());
|
|
|
|
metrics2.build_overview(&overview_path);
|
|
let overview_json = std::fs::read_to_string(&overview_path).unwrap();
|
|
let overview: ClientOverview = serde_json::from_str(&overview_json).unwrap();
|
|
|
|
assert_eq!(overview.total_sessions, 3);
|
|
assert_eq!(overview.aggregate.auth_failures, 1);
|
|
// Averages should only count successful sessions
|
|
assert!((overview.aggregate.avg_auth_duration_ms - 71.0).abs() < 0.01); // (42+100)/2
|
|
assert!((overview.aggregate.avg_message_roundtrip_ms - 9.0).abs() < 0.01); // (10+8)/2
|
|
|
|
let _ = std::fs::remove_file(&path);
|
|
let _ = std::fs::remove_file(&overview_path);
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Integration-style tests
|
|
// -----------------------------------------------------------------------
|
|
|
|
fn make_pr(size: usize, iteration: usize, total_ms: f64, data_only_ms: f64) -> PipeResult {
|
|
PipeResult {
|
|
size,
|
|
iteration,
|
|
total_ms,
|
|
data_only_ms,
|
|
bytes_matched: true,
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_full_client_lifecycle() {
|
|
let path = tmp_path("client_lifecycle.json");
|
|
let overview_path = tmp_path("client_lifecycle_overview.json");
|
|
|
|
let mut metrics = ClientMetrics::load(&path);
|
|
|
|
let mut b1 = SessionBuilder::new("connect", Duration::from_millis(42));
|
|
b1.set_message_roundtrip(Duration::from_millis(10));
|
|
b1.add_pipe_result(make_pr(64, 0, 1.5, 0.8));
|
|
b1.add_pipe_result(make_pr(256, 0, 2.5, 1.2));
|
|
metrics.record_session(b1.build());
|
|
|
|
let mut b2 = SessionBuilder::new("register", Duration::from_millis(150));
|
|
b2.set_message_roundtrip(Duration::from_millis(15));
|
|
b2.add_pipe_result(make_pr(64, 0, 2.0, 1.0));
|
|
b2.add_pipe_result(make_pr(1024, 0, 5.0, 3.0));
|
|
metrics.record_session(b2.build());
|
|
|
|
metrics.save(&path);
|
|
let metrics2 = ClientMetrics::load(&path);
|
|
assert_eq!(metrics2.sessions.len(), 2);
|
|
|
|
let s1 = &metrics2.sessions[0];
|
|
assert_eq!(s1.auth_method, "connect");
|
|
assert!((s1.auth_duration_ms - 42.0).abs() < 0.01);
|
|
assert!((s1.message_roundtrip_ms - 10.0).abs() < 0.01);
|
|
assert_eq!(s1.pipe_results.len(), 2);
|
|
assert_eq!(s1.total_pipe_bytes, 320);
|
|
assert!((s1.overall_pipe_avg_total_ms - 2.0).abs() < 0.01);
|
|
assert!((s1.overall_pipe_avg_data_ms - 1.0).abs() < 0.01);
|
|
|
|
let s2 = &metrics2.sessions[1];
|
|
assert_eq!(s2.auth_method, "register");
|
|
assert_eq!(s2.pipe_results.len(), 2);
|
|
assert_eq!(s2.total_pipe_bytes, 1088);
|
|
|
|
metrics2.build_overview(&overview_path);
|
|
let overview_json = std::fs::read_to_string(&overview_path).unwrap();
|
|
let overview: ClientOverview = serde_json::from_str(&overview_json).unwrap();
|
|
assert_eq!(overview.total_sessions, 2);
|
|
assert!((overview.aggregate.avg_auth_duration_ms - 96.0).abs() < 0.01);
|
|
assert!((overview.aggregate.avg_message_roundtrip_ms - 12.5).abs() < 0.01);
|
|
assert_eq!(overview.aggregate.total_pipe_bytes, 1408);
|
|
assert!(overview.aggregate.avg_pipe_throughput_mbps > 0.0);
|
|
|
|
let _ = std::fs::remove_file(&path);
|
|
let _ = std::fs::remove_file(&overview_path);
|
|
}
|
|
|
|
#[test]
|
|
fn test_cross_session_accumulation() {
|
|
let path = tmp_path("client_accumulate.json");
|
|
let overview_path = tmp_path("client_accumulate_overview.json");
|
|
|
|
{
|
|
let mut metrics = ClientMetrics::load(&path);
|
|
let mut b = SessionBuilder::new("connect", Duration::from_millis(30));
|
|
b.set_message_roundtrip(Duration::from_millis(8));
|
|
b.add_pipe_result(make_pr(64, 0, 1.0, 0.5));
|
|
metrics.record_session(b.build());
|
|
metrics.save(&path);
|
|
}
|
|
|
|
{
|
|
let mut metrics = ClientMetrics::load(&path);
|
|
assert_eq!(metrics.sessions.len(), 1);
|
|
let mut b = SessionBuilder::new("register", Duration::from_millis(200));
|
|
b.set_message_roundtrip(Duration::from_millis(12));
|
|
b.add_pipe_result(make_pr(1024, 0, 4.0, 2.5));
|
|
metrics.record_session(b.build());
|
|
metrics.save(&path);
|
|
}
|
|
|
|
let metrics = ClientMetrics::load(&path);
|
|
assert_eq!(metrics.sessions.len(), 2);
|
|
assert_eq!(metrics.sessions[0].auth_method, "connect");
|
|
assert_eq!(metrics.sessions[1].auth_method, "register");
|
|
|
|
metrics.build_overview(&overview_path);
|
|
let overview_json = std::fs::read_to_string(&overview_path).unwrap();
|
|
let overview: ClientOverview = serde_json::from_str(&overview_json).unwrap();
|
|
assert_eq!(overview.total_sessions, 2);
|
|
assert!((overview.aggregate.avg_auth_duration_ms - 115.0).abs() < 0.01);
|
|
assert!((overview.aggregate.avg_message_roundtrip_ms - 10.0).abs() < 0.01);
|
|
assert_eq!(overview.aggregate.total_pipe_bytes, 1088);
|
|
|
|
let _ = std::fs::remove_file(&path);
|
|
let _ = std::fs::remove_file(&overview_path);
|
|
}
|
|
}
|