Struct session_log::Session

pub struct Session { /* private fields */ }

Sessions are a way to group log messages together. They are useful for tracking the flow of a program. They can be nested, and when a session is dropped, it will dump all of its messages to the file at once. Despite the file being written to at once, the messages are still written in the traditional order on the terminal. It can also be used as a simple profiling tool, as it will track the starting time of the session and the elapsed time when it is dropped.

Example

use session_log::{Logger, Loggable};


fn main() {
  let logger = Logger::new("main");

  foo(logger.session("foo"), 10);
  bar(logger.session("bar"), 10);
}


fn foo(logger: impl Loggable, n: usize) {
  for i in 0..n {
    logger.info(&format!("message-{}", i));
  }
}


fn bar(logger: impl Loggable, n: usize) {
  for i in 0..n {
    logger.warning(&format!("message-{}", i));
  }
}

Implementations

impl Session

pub fn session(&self, name: &str) -> Result<Session, SessionErrorKind>

Create a nested session under the current session.

Trait Implementations

impl Drop for Session

fn drop(&mut self)

Executes the destructor for this type.

impl Loggable for Session

fn log(&self, level: Level, message: &str)

Log a message with the dynamic level.

fn debug(&self, message: &str)

Log a message at the debug level with caller position.

fn verbose(&self, message: &str)

Log a message at the verbose level with caller position.

fn info(&self, message: &str)

Log a message at the info level with caller position.

fn warning(&self, message: &str)

Log a message at the warning level with caller position.

fn critical(&self, message: &str)

Log a message at the critical level with caller position.

fn error(&self, message: &str)

Log a message at the error level with caller position.

fn fatal(&self, message: &str) -> !

Log a message at the fatal level with caller position then panic.