Enum IbkrFlexError 

#[non_exhaustive]
pub enum IbkrFlexError {
    EnvVar(String),
    InvalidCredential(String),
    Http(Error),
    HttpStatus {
        status: u16,
        body: String,
    },
    Flex {
        code: String,
        message: String,
    },
    PollTimeout {
        attempts: u32,
    },
    Parse(String),
}

Errors from IBKR Flex Web Service operations.

#[non_exhaustive]: the Flex service may introduce new failure conditions over time, so new variants can be added without a breaking change; downstream matches must include a wildcard arm.

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.

EnvVar(String)

A required environment variable is not set (see IbkrFlexConfig::from_env).

InvalidCredential(String)

A supplied credential (the Flex token or query_id) is empty after trimming surrounding whitespace. Raised by IbkrFlexConfig::new so a malformed credential fails observably at construction, naming the offending field, rather than later as an opaque IBKR 1003 “invalid token” after a live fetch.

Http(Error)

Transport-level HTTP error (connection, timeout, or body-decode failure).

A non-2xx HTTP status no longer surfaces here: the client reads the response body before branching on status and reports a non-success status as IbkrFlexError::HttpStatus (or the richer IbkrFlexError::Flex when the body is a Flex error envelope). This variant is now purely a connection/timeout/decode failure.

The inner reqwest::Error never carries the request URL. The Flex token is transmitted as t=<TOKEN> in every request URL, and reqwest::Error’s Display and Debug both embed that URL verbatim when present. The From<reqwest::Error> conversion for this type always strips it via reqwest::Error::without_url before the error is stored, covering every reqwest site that attaches a URL (send, body decode); Client::build() errors carry no URL, so the strip is a no-op for them. The source() chain (hyper/IO transport errors) is preserved and does not independently carry the URL.

Safe to log or display without credential scrubbing.

HttpStatus

The service returned a non-success HTTP status whose body was not a recognizable Flex envelope — e.g. a proxy/CDN/WAF error page or a gateway timeout served in front of the Flex Web Service.

The body is read before the status is inspected (so the diagnostic is preserved rather than discarded by error_for_status), then bounded to 1 KiB and token-scrubbed before storage: the Flex token rides in the request URL’s t= parameter, so a proxy that echoes the request line into its error page could otherwise reflect the credential into this body. The scrub is best-effort defense-in-depth — it redacts both the raw token and the encoded form it takes on the wire. An IBKR application error that arrives under a non-2xx status is still surfaced as the richer IbkrFlexError::Flex, not here.

Fields

status: u16

The non-success HTTP status code.

body: String

A bounded, token-scrubbed slice of the response body.

Flex

The Flex service returned a non-success status (e.g. invalid token, throttled, expired).

message is the <ErrorMessage> element lifted from a server-supplied body, so — like IbkrFlexError::HttpStatus and IbkrFlexError::Parse — both fields are bounded to 1 KiB and token-scrubbed before storage: a proxy that reflected the request line into its <ErrorMessage> could otherwise carry the t= Flex token into it. The scrub is a no-op for a real numeric Flex code/message that does not contain the token.

Fields

code: String

The Flex ErrorCode (empty if the response carried none), bounded and token-scrubbed like message.

message: String

The Flex ErrorMessage (or a synthesised description), bounded and token-scrubbed.

PollTimeout

The statement was still generating after the configured poll budget was exhausted.

Fields

attempts: u32

Number of poll attempts made before giving up — the configured FlexPollPolicy::max_attempts (12 by default), since this error fires only after every attempt reported the statement still generating.

Parse(String)

The statement or status XML could not be parsed.

A parse message embeds the deserialiser’s own rendering of the offending input, so its length tracks the document rather than the failure, and a document that reflected the request line could carry the t= credential into it. This variant is therefore always bounded to 1 KiB, and token-scrubbed on every path where a token is in scope — the same protection IbkrFlexError::HttpStatus gets, for the same reason.

Scrubbing covers every Parse returned by IbkrFlexClient::fetch_statement_xml and IbkrFlexClient::fetch_corporate_actions. The one path it cannot cover is calling parse_corporate_actions directly: there the caller supplies its own XML and no token exists to redact. Such a message is still bounded — just not scrubbed, since there is nothing to scrub against.

Trait Implementations

impl Debug for IbkrFlexError

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

Formats the value using the given formatter.

impl Display for IbkrFlexError

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

Formats the value using the given formatter.

impl Error for IbkrFlexError

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 IbkrFlexError

Convert a reqwest::Error into IbkrFlexError::Http with its request URL stripped.

The Flex token rides in the t= query parameter (IBKR’s protocol), so it is part of every request URL. reqwest::Error’s Display/Debug embed the stored URL verbatim — e.g. "... for url (https://.../SendRequest?t=<TOKEN>&q=...)" — so an unstripped error would leak the credential into any log that formats IbkrFlexError::Http (the shipped example does exactly that).

Stripping lives in this single conversion rather than per-call-site discipline so the “IbkrFlexError::Http never carries the URL” invariant is enforced by the type system: every ? on a reqwest::Error — at the request sites (send, body decode) and any path added later — routes through here. reqwest::Error::without_url sets the stored URL to None (a no-op for Client::build() errors, which carry none) while preserving the diagnostic kind/status and source() chain.

fn from(error: Error) -> Self

Converts to this type from the input type.