Struct StateMachineMetrics 

pub struct StateMachineMetrics {
    pub total_transitions: u64,
    pub successful_transitions: u64,
    pub failed_transitions: u64,
    pub transition_durations: Vec<Duration>,
    pub state_visit_counts: HashMap<String, u64>,
}

Fields

total_transitions: u64

successful_transitions: u64

failed_transitions: u64

transition_durations: Vec<Duration>

state_visit_counts: HashMap<String, u64>

Implementations

impl StateMachineMetrics

pub fn new() -> Self

pub fn average_transition_time(&self) -> Option<Duration>

Examples found in repository

examples/traffic_light_example.rs (line 391)

fn demonstrate_metrics(
    state_machine: &StateMachine<TrafficLightState, TrafficLightEvent, TrafficContext>,
) {
    println!("--- Performance Metrics ---");
    let metrics = state_machine.get_metrics();
    println!("  Total transitions: {}", metrics.total_transitions);
    println!("  Success rate: {:.1}%", metrics.success_rate() * 100.0);
    if let Some(avg_time) = metrics.average_transition_time() {
        println!("  Average transition time: {:?}", avg_time);
    }
    println!("  State visits:");
    for (state, count) in &metrics.state_visit_counts {
        println!("    {}: {} times", state, count);
    }
    println!();
}

examples/order_example.rs (line 260)

fn metrics_example() {
    println!("\n=== Metrics Collection Example ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    // Add multiple transitions
    builder
        .external_transition()
        .from(OrderState::New)
        .to(OrderState::PaymentPending)
        .on(OrderEvent::Pay)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::PaymentPending)
        .to(OrderState::PaymentReceived)
        .on(OrderEvent::ConfirmPayment)
        .when(|_s, _e, ctx| ctx.amount > 0.0)
        .perform(|_s, _e, _c| {});

    builder
        .external_transitions()
        .from_among(vec![
            OrderState::New,
            OrderState::PaymentPending,
            OrderState::Processing,
        ])
        .to(OrderState::Cancelled)
        .on(OrderEvent::Cancel)
        .perform(|_s, _e, _c| {});

    let state_machine = builder.id("MetricsOrderMachine").build();

    // Simulate multiple orders
    for i in 0..10 {
        let context = OrderContext {
            order_id: format!("ORD-{:03}", i),
            amount: (i as f64) * 10.0,
            customer_id: format!("CUST-{:03}", i),
        };

        let _ = state_machine.fire_event(OrderState::New, OrderEvent::Pay, context.clone());

        if i % 3 == 0 {
            // Some orders get cancelled
            let _ =
                state_machine.fire_event(OrderState::PaymentPending, OrderEvent::Cancel, context);
        } else {
            // Others proceed normally
            let _ = state_machine.fire_event(
                OrderState::PaymentPending,
                OrderEvent::ConfirmPayment,
                context,
            );
        }
    }

    // Get and display metrics
    let metrics = state_machine.get_metrics();
    println!("State Machine Metrics:");
    println!("  Total transitions: {}", metrics.total_transitions);
    println!("  Successful: {}", metrics.successful_transitions);
    println!("  Failed: {}", metrics.failed_transitions);
    println!("  Success rate: {:.2}%", metrics.success_rate() * 100.0);

    if let Some(avg_time) = metrics.average_transition_time() {
        println!("  Average transition time: {:?}", avg_time);
    }

    println!("  State visit counts:");
    for (state, count) in &metrics.state_visit_counts {
        println!("    {}: {}", state, count);
    }
}

pub fn success_rate(&self) -> f64

Examples found in repository

examples/traffic_light_example.rs (line 390)

fn demonstrate_metrics(
    state_machine: &StateMachine<TrafficLightState, TrafficLightEvent, TrafficContext>,
) {
    println!("--- Performance Metrics ---");
    let metrics = state_machine.get_metrics();
    println!("  Total transitions: {}", metrics.total_transitions);
    println!("  Success rate: {:.1}%", metrics.success_rate() * 100.0);
    if let Some(avg_time) = metrics.average_transition_time() {
        println!("  Average transition time: {:?}", avg_time);
    }
    println!("  State visits:");
    for (state, count) in &metrics.state_visit_counts {
        println!("    {}: {} times", state, count);
    }
    println!();
}

examples/order_example.rs (line 258)

fn metrics_example() {
    println!("\n=== Metrics Collection Example ===");

    let mut builder = StateMachineBuilderFactory::create::<OrderState, OrderEvent, OrderContext>();

    // Add multiple transitions
    builder
        .external_transition()
        .from(OrderState::New)
        .to(OrderState::PaymentPending)
        .on(OrderEvent::Pay)
        .perform(|_s, _e, _c| {});

    builder
        .external_transition()
        .from(OrderState::PaymentPending)
        .to(OrderState::PaymentReceived)
        .on(OrderEvent::ConfirmPayment)
        .when(|_s, _e, ctx| ctx.amount > 0.0)
        .perform(|_s, _e, _c| {});

    builder
        .external_transitions()
        .from_among(vec![
            OrderState::New,
            OrderState::PaymentPending,
            OrderState::Processing,
        ])
        .to(OrderState::Cancelled)
        .on(OrderEvent::Cancel)
        .perform(|_s, _e, _c| {});

    let state_machine = builder.id("MetricsOrderMachine").build();

    // Simulate multiple orders
    for i in 0..10 {
        let context = OrderContext {
            order_id: format!("ORD-{:03}", i),
            amount: (i as f64) * 10.0,
            customer_id: format!("CUST-{:03}", i),
        };

        let _ = state_machine.fire_event(OrderState::New, OrderEvent::Pay, context.clone());

        if i % 3 == 0 {
            // Some orders get cancelled
            let _ =
                state_machine.fire_event(OrderState::PaymentPending, OrderEvent::Cancel, context);
        } else {
            // Others proceed normally
            let _ = state_machine.fire_event(
                OrderState::PaymentPending,
                OrderEvent::ConfirmPayment,
                context,
            );
        }
    }

    // Get and display metrics
    let metrics = state_machine.get_metrics();
    println!("State Machine Metrics:");
    println!("  Total transitions: {}", metrics.total_transitions);
    println!("  Successful: {}", metrics.successful_transitions);
    println!("  Failed: {}", metrics.failed_transitions);
    println!("  Success rate: {:.2}%", metrics.success_rate() * 100.0);

    if let Some(avg_time) = metrics.average_transition_time() {
        println!("  Average transition time: {:?}", avg_time);
    }

    println!("  State visit counts:");
    for (state, count) in &metrics.state_visit_counts {
        println!("    {}: {}", state, count);
    }
}

Trait Implementations

impl Clone for StateMachineMetrics

fn clone(&self) -> StateMachineMetrics

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StateMachineMetrics

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.