Skip to main content

vtcode_core/metrics/
sdk_metrics.rs

1use serde::{Deserialize, Serialize};
2
3#[derive(Debug, Clone, Serialize, Deserialize)]
4pub struct SdkMetrics {
5    pub total_generations: u64,
6    pub total_generation_time_ms: u64,
7    pub cache_hits: u64,
8    pub tools_total_generated: u64,
9    pub max_tools_per_generation: u64,
10}
11
12impl SdkMetrics {
13    pub fn new() -> Self {
14        Self {
15            total_generations: 0,
16            total_generation_time_ms: 0,
17            cache_hits: 0,
18            tools_total_generated: 0,
19            max_tools_per_generation: 0,
20        }
21    }
22
23    pub fn record_generation(&mut self, generation_time_ms: u64, tools_count: u64) {
24        self.total_generations += 1;
25        self.total_generation_time_ms += generation_time_ms;
26        self.tools_total_generated += tools_count;
27        if tools_count > self.max_tools_per_generation {
28            self.max_tools_per_generation = tools_count;
29        }
30    }
31
32    pub fn record_cache_hit(&mut self) {
33        self.cache_hits += 1;
34    }
35
36    pub fn avg_generation_time_ms(&self) -> u64 {
37        if self.total_generations > 0 {
38            self.total_generation_time_ms / self.total_generations
39        } else {
40            0
41        }
42    }
43
44    pub fn avg_tools_per_generation(&self) -> u64 {
45        if self.total_generations > 0 {
46            self.tools_total_generated / self.total_generations
47        } else {
48            0
49        }
50    }
51
52    pub fn cache_hit_rate(&self) -> f64 {
53        if self.total_generations > 0 {
54            self.cache_hits as f64 / self.total_generations as f64
55        } else {
56            0.0
57        }
58    }
59}
60
61impl Default for SdkMetrics {
62    fn default() -> Self {
63        Self::new()
64    }
65}
66
67#[cfg(test)]
68mod tests {
69    use super::*;
70
71    #[test]
72    fn test_record_generation() {
73        let mut metrics = SdkMetrics::new();
74        metrics.record_generation(50, 10);
75
76        assert_eq!(metrics.total_generations, 1);
77        assert_eq!(metrics.total_generation_time_ms, 50);
78        assert_eq!(metrics.tools_total_generated, 10);
79    }
80
81    #[test]
82    fn test_avg_generation_time() {
83        let mut metrics = SdkMetrics::new();
84        metrics.record_generation(50, 10);
85        metrics.record_generation(60, 12);
86        metrics.record_generation(40, 8);
87
88        assert_eq!(metrics.avg_generation_time_ms(), 50);
89    }
90
91    #[test]
92    fn test_max_tools() {
93        let mut metrics = SdkMetrics::new();
94        metrics.record_generation(50, 10);
95        metrics.record_generation(60, 25);
96        metrics.record_generation(40, 8);
97
98        assert_eq!(metrics.max_tools_per_generation, 25);
99    }
100
101    #[test]
102    fn test_cache_hit_rate() {
103        let mut metrics = SdkMetrics::new();
104        metrics.record_generation(50, 10);
105        metrics.record_generation(60, 12);
106        metrics.record_cache_hit();
107        metrics.record_cache_hit();
108
109        assert_eq!(metrics.total_generations, 2);
110        assert_eq!(metrics.cache_hits, 2);
111        assert!(metrics.cache_hit_rate() > 0.0);
112    }
113}