Struct RecorderBuilder

pub struct RecorderBuilder<M = Disk>where
    M: BufferMode,
{ /* private fields */ }

Available on crate feature dial9 only.

Expand description

Builder for a runtime-agnostic Recorder. See recorder.

Implementations§

§

impl<M> RecorderBuilder<M>
where M: BufferMode,

pub fn source(self, source: impl Source + 'static) -> RecorderBuilder<M>

Register a Source drained by the flush thread each cycle.

pub fn source_names(&self) -> impl Iterator<Item = &str>

Names of the registered sources, in registration order.

pub fn writer_boot_id(&self) -> Option<&str>

The writer’s per-process namespace boot id, or None before set_namespace has run.

pub fn segment_metadata( self, entries: impl IntoIterator<Item = (String, String)>, ) -> RecorderBuilder<M>

Static metadata written into every rotated segment header. Merged across calls (and across the tokio layer); on a key collision the later value wins.

§Examples

use dial9_core::buffer::MemoryBuffer;
use dial9_core::recorder::recorder;

let recorder = recorder(MemoryBuffer::new(1024 * 1024)?)
    .segment_metadata([("service".into(), "checkout".into())])
    .segment_metadata([("environment".into(), "production".into())])
    .segment_metadata([("service".into(), "payments".into())])
    .build();

// Metadata is merged across calls. The third call overrides `service`
// from the first, so its value is `payments`.

pub fn metrics_sink(self, sink: BoxEntrySink) -> RecorderBuilder<M>

Metrics sink for the flush (and, with pipeline, worker) threads. Defaults to discarding flush metrics.

pub fn build(self) -> Recorder

Start the recorder and begin recording.

Chain paused beforehand to build without recording, then start it later with Recorder::enable.

Yields a disabled recorder when the writer could not be created (see recorder_or_disabled); the sources and pipeline configured on the way here are never started.

pub fn paused(self) -> RecorderBuilder<M>

Build without recording. Recorder::enable starts it later.

Use for a recorder that should exist but stay quiet until something turns it on; for permanently-off telemetry prefer recorder_disabled, which allocates no writer at all.

pub fn on_recording_start( self, hook: impl FnOnce(&Dial9Handle) + Send + 'static, ) -> RecorderBuilder<M>

Register a hook run once, with the live Dial9Handle, when the recorder starts recording.

pub fn on_recording_thread_start<F, T>(self, hook: F) -> RecorderBuilder<M>
where F: Fn() -> T + Send + Sync + 'static, T: FnOnce() + Send + 'static,

Register a hook run on each of dial9’s own threads (the flush thread and, with pipeline, the background worker) before it starts, returning a teardown run when it stops. Defaults to a no-op.

pub fn with_custom_events<F>( self, config: CustomEventsConfig, callback: F, ) -> RecorderBuilder<M>
where F: for<'a> FnMut(&mut CustomEventsContext<'a>) + Send + 'static,

Register a callback that dial9 invokes on the flush thread at the config’s interval to emit custom events. Sugar for source with a CustomEventsSource. Not tokio-coupled — works on the plain recorder and the tokio builder.

§