Struct Notice 

pub struct Notice {

    pub id: String,
    pub key: String,
    pub severity: Severity,
    pub message: String,
    pub link: Option<Link>,
    pub first_at: Timestamp,
    pub last_at: Timestamp,
    pub count: u32,
    pub read_at: Option<Timestamp>,
    pub dismissed_at: Option<Timestamp>,
    pub subjects: Vec<String>,
    pub related_run: Option<String>,
    pub covered_by: Option<String>,
    pub since: Option<Timestamp>,
    pub cause: Option<String>,
    pub schema: u32,
    pub delivery_id: Option<String>,
    pub generation: u32,
    pub delivered: u32,
}

One thing the operator should know.

Fields

id: String

Stable file-name-safe id derived from Notice::key.

key: String

Deduplication key: kind and subject, never prose.

severity: Severity

How serious.

message: String

What happened.

link: Option<Link>

Where it points, when it points anywhere.

first_at: Timestamp

First raised.

last_at: Timestamp

Last raised.

count: u32

How many times this key was raised.

read_at: Option<Timestamp>

When it was marked read.

dismissed_at: Option<Timestamp>

When it was dismissed; the tombstone.

subjects: Vec<String>

The task and run ids this notice is about. A question whose run names one of them already pages the operator for the same cause.

related_run: Option<String>

Run association when the display link points elsewhere (for example a PR).

covered_by: Option<String>

The question that carries this notice as context, when it was filed already read for that reason. Never a tombstone: a recurrence with a newer cause or higher severity is unread again.

since: Option<Timestamp>

When the cause this notice reports began (a task’s held_at). A question filed before it is about an older cause and does not cover it; None keeps the broad coverage of notices without one.

cause: Option<String>

Producer-defined cause identity (phase and immutable target), never prose.

schema: u32

On-disk format version.

delivery_id: Option<String>

Persistent incarnation, so pruning history cannot reuse a chat receipt. Legacy records keep their original receipt key.

generation: u32

Delivery generation, advanced only by the shared page decision.

delivered: u32

Last generation durably accepted by a chat.

Implementations

impl Notice

pub fn new(severity: Severity, key: &str, message: impl Into<String>) -> Self

A notice of severity for key.

pub fn about<I, S>(self, subjects: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Name the task / run ids this notice is about.

pub fn for_run(self, run: Option<String>) -> Self

Associate a run independently of the display link.

pub fn info(key: &str, message: impl Into<String>) -> Self

An Severity::Info notice.

pub fn warn(key: &str, message: impl Into<String>) -> Self

A Severity::Warn notice.

pub fn error(key: &str, message: impl Into<String>) -> Self

An Severity::Error notice.

pub fn since(self, at: Option<Timestamp>) -> Self

Record when the reported cause began.

pub fn cause(self, cause: impl Into<String>) -> Self

Distinguish material producer state transitions without keying on wording.

pub fn link(self, link: Link) -> Self

Attach a link.

pub fn unread(&self) -> bool

Neither read nor dismissed.

pub fn raise_again(&mut self, again: &Notice, now: Timestamp) -> bool

Fold a repeat into this notice. Wording updates evidence; a newer cause or higher severity makes it unread and advances delivery.

Returns whether this raise should page the operator: it relit the notice (higher severity or newer cause) and no open question already carries it. This is the only place that decides.

pub fn mark_read(&mut self, now: Timestamp)

Mark read, keeping the first read time.

pub fn dismiss(&mut self, now: Timestamp)

Tombstone: read and hidden from the list.

Trait Implementations

impl Clone for Notice

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Notice

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Notice

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Notice

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

where __S: Serializer,

Serialize this value into the given Serde serializer.