use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use std::collections::VecDeque;
use std::sync::{Arc, Mutex};
use std::time::{SystemTime, UNIX_EPOCH};
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
pub struct LogEntry {
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
pub timestamp_ms: u64,
#[serde(skip_serializing_if = "Option::is_none")]
pub direction: Option<String>,
pub event: LogEvent,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
#[serde(tag = "event", rename_all = "snake_case")]
pub enum LogEvent {
RxData {
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
bytes: usize,
},
TxData {
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
bytes: usize,
},
Open,
Close,
Disconnect { error: String },
ReconnectStart {
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
attempt: u32,
},
ReconnectSuccess,
ReconnectFailed {
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
attempt: u32,
error: String,
},
ReconnectExhausted,
MatchFound { pattern: String, mode: String },
Truncated {
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
observed: usize,
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
returned: usize,
},
ReadStarted,
ReadCompleted {
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
bytes: usize,
},
WriteStarted,
WriteCompleted {
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
bytes: usize,
},
Error { message: String },
}
#[derive(Debug)]
pub struct LogBuffer {
events: Mutex<VecDeque<LogEntry>>,
capacity: usize,
enabled: bool,
}
impl LogBuffer {
pub fn new(capacity: usize, enabled: bool) -> Self {
Self {
events: Mutex::new(VecDeque::with_capacity(capacity)),
capacity,
enabled,
}
}
pub fn is_enabled(&self) -> bool {
self.enabled
}
pub fn capacity(&self) -> usize {
self.capacity
}
pub fn record(&self, direction: Option<&str>, event: LogEvent) {
if !self.enabled {
return;
}
let timestamp_ms = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_millis() as u64)
.unwrap_or(0);
let entry = LogEntry {
timestamp_ms,
direction: direction.map(str::to_string),
event,
};
let mut events = self.events.lock().expect("log mutex poisoned");
events.push_back(entry);
while events.len() > self.capacity {
events.pop_front();
}
}
pub fn snapshot(&self) -> Vec<LogEntry> {
let events = self.events.lock().expect("log mutex poisoned");
events.iter().cloned().collect()
}
pub fn jsonl_snapshot(&self, max_bytes: u64) -> Result<JsonlSnapshot, String> {
let events = self.events.lock().expect("log mutex poisoned");
let mut out: Vec<u8> = Vec::new();
let mut count: usize = 0;
for entry in events.iter() {
let line = serde_json::to_string(entry)
.map_err(|e| format!("Failed to serialize log entry: {e}"))?;
let out_len =
u64::try_from(out.len()).map_err(|_| "log snapshot size overflow".to_string())?;
let line_len = u64::try_from(line.len())
.map_err(|_| "log snapshot line size overflow".to_string())?;
let needed = line_len
.checked_add(1)
.ok_or_else(|| "log snapshot line size overflow".to_string())?;
let projected = out_len
.checked_add(needed)
.ok_or_else(|| "log snapshot size overflow".to_string())?;
if projected > max_bytes {
return Err(format!(
"log snapshot exceeds capture per-file quota ({max_bytes} bytes); \
reduce log_capacity or raise --capture-max-file-bytes"
));
}
out.extend_from_slice(line.as_bytes());
out.push(b'\n');
count = count
.checked_add(1)
.ok_or_else(|| "log snapshot event count overflow".to_string())?;
}
Ok(JsonlSnapshot {
bytes: out,
events: count,
})
}
pub fn clear(&self) {
let mut events = self.events.lock().expect("log mutex poisoned");
events.clear();
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct JsonlSnapshot {
pub bytes: Vec<u8>,
pub events: usize,
}
impl Default for LogBuffer {
fn default() -> Self {
Self::new(1024, false)
}
}
impl LogBuffer {
pub fn new_shared(capacity: usize, enabled: bool) -> Arc<Self> {
Arc::new(Self::new(capacity, enabled))
}
}
impl LogBuffer {
pub fn rx_data(&self, bytes: usize) {
self.record(Some("rx"), LogEvent::RxData { bytes });
}
pub fn tx_data(&self, bytes: usize) {
self.record(Some("tx"), LogEvent::TxData { bytes });
}
pub fn opened(&self) {
self.record(None, LogEvent::Open);
}
pub fn closed(&self) {
self.record(None, LogEvent::Close);
}
pub fn match_found(&self, pattern: &str, mode: &str) {
self.record(
None,
LogEvent::MatchFound {
pattern: pattern.to_string(),
mode: mode.to_string(),
},
);
}
pub fn truncated(&self, observed: usize, returned: usize) {
self.record(None, LogEvent::Truncated { observed, returned });
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn log_buffer_records_and_snapshots() {
let log = LogBuffer::new(10, true);
log.rx_data(5);
log.tx_data(3);
let snap = log.snapshot();
assert_eq!(snap.len(), 2);
assert!(snap[0].timestamp_ms > 0);
}
#[test]
fn log_buffer_disabled_does_not_record() {
let log = LogBuffer::new(10, false);
log.rx_data(5);
assert!(log.snapshot().is_empty());
}
#[test]
fn log_buffer_evicts_when_capacity_exceeded() {
let log = LogBuffer::new(3, true);
for i in 0..5 {
log.rx_data(i);
}
let snap = log.snapshot();
assert_eq!(snap.len(), 3);
if let LogEvent::RxData { bytes } = &snap[0].event {
assert_eq!(*bytes, 2);
}
}
#[test]
fn log_buffer_clear_empties() {
let log = LogBuffer::new(10, true);
log.rx_data(1);
log.tx_data(2);
log.clear();
assert!(log.snapshot().is_empty());
}
#[test]
fn log_entry_serialization_is_jsonl_compatible() {
let log = LogBuffer::new(10, true);
log.rx_data(42);
let snap = log.snapshot();
let json = serde_json::to_string(&snap[0]).unwrap();
assert!(json.contains("\"event\":\"rx_data\""));
assert!(json.contains("\"bytes\":42"));
assert!(json.contains("\"direction\":\"rx\""));
}
#[test]
fn jsonl_snapshot_matches_get_log_snapshot() {
let log = LogBuffer::new(10, true);
log.opened();
log.rx_data(5);
log.tx_data(3);
log.match_found("OK", "literal_substring");
let snap = log.jsonl_snapshot(u64::MAX).unwrap();
assert_eq!(snap.events, 4);
let text = String::from_utf8(snap.bytes.clone()).unwrap();
assert_eq!(text.lines().count(), 4);
assert!(text.ends_with('\n'));
let expected: Vec<LogEntry> = log.snapshot();
for (i, line) in text.lines().enumerate() {
let parsed: LogEntry = serde_json::from_str(line).unwrap();
assert_eq!(parsed, expected[i]);
}
}
#[test]
fn jsonl_snapshot_exact_limit_and_one_byte_over() {
let log = LogBuffer::new(10, true);
log.rx_data(1);
log.rx_data(2);
let unlimited = log.jsonl_snapshot(u64::MAX).unwrap();
assert!(!unlimited.bytes.is_empty());
let exact = log.jsonl_snapshot(unlimited.bytes.len() as u64).unwrap();
assert_eq!(exact.bytes, unlimited.bytes);
assert_eq!(exact.events, unlimited.events);
let err = log
.jsonl_snapshot(unlimited.bytes.len() as u64 - 1)
.unwrap_err();
assert!(err.contains("quota"), "got: {err}");
assert!(log.jsonl_snapshot(0).is_err());
let empty = LogBuffer::new(10, true);
let snap = empty.jsonl_snapshot(0).unwrap();
assert!(snap.bytes.is_empty());
assert_eq!(snap.events, 0);
}
#[test]
fn jsonl_snapshot_disabled_log_is_zero_bytes() {
let log = LogBuffer::new(10, false);
log.rx_data(5);
let snap = log.jsonl_snapshot(u64::MAX).unwrap();
assert!(snap.bytes.is_empty());
assert_eq!(snap.events, 0);
}
#[test]
fn jsonl_snapshot_is_point_in_time_under_concurrent_records() {
let log = LogBuffer::new(1000, true);
log.rx_data(1);
let snap = log.jsonl_snapshot(u64::MAX).unwrap();
assert_eq!(snap.events, 1);
log.rx_data(2);
log.rx_data(3);
let lines = String::from_utf8(snap.bytes).unwrap();
assert_eq!(lines.lines().count(), 1);
assert!(!lines.contains("\"bytes\":2"));
assert!(!lines.contains("\"bytes\":3"));
}
}