mockforge_performance/
metrics.rs

1//! Performance Metrics
2//!
3//! Tracks and aggregates performance metrics during load simulation.
4
5use chrono::{DateTime, Utc};
6use serde::{Deserialize, Serialize};
7use std::collections::HashMap;
8
9/// Performance metrics
10#[derive(Debug, Clone, Serialize, Deserialize)]
11pub struct PerformanceMetrics {
12    /// Total requests
13    pub total_requests: u64,
14    /// Successful requests
15    pub successful_requests: u64,
16    /// Failed requests
17    pub failed_requests: u64,
18    /// Current RPS
19    pub current_rps: f64,
20    /// Target RPS
21    pub target_rps: f64,
22    /// Average latency (ms)
23    pub avg_latency_ms: f64,
24    /// P95 latency (ms)
25    pub p95_latency_ms: u64,
26    /// P99 latency (ms)
27    pub p99_latency_ms: u64,
28    /// Error rate (0.0-1.0)
29    pub error_rate: f64,
30    /// Metrics by endpoint
31    pub endpoint_metrics: HashMap<String, EndpointMetrics>,
32    /// Timestamp
33    pub timestamp: DateTime<Utc>,
34}
35
36/// Endpoint-specific metrics
37#[derive(Debug, Clone, Serialize, Deserialize)]
38pub struct EndpointMetrics {
39    /// Request count
40    pub request_count: u64,
41    /// Average latency (ms)
42    pub avg_latency_ms: f64,
43    /// P95 latency (ms)
44    pub p95_latency_ms: u64,
45    /// P99 latency (ms)
46    pub p99_latency_ms: u64,
47    /// Error count
48    pub error_count: u64,
49    /// Error rate (0.0-1.0)
50    pub error_rate: f64,
51}
52
53/// Performance snapshot
54///
55/// A snapshot of performance metrics at a point in time.
56#[derive(Debug, Clone, Serialize, Deserialize)]
57pub struct PerformanceSnapshot {
58    /// Snapshot ID
59    pub id: String,
60    /// Timestamp
61    pub timestamp: DateTime<Utc>,
62    /// Metrics
63    pub metrics: PerformanceMetrics,
64    /// Active bottlenecks
65    pub active_bottlenecks: Vec<String>,
66}
67
68impl PerformanceMetrics {
69    /// Create new performance metrics
70    pub fn new() -> Self {
71        Self {
72            total_requests: 0,
73            successful_requests: 0,
74            failed_requests: 0,
75            current_rps: 0.0,
76            target_rps: 0.0,
77            avg_latency_ms: 0.0,
78            p95_latency_ms: 0,
79            p99_latency_ms: 0,
80            error_rate: 0.0,
81            endpoint_metrics: HashMap::new(),
82            timestamp: Utc::now(),
83        }
84    }
85
86    /// Update from latency statistics
87    pub fn update_from_latency_stats(
88        &mut self,
89        stats: &crate::latency::LatencyStats,
90        current_rps: f64,
91        target_rps: f64,
92    ) {
93        self.total_requests = stats.count as u64;
94        self.current_rps = current_rps;
95        self.target_rps = target_rps;
96        self.avg_latency_ms = stats.avg;
97        self.p95_latency_ms = stats.p95;
98        self.p99_latency_ms = stats.p99;
99        self.error_rate = stats.error_rate;
100        self.timestamp = Utc::now();
101    }
102}
103
104impl Default for PerformanceMetrics {
105    fn default() -> Self {
106        Self::new()
107    }
108}
109
110impl EndpointMetrics {
111    /// Create new endpoint metrics
112    pub fn new() -> Self {
113        Self {
114            request_count: 0,
115            avg_latency_ms: 0.0,
116            p95_latency_ms: 0,
117            p99_latency_ms: 0,
118            error_count: 0,
119            error_rate: 0.0,
120        }
121    }
122}
123
124impl Default for EndpointMetrics {
125    fn default() -> Self {
126        Self::new()
127    }
128}