bflog 0.1.0

Very tiny logging framework made for microservices.
Documentation 
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
99
100
101

use chrono::prelude::*;
use serde_json;
use std::env;
use std::io::{self, Write};

use super::prelude::*;

pub struct Log {
  pub format: Format,
  pub level: Severity,
}

impl Logging for Log {
  fn raw_msg(&self, severity: Severity, msg: &str) -> io::Result<Option<ContextWriter>> {
    if severity.to_level() < self.level.to_level() {
      return Ok(None);
    }

    let mut output = Output::new(&severity);

    match self.format {
      Format::Json => {
        output.write(b"{\"time\":\"")?;
        write_time(&mut output)?;

        write!(
          &mut output,
          "\",\"severity\":\"{}\",\"message\":",
          severity.to_str()
        )?;

        serde_json::to_writer(&mut output, msg)?;
      }

      ref format => {
        if format.is_colored() {
          output.set_color(Color::BrightBlack)?;
        }

        write_time(&mut output)?;

        if format.is_colored() {
          output.set_color(match severity {
            Severity::Debug => Color::Magenta,
            Severity::Info => Color::BrightBlue,
            Severity::Warn => Color::BrightYellow,
            Severity::Error => Color::BrightRed,
          })?;
        }

        if format.has_icons() {
          write!(&mut output, " {}", severity.to_icon())?;
        }

        write!(&mut output, " {} ", severity.to_aligned_str())?;

        if format.is_colored() {
          output.reset_colors()?;
        }

        output.write(msg.as_bytes())?;
      }
    }

    Ok(Some(ContextWriter::new(self.format.clone(), output)))
  }
}

impl Default for Log {
  fn default() -> Log {
    Log {
      // Load level from the BFLOG_LEVEL env var.
      level: env::var("BFLOG_LEVEL")
        .ok()
        .and_then(Severity::from_str)
        .unwrap_or_default(),

      // Load format from the BFLOG_FORMAT env var.
      format: env::var("BFLOG_FORMAT")
        .ok()
        .and_then(Format::from_str)
        .unwrap_or_default(),
    }
  }
}

fn write_time(output: &mut impl io::Write) -> io::Result<()> {
  let time = Local::now();

  write!(
    output,
    "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}{}",
    time.year(),
    time.month(),
    time.day(),
    time.hour(),
    time.minute(),
    time.second(),
    time.offset(),
  )
}