use std::collections::VecDeque;
use sightloom_core::{Detection, FrameStamp, MediaTime, SourceId};
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum DropPolicy {
#[default]
RejectNew,
DropOldest,
DropNewest,
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum LateFramePolicy {
#[default]
Reject,
AcceptMark,
Drop,
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum OutOfOrderPolicy {
#[default]
Reject,
Accept,
Drop,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct IngestPolicy {
pub max_queue_depth: usize,
pub drop_policy: DropPolicy,
pub late_frame_policy: LateFramePolicy,
pub out_of_order_policy: OutOfOrderPolicy,
pub max_lateness_ns: i64,
}
impl Default for IngestPolicy {
fn default() -> Self {
Self {
max_queue_depth: 64,
drop_policy: DropPolicy::RejectNew,
late_frame_policy: LateFramePolicy::Reject,
out_of_order_policy: OutOfOrderPolicy::Reject,
max_lateness_ns: 0,
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct SourceWatermark {
pub source_id: SourceId,
pub high_pts: Option<MediaTime>,
pub high_frame_index: u64,
pub sequence: u64,
}
impl SourceWatermark {
#[must_use]
pub const fn new(source_id: SourceId) -> Self {
Self {
source_id,
high_pts: None,
high_frame_index: 0,
sequence: 0,
}
}
pub fn advance(&mut self, stamp: FrameStamp) {
self.high_pts = Some(stamp.pts);
self.high_frame_index = self.high_frame_index.max(stamp.frame_index);
self.sequence = self.sequence.saturating_add(1);
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum IngestDecision {
Accept,
Drop,
RejectLate,
RejectOutOfOrder,
}
#[must_use]
pub fn evaluate_stamp(
policy: &IngestPolicy,
watermark: &SourceWatermark,
stamp: FrameStamp,
) -> IngestDecision {
if let Some(high) = watermark.high_pts {
let delta = high.as_nanos().saturating_sub(stamp.pts.as_nanos());
if delta > policy.max_lateness_ns && stamp.pts.as_nanos() < high.as_nanos() {
return match policy.late_frame_policy {
LateFramePolicy::Reject => IngestDecision::RejectLate,
LateFramePolicy::Drop => IngestDecision::Drop,
LateFramePolicy::AcceptMark => IngestDecision::Accept,
};
}
if stamp.pts.as_nanos() < high.as_nanos() {
return match policy.out_of_order_policy {
OutOfOrderPolicy::Reject => IngestDecision::RejectOutOfOrder,
OutOfOrderPolicy::Drop => IngestDecision::Drop,
OutOfOrderPolicy::Accept => IngestDecision::Accept,
};
}
}
IngestDecision::Accept
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct IngestMetrics {
pub accepted: u64,
pub dropped: u64,
pub rejected_late: u64,
pub rejected_ooo: u64,
pub queue_hwm: u64,
pub source_resets: u64,
pub checkpoints: u64,
}
impl IngestMetrics {
pub fn record(&mut self, decision: IngestDecision) {
match decision {
IngestDecision::Accept => self.accepted = self.accepted.saturating_add(1),
IngestDecision::Drop => self.dropped = self.dropped.saturating_add(1),
IngestDecision::RejectLate => self.rejected_late = self.rejected_late.saturating_add(1),
IngestDecision::RejectOutOfOrder => {
self.rejected_ooo = self.rejected_ooo.saturating_add(1);
}
}
}
}
#[must_use]
pub fn prometheus_text(namespace: &str, session: &str, metrics: &IngestMetrics) -> String {
let ns = if namespace.is_empty() {
"sightloom"
} else {
namespace
};
let label = session.replace('"', "");
format!(
"# HELP {ns}_ingest_accepted Frames accepted by ingest policy.\n\
# TYPE {ns}_ingest_accepted counter\n\
{ns}_ingest_accepted{{session=\"{label}\"}} {}\n\
# HELP {ns}_ingest_dropped Frames dropped by policy.\n\
# TYPE {ns}_ingest_dropped counter\n\
{ns}_ingest_dropped{{session=\"{label}\"}} {}\n\
# HELP {ns}_ingest_rejected_late Frames rejected as late.\n\
# TYPE {ns}_ingest_rejected_late counter\n\
{ns}_ingest_rejected_late{{session=\"{label}\"}} {}\n\
# HELP {ns}_ingest_rejected_ooo Frames rejected as out-of-order.\n\
# TYPE {ns}_ingest_rejected_ooo counter\n\
{ns}_ingest_rejected_ooo{{session=\"{label}\"}} {}\n\
# HELP {ns}_ingest_queue_hwm Queue high-water mark.\n\
# TYPE {ns}_ingest_queue_hwm gauge\n\
{ns}_ingest_queue_hwm{{session=\"{label}\"}} {}\n\
# HELP {ns}_ingest_source_resets Source reset events.\n\
# TYPE {ns}_ingest_source_resets counter\n\
{ns}_ingest_source_resets{{session=\"{label}\"}} {}\n\
# HELP {ns}_ingest_checkpoints Checkpoint saves.\n\
# TYPE {ns}_ingest_checkpoints counter\n\
{ns}_ingest_checkpoints{{session=\"{label}\"}} {}\n",
metrics.accepted,
metrics.dropped,
metrics.rejected_late,
metrics.rejected_ooo,
metrics.queue_hwm,
metrics.source_resets,
metrics.checkpoints,
)
}
#[derive(Clone, Debug, PartialEq)]
pub struct QueuedFrame {
pub stamp: FrameStamp,
pub detections: Vec<Detection>,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum QueuePushResult {
Enqueued,
RejectedNew,
DroppedNewest,
DroppedOldest,
}
#[derive(Clone, Debug, Default)]
pub struct FrameQueue {
items: VecDeque<QueuedFrame>,
max_depth: usize,
drop_policy: DropPolicy,
hwm: usize,
dropped: u64,
rejected_new: u64,
}
impl FrameQueue {
#[must_use]
pub fn from_policy(policy: &IngestPolicy) -> Self {
Self {
items: VecDeque::new(),
max_depth: policy.max_queue_depth,
drop_policy: policy.drop_policy,
hwm: 0,
dropped: 0,
rejected_new: 0,
}
}
#[must_use]
pub fn new(max_depth: usize, drop_policy: DropPolicy) -> Self {
Self {
items: VecDeque::new(),
max_depth,
drop_policy,
hwm: 0,
dropped: 0,
rejected_new: 0,
}
}
#[must_use]
pub fn len(&self) -> usize {
self.items.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.items.is_empty()
}
#[must_use]
pub const fn high_water_mark(&self) -> usize {
self.hwm
}
#[must_use]
pub const fn dropped(&self) -> u64 {
self.dropped
}
#[must_use]
pub const fn rejected_new(&self) -> u64 {
self.rejected_new
}
pub fn push(&mut self, stamp: FrameStamp, detections: Vec<Detection>) -> QueuePushResult {
let unlimited = self.max_depth == 0;
if !unlimited && self.items.len() >= self.max_depth {
match self.drop_policy {
DropPolicy::RejectNew => {
self.rejected_new = self.rejected_new.saturating_add(1);
return QueuePushResult::RejectedNew;
}
DropPolicy::DropNewest => {
self.dropped = self.dropped.saturating_add(1);
return QueuePushResult::DroppedNewest;
}
DropPolicy::DropOldest => {
let _ = self.items.pop_front();
self.dropped = self.dropped.saturating_add(1);
self.items.push_back(QueuedFrame { stamp, detections });
self.hwm = self.hwm.max(self.items.len());
return QueuePushResult::DroppedOldest;
}
}
}
self.items.push_back(QueuedFrame { stamp, detections });
self.hwm = self.hwm.max(self.items.len());
QueuePushResult::Enqueued
}
pub fn pop_front(&mut self) -> Option<QueuedFrame> {
self.items.pop_front()
}
#[must_use]
pub fn front(&self) -> Option<&QueuedFrame> {
self.items.front()
}
pub fn clear(&mut self) {
self.items.clear();
}
pub fn drain(&mut self, max: Option<usize>) -> Vec<QueuedFrame> {
let n = max.unwrap_or(self.items.len()).min(self.items.len());
let mut out = Vec::with_capacity(n);
for _ in 0..n {
if let Some(item) = self.items.pop_front() {
out.push(item);
}
}
out
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SourceLifecycle {
Added {
source_id: SourceId,
},
Removed {
source_id: SourceId,
reset_tracker: bool,
},
Reconnected {
source_id: SourceId,
},
Reset {
source_id: SourceId,
},
}