Struct Consumed 

pub struct Consumed {
    pub steps: usize,
    pub effects: usize,
    pub spend: Spend,
    pub elapsed_secs: u64,
    pub denials: u32,
    pub egress_bytes: u64,
}

Running totals for one run.

Fields

steps: usize

effects: usize

Effects dispatched, not effects that succeeded.

A call that fails still consumed a call — it occupied a connection, hit a rate limit, and may have cost money on the way to failing. Counting only successes leaves the one loop a ceiling most needs to stop, a failing call retried forever, costing nothing on paper.

spend: Spend

elapsed_secs: u64

Whole seconds between the first and last journaled clock reading.

A difference of unix timestamps rather than a duration, so it counts second boundaries crossed: the same 1.4 s of work reads as 1 or 2 depending on where in a second it began, and two runs of one workload can report different figures. That is deliberate and is what makes the ceiling replayable — a duration measured off the wall clock would give a different verdict on every look, and a resumed run would replay as healthy. What it costs is that this is not a stopwatch: a ceiling set close to a step’s real cost admits a step at one starting instant and refuses the same step a fraction of a second later.

denials: u32

Policy refusals this run has accrued.

egress_bytes: u64

Bytes this run has sent into sinks.

Accumulated from each announced attempt’s outbound value, on the pass that announces it and on every pass that replays it. Recomputed from the effect rather than read back from the record, which is sound here and not for spend: the outbound value lives inside descriptor.args and so inside the effect key, and a value that changed would diverge before it could be billed. Spend has no such cover, which is why it is journaled.

Trait Implementations

impl Clone for Consumed

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Consumed

impl Debug for Consumed

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

Formats the value using the given formatter.

impl Default for Consumed

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Consumed

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Consumed

impl PartialEq for Consumed

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Consumed

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 Consumed