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 enable(&mut self)

Re-enable the session so it can log messages again.

pub fn disable(&mut self)

Temporarily disable the session so it will not log messages.

pub fn set_ease_on_empty(self, ease: bool) -> Self

Set if the session write only elapsed when empty session dump.
Default is true.

Trait Implementations

impl Drop for Session

fn drop(&mut self)

Executes the destructor for this type.

impl Loggable for Session

fn log(&self, ctx: Context<'_>)

Log a message with the dynamic level.

fn session(&self, name: impl Into<String>) -> Session

Create a new session with the given name.

fn get_name(&self) -> &str

Get the name of the current loggable.

fn get_logger_name(&self) -> &str

Get the current logging entry name.

fn get_logger(&self) -> Logger

Get the logger of the current loggable.

fn get_session(&self) -> Option<&str>

Get the current session name.

fn get_log_level(&self) -> Level

Get the log level of current loggable.

fn get_write_level(&self) -> Level

Get the write level of current loggable.

fn debug(&self, message: impl Into<String>)

Log a message at the debug level with caller position.

fn verbose(&self, message: impl Into<String>)

Log a message at the verbose level with caller position.

fn info(&self, message: impl Into<String>)

Log a message at the info level with caller position.

fn warning(&self, message: impl Into<String>)

Log a message at the warning level with caller position.

fn critical(&self, message: impl Into<String>)

Log a message at the critical level with caller position.

fn error(&self, message: impl Into<String>)

Log a message at the error level with caller position.

fn fatal(&self, message: impl Into<String>) -> !

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