use apalis_rtui_types::LogEntry;
use futures::channel::mpsc::{SendError, Sender, channel};
use std::sync::{Arc, Mutex};
use crate::api::sse::Client;
#[derive(Debug)]
pub struct TracingBroadcaster {
clients: Vec<Sender<LogEntry>>,
}
impl Default for TracingBroadcaster {
fn default() -> Self {
Self::new()
}
}
impl TracingBroadcaster {
#[must_use]
pub fn create() -> Arc<Mutex<Self>> {
Arc::new(Mutex::new(Self::new()))
}
#[must_use]
pub fn new() -> Self {
Self {
clients: Vec::new(),
}
}
pub fn new_client(&mut self) -> Client {
let (tx, rx) = channel(100);
self.clients.push(tx);
Client(rx)
}
pub fn send(&mut self, msg: &LogEntry) -> Result<(), SendError> {
self.clients.retain_mut(|client| {
match client.try_send(msg.clone()) {
Ok(()) => true,
Err(error) => !error.is_disconnected(),
}
});
Ok(())
}
}
#[cfg(test)]
mod tests {
use apalis_rtui_types::{Entry, LogLevel, Span};
use futures::StreamExt as _;
use super::*;
fn frame(message: &str) -> LogEntry {
LogEntry {
span: Some(Span {
attempt: 1,
task_id: "01K7EXAMPLE".to_owned(),
name: "task".to_owned(),
}),
level: LogLevel::Debug,
timestamp: "2024-01-01T00:00:00Z".to_owned(),
target: "apalis::layers::tracing::on_request".to_owned(),
entry: Entry {
message: Some(message.to_owned()),
entry_type: None,
},
}
}
#[test]
fn a_full_client_does_not_starve_a_healthy_one() {
let mut broadcaster = TracingBroadcaster::new();
let _stalled = broadcaster.new_client();
for seq in 0..200 {
broadcaster
.send(&frame(&format!("fill {seq}")))
.expect("send never fails");
}
let healthy = broadcaster.new_client();
for seq in 0..5 {
broadcaster
.send(&frame(&format!("live {seq}")))
.expect("send never fails");
}
drop(broadcaster);
let received: Vec<_> = futures::executor::block_on(healthy.0.collect::<Vec<_>>());
assert_eq!(received.len(), 5, "the healthy client got every live frame");
}
#[test]
fn a_disconnected_client_is_pruned() {
let mut broadcaster = TracingBroadcaster::new();
let kept = broadcaster.new_client();
let dropped = broadcaster.new_client();
assert_eq!(broadcaster.clients.len(), 2);
drop(dropped);
broadcaster.send(&frame("after drop")).expect("send");
assert_eq!(broadcaster.clients.len(), 1);
drop(kept);
broadcaster.send(&frame("after both")).expect("send");
assert_eq!(broadcaster.clients.len(), 0);
}
}