use std::collections::VecDeque;
use std::sync::atomic::{AtomicI64, AtomicU64, Ordering};
use std::sync::Mutex;
use crate::{RunnerHealth, RunnerPhase, TaskStatus, TaskType};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FrozenEvidence {
pub task_type: TaskType,
pub partition: u32,
pub status: TaskStatus,
pub reason: Option<&'static str>,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct FrozenEvidenceSnapshot {
pub recent: Vec<FrozenEvidence>,
pub total: u64,
pub overwritten: u64,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct RunnerMetricsSnapshot {
pub phase: RunnerPhase,
pub health: RunnerHealth,
pub epoch: u64,
pub partitions: u64,
pub accepting_partitions: u64,
pub failed_partitions: u64,
pub submitted: u64,
pub completed: u64,
pub cancelled: u64,
pub failed: u64,
pub task_panics: u64,
pub aborted: u64,
pub rejected_shutting_down: u64,
pub rejected_queue_full: u64,
pub rejected_overloaded: u64,
pub rejected_ordering_conflict: u64,
pub rejected_lane_failed: u64,
pub rejected_lane_limit: u64,
pub rejected_reserved_type: u64,
pub steal_attempts: u64,
pub steal_successes: u64,
pub releases: u64,
pub frozen: u64,
pub lanes: u64,
pub type_state_limit: u64,
pub failed_lanes: u64,
pub dead_workers: i64,
pub queued_depth: u64,
pub main_queue_depth: u64,
pub control_queue_depth: u64,
pub reserved_queue_heads: u64,
pub producer_inflight: u64,
pub admit_available: u64,
pub delayed_pending: u64,
pub timer_physical_slots: u64,
pub timer_cancelled: u64,
pub timer_compactions: u64,
pub running: u64,
pub moving: u64,
pub non_strict_tunnels: u64,
pub strict_tunnels: u64,
pub non_strict_tunnels_open: u64,
pub non_strict_tunnels_draining: u64,
pub strict_stock_depth: u64,
pub strict_incremental_depth: u64,
pub strict_staging_depth: u64,
pub strict_local: u64,
pub strict_migrating: u64,
pub strict_stolen: u64,
pub strict_return_prepare: u64,
pub strict_returning: u64,
pub strict_local_catchup: u64,
pub strict_stolen_catchup: u64,
pub strict_failed: u64,
pub frozen_evidence_samples: u64,
pub frozen_evidence_overwritten: u64,
pub supervised_tasks: u64,
}
pub type MetricsSnapshot = RunnerMetricsSnapshot;
pub(crate) struct RunnerMetrics {
pub(crate) submitted: AtomicU64,
pub(crate) completed: AtomicU64,
pub(crate) cancelled: AtomicU64,
pub(crate) failed: AtomicU64,
pub(crate) task_panics: AtomicU64,
pub(crate) aborted: AtomicU64,
pub(crate) frozen: AtomicU64,
pub(crate) rejected_shutting_down: AtomicU64,
pub(crate) rejected_queue_full: AtomicU64,
pub(crate) rejected_overloaded: AtomicU64,
pub(crate) rejected_ordering_conflict: AtomicU64,
pub(crate) rejected_type_failed: AtomicU64,
pub(crate) rejected_type_limit: AtomicU64,
pub(crate) rejected_reserved_type: AtomicU64,
pub(crate) steal_attempts: AtomicU64,
pub(crate) steal_successes: AtomicU64,
pub(crate) releases: AtomicU64,
pub(crate) failed_types: AtomicU64,
pub(crate) dead_workers: AtomicI64,
pub(crate) running: AtomicU64,
pub(crate) moving: AtomicU64,
pub(crate) non_strict_tunnels: AtomicU64,
pub(crate) strict_tunnels: AtomicU64,
}
impl RunnerMetrics {
pub(crate) fn new() -> Self {
Self {
submitted: AtomicU64::new(0),
completed: AtomicU64::new(0),
cancelled: AtomicU64::new(0),
failed: AtomicU64::new(0),
task_panics: AtomicU64::new(0),
aborted: AtomicU64::new(0),
frozen: AtomicU64::new(0),
rejected_shutting_down: AtomicU64::new(0),
rejected_queue_full: AtomicU64::new(0),
rejected_overloaded: AtomicU64::new(0),
rejected_ordering_conflict: AtomicU64::new(0),
rejected_type_failed: AtomicU64::new(0),
rejected_type_limit: AtomicU64::new(0),
rejected_reserved_type: AtomicU64::new(0),
steal_attempts: AtomicU64::new(0),
steal_successes: AtomicU64::new(0),
releases: AtomicU64::new(0),
failed_types: AtomicU64::new(0),
dead_workers: AtomicI64::new(0),
running: AtomicU64::new(0),
moving: AtomicU64::new(0),
non_strict_tunnels: AtomicU64::new(0),
strict_tunnels: AtomicU64::new(0),
}
}
}
pub(crate) struct FrozenEvidenceRing {
capacity: usize,
recent: Mutex<VecDeque<FrozenEvidence>>,
total: AtomicU64,
overwritten: AtomicU64,
}
impl FrozenEvidenceRing {
pub(crate) fn new(capacity: usize) -> Self {
Self {
capacity,
recent: Mutex::new(VecDeque::with_capacity(capacity)),
total: AtomicU64::new(0),
overwritten: AtomicU64::new(0),
}
}
pub(crate) fn push(&self, evidence: FrozenEvidence) {
self.total.fetch_add(1, Ordering::Relaxed);
let mut recent = self.recent.lock().unwrap_or_else(|e| e.into_inner());
if recent.len() == self.capacity {
recent.pop_front();
self.overwritten.fetch_add(1, Ordering::Relaxed);
}
recent.push_back(evidence);
}
pub(crate) fn snapshot(&self) -> FrozenEvidenceSnapshot {
FrozenEvidenceSnapshot {
recent: self
.recent
.lock()
.unwrap_or_else(|e| e.into_inner())
.iter()
.cloned()
.collect(),
total: self.total.load(Ordering::Acquire),
overwritten: self.overwritten.load(Ordering::Acquire),
}
}
pub(crate) fn counts(&self) -> (u64, u64) {
(
self.recent.lock().unwrap_or_else(|e| e.into_inner()).len() as u64,
self.overwritten.load(Ordering::Acquire),
)
}
}