canic-host 0.110.53

Host-side App build and desired-state Fleet reconciliation library for Canic workspaces
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

//! Module: observatory::ops::cost
//!
//! Responsibility: bounded projection of existing metric owners into private cost evidence.
//! Boundary: read cached measurements; never schedule work or infer cycle consumption.

use crate::{
    observatory::{
        ops::{outcome, transport::ObservatoryTransport},
        view::*,
    },
    registry::RegistryEntry,
};
use canic_core::dto::public_status::PublicMetricFamily;

pub(super) fn collect(
    entry: &RegistryEntry,
    transport: &mut impl ObservatoryTransport,
) -> RoleCostEvidenceView {
    let source = ObservationSource::PublicMetricCache;
    let mut evidence = RoleCostEvidenceView {
        balance: outcome(
            transport.metric_samples(entry, PublicMetricFamily::Cycles),
            source,
        ),
        funding_and_callbacks: outcome(
            transport.metric_samples(entry, PublicMetricFamily::Operations),
            source,
        ),
        timer_instructions: outcome(
            transport.metric_samples(entry, PublicMetricFamily::Performance),
            source,
        ),
        // Read after the families: a restart between reads invalidates samples older than this heap.
        window: outcome(transport.cost_window(entry), source),
        limitations: vec![
            CostEvidenceLimitation::SingleSnapshot,
            CostEvidenceLimitation::AggregateTimerCallbacksUnqualified,
            CostEvidenceLimitation::TransferCoverageIncomplete,
            CostEvidenceLimitation::UnattributedExecutionMessageStorage,
        ],
    };
    check_window(&mut evidence);
    evidence
}

fn check_window(evidence: &mut RoleCostEvidenceView) {
    let Observation::Observed {
        value:
            CostWindowView {
                heap_started_at_ns: Some(start),
                ..
            },
        ..
    } = &evidence.window
    else {
        evidence
            .limitations
            .push(CostEvidenceLimitation::SourceWindowUnavailable);
        return;
    };
    let changed = [
        &evidence.balance,
        &evidence.funding_and_callbacks,
        &evidence.timer_instructions,
    ]
    .into_iter()
    .any(|observation| match observation {
        Observation::Observed { value, .. } => {
            value.sampled_at_ns.is_some_and(|at| at < *start)
                || value.rows.iter().any(|row| row.observed_at_ns < *start)
        }
        Observation::Unavailable { .. } => false,
    });
    if changed {
        evidence
            .limitations
            .push(CostEvidenceLimitation::SourceWindowChanged);
    }
}