Struct RecorderBuilder 

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

Builder for a runtime-agnostic Recorder. See recorder.

Implementations

impl<M: BufferMode> RecorderBuilder<M>

pub fn source(self, source: impl Source + 'static) -> Self

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)>, ) -> Self

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) -> Self

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) -> Self

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.

impl<M: BufferMode> RecorderBuilder<M>

pub fn pipe(self, processor: impl SegmentProcessor + 'static) -> Self

Available on crate feature pipeline only.

Append a segment processor (compress, symbolize, upload, write-back), replacing dial9’s default pipeline with your own stages.

pub fn processors(self, processors: Vec<Box<dyn SegmentProcessor>>) -> Self

Available on crate feature pipeline only.

Set the full processor pipeline at once, replacing dial9’s default and anything added with pipe. Use this when you already have a built list, or pipe to append incrementally.

pub fn terminal_processor( self, processor: impl SegmentProcessor + 'static, ) -> Self

Available on crate feature pipeline only.

Replace write-back as the last stage of the default pipeline, so sealed segments are shipped elsewhere instead of written back to disk. This also makes processing meaningful even with no other stage, so the worker still runs.

Ignored when a custom pipeline is set. The S3 uploader is wired up this way.

pub fn worker_poll_interval(self, interval: Duration) -> Self

Available on crate feature pipeline only.

How often the background worker polls for sealed segments.

pub fn trigger(self, trigger: DumpRx) -> Self

Available on crate feature pipeline only.

Trigger receiver switching the worker into on-demand dump mode; see crate::dump. None keeps continuous mode.

pub fn with_dump_trigger<F>(self, configure: F) -> Self

where F: FnOnce(&mut DumpTriggerConfig),

Available on crate feature pipeline only.

Enable on-demand dump mode: the background worker runs the pipeline only when a dump is requested through the DumpTrigger, reachable from any recording thread via Dial9Handle::dump_trigger. Pass |_| {} for the default, or |t| { t.debounce(window); } to coalesce bursts.

Trait Implementations

impl<M: BufferMode> Debug for RecorderBuilder<M>

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

Formats the value using the given formatter.

impl<M: BufferMode> RecorderSourceExt for RecorderBuilder<M>

fn source(self, source: impl Source + 'static) -> Self

Register a Source with the underlying recording recorder.

fn on_recording_start( self, hook: impl FnOnce(&Dial9Handle) + Send + 'static, ) -> Self

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

fn on_recording_thread_start<F, T>(self, hook: F) -> Self

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.

fn with_custom_events<F>(self, config: CustomEventsConfig, callback: F) -> Self

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.