Struct NodeSnapshot 

pub struct NodeSnapshot {

    pub name: String,
    pub kind: NodeKind,
    pub process_name: Option<String>,
    pub process_id: Option<u64>,
    pub state: NodeState,
    pub restart: RestartType,
    pub significant: bool,
    pub created_at: UnixMillis,
    pub started_at: Option<UnixMillis>,
    pub uptime_ms: Option<u64>,
    pub restart_count: u32,
    pub exited_at: Option<UnixMillis>,
    pub resource_group: Option<String>,
    pub resources: Option<ResourceUsage>,
    pub supervision: Option<SupervisionSettings>,
    pub children: Vec<NodeSnapshot>,
}

One node – a supervisor or a worker – in a TreeSnapshot.

Fields

name: String

The node’s bare name, as registered with its supervisor.

kind: NodeKind

Whether the node is a supervisor or a worker.

process_name: Option<String>

The node’s fully qualified, dot-scoped process name. None if the node has never run.

process_id: Option<u64>

Identifier of the node’s most recent process. None if the node has never run.

A restart gives the node a new process, and so a new identifier. A node that has stopped keeps the identifier it last ran under, which is what state is for: this says what the node ran as, and state says whether it still is.

state: NodeState

Where the node is in its lifecycle.

restart: RestartType

The node’s restart policy.

significant: bool

Whether the node’s termination can drive its supervisor to shut down.

created_at: UnixMillis

When the node first became part of the tree.

Constant across restarts, so the difference between this and started_at is the time the node has spent not running since it was created.

started_at: Option<UnixMillis>

When the node’s most recent process started. None if the node has never run.

uptime_ms: Option<u64>

How long the node’s current process has been running, in milliseconds. None unless it is running.

restart_count: u32

How many times the node has been restarted since it was created.

Counts every restart that gave the node a new process, whether it was restarted on its own account or brought back as part of its supervisor restarting – either by a group restart or by the supervisor itself being restarted from above. Only statically declared nodes accumulate this across a supervisor restart, since only they have an identity that survives one; a dynamically spawned node is never restored.

exited_at: Option<UnixMillis>

When the node exited without being restarted. None unless it has exited.

resource_group: Option<String>

The resource group the node’s allocations are attributed to. None if the node has never run.

For a supervisor this is its own group. For a worker it is its supervisor’s, since a worker inherits its supervisor’s group rather than owning one.

resources: Option<ResourceUsage>

Resource usage attributed to this node.

Populated for a supervisor, which owns a resource group covering itself and its workers. Always absent for a worker, whose usage is counted against the supervisor named by resource_group.

supervision: Option<SupervisionSettings>

How the node supervises its children. Absent for a worker.

children: Vec<NodeSnapshot>

The node’s children. Empty for a worker.

Trait Implementations

impl Clone for NodeSnapshot

fn clone(&self) -> NodeSnapshot

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NodeSnapshot

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NodeSnapshot

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for NodeSnapshot

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

where __S: Serializer,

Serialize this value into the given Serde serializer.