//! JSON-lines logging of the parent (STORAGE.md §3.7): one object per line on stdout, an //! allowlist of fields, values authored by the worker only. Text a child wrote is escaped //! by the JSON encoder and truncated; no key, no token, no user content ever reaches a line. use std::io::Write; use std::sync::OnceLock; use std::time::{SystemTime, UNIX_EPOCH}; use serde_json::{Map, Value}; static WORKER_ID: OnceLock = OnceLock::new(); /// Tags every later line with the worker id (first call wins). pub fn set_worker_id(id: &str) { let _ = WORKER_ID.set(id.to_owned()); } /// Longest child stderr excerpt kept in a line. pub const CHILD_STDERR_MAX: usize = 200; /// One line under construction. #[must_use = "a log line is written by emit()"] pub struct LogLine { fields: Map, } pub fn info(event: &str) -> LogLine { LogLine::new("info", event) } pub fn warn(event: &str) -> LogLine { LogLine::new("warn", event) } pub fn error(event: &str) -> LogLine { LogLine::new("error", event) } impl LogLine { fn new(level: &str, event: &str) -> Self { let mut fields = Map::new(); fields.insert("ts".into(), Value::from(unix_seconds())); fields.insert("level".into(), Value::from(level)); fields.insert("event".into(), Value::from(event)); if let Some(id) = WORKER_ID.get() { fields.insert("worker_id".into(), Value::from(id.as_str())); } Self { fields } } fn with(mut self, key: &str, value: impl Into) -> Self { self.fields.insert(key.to_owned(), value.into()); self } pub fn asset(self, id: &str) -> Self { self.with("asset_id", id) } /// A sheet verification round (V1-2.3). pub fn review(self, id: &str) -> Self { self.with("review_id", id) } pub fn stage(self, stage: &str) -> Self { self.with("stage", stage) } pub fn code(self, code: &str) -> Self { self.with("code", code) } pub fn signal(self, signal: i32) -> Self { self.with("signal", signal) } pub fn http_status(self, status: u16) -> Self { self.with("http_status", status) } pub fn duration_ms(self, ms: u128) -> Self { self.with("duration_ms", u64::try_from(ms).unwrap_or(u64::MAX)) } pub fn count(self, count: usize) -> Self { self.with("count", u64::try_from(count).unwrap_or(u64::MAX)) } /// Worker-authored text only (never a child's or a server's free text). pub fn detail(self, detail: &str) -> Self { self.with("detail", detail) } /// Child-controlled text: truncated on a character boundary, escaped by the encoder. pub fn child_stderr(self, text: &str) -> Self { self.with("child_stderr", truncate(text, CHILD_STDERR_MAX)) } /// Renders the line (tests read it, `emit` writes it). pub fn render(&self) -> String { Value::Object(self.fields.clone()).to_string() } pub fn emit(self) { let stdout = std::io::stdout(); let mut lock = stdout.lock(); let _ = writeln!(lock, "{}", self.render()); let _ = lock.flush(); } } fn truncate(text: &str, max: usize) -> &str { if text.len() <= max { return text; } let mut end = max; while !text.is_char_boundary(end) { end -= 1; } &text[..end] } fn unix_seconds() -> u64 { SystemTime::now() .duration_since(UNIX_EPOCH) .map(|d| d.as_secs()) .unwrap_or(0) } #[cfg(test)] mod tests { #![allow(clippy::unwrap_used)] use super::*; #[test] fn lines_are_json_objects_with_the_allowlisted_fields() { let line = info("job_done") .asset("a1") .stage("commit") .duration_ms(12) .render(); let value: Value = serde_json::from_str(&line).unwrap(); assert_eq!(value["event"], "job_done"); assert_eq!(value["asset_id"], "a1"); assert_eq!(value["stage"], "commit"); assert_eq!(value["duration_ms"], 12); assert!(value["ts"].as_u64().is_some()); } #[test] fn child_text_is_escaped_and_truncated() { let hostile = format!("line\n\u{1b}[31mred\"quote{}", "é".repeat(300)); let line = warn("child").child_stderr(&hostile).render(); assert!(!line.contains('\n')); assert!(!line.contains('\u{1b}')); let value: Value = serde_json::from_str(&line).unwrap(); let kept = value["child_stderr"].as_str().unwrap(); assert!(kept.len() <= CHILD_STDERR_MAX); assert!(kept.starts_with("line\n")); } }