Struct Log 

pub struct Log {
    pub session_id: u64,
    pub time: Cow<'static, str>,
    pub level: LogLevel,
    pub component: Cow<'static, str>,
    pub description: String,
    pub format: LogFormat,
    pub attributes: BTreeMap<String, Value>,
}

A structured log entry with a chainable builder API.

Fields use Cow<'static, str> and u64 where possible to minimize heap allocations on the ingestion hot path.

Construct via level shortcuts (Log::info, Log::error, …) or the generic Log::build. Dispatch with Log::fire.

Fields

session_id: u64

Monotonic counter assigned at build() time.

time: Cow<'static, str>

Wall-clock timestamp. Populated at build time; override with .time().

level: LogLevel

Severity level (INFO, ERROR, etc.).

component: Cow<'static, str>

Originating service or module name. Defaults to "default".

description: String

Human-readable message body.

format: LogFormat

Output format applied during Display serialization.

attributes: BTreeMap<String, Value>

Arbitrary key-value attributes for structured context.

Implementations

impl Log

pub fn log(&self)

Ingest this entry into the engine by cloning it.

Prefer fire(), which consumes self and avoids the clone. Use log() only when you need to retain the entry.

pub fn info(description: &str) -> Self

Build an INFO-level log entry.

pub fn warn(description: &str) -> Self

Build a WARN-level log entry.

pub fn error(description: &str) -> Self

Build an ERROR-level log entry.

pub fn debug(description: &str) -> Self

Build a DEBUG-level log entry.

pub fn trace(description: &str) -> Self

Build a TRACE-level log entry.

pub fn verbose(description: &str) -> Self

Build a VERBOSE-level log entry.

pub fn fatal(description: &str) -> Self

Build a FATAL-level log entry.

pub fn critical(description: &str) -> Self

Build a CRITICAL-level log entry.

pub fn build(level: LogLevel, description: &str) -> Self

Build a log entry with an explicit level and description.

Assigns a monotonic session_id and captures the current wall-clock time. Defaults to LogFormat::MCP and component "default".

pub fn time(self, time: &str) -> Self

Override the timestamp for this entry.

pub const fn session_id(self, session_id: u64) -> Self

Override the auto-assigned session ID.

pub fn with<T: Serialize>(self, key: &str, value: T) -> Self

Attach a key-value attribute. Accepts any T: Serialize.

pub fn component(self, component: &str) -> Self

Tag the originating service or module.

pub const fn format(self, format: LogFormat) -> Self

Set the output format for this entry.

pub fn fire(self)

Consume this entry and push it into the ring buffer.

Cost: one Log move (~128 bytes). Serialization is deferred. Automatically captures file:line via #[track_caller].

Trait Implementations

impl Clone for Log

fn clone(&self) -> Log

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Log

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

Formats the value using the given formatter.

impl Default for Log

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Log

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Log

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

Formats the value using the given formatter.

impl PartialEq for Log

fn eq(&self, other: &Log) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Log

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Log

impl StructuralPartialEq for Log