tinylog 4.0.3

A logger for my personal projects.
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use crate::{
	Logger, PrefixOptions,
	util::{Indented, StringLike, with_local_string},
};
use log::{Log, kv};
use std::{fmt, io};

#[cfg(feature = "timestamps")]
use std::time::SystemTime;

impl<T: io::Write + Send + Sync + 'static> Log for Logger<T> {
	fn enabled(&self, _: &log::Metadata) -> bool {
		true
	}

	fn flush(&self) {
		#[allow(unused_mut)]
		let mut output = self.output.lock();
		#[cfg(not(feature = "parking_lot"))]
		let mut output = output.unwrap_or_else(|e| e.into_inner());
		output.flush().expect("failed to flush log output");
	}

	fn log(&self, record: &log::Record) {
		#[cfg(feature = "timestamps")]
		let time = SystemTime::now();

		with_local_string(move |mut buf| {
			buf.clear();

			self.write_prefix(
				&mut buf,
				&record.into(),
				&PrefixOptions {
					align: true,
					#[cfg(feature = "timestamps")]
					time: Some(time),
				},
			);

			let mut indented = Indented::new(&mut buf, 8);
			let args = record.args();
			match args.as_str() {
				Some(str) if !str.is_empty() => {
					indented.reserve(1 + str.len());
					indented.push('\n');
					indented.push_str(str);
				},
				None => {
					indented.push('\n');
					fmt::Write::write_fmt(&mut indented, *args).expect("fmt error");
				},
				_ => (),
			}

			record
				.key_values()
				.visit(&mut KeyValueVisitor(indented))
				.expect("key value visitor failed");

			buf.push('\n');
			#[allow(unused_mut)]
			let mut output = self.output.lock();
			#[cfg(not(feature = "parking_lot"))]
			let mut output = output.unwrap_or_else(|e| e.into_inner());
			output.write_all(buf.as_bytes()).expect("io error");
		})
	}
}

struct KeyValueVisitor<T: StringLike + fmt::Write>(Indented<T>);

impl<'kvs, T: StringLike + fmt::Write> kv::VisitSource<'kvs> for KeyValueVisitor<T> {
	fn visit_pair(&mut self, key: kv::Key<'kvs>, value: kv::Value<'kvs>) -> Result<(), kv::Error> {
		let key_name = key.as_str();
		self.0.reserve(key_name.len() + 3);
		self.0.push('\n');
		self.0.push_str(key_name);
		self.0.push_str(": ");
		self.0.indent += 2;
		let result = value.visit(&mut *self);
		self.0.indent -= 2;
		result
	}
}

impl<'v, T: StringLike + fmt::Write> kv::VisitValue<'v> for KeyValueVisitor<T> {
	fn visit_any(&mut self, value: kv::Value) -> Result<(), kv::Error> {
		fmt::Write::write_fmt(&mut self.0, format_args!("{value:?}"))
			.map_err(|_| kv::Error::msg("fmt error"))
	}

	fn visit_null(&mut self) -> Result<(), kv::Error> {
		self.0.push_str("null");
		Ok(())
	}

	fn visit_u64(&mut self, value: u64) -> Result<(), kv::Error> {
		self.0.push_str(itoa::Buffer::new().format(value));
		Ok(())
	}

	fn visit_i64(&mut self, value: i64) -> Result<(), kv::Error> {
		self.0.push_str(itoa::Buffer::new().format(value));
		Ok(())
	}

	fn visit_u128(&mut self, value: u128) -> Result<(), kv::Error> {
		self.0.push_str(itoa::Buffer::new().format(value));
		Ok(())
	}

	fn visit_i128(&mut self, value: i128) -> Result<(), kv::Error> {
		self.0.push_str(itoa::Buffer::new().format(value));
		Ok(())
	}

	fn visit_f64(&mut self, value: f64) -> Result<(), kv::Error> {
		self.0.push_str(zmij::Buffer::new().format(value));
		Ok(())
	}

	fn visit_bool(&mut self, value: bool) -> Result<(), kv::Error> {
		self.0.push_str(if value { "true" } else { "false" });
		Ok(())
	}

	fn visit_str(&mut self, value: &str) -> Result<(), kv::Error> {
		self.0.push_str(value);
		Ok(())
	}

	fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), kv::Error> {
		self.0.push_str(value);
		Ok(())
	}

	fn visit_char(&mut self, value: char) -> Result<(), kv::Error> {
		self.0.push(value);
		Ok(())
	}
}