Struct ScopedGuard 

pub struct ScopedGuard<K: Key, F>
where
    F: FnOnce(&WideEvent<K>) + Send + 'static,
{ /* private fields */ }

RAII guard that owns a WideEvent and emits it on drop.

The guard starts a timer on creation. On drop, it sets the duration field (via Key::DURATION_PATH) to the elapsed milliseconds, sets the timestamp field (via Key::TIMESTAMP_PATH) to the current time as an RFC 3339 string in the guard’s timezone, and calls the emit function with a reference to the event.

Implements Deref / DerefMut to WideEvent so you can call add, add_path, inc, etc. directly on the guard.

The wide_log! macro generates a WideLogGuard that wraps this guard and manages the thread-local / task-local pointer. Users typically interact with WideLogGuard, not ScopedGuard directly.

Implementations

impl<K: Key, F> ScopedGuard<K, F>

where F: FnOnce(&WideEvent<K>) + Send + 'static,

pub fn new_with_tz(emit_fn: F, tz: Tz) -> Self

Creates a new guard with the given emit function and timezone.

The timezone is used to format the timestamp set on drop.

Methods from Deref<Target = WideEvent<K>>

pub fn add_path<V: Into<Value<K>>>(&mut self, path: &[K], value: V)

Set a value at a nested path. Traverses/creates intermediate objects.

pub fn inc_path(&mut self, path: &[K])

pub fn dec_path(&mut self, path: &[K])

pub fn add_n_path(&mut self, path: &[K], n: i64)

pub fn append_log_entry(&mut self, level: &'static str, message: &str)

pub fn append_log_entry_static( &mut self, level: &'static str, message: &'static str, )

Append a log entry with a &'static str message — zero-copy.

pub fn to_json(&self) -> Result<String, Error>

pub fn serialize_to<W: Write>(&self, w: &mut W) -> Result<(), Error>

Serialize directly to a writer, bypassing serde entirely. Uses itoa/ryu for zero-allocation number formatting.

Trait Implementations

impl<K: Key, F> Deref for ScopedGuard<K, F>

where F: FnOnce(&WideEvent<K>) + Send + 'static,

type Target = WideEvent<K>

The resulting type after dereferencing.

fn deref(&self) -> &WideEvent<K>

Dereferences the value.

impl<K: Key, F> DerefMut for ScopedGuard<K, F>

where F: FnOnce(&WideEvent<K>) + Send + 'static,

fn deref_mut(&mut self) -> &mut WideEvent<K>

Mutably dereferences the value.

impl<K: Key, F> Drop for ScopedGuard<K, F>

where F: FnOnce(&WideEvent<K>) + Send + 'static,

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.