Struct TaskMetrics 

pub struct TaskMetrics {
    pub pending: usize,
    pub running: usize,
    pub completed: usize,
    pub failed: usize,
    pub cancelled: usize,
    pub total: usize,
}

Fields

pending: usize

running: usize

completed: usize

failed: usize

cancelled: usize

total: usize

Implementations

impl TaskMetrics

pub fn success_rate(&self) -> f64

Examples found in repository

examples/custom_handler.rs (line 288)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    init();

    let config = TaskFlowConfig::with_in_memory();
    let taskflow = TaskFlow::new(config).await?;

    taskflow.register_handler(Arc::new(MathTaskHandler)).await;
    taskflow
        .register_handler(Arc::new(DataProcessingHandler))
        .await;

    println!("TaskFlow with custom handlers started!");

    let add_task = TaskDefinition::new("addition", "math_operation")
        .with_payload("operation", serde_json::Value::String("add".to_string()))
        .with_payload("a", serde_json::Value::Number(serde_json::Number::from(10)))
        .with_payload("b", serde_json::Value::Number(serde_json::Number::from(5)));

    let add_task_id = taskflow.submit_task(add_task).await?;
    println!("Submitted addition task: {}", add_task_id);

    let multiply_task = TaskDefinition::new("multiplication", "math_operation")
        .with_payload(
            "operation",
            serde_json::Value::String("multiply".to_string()),
        )
        .with_payload("a", serde_json::Value::Number(serde_json::Number::from(7)))
        .with_payload("b", serde_json::Value::Number(serde_json::Number::from(3)));

    let multiply_task_id = taskflow.submit_task(multiply_task).await?;
    println!("Submitted multiplication task: {}", multiply_task_id);

    let data_array = vec![
        serde_json::Value::Number(serde_json::Number::from(1)),
        serde_json::Value::Number(serde_json::Number::from(2)),
        serde_json::Value::Number(serde_json::Number::from(3)),
        serde_json::Value::Number(serde_json::Number::from(4)),
        serde_json::Value::Number(serde_json::Number::from(5)),
    ];

    let sum_task = TaskDefinition::new("sum_data", "data_processing")
        .with_payload("operation", serde_json::Value::String("sum".to_string()))
        .with_payload("data", serde_json::Value::Array(data_array.clone()));

    let sum_task_id = taskflow.submit_task(sum_task).await?;
    println!("Submitted sum task: {}", sum_task_id);

    let avg_task = TaskDefinition::new("average_data", "data_processing")
        .with_payload(
            "operation",
            serde_json::Value::String("average".to_string()),
        )
        .with_payload("data", serde_json::Value::Array(data_array))
        .with_dependencies(vec![sum_task_id.clone()]);

    let avg_task_id = taskflow.submit_task(avg_task).await?;
    println!("Submitted average task (depends on sum): {}", avg_task_id);

    let taskflow_clone = std::sync::Arc::new(taskflow);
    let taskflow_for_execution = taskflow_clone.clone();

    let execution_handle = tokio::spawn(async move {
        if let Err(e) = taskflow_for_execution.start().await {
            eprintln!("TaskFlow execution failed: {}", e);
        }
    });

    tokio::time::sleep(std::time::Duration::from_secs(1)).await;

    loop {
        let metrics = taskflow_clone.get_task_metrics().await?;
        println!(
            "Task metrics: pending={}, running={}, completed={}, failed={}",
            metrics.pending, metrics.running, metrics.completed, metrics.failed
        );

        if metrics.pending == 0 && metrics.running == 0 {
            break;
        }

        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    }

    println!("\nAll tasks completed! Results:");

    let tasks = taskflow_clone.list_tasks(None).await?;
    for task in tasks {
        println!(
            "\nTask: {} ({})",
            task.definition.name, task.definition.task_type
        );
        println!("  Status: {:?}", task.status);
        if let Some(result) = &task.result {
            if result.success {
                println!(
                    "  Result: {}",
                    result.output.as_ref().unwrap_or(&"No output".to_string())
                );
                println!("  Execution time: {}ms", result.execution_time_ms);
                if !result.metadata.is_empty() {
                    println!("  Metadata: {:?}", result.metadata);
                }
            } else {
                println!(
                    "  Error: {}",
                    result
                        .error
                        .as_ref()
                        .unwrap_or(&"Unknown error".to_string())
                );
            }
        }
    }

    let final_metrics = taskflow_clone.get_task_metrics().await?;
    println!("\nFinal metrics:");
    println!("  Total tasks: {}", final_metrics.total);
    println!(
        "  Success rate: {:.1}%",
        final_metrics.success_rate() * 100.0
    );

    taskflow_clone.shutdown().await?;
    execution_handle.abort();

    Ok(())
}

Trait Implementations

impl Clone for TaskMetrics

fn clone(&self) -> TaskMetrics

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TaskMetrics

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

Formats the value using the given formatter.