rust-a-log 0.1.1

A fast file log viewer and TUI for local and LAN application streams
Documentation
use crate::live::{self, Event, Record, Shared};
use std::fs::File;
use std::io::{self, BufRead, BufReader, Seek, SeekFrom, Write};
use std::path::Path;
use std::process::{Child, Command, Stdio};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::thread;
use std::time::Duration;

pub fn cancellation() -> io::Result<Arc<AtomicBool>> {
    let interrupted = Arc::new(AtomicBool::new(false));
    let flag = interrupted.clone();
    ctrlc::set_handler(move || flag.store(true, Ordering::Relaxed)).map_err(io::Error::other)?;
    Ok(interrupted)
}

pub fn write_event(output: &mut impl Write, event: &Event, json: bool) -> io::Result<()> {
    if json {
        serde_json::to_writer(&mut *output, event)?;
        writeln!(output)?;
    } else {
        writeln!(
            output,
            "{} [{}] {}: {}",
            live::safe_text(&event.record.timestamp),
            event.record.level,
            live::safe_text(&event.source),
            live::safe_text(&event.record.message)
        )?;
    }
    Ok(())
}

pub fn print_live(
    state: &Shared,
    json: bool,
    mut finished: impl FnMut() -> bool,
) -> io::Result<()> {
    let mut output = io::BufWriter::new(io::stdout().lock());
    let (mut sequence, mut rejected, mut dropped) = (0, 0, 0);
    loop {
        let done = finished();
        let (events, errors, last_error, oldest, lost) = {
            let state = state.lock().unwrap();
            (
                state
                    .events
                    .iter()
                    .filter(|event| event.sequence > sequence)
                    .cloned()
                    .collect::<Vec<_>>(),
                state.rejected,
                state.last_error.clone(),
                state.events.front().map(|event| event.sequence),
                state.adapter_dropped,
            )
        };
        if let Some(oldest) = oldest
            && oldest > sequence + 1
        {
            eprintln!(
                "rual: {} records expired before output",
                oldest - sequence - 1
            );
        }
        if errors > rejected {
            eprintln!(
                "rual: rejected client ({errors} total): {}",
                live::safe_text(&last_error)
            );
            rejected = errors;
        }
        if lost > dropped {
            eprintln!("rual: adapters report {lost} discarded records");
            dropped = lost;
        }
        for event in events {
            write_event(&mut output, &event, json)?;
            sequence = event.sequence;
        }
        output.flush()?;
        if done {
            return Ok(());
        }
        thread::sleep(Duration::from_millis(25));
    }
}

pub fn stdin(filter: &crate::Filter) -> io::Result<()> {
    let mut output = io::BufWriter::new(io::stdout().lock());
    stream_lines(&mut io::stdin().lock(), |line| {
        let line = live::safe_text(line);
        if filter.matches(&line) {
            crate::print_record(&mut output, &line)?;
            output.flush()?;
        }
        Ok(())
    })
}

fn stream_lines(
    reader: &mut impl BufRead,
    mut emit: impl FnMut(&str) -> io::Result<()>,
) -> io::Result<()> {
    let mut pending = Vec::new();
    loop {
        match live::frame(reader, &mut pending) {
            Ok(Some(bytes)) => {
                emit(String::from_utf8_lossy(&bytes).trim_end_matches(['\r', '\n']))?
            }
            Ok(None) => continue,
            Err(error) if error.kind() == io::ErrorKind::UnexpectedEof => {
                if !pending.is_empty() {
                    emit(&String::from_utf8_lossy(&pending))?;
                }
                return Ok(());
            }
            Err(error) => return Err(error),
        }
    }
}

struct ChildGuard(Child);
impl Drop for ChildGuard {
    fn drop(&mut self) {
        let _ = self.0.kill();
        let _ = self.0.wait();
    }
}

pub fn run_command(args: &clap::ArgMatches) -> io::Result<u8> {
    if args.get_flag("tui")
        && (!io::IsTerminal::is_terminal(&io::stdin())
            || !io::IsTerminal::is_terminal(&io::stdout()))
    {
        return Err(io::Error::other("TUI requires an interactive terminal"));
    }
    let interrupted = cancellation()?;
    let mut command = args.get_many::<std::ffi::OsString>("command").unwrap();
    let mut child = ChildGuard(
        Command::new(command.next().unwrap())
            .args(command)
            .stdin(Stdio::null())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .spawn()?,
    );
    let state = Shared::default();
    let id = state.lock().unwrap().register(
        args.get_one::<String>("name").unwrap().clone(),
        "process".into(),
    )?;
    let failed = Arc::new(AtomicBool::new(false));
    let workers: Vec<_> = [
        Box::new(child.0.stdout.take().unwrap()) as Box<dyn io::Read + Send>,
        Box::new(child.0.stderr.take().unwrap()) as Box<dyn io::Read + Send>,
    ]
    .into_iter()
    .enumerate()
    .map(|(index, reader)| {
        let state = state.clone();
        let failed = failed.clone();
        thread::spawn(move || {
            let result = stream_lines(&mut BufReader::new(reader), |line| {
                let mut record = Record::from_line(line);
                record.fields["stream"] = if index == 0 { "stdout" } else { "stderr" }.into();
                state.lock().unwrap().push(id, record);
                Ok(())
            });
            if result.is_err() {
                failed.store(true, Ordering::Relaxed);
            }
            result
        })
    })
    .collect();
    if args.get_flag("tui") {
        crate::tui::run(&state, "process capture")?;
        let _ = child.0.kill();
        state.lock().unwrap().disconnect(id);
        return Ok(0);
    } else {
        print_live(&state, args.get_flag("json"), || {
            interrupted.load(Ordering::Relaxed)
                || failed.load(Ordering::Relaxed)
                || workers.iter().all(|worker| worker.is_finished())
        })?;
    }
    if interrupted.load(Ordering::Relaxed) {
        return Ok(130);
    }
    if failed.load(Ordering::Relaxed) {
        return Err(io::Error::other(
            "process output exceeded the 64 KiB record limit or failed to read",
        ));
    }
    for worker in workers {
        worker
            .join()
            .map_err(|_| io::Error::other("capture worker failed"))??;
    }
    state.lock().unwrap().disconnect(id);
    let status = loop {
        if interrupted.load(Ordering::Relaxed) {
            return Ok(130);
        }
        if let Some(status) = child.0.try_wait()? {
            break status;
        }
        thread::sleep(Duration::from_millis(25));
    };
    Ok(status
        .code()
        .and_then(|code| u8::try_from(code).ok())
        .unwrap_or(1))
}

pub fn follow_file(path: &Path, state: Shared, stop: Arc<AtomicBool>) -> io::Result<()> {
    let mut file = File::open(path)?;
    if !file.metadata()?.is_file() {
        return Err(io::Error::other("expected a regular file"));
    }
    let end = file.metadata()?.len();
    let start = crate::tail::find_plain_start(&mut file, end, 100)?;
    file.seek(SeekFrom::Start(start))?;
    let path = path.to_path_buf();
    let id = state
        .lock()
        .unwrap()
        .register(path.to_string_lossy().into(), "file".into())?;
    thread::spawn(move || {
        let result = crate::tail::follow_until(
            &path,
            file,
            Vec::new(),
            |line| {
                state.lock().unwrap().push(id, Record::from_line(line));
                Ok(())
            },
            || !stop.load(Ordering::Relaxed),
            live::MAX_FRAME,
        );
        let mut state = state.lock().unwrap();
        state.disconnect(id);
        if let Err(error) = result {
            state.last_error = format!("file {path:?}: {error}");
            state.rejected += 1;
        }
    });
    Ok(())
}