Struct RefreshLedgerEvidenceComparison 

pub struct RefreshLedgerEvidenceComparison {
    pub phase_deltas: Vec<RefreshPhaseDelta>,
    pub aggregate_duration_delta_pct: Option<f64>,
    pub aggregate_throughput_delta_pct: Option<f64>,
    pub dominant_phase_shift: Option<(RefreshPhase, RefreshPhase)>,
}

Cross-run comparison summary suitable for benchmark CI gates and regression dashboards. Computed by RefreshLedgerEvidence::compare_to.

Fields

phase_deltas: Vec<RefreshPhaseDelta>

Per-phase delta for every phase that ran in EITHER side. Phases unique to one side surface with a zero on the missing side — operators can grep for the missing phase and decide.

aggregate_duration_delta_pct: Option<f64>

Aggregate wall-clock delta. Positive ⇒ slower in current.

aggregate_throughput_delta_pct: Option<f64>

Aggregate items/sec delta. Positive ⇒ faster in current.

dominant_phase_shift: Option<(RefreshPhase, RefreshPhase)>

Some((from, to)) when the dominant phase shifted between baseline and current. A dominant-phase shift is itself a regression signal — the operator should look at why the hot phase changed even if absolute totals are similar.

Implementations

impl RefreshLedgerEvidenceComparison

pub fn regression_verdict( &self, thresholds: &RegressionVerdictThresholds, ) -> RegressionVerdict

Compute the CI hard-gate verdict for this comparison against caller-supplied thresholds. Pure function; no I/O. Use emit_tracing_summary for operator-visibility soft signaling instead of CI gating.

coding_agent_session_search-ibuuh.24: this is the bench-CI consumer of compare_to. A regression test asserts the verdict tiering matches the threshold contract exactly, so a project tuning thresholds for its own bench harness gets predictable behavior at the boundary cases.

Degenerate cases:

• aggregate_duration_delta_pct == None (baseline missing or empty) ⇒ Clean — no measurement to gate on.
• Negative duration delta (improvement) ⇒ always Clean, regardless of threshold polarity (an improvement cannot trigger a regression failure).

impl RefreshLedgerEvidenceComparison

pub fn emit_tracing_summary(&self)

Emit a single structured tracing event summarizing the cross-run comparison. Operators see “this rebuild was N% slower than the previous publish” in default-level logs without running a benchmark harness.

coding_agent_session_search-ibuuh.24: pure helper that any caller (the publish path, a cass status summary surface, CI bench gates) can invoke after compare_to. Severity is chosen by the regression magnitude:

• aggregate_duration_delta_pct >= +25.0 ⇒ warn (significant slowdown — surface in default logs so the operator sees it without dredging)
• aggregate_duration_delta_pct <= -10.0 ⇒ info (notable improvement — worth surfacing as a positive signal)
• otherwise ⇒ debug (steady state — high-volume noise on every publish; only visible at debug level)

The thresholds (+25% slowdown / -10% improvement) are the “operator should look” signal levels, NOT a hard regression gate. CI hard gates compare against benchmark baselines with project-specific thresholds; this helper is for ambient operator visibility.

dominant_phase_shift is reported on every emission regardless of severity tier — a hot-phase change is itself a regression signal worth surfacing even when the absolute totals look similar.

Trait Implementations

impl Clone for RefreshLedgerEvidenceComparison

fn clone(&self) -> RefreshLedgerEvidenceComparison

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RefreshLedgerEvidenceComparison

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RefreshLedgerEvidenceComparison

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RefreshLedgerEvidenceComparison

fn eq(&self, other: &RefreshLedgerEvidenceComparison) -> 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 Serialize for RefreshLedgerEvidenceComparison

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 RefreshLedgerEvidenceComparison