Enum ClientError 

#[non_exhaustive]
pub enum ClientError {
    Transport(Error),
    Http {
        status: u16,
        body: String,
        request_id: Option<String>,
    },
    Auth(String),
    Decode(Error),
    MalformedEvent(String),
    HistoryGap {
        reason: GapReason,
    },
    StreamProtocol {
        message: String,
        request_id: Option<String>,
    },
    Config(String),
    StateStore(StoreError),
    TriggerFailed {
        kind: TriggerKindLabel,
        source: TriggerError,
    },
}

Errors returned by aviso client operations.

Variants are added as new features land. The enum is marked #[non_exhaustive] so downstream match arms must include a wildcard.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Transport(Error)

Network-level failure: connect, TLS, DNS, or partial body read.

Http

Server responded with a non-success HTTP status. Carries the verbatim response body and the server’s X-Request-ID header (if present).

Fields

status: u16

HTTP status code from the response.

body: String

Verbatim response body (may be empty).

request_id: Option<String>

Server-supplied X-Request-ID header, when present.

Auth(String)

Authentication setup, token refresh, or auth source resolution failed.

Decode(Error)

Failed to decode a response body as JSON.

MalformedEvent(String)

CloudEvent envelope contained a malformed event id. Terminal per D9 to avoid reconnect livelock on a poisoned server stream.

HistoryGap

A gap was detected in the watch stream. The accompanying GapReason explains why.

This variant is surfaced on the watch stream when the supervisor detects either a non-consecutive sequence number on the wire or a server-emitted notification_replay_limit_reached signal. The watch terminates after this error because continuing past a known gap would silently violate at-least-once delivery.

Fields

reason: GapReason

The kind of gap that was detected.

StreamProtocol

A wire-protocol-level fatal condition was observed on the watch stream.

Surfaced when the server emits an error SSE event, when a connection-closing frame carries an unrecognised reason, or when any other recognised-shape frame is fundamentally not implementable by this client. The message is taken verbatim from the server payload when one is provided. request_id carries the server-supplied correlation id when the payload includes one.

Distinct from ClientError::Http, which describes a non-success HTTP status on the initial response; StreamProtocol is for fatal frames that arrive over a stream that initially returned 200.

Fields

message: String

Human-readable description from the server-side payload.

request_id: Option<String>

Server-supplied X-Request-ID-equivalent value, when present.

Config(String)

Configuration-time error (invalid auth source, missing field, and so on).

StateStore(StoreError)

Persistent state-store operation failed during a watch session.

Surfaced when crate::state::StateStore::get or crate::state::StateStore::put returns an error while the watch supervisor is consulting or updating the durable resume cursor. The supervisor cannot continue at-least-once delivery without a working store, so this error is terminal: the stream yields None after it.

The #[from] impl preserves the underlying error chain (StoreError::Io, StoreError::Decode, and so on) so callers can classify the root cause via source() if they need to.

TriggerFailed

A required trigger failed after all configured retries.

Surfaced when a crate::watch::Trigger configured on a crate::watch::WatchRequest with required: true (the default) exhausts its retry budget. Terminal: the stream yields None after this error and the supervisor exits.

The committed checkpoint stays at the previous notification’s sequence (or remains unset if the failing trigger was on the very first notification of the session). On next process start the supervisor re-delivers the notification whose trigger failed.

kind names the trigger for diagnostics; source carries the underlying error (typically a crate::watch::TriggerError::Io).

Fields

kind: TriggerKindLabel

Kind of trigger that failed (echo or log).

source: TriggerError

Inner error from the trigger dispatcher.

Implementations

impl ClientError

pub fn request_id(&self) -> Option<&str>

Returns the server-supplied request-id correlation for variants that carry one, or None otherwise.

Currently this is ClientError::Http and ClientError::StreamProtocol; the other variants either represent client-side conditions (ClientError::Config, ClientError::Auth) or do not reliably carry a server identifier (ClientError::Transport, ClientError::Decode, ClientError::MalformedEvent, ClientError::HistoryGap).

Trait Implementations

impl Debug for ClientError

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

Formats the value using the given formatter.

impl Display for ClientError

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

Formats the value using the given formatter.

impl Error for ClientError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for ClientError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for ClientError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<StoreError> for ClientError

fn from(source: StoreError) -> Self

Converts to this type from the input type.