use orcher_sdk_core::interceptor::{InterceptorContext, InterceptorHook, OperationType};
use std::sync::atomic::{AtomicU64, Ordering};
pub struct MetricsInterceptor {
workflow_started: AtomicU64,
workflow_completed: AtomicU64,
workflow_failed: AtomicU64,
workflow_total_ms: AtomicU64,
task_started: AtomicU64,
task_completed: AtomicU64,
task_failed: AtomicU64,
task_total_ms: AtomicU64,
}
#[derive(Debug, Clone)]
pub struct MetricsSnapshot {
pub workflow_started: u64,
pub workflow_completed: u64,
pub workflow_failed: u64,
pub workflow_total_ms: u64,
pub task_started: u64,
pub task_completed: u64,
pub task_failed: u64,
pub task_total_ms: u64,
}
impl MetricsInterceptor {
pub fn new() -> Self {
Self {
workflow_started: AtomicU64::new(0),
workflow_completed: AtomicU64::new(0),
workflow_failed: AtomicU64::new(0),
workflow_total_ms: AtomicU64::new(0),
task_started: AtomicU64::new(0),
task_completed: AtomicU64::new(0),
task_failed: AtomicU64::new(0),
task_total_ms: AtomicU64::new(0),
}
}
pub fn snapshot(&self) -> MetricsSnapshot {
MetricsSnapshot {
workflow_started: self.workflow_started.load(Ordering::Relaxed),
workflow_completed: self.workflow_completed.load(Ordering::Relaxed),
workflow_failed: self.workflow_failed.load(Ordering::Relaxed),
workflow_total_ms: self.workflow_total_ms.load(Ordering::Relaxed),
task_started: self.task_started.load(Ordering::Relaxed),
task_completed: self.task_completed.load(Ordering::Relaxed),
task_failed: self.task_failed.load(Ordering::Relaxed),
task_total_ms: self.task_total_ms.load(Ordering::Relaxed),
}
}
}
impl Default for MetricsInterceptor {
fn default() -> Self {
Self::new()
}
}
impl InterceptorHook for MetricsInterceptor {
fn name(&self) -> &str {
"metrics"
}
fn before_execution(&self, ctx: &InterceptorContext) {
match ctx.operation_type {
OperationType::Workflow => {
self.workflow_started.fetch_add(1, Ordering::Relaxed);
}
OperationType::Task | OperationType::Actor => {
self.task_started.fetch_add(1, Ordering::Relaxed);
}
}
}
fn after_execution(&self, ctx: &InterceptorContext, duration_ms: u64) {
match ctx.operation_type {
OperationType::Workflow => {
self.workflow_completed.fetch_add(1, Ordering::Relaxed);
self.workflow_total_ms
.fetch_add(duration_ms, Ordering::Relaxed);
}
OperationType::Task | OperationType::Actor => {
self.task_completed.fetch_add(1, Ordering::Relaxed);
self.task_total_ms.fetch_add(duration_ms, Ordering::Relaxed);
}
}
}
fn on_error(&self, ctx: &InterceptorContext, _error: &str, duration_ms: u64) {
match ctx.operation_type {
OperationType::Workflow => {
self.workflow_failed.fetch_add(1, Ordering::Relaxed);
self.workflow_total_ms
.fetch_add(duration_ms, Ordering::Relaxed);
}
OperationType::Task | OperationType::Actor => {
self.task_failed.fetch_add(1, Ordering::Relaxed);
self.task_total_ms.fetch_add(duration_ms, Ordering::Relaxed);
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_metrics_counters() {
let m = MetricsInterceptor::new();
let wf_ctx = InterceptorContext::workflow("wf-1", "Order", 1, "default", "q");
let task_ctx = InterceptorContext::task("t-1", "Process", 1, "default", "q");
m.before_execution(&wf_ctx);
m.after_execution(&wf_ctx, 50);
m.before_execution(&task_ctx);
m.on_error(&task_ctx, "boom", 10);
let snap = m.snapshot();
assert_eq!(snap.workflow_started, 1);
assert_eq!(snap.workflow_completed, 1);
assert_eq!(snap.workflow_failed, 0);
assert_eq!(snap.workflow_total_ms, 50);
assert_eq!(snap.task_started, 1);
assert_eq!(snap.task_completed, 0);
assert_eq!(snap.task_failed, 1);
assert_eq!(snap.task_total_ms, 10);
}
}