Struct StatusPayload 

#[non_exhaustive]
pub struct StatusPayload {
    pub health: Vec<HealthCheck>,
    pub healthy: Option<bool>,
    pub source: Option<String>,
}

A status push: a server’s periodic heartbeat carrying its self-reported health.

Besides the reserved healthy and health keys described here, any additional top-level fields are accepted and stored verbatim as extra status data.

JSON schema

{
 "description": "A status push: a server's periodic heartbeat carrying its self-reported\nhealth.\n\nBesides the reserved `healthy` and `health` keys described here, any\nadditional top-level fields are accepted and stored verbatim as extra\nstatus data.",
 "allOf": [
   {
     "description": "Free-form additional data (uptime, database version, timezone,\nhostname, etc.). Stored verbatim and surfaced as raw JSON in the\nstatus view.\n\nA `tamanuVersion` field here is used as the server's tracked version\n(compared against the published version catalog), superseding the\nlegacy `X-Version` request header. If both are present,\n`tamanuVersion` wins; if neither is, the status is recorded without a\nversion.",
     "type": "object"
   },
   {
     "type": "object",
     "required": [
       "health"
     ],
     "properties": {
       "health": {
         "description": "Per-check breakdown. A push without a `health` array is the legacy\nTamanu direct-report format: it is treated as the `tamanu` source\nreporting a single always-passing `tasks` heartbeat check. May be\nempty (`[]`) for a source that genuinely runs no checks — which\nrecovers every check it previously reported. Each entry must\ninclude a non-empty `check` name and exactly one of `result` /\n`healthy`; any additional fields per check (latency, free disk %,\ncertificate expiry, etc.) are passed through verbatim and shown in the\nstatus UI.\n\nEvery check name seen — whatever its result — is added to the\noperator-facing check catalog, where the policy grading its results\ncan be reviewed and adjusted. A check whose effective result is\nfailed or warning opens (or keeps open) its issue; a broken check\nkeeps the same issue open, retaining a known failure's contribution\nwhile warning the check itself is broken; effective passed and\nskipped results open nothing and close prior issues.",
         "type": "array",
         "items": {
           "$ref": "#/components/schemas/HealthCheck"
         }
       },
       "healthy": {
         "description": "Overall self-reported health of the server. **Absent means `true`**,\nso senders that predate this field are never treated as unhealthy by\nomission. Recorded for historical analysis and display, but **not\nconsulted for incident or severity decisions** — those are derived\nfrom the per-check results in `health`, with each check's severity\ncontrolled by an operator-managed catalog.",
         "type": [
           "boolean",
           "null"
         ]
       },
       "source": {
         "description": "The name of the source pushing this status: the reporting agent, e.g.\n`alertd`. Multiple sources may report on one server, each with its own\nset of checks; a source's push only opens and recovers its own checks.\n\n**Transitionally optional: this field will become mandatory.** A push\nwithout a `source` is attributed to `alertd`; new reporters must send\ntheir own name. Must be a non-empty string; the names `canopy` and\n`manual` are reserved for canopy itself and are rejected.",
         "type": [
           "string",
           "null"
         ]
       }
     }
   }
 ]
}

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

health: Vec<HealthCheck>

Per-check breakdown. A push without a health array is the legacy Tamanu direct-report format: it is treated as the tamanu source reporting a single always-passing tasks heartbeat check. May be empty ([]) for a source that genuinely runs no checks — which recovers every check it previously reported. Each entry must include a non-empty check name and exactly one of result / healthy; any additional fields per check (latency, free disk %, certificate expiry, etc.) are passed through verbatim and shown in the status UI.

Every check name seen — whatever its result — is added to the operator-facing check catalog, where the policy grading its results can be reviewed and adjusted. A check whose effective result is failed or warning opens (or keeps open) its issue; a broken check keeps the same issue open, retaining a known failure’s contribution while warning the check itself is broken; effective passed and skipped results open nothing and close prior issues.

healthy: Option<bool>

Overall self-reported health of the server. Absent means true, so senders that predate this field are never treated as unhealthy by omission. Recorded for historical analysis and display, but not consulted for incident or severity decisions — those are derived from the per-check results in health, with each check’s severity controlled by an operator-managed catalog.

source: Option<String>

The name of the source pushing this status: the reporting agent, e.g. alertd. Multiple sources may report on one server, each with its own set of checks; a source’s push only opens and recovers its own checks.

Transitionally optional: this field will become mandatory. A push without a source is attributed to alertd; new reporters must send their own name. Must be a non-empty string; the names canopy and manual are reserved for canopy itself and are rejected.

Implementations

impl StatusPayload

pub fn builder() -> StatusPayloadBuilder

Create an instance of StatusPayload using the builder syntax

Trait Implementations

impl Clone for StatusPayload

fn clone(&self) -> StatusPayload

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StatusPayload

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StatusPayload

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for StatusPayload

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.