use std::io::Write;
use std::sync::atomic::{AtomicU64, Ordering};
use astrs_daemon::health::ReportSink;
use astrs_wire::{DaemonEvent, LogLevel, LogRecord, NodeExitCause, NodeId, SpawnOutcome};
use tokio::sync::mpsc;
pub const STREAM_CAPACITY: usize = 4096;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum StreamItem {
Record(Box<LogRecord>),
Notice {
level: LogLevel,
node: Option<NodeId>,
message: String,
},
}
impl StreamItem {
#[must_use]
pub fn level(&self) -> LogLevel {
match self {
Self::Record(record) => record.level,
Self::Notice { level, .. } => *level,
}
}
#[must_use]
pub fn node(&self) -> Option<&NodeId> {
match self {
Self::Record(record) => record.node.as_ref(),
Self::Notice { node, .. } => node.as_ref(),
}
}
#[must_use]
pub fn message(&self) -> &str {
match self {
Self::Record(record) => &record.message,
Self::Notice { message, .. } => message,
}
}
}
#[derive(Debug, Clone)]
pub struct LogFilter {
pub min_level: LogLevel,
pub node: Option<NodeId>,
}
impl Default for LogFilter {
fn default() -> Self {
Self {
min_level: LogLevel::Trace,
node: None,
}
}
}
impl LogFilter {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub const fn with_min_level(mut self, level: LogLevel) -> Self {
self.min_level = level;
self
}
#[must_use]
pub fn with_node(mut self, node: Option<NodeId>) -> Self {
self.node = node;
self
}
#[must_use]
pub fn accepts(&self, item: &StreamItem) -> bool {
if !level_at_least(item.level(), self.min_level) {
return false;
}
match (&self.node, item.node()) {
(Some(wanted), Some(actual)) => wanted == actual,
(Some(_), None) => matches!(item, StreamItem::Notice { .. }),
(None, _) => true,
}
}
}
#[must_use]
pub fn level_at_least(level: LogLevel, floor: LogLevel) -> bool {
severity(level) >= severity(floor)
}
const fn severity(level: LogLevel) -> u8 {
match level {
LogLevel::Trace => 0,
LogLevel::Debug => 1,
LogLevel::Info => 2,
LogLevel::Warn => 3,
LogLevel::Error => 4,
_ => u8::MAX,
}
}
pub fn parse_level(flag: &'static str, text: &str) -> Result<LogLevel, crate::error::CliError> {
match text.trim().to_ascii_lowercase().as_str() {
"trace" => Ok(LogLevel::Trace),
"debug" => Ok(LogLevel::Debug),
"info" => Ok(LogLevel::Info),
"warn" | "warning" => Ok(LogLevel::Warn),
"error" | "err" => Ok(LogLevel::Error),
_ => Err(crate::error::CliError::BadArgument {
flag,
value: text.to_owned(),
reason: "expected one of trace, debug, info, warn, error".to_owned(),
}),
}
}
#[derive(Debug)]
pub struct TerminalLogSink {
sender: mpsc::Sender<StreamItem>,
dropped: AtomicU64,
}
impl TerminalLogSink {
#[must_use]
pub fn new() -> (Self, mpsc::Receiver<StreamItem>) {
let (sender, receiver) = mpsc::channel(STREAM_CAPACITY);
(
Self {
sender,
dropped: AtomicU64::new(0),
},
receiver,
)
}
fn offer(&self, item: StreamItem) {
if self.sender.try_send(item).is_err() {
self.dropped.fetch_add(1, Ordering::Relaxed);
}
}
}
impl ReportSink for TerminalLogSink {
fn report(&self, event: DaemonEvent) {
match event {
DaemonEvent::Log { records, .. } => {
for record in records {
self.offer(StreamItem::Record(Box::new(record)));
}
}
DaemonEvent::SpawnResult { node, outcome, .. } => {
if let Some(message) = spawn_failure_text(&outcome) {
self.offer(StreamItem::Notice {
level: LogLevel::Error,
node: Some(node),
message,
});
}
}
DaemonEvent::NodeStopped {
node,
cause,
restarting,
..
} => {
self.offer(StreamItem::Notice {
level: exit_level(&cause),
node: Some(node),
message: exit_text(&cause, restarting),
});
}
_ => {}
}
}
fn dropped(&self) -> u64 {
self.dropped.load(Ordering::Relaxed)
}
fn is_open(&self) -> bool {
!self.sender.is_closed()
}
}
fn spawn_failure_text(outcome: &SpawnOutcome) -> Option<String> {
match outcome {
SpawnOutcome::Spawned { .. } | SpawnOutcome::AwaitingDynamic => None,
SpawnOutcome::Failed { message, errno } => Some(match errno {
Some(number) => format!("failed to spawn: {message} (errno {number})"),
None => format!("failed to spawn: {message}"),
}),
SpawnOutcome::Cancelled => Some("spawn cancelled: the dataflow stopped first".to_owned()),
other => Some(format!("spawn did not start the node: {other:?}")),
}
}
fn exit_level(cause: &NodeExitCause) -> LogLevel {
if cause.is_failure() {
LogLevel::Error
} else {
LogLevel::Info
}
}
fn exit_text(cause: &NodeExitCause, restarting: bool) -> String {
if restarting {
format!("exited ({cause}); restarting")
} else {
format!("exited ({cause})")
}
}
#[derive(Debug, Clone, Copy)]
pub struct LogStyle {
pub color: bool,
pub prefix_width: usize,
pub elapsed: bool,
}
impl Default for LogStyle {
fn default() -> Self {
Self {
color: false,
prefix_width: 0,
elapsed: true,
}
}
}
#[must_use]
pub fn render(item: &StreamItem, style: LogStyle, elapsed: std::time::Duration) -> String {
let mut line = String::with_capacity(item.message().len() + 32);
if style.elapsed {
line.push_str(&format!("{:>8.3}s ", elapsed.as_secs_f64()));
}
let name = item
.node()
.map_or_else(|| "astrs".to_owned(), |node| node.as_str().to_owned());
let padded = if name.len() >= style.prefix_width {
name.clone()
} else {
format!("{name:<width$}", width = style.prefix_width)
};
if style.color {
line.push_str(&format!("{}[{padded}]{} ", node_color(&name), ansi::RESET));
} else {
line.push_str(&format!("[{padded}] "));
}
let level = item.level();
if level_at_least(level, LogLevel::Warn) {
if style.color {
line.push_str(&format!(
"{}{}{} ",
level_color(level),
level_tag(level),
ansi::RESET
));
} else {
line.push_str(&format!("{} ", level_tag(level)));
}
}
line.push_str(item.message());
line
}
const fn level_tag(level: LogLevel) -> &'static str {
match level {
LogLevel::Trace => "TRACE",
LogLevel::Debug => "DEBUG",
LogLevel::Info => "INFO",
LogLevel::Warn => "WARN",
LogLevel::Error => "ERROR",
_ => "LOG",
}
}
mod ansi {
pub const RESET: &str = "\x1b[0m";
pub const PALETTE: &[&str] = &[
"\x1b[36m", "\x1b[35m", "\x1b[32m", "\x1b[34m", "\x1b[33m", "\x1b[31m", ];
pub const YELLOW: &str = "\x1b[33m";
pub const RED: &str = "\x1b[31m";
}
fn node_color(name: &str) -> &'static str {
let mut hash: u64 = 0xcbf2_9ce4_8422_2325;
for byte in name.as_bytes() {
hash ^= u64::from(*byte);
hash = hash.wrapping_mul(0x0000_0100_0000_01b3);
}
let index = usize::try_from(hash % ansi::PALETTE.len() as u64).unwrap_or(0);
ansi::PALETTE.get(index).copied().unwrap_or(ansi::RESET)
}
const fn level_color(level: LogLevel) -> &'static str {
match level {
LogLevel::Error => ansi::RED,
_ => ansi::YELLOW,
}
}
pub async fn print_stream(
receiver: &mut mpsc::Receiver<StreamItem>,
out: &mut (dyn Write + Send),
filter: &LogFilter,
style: LogStyle,
started: std::time::Instant,
) -> usize {
let mut printed = 0;
while let Some(item) = receiver.recv().await {
if !filter.accepts(&item) {
continue;
}
let line = render(&item, style, started.elapsed());
if writeln!(out, "{line}").is_err() {
break;
}
let _ = out.flush();
printed += 1;
}
printed
}
#[must_use]
pub fn prefix_width<'a>(names: impl IntoIterator<Item = &'a str>) -> usize {
names
.into_iter()
.map(str::len)
.max()
.unwrap_or(0)
.max("astrs".len())
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::*;
use astrs_time::HlcTimestamp;
fn node(name: &str) -> NodeId {
NodeId::new(name).unwrap()
}
fn record(level: LogLevel, name: &str, message: &str) -> StreamItem {
StreamItem::Record(Box::new(
LogRecord::new(HlcTimestamp::new(1, 0), level, message).with_node(node(name)),
))
}
#[test]
fn severities_are_ordered_trace_to_error() {
assert!(level_at_least(LogLevel::Error, LogLevel::Trace));
assert!(level_at_least(LogLevel::Info, LogLevel::Info));
assert!(!level_at_least(LogLevel::Debug, LogLevel::Info));
}
#[test]
fn a_level_filter_hides_what_is_below_it() {
let filter = LogFilter::new().with_min_level(LogLevel::Warn);
assert!(!filter.accepts(&record(LogLevel::Info, "cam", "hi")));
assert!(filter.accepts(&record(LogLevel::Warn, "cam", "hi")));
assert!(filter.accepts(&record(LogLevel::Error, "cam", "hi")));
}
#[test]
fn a_node_filter_keeps_only_that_node_but_never_hides_a_global_notice() {
let filter = LogFilter::new().with_node(Some(node("cam")));
assert!(filter.accepts(&record(LogLevel::Info, "cam", "mine")));
assert!(!filter.accepts(&record(LogLevel::Info, "detect", "theirs")));
assert!(filter.accepts(&StreamItem::Notice {
level: LogLevel::Error,
node: None,
message: "the dataflow failed".to_owned(),
}));
}
#[test]
fn parse_level_accepts_the_spellings_a_user_types() {
assert_eq!(parse_level("level", "WARN").unwrap(), LogLevel::Warn);
assert_eq!(parse_level("level", "warning").unwrap(), LogLevel::Warn);
assert_eq!(parse_level("level", " error ").unwrap(), LogLevel::Error);
let error = parse_level("level", "loud").unwrap_err();
assert!(error.to_string().contains("trace"), "{error}");
}
#[test]
fn rendering_pads_the_node_column_and_omits_a_tag_below_warn() {
let style = LogStyle {
color: false,
prefix_width: 8,
elapsed: false,
};
let line = render(
&record(LogLevel::Info, "cam", "frame 1"),
style,
std::time::Duration::ZERO,
);
assert_eq!(line, "[cam ] frame 1");
let line = render(
&record(LogLevel::Error, "cam", "boom"),
style,
std::time::Duration::ZERO,
);
assert_eq!(line, "[cam ] ERROR boom");
}
#[test]
fn rendering_with_color_wraps_the_prefix_and_resets() {
let style = LogStyle {
color: true,
prefix_width: 0,
elapsed: false,
};
let line = render(
&record(LogLevel::Info, "cam", "hi"),
style,
std::time::Duration::ZERO,
);
assert!(line.contains("\x1b["), "{line}");
assert!(line.ends_with("hi"), "{line}");
assert!(line.contains(ansi::RESET));
}
#[test]
fn elapsed_is_rendered_when_asked_for() {
let style = LogStyle {
color: false,
prefix_width: 0,
elapsed: true,
};
let line = render(
&record(LogLevel::Info, "cam", "hi"),
style,
std::time::Duration::from_millis(1500),
);
assert!(line.starts_with(" 1.500s "), "{line}");
}
#[test]
fn a_node_keeps_one_color_across_calls() {
assert_eq!(node_color("camera"), node_color("camera"));
}
#[test]
fn the_prefix_width_never_shrinks_below_the_cli_s_own_name() {
assert_eq!(prefix_width(["a", "bb"]), "astrs".len());
assert_eq!(prefix_width(["a-very-long-node"]), "a-very-long-node".len());
assert_eq!(prefix_width(std::iter::empty()), "astrs".len());
}
#[tokio::test]
async fn the_sink_turns_daemon_log_events_into_stream_items() {
let (sink, mut receiver) = TerminalLogSink::new();
sink.report(DaemonEvent::Log {
request: None,
records: vec![
LogRecord::new(HlcTimestamp::new(1, 0), LogLevel::Info, "one")
.with_node(node("cam")),
LogRecord::new(HlcTimestamp::new(2, 0), LogLevel::Error, "two")
.with_node(node("cam")),
],
truncated: false,
});
assert_eq!(receiver.recv().await.unwrap().message(), "one");
assert_eq!(receiver.recv().await.unwrap().message(), "two");
assert_eq!(sink.dropped(), 0);
}
#[tokio::test]
async fn the_sink_summarizes_a_node_exit_and_marks_a_restart() {
let (sink, mut receiver) = TerminalLogSink::new();
sink.report(DaemonEvent::NodeStopped {
dataflow: astrs_wire::DataflowId::from_u128(1),
node: node("cam"),
generation: 0,
cause: NodeExitCause::ExitCode { code: 3 },
restarting: true,
});
let item = receiver.recv().await.unwrap();
assert_eq!(item.level(), LogLevel::Error);
assert!(item.message().contains("restarting"), "{item:?}");
}
#[tokio::test]
async fn the_sink_ignores_traffic_a_terminal_does_not_want() {
let (sink, mut receiver) = TerminalLogSink::new();
sink.report(DaemonEvent::StateCatchUpAck { seq: 1, applied: 0 });
assert!(
receiver.try_recv().is_err(),
"a catch-up acknowledgement is not news"
);
}
#[tokio::test]
async fn the_sink_counts_what_does_not_fit_instead_of_blocking() {
let (sink, receiver) = TerminalLogSink::new();
for index in 0..(STREAM_CAPACITY + 8) {
sink.report(DaemonEvent::Log {
request: None,
records: vec![LogRecord::new(
HlcTimestamp::new(1, 0),
LogLevel::Info,
format!("line {index}"),
)],
truncated: false,
});
}
assert_eq!(sink.dropped(), 8, "the overflow is counted, not queued");
drop(receiver);
assert!(!sink.is_open());
}
#[tokio::test]
async fn printing_applies_the_filter_and_stops_when_the_senders_go() {
let (sink, mut receiver) = TerminalLogSink::new();
sink.report(DaemonEvent::Log {
request: None,
records: vec![
LogRecord::new(HlcTimestamp::new(1, 0), LogLevel::Debug, "quiet")
.with_node(node("cam")),
LogRecord::new(HlcTimestamp::new(2, 0), LogLevel::Error, "loud")
.with_node(node("cam")),
],
truncated: false,
});
drop(sink);
let mut out: Vec<u8> = Vec::new();
let filter = LogFilter::new().with_min_level(LogLevel::Warn);
let style = LogStyle {
color: false,
prefix_width: 0,
elapsed: false,
};
let printed = print_stream(
&mut receiver,
&mut out,
&filter,
style,
std::time::Instant::now(),
)
.await;
assert_eq!(printed, 1);
let text = String::from_utf8(out).unwrap();
assert!(text.contains("loud"), "{text}");
assert!(!text.contains("quiet"), "{text}");
}
}