Struct Recorder 

pub struct Recorder { /* private fields */ }

Available on crate feature dial9 only.

Owns the recording state: the Dial9Handle, the flush thread, and (with the pipeline feature) the background worker.

This is an RAII guard: dropping it flushes remaining events, seals the final segment, and stops the worker. For a bounded drain of the background worker (symbolize, compress, upload) call graceful_shutdown instead.

Implementations

impl Recorder

pub fn handle(&self) -> &Dial9Handle

The recording handle for this recorder.

pub fn install_global_handle(&self) -> Result<(), InstallGlobalHandleError>

Publish this recorder’s handle as the process-global one.

When set, Dial9Handle::current resolves on every thread in the process. When not set, it resolves only on threads a runtime integration has installed a handle on.

Returns InstallGlobalHandleError and changes nothing if another handle is already installed: two live globals would split one process’s events across two traces. A recorder clears its own when it stops, so a later install succeeds.

use dial9_core::buffer::MemoryBuffer;
use dial9_core::handle::Dial9Handle;
use dial9_core::recorder::recorder;
use dial9_trace_format::TraceEvent;

#[derive(TraceEvent)]
struct Tick {
    #[traceevent(timestamp)]
    timestamp_ns: u64,
}

let rec = recorder(MemoryBuffer::new(1 << 20)?).build();
rec.install_global_handle()?;

std::thread::spawn(|| {
    // reachable here, with no handle plumbed in
    Dial9Handle::current().record_event(Tick { timestamp_ns: 0 });
});

pub fn start_time(&self) -> Option<u64>

Monotonic start time of the recorder in nanoseconds.

pub fn enable(&self)

Enable recording.

pub fn disable(&self)

Disable recording.

pub fn graceful_shutdown(self, timeout: Duration)

Flush remaining events, seal the final segment, and (with pipeline) wait for the background worker to drain within timeout.

Call this after any runtime that owns worker threads has been dropped, so their thread-local buffers have already been flushed. Consumes the recorder so Drop becomes a no-op.

Failures during draining are logged.

Trait Implementations

impl Debug for Recorder

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

Formats the value using the given formatter.

impl Drop for Recorder

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.