Enum HeartbeatNote 

pub enum HeartbeatNote {
    Reported {
        payload: Payload,
        reported_at: DateTime<Utc>,
    },
    NoneSent,
    Unavailable {
        notes_held_since: DateTime<Utc>,
        restarted_since_attempt_began: bool,
    },
}

The most recent progress note the worker serving an attempt has reported — or a typed statement of why there is none.

Notes are VOLATILE. They live in the server process’s per-attempt liveness state and are never written to the store, so a restart loses every note ever reported. That is why absence has two forms and they are never collapsed: Self::NoneSent is a measurement (this process is holding the attempt and nothing has been reported on it), while Self::Unavailable is the absence of a measurement (this process does not hold the attempt, so it cannot say what was reported).

Variants

Reported

The worker serving this attempt reported this note.

Fields

payload: Payload

The worker’s opaque progress payload, exactly as it was sent.

reported_at: DateTime<Utc>

When this server process received the reporting heartbeat.

NoneSent

This server process holds the attempt’s liveness entry and no note has been reported on it. The worker really has said nothing.

Unavailable

This server process does not hold the attempt’s liveness entry, so it cannot say whether a note was reported.

The usual cause is a restart: notes began being held at notes_held_since, and an attempt dispatched before that instant left its notes in a process that no longer exists — restarted_since_attempt_began says so outright. The other causes (the attempt was swept off the tracker with its owner, or it has not been leased) are equally unmeasurable here, and every one of them is reported as this variant rather than as silence.

Fields

notes_held_since: DateTime<Utc>

When this server process began holding progress notes.

restarted_since_attempt_began: bool

True when the attempt was dispatched BEFORE this process began holding notes — a restart demonstrably explains the absence.

Trait Implementations

impl Clone for HeartbeatNote

fn clone(&self) -> HeartbeatNote

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HeartbeatNote

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for HeartbeatNote

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for HeartbeatNote

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for HeartbeatNote

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for HeartbeatNote

impl TS for HeartbeatNote

type WithoutGenerics = HeartbeatNote

If this type does not have generic parameters, then WithoutGenerics should just be Self. If the type does have generic parameters, then all generic parameters must be replaced with a dummy type, e.g ts_rs::Dummy or ().
The only requirement for these dummy types is that EXPORT_TO must be None.

type OptionInnerType = HeartbeatNote

If the implementing type is std::option::Option<T>, then this associated type is set to T. All other implementations of TS should set this type to Self instead.

fn ident(cfg: &Config) -> String

Identifier of this type, excluding generic parameters.

fn docs() -> Option<String>

JSDoc comment to describe this type in TypeScript - when TS is derived, docs are automatically read from your doc comments or #[doc = ".."] attributes

fn name(cfg: &Config) -> String

Name of this type in TypeScript, including generic parameters

fn decl_concrete(cfg: &Config) -> String

Declaration of this type using the supplied generic arguments. The resulting TypeScript definition will not be generic. For that, see TS::decl(). If this type is not generic, then this function is equivalent to TS::decl().

fn decl(cfg: &Config) -> String

Declaration of this type, e.g. type User = { user_id: number, ... }. This function will panic if the type has no declaration.

fn inline(cfg: &Config) -> String

Formats this types definition in TypeScript, e.g { user_id: number }. This function will panic if the type cannot be inlined.

fn inline_flattened(cfg: &Config) -> String

Flatten a type declaration. This function will panic if the type cannot be flattened.

fn visit_generics(v: &mut impl TypeVisitor)

where Self: 'static,

Iterates over all type parameters of this type.

fn output_path() -> Option<PathBuf>

Returns the output path to where T should be exported, relative to the output directory. The returned path does not include any base directory.

fn visit_dependencies(v: &mut impl TypeVisitor)

where Self: 'static,

Iterates over all dependency of this type.

fn dependencies(cfg: &Config) -> Vec<Dependency>

where Self: 'static,

Resolves all dependencies of this type recursively.

fn export(cfg: &Config) -> Result<(), ExportError>

where Self: 'static,

Manually export this type to the filesystem. To export this type together with all of its dependencies, use TS::export_all.

fn export_all(cfg: &Config) -> Result<(), ExportError>

where Self: 'static,

Manually export this type to the filesystem, together with all of its dependencies. To export only this type, without its dependencies, use TS::export.

fn export_to_string(cfg: &Config) -> Result<String, ExportError>

where Self: 'static,

Manually generate bindings for this type, returning a String. This function does not format the output, even if the format feature is enabled.