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

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

Trait Implementations

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

fn clone(&self) -> Self

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

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

Auto Trait Implementations

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

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

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

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

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

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

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

Blanket Implementations

`impl<T> Any for Record<'a> where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for Record<'a> where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for Record<'a> where T: ?Sized,`

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

`impl<T> CloneToUninit for Record<'a> where T: Clone,`

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

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

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

`impl<T> ToOwned for Record<'a> where T: Clone,`

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

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

fn into(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> where U: Into<T>,`

type Error = never;
fn try_from(value: U) -> Result<T, never>

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

type Error = >::Error;
fn try_into(self) -> Result<U, >::Error>