Struct RecorderBuilder 

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

Available on crate feature dial9 only.

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.

impl<M> RecorderBuilder<M>

where M: BufferMode,

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

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>>, ) -> RecorderBuilder<M>

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, ) -> RecorderBuilder<M>

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) -> RecorderBuilder<M>

Available on crate feature pipeline only.

How often the background worker polls for sealed segments.

pub fn trigger(self, trigger: DumpRx) -> RecorderBuilder<M>

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) -> RecorderBuilder<M>

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> Debug for RecorderBuilder<M>

where M: BufferMode,

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

Formats the value using the given formatter.

impl<M> RecorderPipelineExt<M> for RecorderBuilder<M>

where M: BufferMode,

fn with_custom_pipeline<F>(self, build: F) -> RecorderBuilder<M>

where F: FnOnce(PipelineBuilder<M>) -> PipelineBuilder<M>,

Replace the default pipeline with your own processors, run verbatim.

impl<M> RecorderSourceExt for RecorderBuilder<M>

where M: BufferMode,

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

Register a Source with the underlying recording recorder.

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.

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.

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.