Struct `Record`

struct Record<'a> { ... }

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>`

fn builder() -> RecordBuilder<'a>: Returns a new builder.
fn args(self: &Self) -> &fmt::Arguments<'a>: The message body.
fn metadata(self: &Self) -> &Metadata<'a>: Metadata about the log directive.
fn level(self: &Self) -> Level: The verbosity level of the message.
fn target(self: &Self) -> &'a str: The name of the target of the directive.
fn module_path(self: &Self) -> Option<&'a str>: The module path of the message.
fn module_path_static(self: &Self) -> Option<&'static str>: The module path of the message, if it is a 'static string.
fn file(self: &Self) -> Option<&'a str>: The source file containing the message.
fn file_static(self: &Self) -> Option<&'static str>: The source file containing the message, if it is a 'static string.
fn line(self: &Self) -> Option<u32>: The line containing the message.

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

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

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

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

`impl<'a> Freeze for Record<'a>`

`impl<'a> RefUnwindSafe for Record<'a>`

`impl<'a> Send for Record<'a>`

`impl<'a> Sync for Record<'a>`

`impl<'a> Unpin for Record<'a>`

`impl<'a> UnwindSafe for Record<'a>`

`impl<T> Any for Record<'a>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Record<'a>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Record<'a>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for Record<'a>`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for Record<'a>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for Record<'a>`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for Record<'a>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Record<'a>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Record<'a>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>