Struct Record 

pub struct Record<'a> { /* private fields */ }

The “payload” of a log message.

Use

Record structures are passed as parameters to the log method of the Log trait. Logger implementors manipulate these structures in order to display log messages. Records are automatically created by the log! macro and so are not seen by log users.

Note that the level() and target() accessors are equivalent to self.metadata().level() and self.metadata().target() respectively. These methods are provided as a convenience for users of this structure.

Example

The following example shows a simple logger that displays the level, module path, and message of any Record that is passed to it.

struct SimpleLogger;

impl log::Log for SimpleLogger {
   fn enabled(&self, _metadata: &log::Metadata) -> bool {
       true
   }

   fn log(&self, record: &log::Record) {
       if !self.enabled(record.metadata()) {
           return;
       }

       println!("{}:{} -- {}",
                record.level(),
                record.target(),
                record.args());
   }
   fn flush(&self) {}
}

Implementations

impl<'a> Record<'a>

pub fn builder() -> RecordBuilder<'a>

Returns a new builder.

pub fn args(&self) -> &Arguments<'a>

The message body.

Examples found in repository

examples/string-bench.rs (line 44)

    fn msg(&self, record: &Record) -> Box<dyn Send + Sync + std::fmt::Display> {
        Box::new(format!(
            "{} {}/{}:{} {}",
            record.level(),
            std::thread::current().name().unwrap_or_default(),
            record.file().unwrap_or(""),
            record.line().unwrap_or(0),
            record.args()
        ))
    }

examples/custom-format.rs (line 24)

        fn msg(&self, record: &Record) -> Box<dyn Send + Sync + std::fmt::Display> {
            Box::new(Msg {
                level: record.level(),
                thread: std::thread::current().name().map(|n| n.to_string()),
                file: record.file_static(),
                line: record.line(),
                args: format!("{}", record.args()),
                module_path: record.module_path_static(),
            })
        }

pub fn metadata(&self) -> &Metadata<'a>

Metadata about the log directive.

pub fn level(&self) -> Level

The verbosity level of the message.

Examples found in repository

examples/string-bench.rs (line 40)

    fn msg(&self, record: &Record) -> Box<dyn Send + Sync + std::fmt::Display> {
        Box::new(format!(
            "{} {}/{}:{} {}",
            record.level(),
            std::thread::current().name().unwrap_or_default(),
            record.file().unwrap_or(""),
            record.line().unwrap_or(0),
            record.args()
        ))
    }

examples/custom-format.rs (line 20)

        fn msg(&self, record: &Record) -> Box<dyn Send + Sync + std::fmt::Display> {
            Box::new(Msg {
                level: record.level(),
                thread: std::thread::current().name().map(|n| n.to_string()),
                file: record.file_static(),
                line: record.line(),
                args: format!("{}", record.args()),
                module_path: record.module_path_static(),
            })
        }

pub fn target(&self) -> &'a str

The name of the target of the directive.

pub fn module_path(&self) -> Option<&'a str>

The module path of the message.

pub fn module_path_static(&self) -> Option<&'static str>

The module path of the message, if it is a 'static string.

Examples found in repository

examples/custom-format.rs (line 25)

        fn msg(&self, record: &Record) -> Box<dyn Send + Sync + std::fmt::Display> {
            Box::new(Msg {
                level: record.level(),
                thread: std::thread::current().name().map(|n| n.to_string()),
                file: record.file_static(),
                line: record.line(),
                args: format!("{}", record.args()),
                module_path: record.module_path_static(),
            })
        }

pub fn file(&self) -> Option<&'a str>

The source file containing the message.

Examples found in repository

examples/string-bench.rs (line 42)

    fn msg(&self, record: &Record) -> Box<dyn Send + Sync + std::fmt::Display> {
        Box::new(format!(
            "{} {}/{}:{} {}",
            record.level(),
            std::thread::current().name().unwrap_or_default(),
            record.file().unwrap_or(""),
            record.line().unwrap_or(0),
            record.args()
        ))
    }

pub fn file_static(&self) -> Option<&'static str>

The source file containing the message, if it is a 'static string.

Examples found in repository

examples/custom-format.rs (line 22)

        fn msg(&self, record: &Record) -> Box<dyn Send + Sync + std::fmt::Display> {
            Box::new(Msg {
                level: record.level(),
                thread: std::thread::current().name().map(|n| n.to_string()),
                file: record.file_static(),
                line: record.line(),
                args: format!("{}", record.args()),
                module_path: record.module_path_static(),
            })
        }

pub fn line(&self) -> Option<u32>

The line containing the message.

Examples found in repository

examples/string-bench.rs (line 43)

    fn msg(&self, record: &Record) -> Box<dyn Send + Sync + std::fmt::Display> {
        Box::new(format!(
            "{} {}/{}:{} {}",
            record.level(),
            std::thread::current().name().unwrap_or_default(),
            record.file().unwrap_or(""),
            record.line().unwrap_or(0),
            record.args()
        ))
    }

examples/custom-format.rs (line 23)

        fn msg(&self, record: &Record) -> Box<dyn Send + Sync + std::fmt::Display> {
            Box::new(Msg {
                level: record.level(),
                thread: std::thread::current().name().map(|n| n.to_string()),
                file: record.file_static(),
                line: record.line(),
                args: format!("{}", record.args()),
                module_path: record.module_path_static(),
            })
        }

pub fn key_values(&self) -> &dyn Source

The structured key-value pairs associated with the message.

pub fn to_builder(&self) -> RecordBuilder<'_>

Create a new RecordBuilder based on this record.

Trait Implementations

impl<'a> Clone for Record<'a>

fn clone(&self) -> Record<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Record<'a>

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

Formats the value using the given formatter.