Struct SingleSubscriberOutputStream 

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

The output stream from a process. Either representing stdout or stderr.

This is the single-subscriber variant, allowing exactly one active consumer at a time. It is useful when one inspector, collector, or line waiter should own the stream and accidental concurrent fanout should be rejected early. It can reduce coordination overhead in some single-consumer paths, but it is not a categorical throughput replacement for broadcast. If multiple concurrent consumers are required, use the output_stream::backend::broadcast::BroadcastOutputStream.

Implementations

impl<D, R> SingleSubscriberOutputStream<D, R>

where D: Delivery, R: Replay,

pub fn replay_enabled(&self) -> bool

Returns whether replay-specific APIs are enabled for this stream.

pub fn replay_retention(&self) -> Option<ReplayRetention>

Returns the configured replay retention.

impl<D> SingleSubscriberOutputStream<D, ReplayEnabled>

where D: Delivery,

pub fn seal_replay(&self)

Seals replay history for future subscribers.

This is a one-way, idempotent operation.

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> SingleSubscriberOutputStream<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, ) -> Result<impl Future<Output = Result<WaitForLineResult, StreamReadError>> + Send + 'static, StreamConsumerError>

Tries to wait for a line that matches the given predicate within timeout.

Errors

Returns StreamConsumerError if the backend rejects the line waiter.

Panics

Panics if options.max_line_length is zero.

Trait Implementations

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

where D: Delivery, R: Replay,

type Error = StreamConsumerError

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 SingleSubscriberOutputStream<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 SingleSubscriberOutputStream<D, R>

where D: Delivery, R: Replay,

fn drop(&mut self)

Executes the destructor for this type.

impl<D, R> OutputStream for SingleSubscriberOutputStream<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 SingleSubscriberOutputStream<D, R>

where D: Delivery, R: Replay,

type Subscription = SingleSubscriberSubscription

The concrete subscription handle returned by try_subscribe.

type SubscribeError = StreamConsumerError

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.