Enum Charged 

#[non_exhaustive]
pub enum Charged {
    Requested,
    Fallback,
    Overflow,
    Unbounded,
}

Which bucket a super::RateLimitStore::consume_bounded call ended up charging, and why. Purely observational — the decision itself is carried by BoundedOutcome::decision — but it is what lets the middleware log an in-progress amplification attempt instead of silently absorbing it.

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.

Requested

The requested bucket, either already known to the scope or newly admitted under the cap. The normal case, and the one that preserves cratestack#416: distinct callers under the budget never share.

Fallback

The scope was at its cap, so the fallback bucket was charged instead. Stores report this for every over-cap charge; the middleware refines it to Charged::Overflow when it knows the scope was the process-global one (a store cannot tell the two apart, and giving it a way to would duplicate that rule in every backend).

Overflow

As Charged::Fallback, but the scope was the global one used when no verified peer address is available at all — i.e. the deployment is not wired through into_make_service_with_connect_info AND is under an amplification attempt. Distinguished because it is the only case where unrelated callers can be collapsed together, so it warrants a louder log.

Unbounded

The store does not implement consume_bounded, so no bound was applied. Emitted by the trait’s default implementation.

Trait Implementations

impl Clone for Charged

fn clone(&self) -> Charged

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Charged

impl Debug for Charged

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

Formats the value using the given formatter.

impl Eq for Charged

impl PartialEq for Charged

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Charged