monitor.status-page

pub fn status_page(components: &[Component]) -> StatusSummary

/// One row of a status page.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Component {
    pub name: String,
    pub state: String,
}

/// The banner at the top of the page.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct StatusSummary {
    /// the worst component state
    pub state: String,
    /// "All systems operational", "Degraded performance", "Partial outage", "Major outage" or "Scheduled maintenance"
    pub headline: String,
    /// names of the components not operational, in input order
    pub affected: Vec<String>,
}

fune!(monitor.status-page@^1);  // then call status_page(…)

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one

// Worst last. Maintenance ranks below every real problem: an outage elsewhere
// during planned work is still the headline.
const RANK: [&str; 5] = ["operational", "maintenance", "degraded", "partial-outage", "major-outage"];
const HEADLINE: [&str; 5] = [
    "All systems operational",
    "Scheduled maintenance",
    "Degraded performance",
    "Partial outage",
    "Major outage",
];

/// The banner for a whole status page: the worst component state wins.
///
/// # Panics
/// Panics on no components, an empty or duplicate name, or an unknown state.
pub fn status_page(components: &[Component]) -> StatusSummary {
    if components.is_empty() {
        panic!("components must not be empty");
    }
    let mut seen: Vec<&str> = Vec::new();
    let mut worst = 0usize;
    let mut affected: Vec<String> = Vec::new();
    for c in components {
        if c.name.is_empty() {
            panic!("component name must not be empty");
        }
        if seen.contains(&c.name.as_str()) {
            panic!("duplicate component name: {}", c.name);
        }
        seen.push(&c.name);
        let rank = match RANK.iter().position(|r| *r == c.state) {
            Some(r) => r,
            None => panic!("unknown component state: {}", c.state),
        };
        if rank > worst {
            worst = rank;
        }
        if rank > 0 {
            affected.push(c.name.clone());
        }
    }
    StatusSummary {
        state: RANK[worst].to_string(),
        headline: HEADLINE[worst].to_string(),
        affected,
    }
}

/// A `Component` from its JSON form, for adapters of capabilities built on this one.
pub fn component_from_value(v: &Value) -> Component {
    Component { name: v.get("name").as_str().to_string(), state: v.get("state").as_str().to_string() }
}

pub fn status_summary_to_value(s: &StatusSummary) -> Value {
    Value::obj(vec![
        ("state", Value::str(&s.state)),
        ("headline", Value::str(&s.headline)),
        ("affected", Value::Arr(s.affected.iter().map(|a| Value::str(a)).collect())),
    ])
}

pub fn fune_vector(args: &[Value]) -> Value {
    let components: Vec<Component> = args[0].as_arr().iter().map(component_from_value).collect();
    status_summary_to_value(&status_page(&components))
}

Install

fune build

With that line in your source, in a Rust project (language rust in fune.project), fune build resolves it and its 1 dependency, pins them in fune.lock, downloads only the Rust package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. A crate’s build.rs runs it before every compile. Or pin a range in fune.project and build in one step:

fune add monitor.status-page

The manifest, vectors and README with only the Rust implementation. Install it without the registry with fune add ./monitor.status-page-1.0.0-rust.fune, or fetch it from a terminal with fune pull monitor.status-page@1.0.0:rust.

The whole function, every language, is one file too: monitor.status-page-1.0.0.fune, 13,298 bytes, sha256 d9db4b93cf50e564dd970817a68ff904dff2740c164187a2bb320660670351ae. It installs into a project of any language.

// fune: before monitor.status-page

// fune: after monitor.status-page

// fune: replace monitor.component-state in monitor.status-page

// fune: step monitor.status-page after <n|label>

More from the author

major-outage > partial-outage > degraded > maintenance > operational

| state | headline | | --- | --- | | `major-outage` | Major outage | | `partial-outage` | Partial outage | | `degraded` | Degraded performance | | `maintenance` | Scheduled maintenance | | `operational` | All systems operational |

Maintenance ranks below every real problem: a component that is degraded while another is under planned maintenance is the news. It still ranks above operational, and a component under maintenance is listed in `affected`, so readers know it may be unavailable.

`affected` is in input order (the order the page lists its components), not sorted by severity, so it matches the page.

## Decisions

- **No components is an error**, not "All systems operational": a page with nothing on it is a configuration mistake, and claiming all is well would hide it. - **Names must be unique and non-empty.** Duplicates would make `affected` ambiguous. Names are compared exactly, so `api` and `API` are different. - States use the registry's kebab-case (`major-outage`); Statuspage's API spelling (`major_outage`) is refused rather than guessed at.

## Errors

- `components must not be empty` - `component name must not be empty` - `duplicate component name: X` - `unknown component state: X`

## Sources

- Atlassian Support, "Show service status with components": https://support.atlassian.com/statuspage/docs/show-service-status-with-components/ - Statuspage Status API, page status and component statuses: https://metastatuspage.com/api. Statuspage's own overall indicator is `none | minor | major | critical`; this capability reports the worst component state instead, which says more and maps onto it directly.

Files