Struct BroadcastOutputStream 

pub struct BroadcastOutputStream<D = LossyWithoutBackpressure, R = NoReplay>
where
    D: Delivery,
    R: Replay,
{ /* private fields */ }

The output stream from a process using a multi-consumer broadcast backend.

Broadcast streams support multiple consumers and can optionally retain replay history for consumers that attach after output has already arrived. Use this backend when the same stream needs concurrent fanout, such as logging plus readiness checks or logging plus collection. Delivery policy still determines whether slow active consumers observe gaps or apply backpressure.

Implementations

impl<D> BroadcastOutputStream<D, ReplayEnabled>

where D: Delivery,

pub fn seal_replay(&self)

Seals replay history for future subscribers.

This is a one-way, idempotent operation. Active subscribers keep their unread tail data according to the configured delivery policy.

Panics

Panics if the internal state mutex is poisoned.

pub fn is_replay_sealed(&self) -> bool

Returns true once replay history has been sealed.

Panics

Panics if the internal state mutex is poisoned.

impl<D, R> BroadcastOutputStream<D, R>

where D: Delivery, R: Replay,

pub fn wait_for_line( &self, timeout: Duration, predicate: impl Fn(Cow<'_, str>) -> bool + Send + 'static, options: LineParsingOptions, ) -> impl Future<Output = Result<WaitForLineResult, StreamReadError>> + Send + 'static

Waits for a line that matches the given predicate within timeout.

The returned future resolves to Ok(WaitForLineResult::Matched) if a matching line is found, Ok(WaitForLineResult::StreamClosed) if the stream ends first, or Ok(WaitForLineResult::Timeout) if the timeout expires first.

The stream subscription is acquired synchronously inside this method, before the returned future is polled, so output produced between this call and the first .await cannot race ahead of the matcher.

The waiter starts at the earliest output currently available to new consumers. With replay enabled and unsealed, that can include retained past output; otherwise it starts at live output.

When chunks are dropped in DeliveryGuarantee::LossyWithoutBackpressure mode, this waiter discards any partial line in progress and resynchronizes at the next newline instead of matching across the gap.

Errors

Returns crate::StreamReadError if the underlying stream fails while being read.

Panics

Panics if options.max_line_length is zero.

Trait Implementations

impl<D, R> Consumable for BroadcastOutputStream<D, R>

where D: Delivery, R: Replay,

type Error = Infallible

Error returned when consumer creation fails. Must be constructible from the underlying Subscribable::SubscribeError so the default consume / consume_async impls can propagate subscription failures.

fn consume<V>(&self, visitor: V) -> Result<Consumer<V::Output>, Self::Error>

where V: StreamVisitor, Self: OutputStream,

Tries to drive the provided synchronous StreamVisitor over this stream and returns a Consumer that owns the spawned task.

fn consume_async<V>( &self, visitor: V, ) -> Result<Consumer<V::Output>, Self::Error>

where V: AsyncStreamVisitor, Self: OutputStream,

Tries to drive the provided asynchronous AsyncStreamVisitor over this stream and returns a Consumer that owns the spawned task.

impl<D, R> Debug for BroadcastOutputStream<D, R>

where D: Delivery + Debug, R: Replay + Debug,

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

Formats the value using the given formatter.

impl<D, R> Drop for BroadcastOutputStream<D, R>

where D: Delivery, R: Replay,

fn drop(&mut self)

Executes the destructor for this type.

impl<D, R> OutputStream for BroadcastOutputStream<D, R>

where D: Delivery, R: Replay,

fn read_chunk_size(&self) -> NumBytes

The maximum size of every chunk read by the backing stream_reader.

fn max_buffered_chunks(&self) -> usize

The number of chunks held by the underlying async channel.

fn name(&self) -> &'static str

Type of stream. Can be “stdout” or “stderr”. But we do not guarantee this output. It should only be used for logging/debugging.

impl<D, R> Subscribable for BroadcastOutputStream<D, R>

where D: Delivery, R: Replay,

type Subscription = BroadcastSubscription<D, R>

The concrete subscription handle returned by try_subscribe.

type SubscribeError = Infallible

The error returned when subscription fails.

fn try_subscribe(&self) -> Result<Self::Subscription, Self::SubscribeError>

Creates a new subscription for a consumer, or returns why the consumer cannot be started.