Struct Logger 

pub struct Logger { /* private fields */ }

A file logger that writes messages to path and filters by level.

By default, the logger starts at LogLevel::Info.

Implementations

impl Logger

pub fn new<P: Into<PathBuf>>(path: P) -> Self

Creates a new Logger that writes to path.

The default level is LogLevel::Info.

Examples

use log_easy::Logger;
let logger = Logger::new("app.log");

Examples found in repository

examples/global.rs (line 13)

fn main() -> Result<()> {
    // Initialize the global logger with a file path and log level.
    log_easy::init_with(Logger::new("target/global.log").with_level(LogLevel::Trace))?;

    // Non-fallible macros (errors are printed to stderr).
    trace!("This is a trace message");
    debug!("Debugging information here");
    info!("Application started");
    warn!("This is a warning");
    error!("An error occurred");

    // Fallible macros (return Result so you can handle failures).
    try_trace!("This is a trace message using the try macro")?;
    try_debug!("This is a debug message using the try macro")?;
    try_info!("This is an info message using the try macro")?;
    try_warn!("This is a warning message using the try macro")?;
    try_error!("This is an error message using the try macro")?;

    // Macros accept formatting args.
    let user = "joe";
    let attempts = 3;
    let elapsed_ms = 127;
    info!("User {user} has attempted login {attempts} times ({elapsed_ms}ms elapsed)");

    Ok(())
}

examples/instance.rs (line 10)

fn main() -> Result<()> {
    // Create an independent Logger instance (separate file/level) without using the global macros.
    let logger = Logger::new("target/instance.log").with_level(LogLevel::Info);

    // Non-fallible instance logging (write failures go to stderr).
    logger.trace("This trace message will not be logged due to log level");
    logger.debug("This debug message will not be logged due to log level");
    logger.info("Instance logger ready");
    logger.warn("This is a warning with the instance logger");
    logger.error("An error occurred with the instance logger");

    // Fallible instance logging: returns Result so you can handle failures.
    logger.try_trace("This is a trace message with try")?;
    logger.try_debug("This is a debug message with try")?;
    logger.try_info("This is an info message with try")?;
    logger.try_warn("This is a warning with try")?;
    logger.try_error("An error occurred with try")?;

    // Instance loggers don't have macros, so format messages manually (macros target the global logger).
    logger.try_info(&format!(
        "Logger initialized with path: {:?} and level: {:?}",
        logger.path(),
        logger.level()
    ))?;

    Ok(())
}

pub fn with_level(self, level: LogLevel) -> Self

Returns a new Logger configured with the given minimum log level.

Messages below this level are ignored.

Examples

use log_easy::{Logger, LogLevel};
let logger = Logger::new("app.log").with_level(LogLevel::Debug);

Examples found in repository

examples/global.rs (line 13)

fn main() -> Result<()> {
    // Initialize the global logger with a file path and log level.
    log_easy::init_with(Logger::new("target/global.log").with_level(LogLevel::Trace))?;

    // Non-fallible macros (errors are printed to stderr).
    trace!("This is a trace message");
    debug!("Debugging information here");
    info!("Application started");
    warn!("This is a warning");
    error!("An error occurred");

    // Fallible macros (return Result so you can handle failures).
    try_trace!("This is a trace message using the try macro")?;
    try_debug!("This is a debug message using the try macro")?;
    try_info!("This is an info message using the try macro")?;
    try_warn!("This is a warning message using the try macro")?;
    try_error!("This is an error message using the try macro")?;

    // Macros accept formatting args.
    let user = "joe";
    let attempts = 3;
    let elapsed_ms = 127;
    info!("User {user} has attempted login {attempts} times ({elapsed_ms}ms elapsed)");

    Ok(())
}

examples/instance.rs (line 10)

fn main() -> Result<()> {
    // Create an independent Logger instance (separate file/level) without using the global macros.
    let logger = Logger::new("target/instance.log").with_level(LogLevel::Info);

    // Non-fallible instance logging (write failures go to stderr).
    logger.trace("This trace message will not be logged due to log level");
    logger.debug("This debug message will not be logged due to log level");
    logger.info("Instance logger ready");
    logger.warn("This is a warning with the instance logger");
    logger.error("An error occurred with the instance logger");

    // Fallible instance logging: returns Result so you can handle failures.
    logger.try_trace("This is a trace message with try")?;
    logger.try_debug("This is a debug message with try")?;
    logger.try_info("This is an info message with try")?;
    logger.try_warn("This is a warning with try")?;
    logger.try_error("An error occurred with try")?;

    // Instance loggers don't have macros, so format messages manually (macros target the global logger).
    logger.try_info(&format!(
        "Logger initialized with path: {:?} and level: {:?}",
        logger.path(),
        logger.level()
    ))?;

    Ok(())
}

pub fn path(&self) -> &Path

Gets the log file path.

Examples found in repository

examples/instance.rs (line 29)

fn main() -> Result<()> {
    // Create an independent Logger instance (separate file/level) without using the global macros.
    let logger = Logger::new("target/instance.log").with_level(LogLevel::Info);

    // Non-fallible instance logging (write failures go to stderr).
    logger.trace("This trace message will not be logged due to log level");
    logger.debug("This debug message will not be logged due to log level");
    logger.info("Instance logger ready");
    logger.warn("This is a warning with the instance logger");
    logger.error("An error occurred with the instance logger");

    // Fallible instance logging: returns Result so you can handle failures.
    logger.try_trace("This is a trace message with try")?;
    logger.try_debug("This is a debug message with try")?;
    logger.try_info("This is an info message with try")?;
    logger.try_warn("This is a warning with try")?;
    logger.try_error("An error occurred with try")?;

    // Instance loggers don't have macros, so format messages manually (macros target the global logger).
    logger.try_info(&format!(
        "Logger initialized with path: {:?} and level: {:?}",
        logger.path(),
        logger.level()
    ))?;

    Ok(())
}

pub fn level(&self) -> LogLevel

Gets the current log level.

Examples found in repository

examples/instance.rs (line 30)

fn main() -> Result<()> {
    // Create an independent Logger instance (separate file/level) without using the global macros.
    let logger = Logger::new("target/instance.log").with_level(LogLevel::Info);

    // Non-fallible instance logging (write failures go to stderr).
    logger.trace("This trace message will not be logged due to log level");
    logger.debug("This debug message will not be logged due to log level");
    logger.info("Instance logger ready");
    logger.warn("This is a warning with the instance logger");
    logger.error("An error occurred with the instance logger");

    // Fallible instance logging: returns Result so you can handle failures.
    logger.try_trace("This is a trace message with try")?;
    logger.try_debug("This is a debug message with try")?;
    logger.try_info("This is an info message with try")?;
    logger.try_warn("This is a warning with try")?;
    logger.try_error("An error occurred with try")?;

    // Instance loggers don't have macros, so format messages manually (macros target the global logger).
    logger.try_info(&format!(
        "Logger initialized with path: {:?} and level: {:?}",
        logger.path(),
        logger.level()
    ))?;

    Ok(())
}

pub fn trace(&self, msg: &str)

These methods log messages at their respective levels. If an error occurs (e.g., file write failure), it is printed to stderr but not returned.

Examples found in repository

examples/instance.rs (line 13)

fn main() -> Result<()> {
    // Create an independent Logger instance (separate file/level) without using the global macros.
    let logger = Logger::new("target/instance.log").with_level(LogLevel::Info);

    // Non-fallible instance logging (write failures go to stderr).
    logger.trace("This trace message will not be logged due to log level");
    logger.debug("This debug message will not be logged due to log level");
    logger.info("Instance logger ready");
    logger.warn("This is a warning with the instance logger");
    logger.error("An error occurred with the instance logger");

    // Fallible instance logging: returns Result so you can handle failures.
    logger.try_trace("This is a trace message with try")?;
    logger.try_debug("This is a debug message with try")?;
    logger.try_info("This is an info message with try")?;
    logger.try_warn("This is a warning with try")?;
    logger.try_error("An error occurred with try")?;

    // Instance loggers don't have macros, so format messages manually (macros target the global logger).
    logger.try_info(&format!(
        "Logger initialized with path: {:?} and level: {:?}",
        logger.path(),
        logger.level()
    ))?;

    Ok(())
}

pub fn debug(&self, msg: &str)

Examples found in repository

examples/instance.rs (line 14)

fn main() -> Result<()> {
    // Create an independent Logger instance (separate file/level) without using the global macros.
    let logger = Logger::new("target/instance.log").with_level(LogLevel::Info);

    // Non-fallible instance logging (write failures go to stderr).
    logger.trace("This trace message will not be logged due to log level");
    logger.debug("This debug message will not be logged due to log level");
    logger.info("Instance logger ready");
    logger.warn("This is a warning with the instance logger");
    logger.error("An error occurred with the instance logger");

    // Fallible instance logging: returns Result so you can handle failures.
    logger.try_trace("This is a trace message with try")?;
    logger.try_debug("This is a debug message with try")?;
    logger.try_info("This is an info message with try")?;
    logger.try_warn("This is a warning with try")?;
    logger.try_error("An error occurred with try")?;

    // Instance loggers don't have macros, so format messages manually (macros target the global logger).
    logger.try_info(&format!(
        "Logger initialized with path: {:?} and level: {:?}",
        logger.path(),
        logger.level()
    ))?;

    Ok(())
}

pub fn info(&self, msg: &str)

Examples found in repository

examples/instance.rs (line 15)

fn main() -> Result<()> {
    // Create an independent Logger instance (separate file/level) without using the global macros.
    let logger = Logger::new("target/instance.log").with_level(LogLevel::Info);

    // Non-fallible instance logging (write failures go to stderr).
    logger.trace("This trace message will not be logged due to log level");
    logger.debug("This debug message will not be logged due to log level");
    logger.info("Instance logger ready");
    logger.warn("This is a warning with the instance logger");
    logger.error("An error occurred with the instance logger");

    // Fallible instance logging: returns Result so you can handle failures.
    logger.try_trace("This is a trace message with try")?;
    logger.try_debug("This is a debug message with try")?;
    logger.try_info("This is an info message with try")?;
    logger.try_warn("This is a warning with try")?;
    logger.try_error("An error occurred with try")?;

    // Instance loggers don't have macros, so format messages manually (macros target the global logger).
    logger.try_info(&format!(
        "Logger initialized with path: {:?} and level: {:?}",
        logger.path(),
        logger.level()
    ))?;

    Ok(())
}

pub fn warn(&self, msg: &str)

Examples found in repository

examples/instance.rs (line 16)

fn main() -> Result<()> {
    // Create an independent Logger instance (separate file/level) without using the global macros.
    let logger = Logger::new("target/instance.log").with_level(LogLevel::Info);

    // Non-fallible instance logging (write failures go to stderr).
    logger.trace("This trace message will not be logged due to log level");
    logger.debug("This debug message will not be logged due to log level");
    logger.info("Instance logger ready");
    logger.warn("This is a warning with the instance logger");
    logger.error("An error occurred with the instance logger");

    // Fallible instance logging: returns Result so you can handle failures.
    logger.try_trace("This is a trace message with try")?;
    logger.try_debug("This is a debug message with try")?;
    logger.try_info("This is an info message with try")?;
    logger.try_warn("This is a warning with try")?;
    logger.try_error("An error occurred with try")?;

    // Instance loggers don't have macros, so format messages manually (macros target the global logger).
    logger.try_info(&format!(
        "Logger initialized with path: {:?} and level: {:?}",
        logger.path(),
        logger.level()
    ))?;

    Ok(())
}

pub fn error(&self, msg: &str)

Examples found in repository

examples/instance.rs (line 17)

fn main() -> Result<()> {
    // Create an independent Logger instance (separate file/level) without using the global macros.
    let logger = Logger::new("target/instance.log").with_level(LogLevel::Info);

    // Non-fallible instance logging (write failures go to stderr).
    logger.trace("This trace message will not be logged due to log level");
    logger.debug("This debug message will not be logged due to log level");
    logger.info("Instance logger ready");
    logger.warn("This is a warning with the instance logger");
    logger.error("An error occurred with the instance logger");

    // Fallible instance logging: returns Result so you can handle failures.
    logger.try_trace("This is a trace message with try")?;
    logger.try_debug("This is a debug message with try")?;
    logger.try_info("This is an info message with try")?;
    logger.try_warn("This is a warning with try")?;
    logger.try_error("An error occurred with try")?;

    // Instance loggers don't have macros, so format messages manually (macros target the global logger).
    logger.try_info(&format!(
        "Logger initialized with path: {:?} and level: {:?}",
        logger.path(),
        logger.level()
    ))?;

    Ok(())
}

pub fn try_trace(&self, msg: &str) -> Result<()>

Fallible variants of the logging methods.

Unlike info()/warn() etc., these return std::io::Result<()> so callers can handle failures.

Examples found in repository

examples/instance.rs (line 20)

fn main() -> Result<()> {
    // Create an independent Logger instance (separate file/level) without using the global macros.
    let logger = Logger::new("target/instance.log").with_level(LogLevel::Info);

    // Non-fallible instance logging (write failures go to stderr).
    logger.trace("This trace message will not be logged due to log level");
    logger.debug("This debug message will not be logged due to log level");
    logger.info("Instance logger ready");
    logger.warn("This is a warning with the instance logger");
    logger.error("An error occurred with the instance logger");

    // Fallible instance logging: returns Result so you can handle failures.
    logger.try_trace("This is a trace message with try")?;
    logger.try_debug("This is a debug message with try")?;
    logger.try_info("This is an info message with try")?;
    logger.try_warn("This is a warning with try")?;
    logger.try_error("An error occurred with try")?;

    // Instance loggers don't have macros, so format messages manually (macros target the global logger).
    logger.try_info(&format!(
        "Logger initialized with path: {:?} and level: {:?}",
        logger.path(),
        logger.level()
    ))?;

    Ok(())
}

pub fn try_debug(&self, msg: &str) -> Result<()>

Examples found in repository

examples/instance.rs (line 21)

fn main() -> Result<()> {
    // Create an independent Logger instance (separate file/level) without using the global macros.
    let logger = Logger::new("target/instance.log").with_level(LogLevel::Info);

    // Non-fallible instance logging (write failures go to stderr).
    logger.trace("This trace message will not be logged due to log level");
    logger.debug("This debug message will not be logged due to log level");
    logger.info("Instance logger ready");
    logger.warn("This is a warning with the instance logger");
    logger.error("An error occurred with the instance logger");

    // Fallible instance logging: returns Result so you can handle failures.
    logger.try_trace("This is a trace message with try")?;
    logger.try_debug("This is a debug message with try")?;
    logger.try_info("This is an info message with try")?;
    logger.try_warn("This is a warning with try")?;
    logger.try_error("An error occurred with try")?;

    // Instance loggers don't have macros, so format messages manually (macros target the global logger).
    logger.try_info(&format!(
        "Logger initialized with path: {:?} and level: {:?}",
        logger.path(),
        logger.level()
    ))?;

    Ok(())
}

pub fn try_info(&self, msg: &str) -> Result<()>

Examples found in repository

examples/instance.rs (line 22)

fn main() -> Result<()> {
    // Create an independent Logger instance (separate file/level) without using the global macros.
    let logger = Logger::new("target/instance.log").with_level(LogLevel::Info);

    // Non-fallible instance logging (write failures go to stderr).
    logger.trace("This trace message will not be logged due to log level");
    logger.debug("This debug message will not be logged due to log level");
    logger.info("Instance logger ready");
    logger.warn("This is a warning with the instance logger");
    logger.error("An error occurred with the instance logger");

    // Fallible instance logging: returns Result so you can handle failures.
    logger.try_trace("This is a trace message with try")?;
    logger.try_debug("This is a debug message with try")?;
    logger.try_info("This is an info message with try")?;
    logger.try_warn("This is a warning with try")?;
    logger.try_error("An error occurred with try")?;

    // Instance loggers don't have macros, so format messages manually (macros target the global logger).
    logger.try_info(&format!(
        "Logger initialized with path: {:?} and level: {:?}",
        logger.path(),
        logger.level()
    ))?;

    Ok(())
}

pub fn try_warn(&self, msg: &str) -> Result<()>

Examples found in repository

examples/instance.rs (line 23)

fn main() -> Result<()> {
    // Create an independent Logger instance (separate file/level) without using the global macros.
    let logger = Logger::new("target/instance.log").with_level(LogLevel::Info);

    // Non-fallible instance logging (write failures go to stderr).
    logger.trace("This trace message will not be logged due to log level");
    logger.debug("This debug message will not be logged due to log level");
    logger.info("Instance logger ready");
    logger.warn("This is a warning with the instance logger");
    logger.error("An error occurred with the instance logger");

    // Fallible instance logging: returns Result so you can handle failures.
    logger.try_trace("This is a trace message with try")?;
    logger.try_debug("This is a debug message with try")?;
    logger.try_info("This is an info message with try")?;
    logger.try_warn("This is a warning with try")?;
    logger.try_error("An error occurred with try")?;

    // Instance loggers don't have macros, so format messages manually (macros target the global logger).
    logger.try_info(&format!(
        "Logger initialized with path: {:?} and level: {:?}",
        logger.path(),
        logger.level()
    ))?;

    Ok(())
}

pub fn try_error(&self, msg: &str) -> Result<()>

Examples found in repository

examples/instance.rs (line 24)

fn main() -> Result<()> {
    // Create an independent Logger instance (separate file/level) without using the global macros.
    let logger = Logger::new("target/instance.log").with_level(LogLevel::Info);

    // Non-fallible instance logging (write failures go to stderr).
    logger.trace("This trace message will not be logged due to log level");
    logger.debug("This debug message will not be logged due to log level");
    logger.info("Instance logger ready");
    logger.warn("This is a warning with the instance logger");
    logger.error("An error occurred with the instance logger");

    // Fallible instance logging: returns Result so you can handle failures.
    logger.try_trace("This is a trace message with try")?;
    logger.try_debug("This is a debug message with try")?;
    logger.try_info("This is an info message with try")?;
    logger.try_warn("This is a warning with try")?;
    logger.try_error("An error occurred with try")?;

    // Instance loggers don't have macros, so format messages manually (macros target the global logger).
    logger.try_info(&format!(
        "Logger initialized with path: {:?} and level: {:?}",
        logger.path(),
        logger.level()
    ))?;

    Ok(())
}

Trait Implementations

impl Debug for Logger

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.