use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
use std::thread::{self, JoinHandle};
use std::time::{Duration, Instant};
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct TelemetryItem {
pub pillar: String,
pub event_type: String,
pub payload: serde_json::Value,
pub timestamp_ms: i64,
}
enum QueueMessage {
Item(TelemetryItem),
Flush(SyncSender<()>),
Shutdown,
}
pub struct AsyncTelemetryWriter {
sender: SyncSender<QueueMessage>,
worker_handle: Option<JoinHandle<()>>,
}
impl AsyncTelemetryWriter {
pub fn new(capacity: usize, batch_size: usize, flush_interval: Duration) -> Self {
let (sender, receiver) = sync_channel::<QueueMessage>(capacity);
let handle = thread::spawn(move || {
Self::worker_loop(receiver, batch_size, flush_interval);
});
Self {
sender,
worker_handle: Some(handle),
}
}
#[inline]
pub fn enqueue(&self, item: TelemetryItem) -> Result<(), &'static str> {
match self.sender.try_send(QueueMessage::Item(item)) {
Ok(()) => Ok(()),
Err(std::sync::mpsc::TrySendError::Full(_)) => Err("Telemetry queue full"),
Err(std::sync::mpsc::TrySendError::Disconnected(_)) => Err("Telemetry worker terminated"),
}
}
pub fn flush_sync(&self) -> Result<(), &'static str> {
let (ack_tx, ack_rx) = sync_channel::<()>(1);
self.sender
.send(QueueMessage::Flush(ack_tx))
.map_err(|_| "Failed to send flush signal")?;
ack_rx.recv().map_err(|_| "Flush acknowledgment failed")?;
Ok(())
}
fn worker_loop(
receiver: Receiver<QueueMessage>,
batch_size: usize,
flush_interval: Duration,
) {
let mut buffer = Vec::with_capacity(batch_size);
let mut last_flush = Instant::now();
loop {
let timeout = flush_interval.saturating_sub(last_flush.elapsed());
match receiver.recv_timeout(timeout) {
Ok(QueueMessage::Item(item)) => {
buffer.push(item);
if buffer.len() >= batch_size || last_flush.elapsed() >= flush_interval {
Self::flush_batch(&mut buffer);
last_flush = Instant::now();
}
}
Ok(QueueMessage::Flush(ack)) => {
if !buffer.is_empty() {
Self::flush_batch(&mut buffer);
last_flush = Instant::now();
}
let _ = ack.send(());
}
Ok(QueueMessage::Shutdown) => {
if !buffer.is_empty() {
Self::flush_batch(&mut buffer);
}
break;
}
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
if !buffer.is_empty() {
Self::flush_batch(&mut buffer);
last_flush = Instant::now();
}
}
Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => {
if !buffer.is_empty() {
Self::flush_batch(&mut buffer);
}
break;
}
}
}
}
fn flush_batch(buffer: &mut Vec<TelemetryItem>) {
if buffer.is_empty() {
return;
}
buffer.clear();
}
}
impl Drop for AsyncTelemetryWriter {
fn drop(&mut self) {
let _ = self.sender.send(QueueMessage::Shutdown);
if let Some(handle) = self.worker_handle.take() {
let _ = handle.join();
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_async_writer_enqueue_latency() {
let writer = AsyncTelemetryWriter::new(100_000, 256, Duration::from_millis(10));
let item = TelemetryItem {
pillar: "execution_log".to_string(),
event_type: "benchmark_trace".to_string(),
payload: serde_json::json!({"action": "test", "val": 42}),
timestamp_ms: 123456789,
};
for _ in 0..100 {
let _ = writer.enqueue(item.clone());
}
let iterations = 10_000;
let t0 = Instant::now();
for _ in 0..iterations {
writer.enqueue(item.clone()).expect("Queue should not be full");
}
let total_time = t0.elapsed();
let avg_time_us = total_time.as_micros() as f64 / iterations as f64;
println!("[INV-420] Rust AsyncTelemetryWriter enqueue latency: {:.3}µs", avg_time_us);
crate::utils::assert_within(std::time::Duration::from_secs_f64(avg_time_us / 1e6), std::time::Duration::from_micros(10), "telemetry enqueue latency");
writer.flush_sync().expect("Flush sync should succeed");
}
}