Struct SessionEvents 

pub struct SessionEvents { /* private fields */ }

The stream of session-level events.

Handed back by Client::connect, alongside the client itself, because a caller that never reads it should have to decide that on purpose rather than by omission. It implements futures_util::Stream.

Dropping this stream

Dropping it means “I do not want session events”. The client keeps running exactly as before — reconnection, recovery and resubscription all still happen — you simply stop being told about them. Nothing blocks and nothing leaks.

Backpressure: bounded, and nothing is dropped

The stream is fed by a bounded channel of ConnectionOptions::with_session_event_capacity events — 256 by default. While you hold it, the client blocks rather than discarding an event when the buffer is full, and that backpressure reaches the socket. A held-but-unread stream will therefore stall the client once it fills.

The reasoning is the same as for Updates: these events are what tell an application whether its derived state survived, so silently dropping one would be worse than making a slow consumer visible. If you do not intend to read them, drop the stream — that is the supported way to opt out.

A stall longer than the session’s keepalive interval provokes a reconnection, for the reason set out under Updates. Holding this stream and not reading it is the one shape to avoid.

As with Updates, losslessness holds while the client is running and yields to an ordered shutdown: a stream nobody is reading cannot keep a client that has been asked to stop alive. Anything not yet delivered when that happens goes with the stream.

Events from before this stream existed

Client::connect hands this over once the session is bound, so nobody can hold it while the connection attempts that preceded the bind are happening. Those events are not lost: they are replayed here first, in the order they occurred. Past the configured capacity they are discarded with a warning instead — there is no consumer for them yet, and waiting for one would deadlock the very bind that produces this stream.

Examples

let (client, events) = Client::connect(config).await?;
// Not interested: opt out explicitly, and nothing ever blocks on it.
drop(events);

Trait Implementations

impl Debug for SessionEvents

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

Formats the value using the given formatter.

impl Stream for SessionEvents

type Item = SessionEvent

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.