#[derive(Clone, Debug, PartialEq, Eq)]
pub struct HealthTransition {
pub sequence: u64,
pub observed_after: Duration,
pub previous: Option<HealthState>,
pub current: HealthState,
pub status: TaskStatus,
}
pub struct TransitionCursor {
inner: Arc<Inner>,
states: HashMap<TaskId, HealthState>,
next_sequence: u64,
}
impl Monitor {
#[must_use]
pub fn transition_cursor(&self) -> TransitionCursor {
TransitionCursor {
inner: Arc::clone(&self.inner),
states: HashMap::new(),
next_sequence: 1,
}
}
}
impl TransitionCursor {
#[must_use]
pub fn poll(&mut self) -> Vec<HealthTransition> {
let now = self.inner.now_tick();
self.poll_at(now)
}
#[must_use]
pub fn poll_task(&mut self, id: TaskId) -> Option<HealthTransition> {
let now = self.inner.now_tick();
self.poll_task_at(id, now)
}
#[must_use]
pub fn tracked_len(&self) -> usize {
self.states.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.states.is_empty()
}
pub fn reset(&mut self) {
self.states.clear();
self.next_sequence = 1;
}
fn poll_at(&mut self, now: u64) -> Vec<HealthTransition> {
let tasks = self.inner.read_tasks();
let mut statuses = tasks
.values()
.map(|entry| status_for(entry, now))
.collect::<Vec<_>>();
drop(tasks);
statuses.sort_unstable_by_key(|status| status.id);
self.states.retain(|id, _| {
statuses
.binary_search_by_key(id, |status| status.id)
.is_ok()
});
let observed_after = tick_duration(now, 1);
statuses
.into_iter()
.filter_map(|status| self.observe(status, observed_after))
.collect()
}
fn poll_task_at(&mut self, id: TaskId, now: u64) -> Option<HealthTransition> {
let status = {
let tasks = self.inner.read_tasks();
tasks.get(&id).map(|entry| status_for(entry, now))
};
let Some(status) = status else {
self.states.remove(&id);
return None;
};
self.observe(status, tick_duration(now, 1))
}
fn observe(
&mut self,
status: TaskStatus,
observed_after: Duration,
) -> Option<HealthTransition> {
let current = status.health.state();
let previous = self.states.insert(status.id, current);
if previous == Some(current) {
return None;
}
let sequence = self.next_sequence;
self.next_sequence = self.next_sequence.saturating_add(1);
Some(HealthTransition {
sequence,
observed_after,
previous,
current,
status,
})
}
}