clm_rust_core/telemetry/
async_writer.rs1use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
8use std::thread::{self, JoinHandle};
9use std::time::{Duration, Instant};
10
11#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
12pub struct TelemetryItem {
13 pub pillar: String,
14 pub event_type: String,
15 pub payload: serde_json::Value,
16 pub timestamp_ms: i64,
17}
18
19enum QueueMessage {
20 Item(TelemetryItem),
21 Flush(SyncSender<()>),
22 Shutdown,
23}
24
25pub struct AsyncTelemetryWriter {
27 sender: SyncSender<QueueMessage>,
28 worker_handle: Option<JoinHandle<()>>,
29}
30
31impl AsyncTelemetryWriter {
32 pub fn new(capacity: usize, batch_size: usize, flush_interval: Duration) -> Self {
34 let (sender, receiver) = sync_channel::<QueueMessage>(capacity);
35
36 let handle = thread::spawn(move || {
37 Self::worker_loop(receiver, batch_size, flush_interval);
38 });
39
40 Self {
41 sender,
42 worker_handle: Some(handle),
43 }
44 }
45
46 #[inline]
48 pub fn enqueue(&self, item: TelemetryItem) -> Result<(), &'static str> {
49 match self.sender.try_send(QueueMessage::Item(item)) {
50 Ok(()) => Ok(()),
51 Err(std::sync::mpsc::TrySendError::Full(_)) => Err("Telemetry queue full"),
52 Err(std::sync::mpsc::TrySendError::Disconnected(_)) => Err("Telemetry worker terminated"),
53 }
54 }
55
56 pub fn flush_sync(&self) -> Result<(), &'static str> {
58 let (ack_tx, ack_rx) = sync_channel::<()>(1);
59 self.sender
60 .send(QueueMessage::Flush(ack_tx))
61 .map_err(|_| "Failed to send flush signal")?;
62 ack_rx.recv().map_err(|_| "Flush acknowledgment failed")?;
63 Ok(())
64 }
65
66 fn worker_loop(
67 receiver: Receiver<QueueMessage>,
68 batch_size: usize,
69 flush_interval: Duration,
70 ) {
71 let mut buffer = Vec::with_capacity(batch_size);
72 let mut last_flush = Instant::now();
73
74 loop {
75 let timeout = flush_interval.saturating_sub(last_flush.elapsed());
77
78 match receiver.recv_timeout(timeout) {
79 Ok(QueueMessage::Item(item)) => {
80 buffer.push(item);
81 if buffer.len() >= batch_size || last_flush.elapsed() >= flush_interval {
82 Self::flush_batch(&mut buffer);
83 last_flush = Instant::now();
84 }
85 }
86 Ok(QueueMessage::Flush(ack)) => {
87 if !buffer.is_empty() {
88 Self::flush_batch(&mut buffer);
89 last_flush = Instant::now();
90 }
91 let _ = ack.send(());
92 }
93 Ok(QueueMessage::Shutdown) => {
94 if !buffer.is_empty() {
95 Self::flush_batch(&mut buffer);
96 }
97 break;
98 }
99 Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
100 if !buffer.is_empty() {
101 Self::flush_batch(&mut buffer);
102 last_flush = Instant::now();
103 }
104 }
105 Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => {
106 if !buffer.is_empty() {
107 Self::flush_batch(&mut buffer);
108 }
109 break;
110 }
111 }
112 }
113 }
114
115 fn flush_batch(buffer: &mut Vec<TelemetryItem>) {
116 if buffer.is_empty() {
117 return;
118 }
119
120 buffer.clear();
123 }
124}
125
126impl Drop for AsyncTelemetryWriter {
127 fn drop(&mut self) {
128 let _ = self.sender.send(QueueMessage::Shutdown);
129 if let Some(handle) = self.worker_handle.take() {
130 let _ = handle.join();
131 }
132 }
133}
134
135#[cfg(test)]
136mod tests {
137 use super::*;
138
139 #[test]
140 fn test_async_writer_enqueue_latency() {
141 let writer = AsyncTelemetryWriter::new(100_000, 256, Duration::from_millis(10));
142 let item = TelemetryItem {
143 pillar: "execution_log".to_string(),
144 event_type: "benchmark_trace".to_string(),
145 payload: serde_json::json!({"action": "test", "val": 42}),
146 timestamp_ms: 123456789,
147 };
148
149 for _ in 0..100 {
151 let _ = writer.enqueue(item.clone());
152 }
153
154 let iterations = 10_000;
155 let t0 = Instant::now();
156 for _ in 0..iterations {
157 writer.enqueue(item.clone()).expect("Queue should not be full");
158 }
159 let total_time = t0.elapsed();
160 let avg_time_us = total_time.as_micros() as f64 / iterations as f64;
161
162 println!("[INV-420] Rust AsyncTelemetryWriter enqueue latency: {:.3}µs", avg_time_us);
163 crate::utils::assert_within(std::time::Duration::from_secs_f64(avg_time_us / 1e6), std::time::Duration::from_micros(10), "telemetry enqueue latency");
164
165 writer.flush_sync().expect("Flush sync should succeed");
166 }
167}