Struct HeadlessObserver 

pub struct HeadlessObserver { /* private fields */ }

A headless RunObserver: captures lifecycle + log into an outcome, draws nothing. Each concurrent execution gets its own, so events route here via the task-local context (observer::global_observer() resolves to it) and never to a shared global.

Implementations

impl HeadlessObserver

pub fn new() -> Self

Trait Implementations

impl Default for HeadlessObserver

fn default() -> Self

Returns the “default value” for a type.

impl RunObserver for HeadlessObserver

fn phase_starting( &self, _scene_node_id: SceneNodeId, _name: &str, _labels: &str, _ops: usize, _cycles: u64, _conc: usize, )

A phase is about to start executing.

fn phase_completed( &self, _scene_node_id: SceneNodeId, name: &str, labels: &str, duration_secs: f64, )

A phase completed successfully. scene_node_id keys the node to flip (see Self::phase_starting).

fn phase_failed( &self, _scene_node_id: SceneNodeId, name: &str, labels: &str, error: &str, )

A phase failed. scene_node_id keys the node to flip (see Self::phase_starting).

fn phase_progress(&self, _update: &PhaseProgressUpdate)

Update live metrics for the active phase (called at progress tick rate).

fn run_finished(&self)

The entire run is complete.

fn log(&self, _level: LogLevel, message: &str)

Diagnostic log message. Routed to stderr in CLI mode, to a ring buffer in TUI mode. All eprintln! in the runtime should go through this instead.

fn sysmon_update(&self, _sample: &SysmonSample)

A completed sysmon sample window (session-level host utilization). Display surfaces override; everything else ignores it.

fn session_dir_ready(&self, _dir: &Path)

The session directory now exists. Display surfaces that persist a transcript open it here — the runner creates the directory well after the observer is built, so this is the first moment the path is known.

fn op_starting(&self, _parent_phase: SceneNodeId, _op_name: &str)

SRD-63 — an op-level execution leaf became visible (readout: visible, enabled by the readout wrapper). Nests under parent_phase in the hierarchic status view; the consumer assigns its sequence within the phase from arrival order. Default no-op so observers that don’t render op-level leaves (and the zero-cost non-readout path) are unaffected.

fn op_completed( &self, _parent_phase: SceneNodeId, _op_name: &str, _duration_secs: f64, )

An op-level execution leaf completed. duration_secs is the op’s own cumulative execution time. Default no-op.

fn op_measure(&self, _parent_phase: SceneNodeId, _op_name: &str, _text: &str)

The op’s KEY MEASURABLE, rendered from its measure: template at completion — “12 sstables”, “1.4 GiB”, “98.1%”.

fn op_failed(&self, _parent_phase: SceneNodeId, _op_name: &str, _error: &str)

An op-level execution leaf failed. Default no-op.

fn phase_render_attach(&self, _handle: PhaseRenderHandle)

SRD-100 P2 — attach the per-phase PhaseRenderHandle to the live display fold, once, after the activity’s metrics/binder exist (the executor calls this on-task at progress-setup time). Observers that own a run-state actor (TUI / log-only) route it to an AttachPhaseRender mutation so the consumer can fold active_phases and re-derive each phase’s status line itself; the no-op default is correct for surfaces with no live status fold (Stderr / Headless).

fn log_tagged(&self, level: LogLevel, _tag: EventTag, message: &str)

Log a message carrying an explicit EventTag. The default ignores the tag and delegates to Self::log — correct for every observer whose surface treats all events alike. Observers that feed a tag-aware sink (the run-state actor ring) override this to retain both axes.

fn suppresses_stderr(&self) -> bool

Whether to suppress the inline stderr progress line (because the TUI is handling display).

fn live_suppress_flag(&self) -> Option<Arc<AtomicBool>>

Optional shared flag mirroring Self::suppresses_stderr that the runner threads into long-lived components (e.g. the activity’s inline status thread) so they can react to dismissal mid-run rather than honoring a snapshot taken at construction. When None, the activity uses a fresh AtomicBool(false) (never suppress). Implementations that go through a TUI (and only those) typically expose their internal “tui_active” flag here.

fn reporter(&self) -> Option<Box<dyn Reporter>>

Optional reporter to register on the metrics scheduler. The runner calls this once during setup. Return None for observers that don’t need metrics frames (like StderrObserver).

fn reporters(&self) -> Vec<(Duration, Box<dyn Reporter>)>

Multiple reporters with explicit cadences. The runner calls this once during setup. Each (interval, reporter) entry is registered with the scheduler at that interval. The default implementation returns whatever [reporter] produced at the base 1s cadence, so existing observers work unchanged.

fn cadences(&self) -> Option<Cadences>

User-declared cadences for this observer’s consumers (SRD-42).

fn on_metrics_query(&self, _query: Arc<MetricsQuery>)

Callback invoked once the runner has built the shared nmbrs_metrics::metrics_query::MetricsQuery. Observers that render metrics (TUI, CLI status) capture this handle to read cadence windows, now values, and session-lifetime aggregates.

fn scenario_pre_mapped(&self, _tree: &SceneTree)

Pre-populated scenario tree.