Struct HealthTick 

pub struct HealthTick {
    handle: JoinHandle<()>,
    stop: Arc<Notify>,
    state: Arc<HealthState>,
}

A running health tick, stopped by HealthTick::stop or by dropping it.

The task holds only an Arc<dyn Registry> and never keeps the process alive on its own: a tokio task dies with its runtime, and this handle aborts it on drop so a server that has finished shutting down does not leave a timer writing lines about a registry nobody is serving.

Fields

handle: JoinHandle<()>

stop: Arc<Notify>

state: Arc<HealthState>

Implementations

impl HealthTick

pub fn spawn(registry: Arc<dyn Registry>, interval: Duration) -> Self

Starts writing a health line every interval, with its own HealthState a caller can read back through HealthTick::state.

The first line comes after one interval rather than immediately: at startup the counts are all zero and the banner has just said as much.

A tick that arrives late is delayed rather than replayed. Catching up on missed ticks would print several identical lines in a row after the machine came back from a suspend, which says nothing a single current line does not.

pub fn state(&self) -> Arc<HealthState>

The pulse this tick is keeping, for wiring into the HTTP router.

pub async fn stop(self)

Stops the tick and waits for the task to finish.

Awaiting the join is what makes “stopped” true rather than “asked to stop”: a caller that returns immediately can still race one last line into the log after its own shutdown message.

Trait Implementations

impl Debug for HealthTick

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

Formats the value using the given formatter.

impl Drop for HealthTick

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.