use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::time::{Duration, SystemTime};
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum TraceLevel {
Error,
Warn,
Info,
Debug,
Trace,
}
impl From<tracing::Level> for TraceLevel {
fn from(level: tracing::Level) -> Self {
match level {
tracing::Level::ERROR => TraceLevel::Error,
tracing::Level::WARN => TraceLevel::Warn,
tracing::Level::INFO => TraceLevel::Info,
tracing::Level::DEBUG => TraceLevel::Debug,
tracing::Level::TRACE => TraceLevel::Trace,
}
}
}
#[derive(Debug, Clone)]
pub struct ExecutionEvent {
pub timestamp: SystemTime,
pub level: TraceLevel,
pub kind: String,
pub workflow_id: String,
pub message: String,
pub metadata: HashMap<String, String>,
}
impl ExecutionEvent {
pub fn new(
level: TraceLevel,
kind: impl Into<String>,
workflow_id: impl Into<String>,
message: impl Into<String>,
) -> Self {
Self {
timestamp: SystemTime::now(),
level,
kind: kind.into(),
workflow_id: workflow_id.into(),
message: message.into(),
metadata: HashMap::new(),
}
}
pub fn with_metadata(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
self.metadata.insert(key.into(), value.into());
self
}
pub fn elapsed(&self) -> Duration {
SystemTime::now()
.duration_since(self.timestamp)
.unwrap_or(Duration::ZERO)
}
}
#[derive(Debug, Clone)]
pub struct ExecutionTrace {
pub workflow_id: String,
pub workflow_type: String,
pub started_at: SystemTime,
pub ended_at: Option<SystemTime>,
pub events: Vec<ExecutionEvent>,
pub command_count: usize,
pub state_keys: Vec<String>,
}
impl ExecutionTrace {
pub fn new(workflow_id: impl Into<String>, workflow_type: impl Into<String>) -> Self {
Self {
workflow_id: workflow_id.into(),
workflow_type: workflow_type.into(),
started_at: SystemTime::now(),
ended_at: None,
events: Vec::new(),
command_count: 0,
state_keys: Vec::new(),
}
}
pub fn add_event(&mut self, event: ExecutionEvent) {
self.events.push(event);
}
pub fn complete(&mut self) {
self.ended_at = Some(SystemTime::now());
}
pub fn duration(&self) -> Option<Duration> {
self.ended_at
.and_then(|end| end.duration_since(self.started_at).ok())
}
pub fn events_at_level(&self, level: TraceLevel) -> Vec<&ExecutionEvent> {
self.events.iter().filter(|e| e.level <= level).collect()
}
pub fn events_of_kind(&self, kind: &str) -> Vec<&ExecutionEvent> {
self.events.iter().filter(|e| e.kind == kind).collect()
}
pub fn event_count(&self) -> usize {
self.events.len()
}
pub fn has_errors(&self) -> bool {
self.events.iter().any(|e| e.level == TraceLevel::Error)
}
pub fn errors(&self) -> Vec<&ExecutionEvent> {
self.events
.iter()
.filter(|e| e.level == TraceLevel::Error)
.collect()
}
}
#[derive(Clone)]
pub struct ExecutionTracer {
level: TraceLevel,
capture_spans: bool,
capture_events: bool,
traces: Arc<Mutex<HashMap<String, ExecutionTrace>>>,
enabled: bool,
}
impl ExecutionTracer {
pub fn new() -> Self {
Self {
level: TraceLevel::Info,
capture_spans: true,
capture_events: true,
traces: Arc::new(Mutex::new(HashMap::new())),
enabled: false,
}
}
pub fn with_level(mut self, level: TraceLevel) -> Self {
self.level = level;
self
}
pub fn with_spans(mut self, capture: bool) -> Self {
self.capture_spans = capture;
self
}
pub fn with_events(mut self, capture: bool) -> Self {
self.capture_events = capture;
self
}
pub fn enable(mut self) -> Self {
self.enabled = true;
self
}
pub fn disable(mut self) -> Self {
self.enabled = false;
self
}
pub fn is_enabled(&self) -> bool {
self.enabled
}
pub fn start_trace(&self, workflow_id: impl Into<String>, workflow_type: impl Into<String>) {
if !self.enabled {
return;
}
let workflow_id = workflow_id.into();
let workflow_type = workflow_type.into();
let mut traces = self.traces.lock().unwrap();
traces.insert(
workflow_id.clone(),
ExecutionTrace::new(workflow_id, workflow_type),
);
}
pub fn record_event(&self, workflow_id: &str, event: ExecutionEvent) {
if !self.enabled || !self.capture_events {
return;
}
if event.level > self.level {
return;
}
let mut traces = self.traces.lock().unwrap();
if let Some(trace) = traces.get_mut(workflow_id) {
trace.add_event(event);
}
}
pub fn record_command(&self, workflow_id: &str, command_type: &str) {
if !self.enabled {
return;
}
let mut traces = self.traces.lock().unwrap();
if let Some(trace) = traces.get_mut(workflow_id) {
trace.command_count += 1;
let event = ExecutionEvent::new(
TraceLevel::Debug,
"command_generated",
workflow_id,
format!("Command generated: {}", command_type),
)
.with_metadata("command_type", command_type);
trace.add_event(event);
}
}
pub fn record_state_access(&self, workflow_id: &str, key: &str) {
if !self.enabled {
return;
}
let mut traces = self.traces.lock().unwrap();
if let Some(trace) = traces.get_mut(workflow_id) {
if !trace.state_keys.contains(&key.to_string()) {
trace.state_keys.push(key.to_string());
}
}
}
pub fn complete_trace(&self, workflow_id: &str) {
if !self.enabled {
return;
}
let mut traces = self.traces.lock().unwrap();
if let Some(trace) = traces.get_mut(workflow_id) {
trace.complete();
}
}
pub fn get_trace(&self, workflow_id: &str) -> Option<ExecutionTrace> {
let traces = self.traces.lock().unwrap();
traces.get(workflow_id).cloned()
}
pub fn all_traces(&self) -> Vec<ExecutionTrace> {
let traces = self.traces.lock().unwrap();
traces.values().cloned().collect()
}
pub fn clear(&self) {
let mut traces = self.traces.lock().unwrap();
traces.clear();
}
pub fn trace_count(&self) -> usize {
let traces = self.traces.lock().unwrap();
traces.len()
}
}
impl Default for ExecutionTracer {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_execution_tracer_creation() {
let tracer = ExecutionTracer::new();
assert!(!tracer.is_enabled());
assert_eq!(tracer.level, TraceLevel::Info);
}
#[test]
fn test_execution_tracer_enable() {
let tracer = ExecutionTracer::new().enable();
assert!(tracer.is_enabled());
}
#[test]
fn test_execution_tracer_with_level() {
let tracer = ExecutionTracer::new().with_level(TraceLevel::Debug);
assert_eq!(tracer.level, TraceLevel::Debug);
}
#[test]
fn test_start_and_get_trace() {
let tracer = ExecutionTracer::new().enable();
tracer.start_trace("wf-123", "TestWorkflow");
let trace = tracer.get_trace("wf-123");
assert!(trace.is_some());
let trace = trace.unwrap();
assert_eq!(trace.workflow_id, "wf-123");
assert_eq!(trace.workflow_type, "TestWorkflow");
assert_eq!(trace.event_count(), 0);
}
#[test]
fn test_record_event() {
let tracer = ExecutionTracer::new().enable();
tracer.start_trace("wf-123", "TestWorkflow");
let event = ExecutionEvent::new(TraceLevel::Info, "test_event", "wf-123", "Test message");
tracer.record_event("wf-123", event);
let trace = tracer.get_trace("wf-123").unwrap();
assert_eq!(trace.event_count(), 1);
assert_eq!(trace.events[0].kind, "test_event");
}
#[test]
fn test_record_command() {
let tracer = ExecutionTracer::new().enable();
tracer.start_trace("wf-123", "TestWorkflow");
tracer.record_command("wf-123", "ScheduleTask");
tracer.record_command("wf-123", "StartTimer");
let trace = tracer.get_trace("wf-123").unwrap();
assert_eq!(trace.command_count, 2);
}
#[test]
fn test_record_state_access() {
let tracer = ExecutionTracer::new().enable();
tracer.start_trace("wf-123", "TestWorkflow");
tracer.record_state_access("wf-123", "counter");
tracer.record_state_access("wf-123", "status");
tracer.record_state_access("wf-123", "counter");
let trace = tracer.get_trace("wf-123").unwrap();
assert_eq!(trace.state_keys.len(), 2);
assert!(trace.state_keys.contains(&"counter".to_string()));
assert!(trace.state_keys.contains(&"status".to_string()));
}
#[test]
fn test_complete_trace() {
let tracer = ExecutionTracer::new().enable();
tracer.start_trace("wf-123", "TestWorkflow");
let trace_before = tracer.get_trace("wf-123").unwrap();
assert!(trace_before.ended_at.is_none());
tracer.complete_trace("wf-123");
let trace_after = tracer.get_trace("wf-123").unwrap();
assert!(trace_after.ended_at.is_some());
assert!(trace_after.duration().is_some());
}
#[test]
fn test_event_filtering() {
let tracer = ExecutionTracer::new()
.enable()
.with_level(TraceLevel::Debug);
tracer.start_trace("wf-123", "TestWorkflow");
tracer.record_event(
"wf-123",
ExecutionEvent::new(TraceLevel::Error, "error", "wf-123", "Error message"),
);
tracer.record_event(
"wf-123",
ExecutionEvent::new(TraceLevel::Info, "info", "wf-123", "Info message"),
);
tracer.record_event(
"wf-123",
ExecutionEvent::new(TraceLevel::Debug, "debug", "wf-123", "Debug message"),
);
let trace = tracer.get_trace("wf-123").unwrap();
assert_eq!(trace.event_count(), 3);
let errors = trace.errors();
assert_eq!(errors.len(), 1);
let info_events = trace.events_at_level(TraceLevel::Info);
assert_eq!(info_events.len(), 2); }
#[test]
fn test_trace_level_ordering() {
assert!(TraceLevel::Error < TraceLevel::Warn);
assert!(TraceLevel::Warn < TraceLevel::Info);
assert!(TraceLevel::Info < TraceLevel::Debug);
assert!(TraceLevel::Debug < TraceLevel::Trace);
}
#[test]
fn test_disabled_tracer() {
let tracer = ExecutionTracer::new(); tracer.start_trace("wf-123", "TestWorkflow");
let trace = tracer.get_trace("wf-123");
assert!(trace.is_none());
}
#[test]
fn test_clear_traces() {
let tracer = ExecutionTracer::new().enable();
tracer.start_trace("wf-1", "Test1");
tracer.start_trace("wf-2", "Test2");
assert_eq!(tracer.trace_count(), 2);
tracer.clear();
assert_eq!(tracer.trace_count(), 0);
}
}