yah-tower 0.8.20

yah-tower — rule-driven monitor on scryer. Rule parser/compiler, ScryerFilter, and dispatch engine.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

//! Minimal event type for tower-internal use.
//!
//! Will be replaced by `observation::Event` when crates/yah/observation/ ships
//! (R093-F1). The shape here mirrors what scryer will produce so that
//! `ScryerFilter::matches` and the tests are faithful to the substrate contract.

use std::collections::HashMap;

use serde_json::Value;
use tower_rules::{ForgeId, HealthSignal, MeshIdent};

/// A single structured event produced by a scryer ingestion adapter.
///
/// The `(scope, seq)` pair is unique and stable across the event's lifetime,
/// per the scryer substrate contract. Tower uses it for dedup in the supervisor.
#[derive(Debug, Clone)]
pub struct Event {
    /// Identifies which service, task-run, forge-run, or health stream this
    /// event belongs to.
    pub scope: EventScope,
    /// Log level. Defaults to `Info` for unstructured lines.
    pub level: Level,
    /// Event category, e.g. `"raft.term_change"` or `"database.query_slow"`.
    pub target: String,
    /// Human-readable message.
    pub msg: String,
    /// Structured key-value payload, JSON-typed.
    pub fields: HashMap<String, Value>,
    /// Per-scope monotonically increasing event number. Unique with `scope`.
    pub seq: u64,
}

/// Identifies which event stream an event belongs to.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum EventScope {
    /// An agent or tool subprocess run.
    TaskRun(String),
    /// A long-running containerd workload identified by its mesh identity.
    Service(MeshIdent),
    /// A transient forge run.
    Forge(ForgeId),
    /// Scryer's own health emissions (produced by the scryer substrate itself,
    /// not by a workload). Used by `Predicate::ScryerHealth`.
    Health,
}

/// Structured log level, ordered Debug < Info < Warn < Error.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum Level {
    Debug = 0,
    Info = 1,
    Warn = 2,
    Error = 3,
}

impl Event {
    /// Construct a health-signal event. These come from scryer's own substrate
    /// and are matched by `Predicate::ScryerHealth` rules.
    pub fn health(signal: HealthSignal, seq: u64) -> Self {
        Event {
            scope: EventScope::Health,
            level: Level::Warn,
            target: format!("scryer.health.{}", health_signal_name(signal)),
            msg: String::new(),
            fields: HashMap::new(),
            seq,
        }
    }
}

pub(crate) fn health_signal_name(signal: HealthSignal) -> &'static str {
    match signal {
        HealthSignal::IngestionLag => "ingestion_lag",
        HealthSignal::RingOverflow => "ring_overflow",
        HealthSignal::FederationTimeout => "federation_timeout",
        HealthSignal::YubabaRaftQuorumLost => "yubaba_raft_quorum_lost",
    }
}