master
Avril 4 years ago
parent ed097b80cb
commit 521d281743
Signed by: flanchan
GPG Key ID: 284488987C31F630

@ -0,0 +1,26 @@
//! Extra logging types for log files and such
use super::*;
use generational_arena::Index;
use std::marker::{Sync, Send};
/// A logging hook
pub trait Hook: Sync + Send
{
/// The name of this hook object
fn name(&self) -> &str {"(unnamed)"}
/// Fired when hook is added
fn initialise(&mut self, _idx: &Index) {}
/// Fired when `println` is called
fn println(&mut self, level: &dyn AsLevel, what: &dyn Display, trace: &Trace) -> io::Result<()>;
/// Fired when hook is removed
fn finalise(&mut self, _idx: Index) {}
}
impl std::fmt::Debug for dyn Hook
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
{
write!(f, "<opaque type>")
}
}

@ -0,0 +1,57 @@
//! Logging level for filtering and such
use super::*;
/// Logging level
#[derive(PartialEq,Copy,Eq,Debug,Clone,Hash,Ord,PartialOrd)]
pub enum Level
{
Silent,
Error,
Warn,
Info,
Debug,
}
/// Append this trait to allow you to
pub trait AsLevel: fmt::Display + Borrow<Level>{
/// Used for derived levels
fn prefix(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
{
write!(f, "{}/", Borrow::<Level>::borrow(self))
}
}
impl AsLevel for Level{
#[inline] fn prefix(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result{Ok(())}
}
impl AsLevel for &Level{
#[inline] fn prefix(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result{Ok(())}
}
impl Default for Level
{
#[inline]
fn default() -> Level
{
#[cfg(debug_assertions)]
return Level::Debug;
#[cfg(not(debug_assertions))]
return Level::Warn;
}
}
impl std::fmt::Display for Level
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
{
use recolored::Colorize;
write!(f, "{}", match &self {
Self::Silent => "Fatal".bright_red().bold(),
Self::Error => "Error".red(),
Self::Warn => "Warning".yellow(),
Self::Info => "Info".normal(),
Self::Debug => "Debug".dimmed(),
})
}
}

@ -0,0 +1,397 @@
//! Global logging state
use super::util::*;
use std::{
fmt::{
self,
Display,
},
io::{
self,
Write,
},
borrow::{Cow,Borrow,},
sync::{RwLock,},
};
use once_cell::sync::OnceCell;
use generational_arena::{Arena,Index};
/// Print local time by default
const DEFAULT_USE_LOCAL_TIME: bool = crate::config::build::log::DEFAULT_LOCAL_TIME;
const DATE_FORMAT: Cow<'static, str> = crate::config::build::log::DATE_FORMAT;
mod level;
pub use level::*;
mod trace;
pub use trace::*;
mod custom;
/// A logger that prints to stdout and stderr idk.
#[derive(Debug)]
pub struct Logger
{
level: Level,
title: String,
use_local_time: bool,
hooks: RwLock<Arena<RwLock<Box<dyn custom::Hook>>>>,
}
static INSTANCE: OnceCell<Logger> = OnceCell::new();
impl Logger
{
/// Create a new logger
pub fn new(level: Level) -> Self
{
Self {
level,
title: String::new(),
use_local_time: DEFAULT_USE_LOCAL_TIME,
hooks: RwLock::new(Arena::new()),
}
}
/// Get a reference to the global logger instance.
#[inline]
pub fn global() -> &'static Logger
{
INSTANCE.get().expect("[logger] uninitialised")
}
fn initialise(level: Level) -> &'static Logger
{
INSTANCE.set(Logger::new(level)).expect("[logger] already initialised");
Logger::global()
}
/// Dispatch on hooks
fn dispatch<L,W,T>(&self, level: &L, what: &W, trace: &T)
where L: AsLevel,
W: Display,
T: Borrow<Trace>
{
let trace = trace.borrow();
let reader = self.hooks.read().expect("Poisoned");
for (idx, dispatch_mtx) in reader.iter() {
if let Ok(mut reader) = dispatch_mtx.try_write() { // Don't try to print in the same log twice
if let Err(e) = reader.println(level, what, trace) {
crate::warn!("Logger `{:?}:{}` failed to print: {}", idx, reader.name(), e);
}
}
}
}
/// Add a logging hook
pub fn add_hook<H: custom::Hook + 'static>(&self, mut hook: H) -> Index
{
let mut writer = self.hooks.write().expect("Poisoned");
let idx = writer.insert_with(move |idx| {
hook.initialise(&idx);
RwLock::new(Box::new(hook))
});
idx
}
/// Try to remove and return a logging hook.
///
/// # Returns
/// `None` if `hook` is not present or its `RwLock` was poisoned, otherwise, returns boxed trait object of the hook.
pub fn remove_hook(&self, hook: impl Into<Index>) -> Option<Box<dyn custom::Hook>>
{
let mut writer = self.hooks.write().expect("Poisoned");
let hook =hook.into();
writer.remove(hook.clone())
.map(|rw| rw.into_inner().ok()
.map(|mut x| {
x.finalise(hook);
x}))
.flatten()
}
/// Print a line to this logger.
/// You should usually print using the macros defined here instead of calling this directly.
pub fn println<W,L,D,T>(&self, mut to: W, level: L, what: D, trace: T) -> io::Result<()>
where W: Write,
L: AsLevel,
D: Display,
T: Borrow<Trace>
{
self.dispatch(&level, &what, &trace);
//lol
enum Date {
Local(chrono::DateTime<chrono::offset::Local>),
Utc(chrono::DateTime<chrono::offset::Utc>),
}
impl std::fmt::Display for Date
{
#[inline]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
{
match self {
Self::Local(l) => write!(f, "{}", l.format(DATE_FORMAT.as_ref())),
Self::Utc(l) => write!(f, "{}", l.format(DATE_FORMAT.as_ref())),
}
}
}
impl From<chrono::DateTime<chrono::offset::Local>> for Date
{
#[inline]
fn from(from: chrono::DateTime<chrono::offset::Local>) -> Self
{
Self::Local(from)
}
}
impl From<chrono::DateTime<chrono::offset::Utc>> for Date
{
#[inline]
fn from(from: chrono::DateTime<chrono::offset::Utc>) -> Self
{
Self::Utc(from)
}
}
if &self.level >= level.borrow() {
let now: Date = if self.use_local_time {
chrono::offset::Local::now().into()
} else {
chrono::offset::Utc::now().into()
};
write!(to, "{} ", now)?;
if self.title.len() > 0 {
write!(to, " <{}>\t", self.title)?;
} else {
write!(to, " <{}>\t", trace.borrow())?;
}
write!(to," [")?;
struct Prefix<'a,L: AsLevel>(&'a L);
impl<'a,L: AsLevel> std::fmt::Display for Prefix<'a, L>
{
#[inline]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
{
self.0.prefix(f)
}
}
write!(to, "{}", Prefix(&level))?; //what a mess...
write!(to, "{}", level)?;
write!(to, "]: ")?;
writeln!(to, "{}", what)?;
}
Ok(())
}
}
#[cfg(any(debug_assertions,feature="debug_logger"))]
#[macro_export] macro_rules! debug {
($obj:expr) => {
{
let stdout = std::io::stdout();
let stdout = stdout.lock();
$crate::log::Logger::global().println(stdout, $crate::log::Level::Debug, $obj, get_trace!()).expect("i/o error");
}
};
($fmt:literal, $($args:expr),*) => {
debug!(format!($fmt, $($args,)*));
};
}
#[cfg(not(any(debug_assertions,feature="debug_logger")))]
#[macro_export] macro_rules! debug {
($obj:expr) => {{}};
($fmt:literal, $($args:expr),*) => {{}};
}
#[cfg(any(debug_assertions,feature="debug_logger"))]
#[macro_export] macro_rules! status {
($obj:expr) => {
{
struct Status;
use std::{
borrow::Borrow,
fmt,
};
impl Borrow<$crate::log::Level> for Status {
fn borrow(&self) -> &$crate::log::Level
{
&$crate::log::Level::Debug
}
}
impl fmt::Display for Status
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
{
use recolored::Colorize;
write!(f, "{}", "Status".blue())
}
}
impl $crate::log::AsLevel for Status{}
let stdout = std::io::stdout();
let stdout = stdout.lock();
$crate::log::Logger::global().println(stdout, Status, $obj, $crate::get_trace!()).expect("i/o error");
}
};
($fmt:literal, $($args:expr),*) => {
status!(format!($fmt, $($args,)*));
};
}
#[cfg(not(any(debug_assertions,feature="debug_logger")))]
#[macro_export] macro_rules! status {
($obj:expr) => {{}};
($fmt:literal, $($args:expr),*) => {{}};
}
#[macro_export] macro_rules! info {
($obj:expr) => {
{
let stdout = std::io::stdout();
let stdout = stdout.lock();
$crate::log::Logger::global().println(stdout, $crate::log::Level::Info, $obj, $crate::get_trace!()).expect("i/o error");
}
};
($fmt:literal, $($args:expr),*) => {
$crate::info!(format!($fmt, $($args,)*));
};
}
#[macro_export] macro_rules! important {
($obj:expr) => {
{
struct Important;
use std::{
borrow::Borrow,
fmt,
};
impl Borrow<$crate::log::Level> for Important {
fn borrow(&self) -> &$crate::log::Level
{
&$crate::log::Level::Info
}
}
impl fmt::Display for Important
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
{
use recolored::Colorize;
write!(f, "{}", "Important".bright_blue())
}
}
impl $crate::log::AsLevel for Important{}
let stdout = std::io::stdout();
let stdout = stdout.lock();
$crate::log::Logger::global().println(stdout, Important, $obj, $crate::get_trace!()).expect("i/o error");
}
};
($fmt:literal, $($args:expr),*) => {
$crate::important!(format!($fmt, $($args,)*));
};
}
#[macro_export] macro_rules! warn {
($obj:expr) => {
{
let stderr = std::io::stderr();
let stderr = stderr.lock();
$crate::log::Logger::global().println(stderr, $crate::log::Level::Warn, $obj, $crate::get_trace!()).expect("i/o error");
}
};
($fmt:literal, $($args:expr),*) => {
$crate::warn!(format!($fmt, $($args,)*));
};
}
#[macro_export] macro_rules! dangerous {
($obj:expr) => {
{
struct Dangerous;
use std::{
borrow::Borrow,
fmt,
};
impl Borrow<$crate::log::Level> for Dangerous {
fn borrow(&self) -> &$crate::log::Level
{
&$crate::log::Level::Warn
}
}
impl fmt::Display for Dangerous
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
{
use recolored::Colorize;
write!(f, "{}", "Dangerous".bright_yellow())
}
}
impl $crate::log::AsLevel for Dangerous{}
let stderr = std::io::stderr();
let stderr = stderr.lock();
$crate::log::Logger::global().println(stderr, Dangerous, $obj, $crate::get_trace!()).expect("i/o error");
}
};
($fmt:literal, $($args:expr),*) => {
$crate::dangerous!(format!($fmt, $($args,)*));
};
}
#[macro_export] macro_rules! error {
($obj:expr) => {
{
let stderr = std::io::stderr();
let stderr = stderr.lock();
$crate::log::Logger::global().println(stderr, $crate::log::Level::Error, $obj, $crate::get_trace!()).expect("i/o error");
}
};
($fmt:literal, $($args:expr),*) => {
$crate::error!(format!($fmt, $($args,)*));
};
}
#[macro_export] macro_rules! fatal {
($obj:expr) => {
{
let stdout = std::io::stdout();
let stdout = stdout.lock();
$crate::log::Logger::global().println(stdout, $crate::log::Level::Silent, $obj, $crate::get_trace!()).expect("i/o error");
std::process::exit(-1)
}
};
($fmt:literal, $($args:expr),*) => {
$crate::fatal!(format!($fmt, $($args,)*));
};
}
/// Initialise the global logger instance. If logging macros are called before this, they will panic.
#[inline]
pub fn init(level: Level)
{
Logger::initialise(level);
}
/// The global logger's level
#[inline]
pub fn level() -> &'static Level
{
&Logger::global().level
}

@ -0,0 +1,132 @@
//! Source traces
use super::*;
/// Contains backtrace info from where the log macro was invoked
#[derive(Debug)]
pub struct Trace
{
line: Option<usize>,
file: Option<&'static str>,
column: Option<usize>,
display: Opaque<RwLock<Option<String>>>,
}
impl Clone for Trace
{
#[inline]
fn clone(&self) -> Self
{
Self {
line: self.line.clone(),
file: self.file.clone(),
column: self.column.clone(),
display: Opaque::new(RwLock::new(None)),
}
}
}
impl std::hash::Hash for Trace
{
fn hash<H: std::hash::Hasher>(&self, state: &mut H)
{
self.line.hash(state);
self.file.hash(state);
self.column.hash(state);
}
}
impl std::cmp::PartialEq for Trace
{
fn eq(&self, other: &Self)->bool
{
self.line == other.line &&
self.file == other.file &&
self.column == other.column
}
}
impl Trace
{
/// Create a new `Trace` manually. Generally not desireable, use `get_trace!()` instead.
pub fn new(file: Option<&'static str>, line: Option<u32>, column: Option<u32>) -> Self
{
use std::convert::TryInto;
let this = Self{
file,
line: line.and_then(|x| x.try_into().ok()),
column: column.and_then(|x| x.try_into().ok()),
display: Opaque::new(RwLock::new(None)),
};
this
}
fn genstring(&self) -> Result<String, fmt::Error>
{
let mut out = String::new();
use std::fmt::Write as FmtWrite;
write!(out, "{}", self.file.unwrap_or("(unbound)"))?;
if let Some(line) = self.line {
write!(&mut out, ":{}", line)?;
} else {
write!(&mut out, ":?")?;
}
if let Some(column) = self.column {
write!(&mut out, ":{}", column)?;
} else {
write!(&mut out, ":?")?;
}
Ok(out)
}
}
impl std::fmt::Display for Trace
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
{
{
let read = self.display.read().expect("Poisoned");
if let Some(opt) = read.as_ref()
{
write!(f, "{}", opt)?;
return Ok(());
}
}
let out = self.genstring()?;
write!(f, "{}", out)?;
let mut write = self.display.write().expect("Poisoned");
*write = Some(out);
Ok(())
}
}
impl Default for Trace
{
#[inline]
fn default() -> Self
{
Self{
line:None,
file:None,
column:None,
display: Opaque::new(RwLock::new(None)),
}
}
}
/// Get a source code trace of the current file, line and column.
#[macro_export] macro_rules! get_trace
{
() => {
$crate::log::Trace::new(Some(file!()), Some(line!()), Some(column!()))
}
}
Loading…
Cancel
Save