use std::fmt::Debug;
use std::fs::File;
use std::io::{self, IsTerminal, Write};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, OnceLock};
use tracing::field::{Field, Visit};
use tracing::{Event, Metadata, Subscriber};
use tracing_subscriber::filter::{FilterExt, filter_fn};
use tracing_subscriber::layer::{Context, Layer, SubscriberExt};
use tracing_subscriber::util::SubscriberInitExt;
use tracing_subscriber::{EnvFilter, fmt};
use super::config::LogLevel;
pub const FRAME_TARGET: &str = "gras::frame";
const TELEMETRY_FILE: &str = "telemetry.jsonl";
static SINK: OnceLock<Sink> = OnceLock::new();
static PENDING: AtomicBool = AtomicBool::new(false);
static ARMED: AtomicBool = AtomicBool::new(false);
const MAX_STARTUP_BYTES: usize = 1 << 20;
pub fn init(level: LogLevel, filter_override: Option<&str>) -> bool {
let base = filter_override.unwrap_or_else(|| level.env_filter());
if let Ok(env) = std::env::var("RUST_LOG")
&& env != base
{
println!("log: RUST_LOG={env} ignored (the configured log level, `{base}`, wins)");
}
let filter = base.to_string();
PENDING.store(true, Ordering::Relaxed);
let console = fmt::layer()
.with_writer(io::stdout)
.with_ansi(false)
.without_time()
.with_target(false)
.with_level(false)
.with_filter(
EnvFilter::new(&filter).and(filter_fn(|m: &Metadata<'_>| m.target() != FRAME_TARGET)),
);
let frame =
FrameLayer::new().with_filter(filter_fn(|m: &Metadata<'_>| m.target() == FRAME_TARGET));
let telemetry = fmt::layer()
.with_writer(SINK.get_or_init(Sink::new).clone())
.with_ansi(false)
.json()
.with_filter(filter_fn(|m: &Metadata<'_>| {
m.target().starts_with("gras")
&& (ARMED.load(Ordering::Relaxed) || PENDING.load(Ordering::Relaxed))
}));
let installed = tracing_subscriber::registry()
.with(console)
.with(frame)
.with(telemetry)
.try_init()
.is_ok();
if !installed {
PENDING.store(false, Ordering::Relaxed);
}
installed
}
pub(crate) fn frame(text: &str) {
tracing::info!(target: FRAME_TARGET, frame = text);
}
pub fn settle_run_dir(run_dir: &Path, trace_file: bool) {
PENDING.store(false, Ordering::Relaxed);
let sink = SINK.get_or_init(Sink::new);
if !trace_file {
sink.lock().buffered.clear();
return;
}
let path = run_dir.join(TELEMETRY_FILE);
let outcome = {
let mut telemetry = sink.lock();
if telemetry.file.is_some() {
return;
}
File::create(&path).map(|mut file| {
let _ = file.write_all(telemetry.buffered.as_bytes());
let _ = file.flush();
telemetry.buffered.clear();
telemetry.file = Some(file);
telemetry.path = Some(path.clone());
})
};
match outcome {
Ok(()) => ARMED.store(true, Ordering::Relaxed),
Err(e) => tracing::warn!("telemetry {} unavailable: {e}", path.display()),
}
}
#[derive(Clone)]
struct Sink(Arc<Mutex<Telemetry>>);
struct Telemetry {
buffered: String,
file: Option<File>,
path: Option<PathBuf>,
}
impl Sink {
fn new() -> Self {
Self(Arc::new(Mutex::new(Telemetry {
buffered: String::new(),
file: None,
path: None,
})))
}
fn lock(&self) -> std::sync::MutexGuard<'_, Telemetry> {
self.0.lock().unwrap_or_else(|e| e.into_inner())
}
}
impl Write for Sink {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
let mut telemetry = self.lock();
match telemetry.file.as_mut() {
Some(file) => file.write(buf),
None => {
if telemetry.buffered.len() < MAX_STARTUP_BYTES {
telemetry.buffered.push_str(&String::from_utf8_lossy(buf));
}
Ok(buf.len())
}
}
}
fn flush(&mut self) -> io::Result<()> {
let mut telemetry = self.lock();
match telemetry.file.as_mut() {
Some(file) => file.flush(),
None => Ok(()),
}
}
}
impl<'a> tracing_subscriber::fmt::MakeWriter<'a> for Sink {
type Writer = Self;
fn make_writer(&'a self) -> Self::Writer {
self.clone()
}
}
struct FrameLayer {
drawn: Mutex<usize>,
}
impl FrameLayer {
fn new() -> Self {
Self {
drawn: Mutex::new(0),
}
}
}
impl<S: Subscriber> Layer<S> for FrameLayer {
fn on_event(&self, event: &Event<'_>, _ctx: Context<'_, S>) {
let mut fields = FrameField::default();
event.record(&mut fields);
let Some(text) = fields.0 else {
return;
};
let mut out = io::stdout().lock();
let mut drawn = self.drawn.lock().unwrap_or_else(|e| e.into_inner());
if *drawn > 0 && out.is_terminal() {
let _ = write!(out, "\x1b[{}A\x1b[0J", *drawn);
}
let _ = writeln!(out, "{text}");
let _ = out.flush();
*drawn = text.lines().count();
}
}
#[derive(Default)]
struct FrameField(Option<String>);
impl Visit for FrameField {
fn record_str(&mut self, field: &Field, value: &str) {
if field.name() == "frame" {
self.0 = Some(value.to_string());
}
}
fn record_debug(&mut self, field: &Field, value: &dyn Debug) {
if field.name() == "frame" {
self.0 = Some(format!("{value:?}"));
}
}
}