canic-core 0.111.0

Canic — a canister orchestration and management toolkit for the Internet Computer
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

//! Module: api::observability
//!
//! Responsibility: expose the Root-owned sensitive-observation relay to generated endpoints.
//! Does not own: caller authorization, target authorization, or metric collection.
//! Boundary: converts relay failures into the public Canic error contract.

use crate::{
    dto::{
        error::Error,
        observability::{CanisterObservabilityRequest, CanisterObservabilityResponse},
    },
    workflow::runtime::observability,
};
use candid::Principal;

/// Public façade for the controller-authenticated Root observability relay.
pub struct ObservabilityApi;

impl ObservabilityApi {
    /// Discover canonical accounting after controller authentication at the endpoint.
    pub fn release_intents(
        start_after: Option<crate::dto::release_intents::IntentReleaseKey>,
    ) -> Result<crate::dto::release_intents::IntentReleaseResponse, Error> {
        observability::release_intents(start_after).map_err(Into::into)
    }

    /// Discover retained replay authority after controller authentication at the endpoint.
    pub fn release_receipts(
        start_after: Option<[u8; 32]>,
    ) -> Result<crate::dto::release_receipts::ReplayReleaseResponse, Error> {
        observability::release_receipts(start_after).map_err(Into::into)
    }

    /// Return child funding usage without changing grants, reservations or replay state.
    pub fn child_funding(
        child: Principal,
    ) -> Result<crate::dto::observability::ChildFundingUsage, Error> {
        observability::child_funding(child).map_err(Into::into)
    }

    /// Observe one canister that independently recognizes this Root as a controller.
    pub async fn observe_root_controlled_canister(
        canister_id: Principal,
        request: CanisterObservabilityRequest,
    ) -> Result<CanisterObservabilityResponse, Error> {
        observability::observe_root_controlled_canister(canister_id, request)
            .await
            .map_err(Into::into)
    }
}