Enum What 

pub enum What {
    ChildStarting {
        transition: Option<StateTransition>,
    },
    ChildRunning {
        transition: Option<StateTransition>,
    },
    ChildReady {
        transition: Option<StateTransition>,
    },
    ChildHeartbeat {
        age_ms: u64,
    },
    ChildFailed {
        failure: TaskFailure,
    },
    ChildPanicked {
        category: String,
    },
    BackoffScheduled {
        delay_ms: u64,
    },
    ChildRestarting {
        generation: u64,
    },
    ChildRestarted {
        restart_count: u64,
    },
    ChildQuarantined {
        reason: String,
    },
    ChildStopped {
        reason: String,
    },
    ChildUnhealthy {
        reason: String,
    },
    Meltdown {
        scope: String,
    },
    ShutdownRequested {
        cause: String,
    },
    ShutdownPhaseChanged {
        from: String,
        to: String,
    },
    ShutdownCompleted {
        result: String,
    },
    CommandAccepted {
        audit: CommandAudit,
    },
    CommandCompleted {
        audit: CommandAudit,
    },
    SubscriberLagged {
        missed: u64,
    },
}

Typed payload for supervisor lifecycle events.

Variants

ChildStarting

Child is being started.

Fields

transition: Option<StateTransition>

Optional state transition carried by this event.

ChildRunning

Child is running.

Fields

transition: Option<StateTransition>

Optional state transition carried by this event.

ChildReady

Child is ready.

Fields

transition: Option<StateTransition>

Optional state transition carried by this event.

ChildHeartbeat

Child emitted a heartbeat.

Fields

age_ms: u64

Heartbeat age in milliseconds.

ChildFailed

Child failed with a typed failure.

Fields

failure: TaskFailure

Failure payload reported by the task.

ChildPanicked

Child panicked.

Fields

category: String

Panic category used for metrics.

BackoffScheduled

Restart backoff was scheduled.

Fields

delay_ms: u64

Backoff delay in milliseconds.

ChildRestarting

Child is restarting.

Fields

generation: u64

Restart generation after the transition.

ChildRestarted

Child restarted.

Fields

restart_count: u64

Restart count for the child window.

ChildQuarantined

Child was quarantined.

Fields

reason: String

Quarantine reason.

ChildStopped

Child stopped.

Fields

reason: String

Exit reason.

ChildUnhealthy

Child became unhealthy.

Fields

reason: String

Unhealthy reason.

Meltdown

Meltdown fuse was tripped.

Fields

scope: String

Scope that tripped the fuse.

ShutdownRequested

Shutdown was requested.

Fields

cause: String

Shutdown cause.

ShutdownPhaseChanged

Shutdown phase changed.

Fields

from: String

Previous phase name.

to: String

New phase name.

ShutdownCompleted

Shutdown completed.

Fields

result: String

Shutdown result summary.

CommandAccepted

Control command was accepted.

Fields

audit: CommandAudit

Command audit payload.

CommandCompleted

Control command completed.

Fields

audit: CommandAudit

Command audit payload.

SubscriberLagged

Event subscriber lagged.

Fields

missed: u64

Number of missed events.

Implementations

impl What

pub fn name(&self) -> &'static str

Returns a low-cardinality event name.

Arguments

This function has no arguments.

Returns

Returns the stable event name.

Examples

let event = rust_supervisor::event::payload::What::ChildRunning {
    transition: None,
};
assert_eq!(event.name(), "ChildRunning");

Examples found in repository

examples/diagnostic_replay.rs (line 179)

fn main() {
    // Build the child identifier.
    let child_id = ChildId::new("market_feed");
    // Build the child path.
    let child_path = SupervisorPath::root().join("market_feed");
    // Build a typed task failure.
    let failure = TaskFailure::new(
        // Set the failure kind.
        TaskFailureKind::Timeout,
        // Set the low-cardinality failure category.
        "external_dependency",
        // Set the diagnostic failure message.
        "market feed heartbeat timed out",
        // Finish the typed task failure.
    );
    // Build the restart policy decision.
    let policy = PolicyDecision::new(
        // Set the decision label.
        "RestartAfter",
        // Set the restart delay.
        Some(500),
        // Set the diagnostic decision reason.
        Some("heartbeat timeout is restartable".to_owned()),
        // Finish the policy decision.
    );

    // Create the fixed-capacity event journal.
    let mut journal = EventJournal::new(8);
    // Push the running event.
    journal.push(event(
        // Set the event sequence.
        1,
        // Clone the child identifier.
        child_id.clone(),
        // Set the child display name.
        "Market Feed",
        // Build the running event payload.
        What::ChildRunning {
            // Attach the state transition.
            transition: Some(StateTransition::new("Starting", "Running")),
            // Finish the running event payload.
        },
        // Attach no policy decision.
        None,
        // Finish the running event.
    ));
    // Push the failed event.
    journal.push(event(
        // Set the event sequence.
        2,
        // Clone the child identifier.
        child_id.clone(),
        // Set the child display name.
        "Market Feed",
        // Build the failed event payload.
        What::ChildFailed {
            // Attach the typed failure.
            failure: failure.clone(),
            // Finish the failed event payload.
        },
        // Attach the restart policy decision.
        Some(policy.clone()),
        // Finish the failed event.
    ));
    // Push the backoff event.
    journal.push(event(
        // Set the event sequence.
        3,
        // Clone the child identifier.
        child_id.clone(),
        // Set the child display name.
        "Market Feed",
        // Build the backoff payload.
        What::BackoffScheduled { delay_ms: 500 },
        // Attach the restart policy decision.
        Some(policy.clone()),
        // Finish the backoff event.
    ));
    // Push the restarted event.
    journal.push(event(
        // Set the event sequence.
        4,
        // Clone the child identifier.
        child_id.clone(),
        // Set the child display name.
        "Market Feed",
        // Build the restarted payload.
        What::ChildRestarted { restart_count: 1 },
        // Attach the restart policy decision.
        Some(policy.clone()),
        // Finish the restarted event.
    ));

    // Build the final child state.
    let child = ChildState::declared(child_path, child_id, "Market Feed")
        // Set the child lifecycle state.
        .with_lifecycle_state(ChildLifecycleState::Running, EventSequence::new(1))
        // Record the latest failure.
        .record_failure(failure, EventSequence::new(2))
        // Record the latest policy decision.
        .with_policy_decision(policy, 1);
    // Build the final supervisor state.
    let final_state = SupervisorState::new(SupervisorPath::root(), EventSequence::new(4), 1)
        // Add the child state.
        .with_child(child)
        // Mark shutdown as completed for the replay.
        .with_shutdown_state(ShutdownState::Completed)
        // Attach the last journal sequence.
        .with_journal_sequence(EventSequence::new(4));
    // Build the diagnostic run summary.
    let summary = RunSummaryBuilder::new(8).build(
        // Read recent events from the journal.
        &journal,
        // Attach the final current state.
        final_state,
        // Attach the shutdown cause.
        Some("diagnostic replay complete".to_owned()),
        // Finish the summary construction.
    );
    // Create the metrics facade.
    let metrics = MetricsFacade::new();

    // Print summary counters.
    println!(
        // Provide the output template.
        "summary restart_count={} failure_count={} recent_events={}",
        // Print the restart count.
        summary.restart_count,
        // Print the failure count.
        summary.failure_count,
        // Print the recent event count.
        summary.recent_events.len(),
        // Finish summary output.
    );
    // Iterate over recent journal events.
    for event in journal.recent(8) {
        // Print event names and derived metrics.
        println!(
            // Provide the output template.
            "event={} metrics={:?}",
            // Print the event name.
            event.what.name(),
            // Print metrics derived from the event.
            metrics.samples_for_event(&event),
            // Finish event output.
        );
        // Finish the journal replay loop.
    }
    // End the diagnostic replay example.
}

Trait Implementations

impl Clone for What

fn clone(&self) -> What

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for What

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for What

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for What

fn eq(&self, other: &What) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for What

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for What

impl StructuralPartialEq for What