narlog/

logger.rs

use std::error::Error;
use std::fmt::{Display, Formatter};
use chrono::Local;
use owo_colors::OwoColorize;
use crate::enums::{LogLevel, TimestampType};

impl Display for LogLevel {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match *self {
            LogLevel::Trace => write!(f, "{}", "Trace".bright_black().bold()),
            LogLevel::Info => write!(f, "{}", "Info".bright_cyan().bold()),
            LogLevel::Debug => write!(f, "{}", "Debug".bright_yellow().bold()),
            LogLevel::Warn => write!(f, "{}", "Warn".bright_yellow().bold()),
            LogLevel::Error => write!(f, "{}", "Error".bright_red().bold()),
            LogLevel::Fatal => write!(f, "{}", "Fatal".red().bold())
        }
    }
}

impl Display for TimestampType {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match *self {
            TimestampType::Time => write!(f, "{}", Local::now().format("%H:%M:%S")),
            TimestampType::DateTime => write!(f, "{}", Local::now().format("%Y-%m-%d %H:%M:%S")),
            TimestampType::VeryDetailed => write!(f, "{}", Local::now())
        }
    }
}

pub struct Logger {
    prefix: Option<String>,
    timestamp_type: Option<TimestampType>
}

impl Logger {
    /// Creates **a logger instance**.
    /// ```
    /// use narlog::prelude::*;
    /// let logger = Logger::new();
    /// ```
    pub fn new() -> Self {
        Self {
            prefix: None,
            timestamp_type: None
        }
    }
    
    /// Sets **a specified prefix**.
    /// ```
    /// use narlog::prelude::*;
    /// let logger = Logger::new().with_prefix("👍");
    /// ```
    pub fn with_prefix(mut self, prefix: impl Into<String>) -> Self {
        self.prefix = Some(prefix.into());
        self
    }

    /// Sets **a timestamp**.
    /// ```
    /// use narlog::prelude::*;
    /// let logger = Logger::new().with_timestamp(TimestampType::Time);
    /// ```
    pub fn with_timestamp(mut self, timestamp_type: TimestampType) -> Self {
        self.timestamp_type = Some(timestamp_type);
        self
    }
    
    fn build_and_output(&self, msg: impl Into<String>, level: LogLevel) {
        let msg = msg.into();
        let mut buffer: Vec<String> = Vec::new();
        
        self.prefix.as_ref().map(|p| buffer.push(p.to_string()));
        buffer.push(level.to_string());
        self.timestamp_type.as_ref().map(|p| buffer.push(p.bright_black().to_string()));
        buffer.push(msg);

        println!("{}", buffer.join(" "));
    }

    /// Logs **a message** at the specified level.
    /// ```
    /// use narlog::prelude::*;
    ///
    /// let logger = Logger::new();
    /// 
    /// logger.log(LogLevel::Info, "Information");
    /// logger.log(LogLevel::Warn, "Warning");
    /// ```
    pub fn log(&self, level: LogLevel, msg: impl Into<String>) {
        self.build_and_output(msg, level);
    }

    /// Logs **a message** at the specified level with an optional error.
    /// ```
    /// use narlog::prelude::*;
    /// use std::io::{self, ErrorKind};
    ///
    /// let logger = Logger::new();
    /// let err = io::Error::new(ErrorKind::Other, "extra details");
    ///
    /// logger.log_with_error(LogLevel::Error, "Something went wrong", Some(&err));
    /// logger.log_with_error(LogLevel::Fatal, "Catastrophic failure", None);
    /// ```
    pub fn log_with_error(&self, level: LogLevel, msg: impl Into<String>, err: Option<&dyn Error>) {
        self.build_and_output(msg, level);
        if let Some(err) = err {
            match level {
                LogLevel::Error => eprintln!("    {} {}", "Caused by:".bright_red(), err),
                LogLevel::Fatal => eprintln!("    {} {}", "Caused by:".red(), err),
                _ => eprintln!("    {} {}", "Caused by:".bright_red(), err),
            }
        }
    }


    // -------------------------//
    //       Easy Methods       //
    // -------------------------//

    /// Logs **a message** at the trace level.
    /// ```
    /// use narlog::prelude::*;
    /// let logger = Logger::new();
    /// logger.trace("Lorem ipsum dolor sit amet");
    /// ```
    pub fn trace(&self, msg: impl Into<String>) {
        self.log(LogLevel::Trace, msg);
    }

    /// Logs **a message** at the info level.
    /// ```
    /// use narlog::prelude::*;
    /// let logger = Logger::new();
    /// logger.info("consectetur adipiscing elit");
    /// ```
    pub fn info(&self, msg: impl Into<String>) {
        self.log(LogLevel::Info, msg);
    }

    /// Logs **a message** at the debug level.
    /// ```
    /// use narlog::prelude::*;
    /// let logger = Logger::new();
    /// logger.debug("sed do eiusmod tempor incididunt ut labore");
    /// ```
    pub fn debug(&self, msg: impl Into<String>) {
        self.log(LogLevel::Debug, msg);
    }


    /// Logs **a message** at the warn level.
    /// ```
    /// use narlog::prelude::*;
    /// let logger = Logger::new();
    /// logger.warn("Ut enim ad minim veniam");
    /// ```
    pub fn warn(&self, msg: impl Into<String>) {
        self.log(LogLevel::Warn, msg);
    }

    /// Logs **a message** at the error level, with optional error details.
    /// ```
    /// use narlog::prelude::*;
    /// use std::io::{self, ErrorKind};
    ///
    /// let logger = Logger::new();
    /// let error = io::Error::new(ErrorKind::Other, "extra details");
    /// logger.error("Something went wrong", Some(&error));
    /// logger.error("Another error without details", None);
    /// ```
    pub fn error(&self, msg: impl Into<String>, err: Option<&dyn Error>) {
        self.log_with_error(LogLevel::Error, msg, err);
    }

    /// Logs **a message** at the fatal level, with optional error details.
    /// ```
    /// use narlog::prelude::*;
    /// use std::io::{self, ErrorKind};
    ///
    /// let logger = Logger::new();
    /// let error = io::Error::new(ErrorKind::Other, "catastrophic failure");
    /// logger.fatal("System crashed", Some(&error));
    /// logger.fatal("Fatal error without details", None);
    /// ```
    pub fn fatal(&self, msg: impl Into<String>, err: Option<&dyn Error>) {
        self.log_with_error(LogLevel::Fatal, msg, err);
    }
}