reclog 0.1.1

Command-line tool to capture command output to a file.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use chrono::{DateTime, Local, TimeDelta};
use clap::ValueEnum;
use rustix::system;
use std::fmt;
use std::time::Instant;

/// How to calculate timestamps.
#[derive(ValueEnum, Debug, Clone, Copy, PartialEq)]
#[clap(rename_all = "kebab_case")]
pub enum TimeSource {
    Wall,
    Elapsed,
    Delta,
}

/// Formats extras: header and timestamps.
pub struct Formatter {
    enable_header: bool,
    enable_time: bool,
    time_format: String,
    time_source: TimeSource,
    command: String,
    base_ts: Option<Instant>,
}

impl Formatter {
    pub fn new(
        enable_header: bool,
        enable_time: bool,
        time_format: &str,
        time_source: TimeSource,
        command: &[String],
    ) -> Self {
        Formatter {
            enable_header,
            enable_time,
            time_format: time_format.into(),
            time_source,
            command: command.join(" "),
            base_ts: None,
        }
    }

    /// True if header should be formatted.
    pub fn need_header(&self) -> bool {
        self.enable_header
    }

    /// Format header to string.
    pub fn format_header(&mut self, result: &mut String) -> fmt::Result {
        let date = Local::now().format("%F %T %z");
        let info = system::uname();

        result.push_str(&format!(
            "# HOST=[{}] OS=[{}_{}] TIME=[{}] CMD=[{}]\n",
            info.nodename().to_str().unwrap(),
            info.sysname().to_str().unwrap().to_lowercase(),
            info.machine().to_str().unwrap(),
            date,
            self.command
        ));

        self.enable_header = false;

        Ok(())
    }

    /// True if timestamp should be formatted.
    pub fn need_timestamp(&self) -> bool {
        self.enable_time
    }

    /// Format timestamp to string.
    pub fn format_timestamp(&mut self, result: &mut String) -> fmt::Result {
        match self.time_source {
            TimeSource::Wall => {
                let now = Local::now();
                now.format(&self.time_format).write_to(result)?;
            }
            TimeSource::Elapsed | TimeSource::Delta => {
                let now = Instant::now();
                if self.base_ts.is_none() {
                    self.base_ts = Some(now);
                }

                let delta = DateTime::UNIX_EPOCH
                    + TimeDelta::from_std(now - self.base_ts.unwrap()).unwrap();
                delta.format(&self.time_format).write_to(result)?;

                if self.time_source == TimeSource::Delta {
                    self.base_ts = Some(now);
                }
            }
        };

        Ok(())
    }
}