loglite/

lib.rs

//! # loglite
//! Simple and lite logging facility with different log levels and only few dependencies

mod global;
pub use global::*;
pub use syslog_client::syslog::Facility;

use chrono::prelude::*;

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

use std::fmt::Debug;
use std::fs::File;
use std::io::{self, BufWriter, Write};
use std::os::unix::fs::PermissionsExt;
use std::path::Path;
use std::sync::{Arc, Mutex};

use syslog_client::syslog::header::*;
use syslog_client::writer::transport::*;
use syslog_client::*;

/// Logging Level
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub enum LogLevel {
	Debug,
	Info,
	Warning,
	Error,
	Critical,
}

pub trait LogOutput: Debug + Write + Send + Sync {}
impl<T: Debug + Write + Send + Sync> LogOutput for T {}

pub trait Logging: Send + Sync {
	/// Default output fn for the log, which has to be implemented
	fn output(&self, level: LogLevel, text: &str) -> Result<(), io::Error>;

	/// Flushes any remaining data to the file
	fn flush(&self) -> Result<(), io::Error>;

	/// Writes out a message as [LogLevel::Error]
	fn error(&self, text: &str) -> Result<(), io::Error> {
		self.output(LogLevel::Error, text)
	}

	/// Writes out a message as [LogLevel::Warning]
	fn warning(&self, text: &str) -> Result<(), io::Error> {
		self.output(LogLevel::Warning, text)
	}

	/// Writes out a message as [LogLevel::Info]
	fn info(&self, text: &str) -> Result<(), io::Error> {
		self.output(LogLevel::Info, text)
	}

	/// Writes out a message as [LogLevel::Debug]
	fn debug(&self, text: &str) -> Result<(), io::Error> {
		self.output(LogLevel::Debug, text)
	}

	/// Writes out a message as [LogLevel::Critical]
	fn critical(&self, text: &str) -> Result<(), io::Error> {
		self.output(LogLevel::Critical, text)
	}
}

/// Creates a new instance of [Logging] which voids the data written to
/// Comparable to [io::Sink]
#[derive(Default)]
pub struct VoidLog {}

impl Logging for VoidLog {
	fn output(&self, _: LogLevel, _: &str) -> Result<(), io::Error> {
		Ok(())
	}

	fn flush(&self) -> Result<(), io::Error> {
		Ok(())
	}
}

// syslog protocol
pub struct SysLog {
	writer: Mutex<Rfc3164BufferedLogger<Unix<'static>>>,
	min_level: LogLevel,
}

impl SysLog {
	const MAPPING: [Severity; 5] = [
		Severity::LOG_DEBUG,
		Severity::LOG_INFO,
		Severity::LOG_WARNING,
		Severity::LOG_ERR,
		Severity::LOG_CRIT,
	];
	/// Creates a new log from any type implementing [Write] and [Debug]
	pub fn new(facility: Facility, tag: &str, min_logging_level: LogLevel) -> Option<Self> {
		let hostname = hostname::get().unwrap().into_string().ok()?;
		let syslog = Syslog::new(
			facility,
			Hostname::new(&hostname)?,
			Tag::new(tag)?,
		);
		Some(Self {
			min_level: min_logging_level,
			writer: Mutex::new(
				Rfc3164Logger::new(syslog, Unix::new_system()?).with_buffer(),
			),
		})
	}
}

impl Logging for SysLog {
	fn output(&self, level: LogLevel, text: &str) -> Result<(), io::Error> {
		if level < self.min_level {
			return Ok(());
		}
		let writer = &mut *self.writer.lock().unwrap();
		writer.write_str(Self::MAPPING[level as usize], text)
	}

	fn flush(&self) -> Result<(), io::Error> {
		Ok(())
	}
}

pub struct GenericLog {
	file: Arc<Mutex<dyn LogOutput>>,
	timestamp: bool,
	min_logging_level: LogLevel,
}

impl GenericLog {
	/// Creates a new log from any type implementing [Write] and [Debug]
	pub fn from_writer<T: LogOutput + 'static>(
		writer: T,
		timestamp: bool,
		min_logging_level: LogLevel,
	) -> Self {
		Self {
			file: Arc::new(Mutex::new(writer)),
			timestamp,
			min_logging_level,
		}
	}
}

impl Logging for GenericLog {
	fn output(&self, level: LogLevel, text: &str) -> Result<(), io::Error> {
		if level < self.min_logging_level {
			return Ok(());
		}
		let writer = &mut *self.file.lock().unwrap();
		match self.timestamp {
			true => writer.write_all(
				format!(
					"({}) [{level:?}]: {text}\n",
					Utc::now().format("%Y.%m.%d-%H:%M:%S")
				)
				.as_bytes(),
			)?,
			false => writer.write_all(format!("[{level:?}]: {text}\n").as_bytes())?,
		};
		Ok(())
	}

	fn flush(&self) -> Result<(), io::Error> {
		(*self.file.lock().unwrap()).flush()
	}
}

impl Drop for GenericLog {
	fn drop(&mut self) {
		self.flush()
			.map_err(|e| eprintln!("Error flushing log file! {e}"))
			.ok();
	}
}

/// Log instance
pub struct FileLog {
	file: Mutex<BufWriter<File>>,
	timestamp: bool,
	min_logging_level: LogLevel,
}

impl FileLog {
	#[cfg(target_family = "unix")]
	const FILE_MODE: u32 = 0o664;

	/// Creates a new [Logging] instance with a given path to write to
	/// `timestamp`: determins whether or not to write the current timestamp into the log
	pub fn new<P: AsRef<Path> + ?Sized>(
		file: &P,
		timestamp: bool,
		min_logging_level: LogLevel,
	) -> Result<Self, io::Error> {
		let fd = Self::get_file(file).map_err(|e| {
			io::Error::new(
				e.kind(),
				format!(
					"Logfile '{}' couldn't be opened/created.",
					file.as_ref().display()
				),
			)
		})?;
		Ok(Self {
			file: Mutex::new(BufWriter::new(fd)),
			timestamp,
			min_logging_level,
		})
	}

	fn get_file<P: AsRef<Path> + ?Sized>(file: &P) -> Result<File, io::Error> {
		match file.as_ref().exists() {
			true => std::fs::OpenOptions::new()
				.append(true)
				.read(false)
				.open(file),
			false => {
				let f = File::create(file)?;
				#[cfg(target_family = "unix")]
				Self::set_perms(file)?;
				Ok(f)
			}
		}
	}

	#[cfg(target_family = "unix")]
	fn set_perms<P: AsRef<Path> + ?Sized>(path: &P) -> Result<(), io::Error> {
		let perms = PermissionsExt::from_mode(Self::FILE_MODE);
		std::fs::set_permissions(path, perms)
	}

	/// Writes out a custom message without any [LogLevel]
	pub fn custom<S: AsRef<str>>(&self, text: S) -> Result<(), io::Error> {
		let writer = &mut *self.file.lock().unwrap();
		writer.write_all(text.as_ref().as_bytes())
	}
}

impl Logging for FileLog {
	fn output(&self, level: LogLevel, text: &str) -> Result<(), io::Error> {
		if level < self.min_logging_level {
			return Ok(());
		}
		let writer = &mut *self.file.lock().unwrap();
		match self.timestamp {
			true => writer.write_all(
				format!(
					"({}) [{level:?}]: {text}\n",
					Utc::now().format("%Y.%m.%d-%H:%M:%S")
				)
				.as_bytes(),
			)?,
			false => writer.write_all(format!("[{level:?}]: {text}\n").as_bytes())?,
		}
		Ok(())
	}

	fn flush(&self) -> Result<(), io::Error> {
		(*self.file.lock().unwrap()).flush()
	}
}

impl Drop for FileLog {
	fn drop(&mut self) {
		self.flush()
			.map_err(|e| eprintln!("Error flushing log file! {e}"))
			.ok();
	}
}

#[cfg(test)]
mod test {
	use crate::LogLevel;
	#[test]
	fn check_level() {
		assert!(LogLevel::Info < LogLevel::Warning);
		assert!(LogLevel::Error < LogLevel::Critical);
		assert!(LogLevel::Error > LogLevel::Warning);
		assert!(LogLevel::Info > LogLevel::Debug);
	}
}