Enum BudgetExceeded 

#[non_exhaustive]
pub enum BudgetExceeded {
    Steps {
        allowed: usize,
    },
    Effects {
        allowed: usize,
        used: usize,
    },
    Replans {
        allowed: u32,
    },
    Denials {
        allowed: u32,
    },
    Recorded {
        limit: String,
        used: String,
    },
    Tokens {
        allowed: u64,
        used: u64,
    },
    Money {
        allowed: u64,
        used: u64,
    },
    Wallclock {
        allowed: u64,
        used: u64,
    },
    Egress {
        allowed: u64,
        used: u64,
        attempted: u64,
    },
    Rate {
        grant: String,
        allowed: u32,
        window_seconds: u64,
        reached: u64,
    },
}

Which limit stopped the run, and where it stood.

Carries the numbers rather than a message: an operator raising a limit needs to know what it actually reached, and “budget exhausted” does not say.

Why the messages state a rule and not a tally

Every metered ceiling here is a pre-dispatch gate on reaching the limit: nothing further starts once the figure is at the ceiling, because a step that would exceed it must not half-run and then be stopped. The refusal is therefore raised at used == allowed, where {allowed} permitted, {used} consumed prints two equal numbers beside the word exhausted and reads like an off-by-one. Telling otherwise means finding the comparison in this file, and a refusal message is the one artifact put in front of somebody who never will. So each states its rule. Egress is the exception twice over: an outbound size is known before dispatch, so that ceiling is exact rather than reached, and its message says what the refused call would have sent.

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.

Steps

Fields

allowed: usize

Effects

Fields

allowed: usize

used: usize

Replans

Fields

allowed: u32

Denials

The run was refused by the policy more often than it is allowed to be.

Not a policy failure — a probing ceiling. See Budget::max_denials.

Fields

allowed: u32

Recorded

A refusal read back from the journal.

Carries the recorded limit rather than the one in force now, because a run replayed under a larger budget still stopped where it stopped.

Fields

limit: String

used: String

Tokens

Fields

allowed: u64

used: u64

Money

Fields

allowed: u64

used: u64

Wallclock

Fields

allowed: u64

used: u64

Egress

The run tried to send more than it may.

Carries attempted as well as used, which the metered ceilings cannot: this one is checked against a size known before dispatch, so an operator raising the limit sees both where the run stood and what it was about to send — and can tell a ceiling that is too low from one call that is too big.

Fields

allowed: u64

used: u64

attempted: u64

Rate

A tool’s cross-run rate ceiling had no room for this call.

Not this run’s consumption: the count is the tenant’s, across runs, so reached is how many calls to grant already fell in the window. The window slides, so a resume once enough of them have aged out continues the run.

Fields

grant: String

allowed: u32

window_seconds: u64

reached: u64

Implementations

impl BudgetExceeded

pub const fn as_str(&self) -> &'static str

Which limit was hit, for a metric label.

The variant only — never the rendered message. Display here embeds the allowed and used figures, and a label carrying those is a new time series per distinct budget, which is how a metrics backend falls over. See runtime::metrics.

Trait Implementations

impl Clone for BudgetExceeded

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BudgetExceeded

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BudgetExceeded

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for BudgetExceeded

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

Formats the value using the given formatter.

impl Eq for BudgetExceeded

impl Error for BudgetExceeded

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<BudgetExceeded> for StepError

fn from(source: BudgetExceeded) -> Self

Converts to this type from the input type.

impl JsonSchema for BudgetExceeded

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for BudgetExceeded

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for BudgetExceeded

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for BudgetExceeded