Struct ObservabilityConfig 

pub struct ObservabilityConfig {
    pub max_event_bytes: usize,
    pub max_stream_events: u64,
    pub max_batch_events: Option<usize>,
    pub max_batch_hold_ms: Option<u64>,
}

Agent-observability transcript settings from [observability]: retention bounds, and the transcript drain’s flush policy.

The two RETENTION knobs default (they guard the durable O keyspace against unbounded growth): max_event_bytes truncates one oversized transcript event before it is persisted, and max_stream_events caps how many events one (workflow, activity, attempt) stream retains (one marker record is persisted at the cap; live streaming continues).

The two FLUSH knobs have no default and are required — see Self::max_batch_events.

Fields

max_event_bytes: usize

Ceiling on one persisted transcript event’s serialized size, bytes.

max_stream_events: u64

Ceiling on retained events per (workflow, activity, attempt) stream.

max_batch_events: Option<usize>

Maximum transcript events the drain commits in ONE durable append. Required; no default — the server refuses to start without it.

Every durable commit re-persists its whole containing storage leaf as a new permanent blob, so committing one event at a time made the store cost of a run linear in event COUNT: measured 2026-08-17, a 136 KB status sweep left 73.7 MB of permanent store (540x) and a single 2,359-byte append bought a 2,303,416-byte blob. Batching divides that count by (up to) this number.

There is deliberately no shipped value: the trade between store cost and how many events one refused commit can lose is the operator’s, and an invented default would silently make it for them. Absent or zero fails startup with OBSERVABILITY_MAX_BATCH_EVENTS_REQUIRED, the same explicit-no-default guard websocket.cluster_broadcast_capacity uses.

max_batch_hold_ms: Option<u64>

How long, in milliseconds, the drain may hold a PARTIAL batch open waiting for it to fill. Required; no default — but 0 is a valid, meaningful setting: never wait, commit whatever is already queued.

This is the only knob here that touches durability timing. Transcript events already wait in an in-memory queue before they are committed, and everything queued there is lost if the process dies; this value bounds how much LONGER an event may wait, and therefore how much transcript a kill-9 can cost. It buys commits: at 0 only events that genuinely arrived together share a commit. The O keyspace is observability, never workflow replay authority, which is why the trade is offered at all.

Absent fails startup with OBSERVABILITY_MAX_BATCH_HOLD_MS_REQUIRED.

Implementations

impl ObservabilityConfig

pub fn with_flush_policy( max_batch_events: usize, max_batch_hold_ms: u64, ) -> Self

The default retention bounds with the REQUIRED flush policy stated.

For an embedder that builds its ServerConfig in code rather than from a file: Default deliberately leaves the flush policy unruled (so a server built from it refuses to start), and this is how such a caller states its ruling in one line. max_batch_hold_ms of 0 means the drain never holds a partial batch open.

Trait Implementations

impl Clone for ObservabilityConfig

fn clone(&self) -> ObservabilityConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for ObservabilityConfig

impl Debug for ObservabilityConfig

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

Formats the value using the given formatter.

impl Default for ObservabilityConfig

fn default() -> Self

The retention bounds fall back to their documented defaults; the flush policy does NOT — None here is “the operator has not ruled”, which the boot path turns into a refusal to start, not into a guess.

impl<'de> Deserialize<'de> for ObservabilityConfig

where ObservabilityConfig: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ObservabilityConfig

impl PartialEq for ObservabilityConfig

fn eq(&self, other: &ObservabilityConfig) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ObservabilityConfig