Struct StepExecution 

#[non_exhaustive]
pub struct StepExecution {

    pub id: Uuid,
    pub name: String,
    pub status: StepStatus,
    pub start_time: Option<Instant>,
    pub end_time: Option<Instant>,
    pub duration: Option<Duration>,
    pub read_count: usize,
    pub write_count: usize,
    pub read_error_count: usize,
    pub process_count: usize,
    pub process_error_count: usize,
    pub filter_count: usize,
    pub write_error_count: usize,
    pub read_duration: Duration,
    pub process_duration: Duration,
    pub write_duration: Duration,
    pub flush_duration: Duration,
}

Represents the execution context and metrics for a step.

StepExecution tracks all relevant information about a step’s execution, including timing, item counts, error counts, and current status.

Construction

This type is #[non_exhaustive], so it cannot be built with a struct literal from outside the crate — use StepExecution::new. Fields stay public and freely readable; the attribute exists so that new metrics can be added in a minor release rather than a breaking one.

Examples

use spring_batch_rs::core::step::{StepExecution, StepStatus};

let mut step_execution = StepExecution::new("data-processing-step");
assert_eq!(step_execution.status, StepStatus::Starting);
assert_eq!(step_execution.read_count, 0);
assert_eq!(step_execution.write_count, 0);
assert_eq!(step_execution.filter_count, 0);

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

id: Uuid

Unique identifier for this step instance

name: String

Human-readable name for the step

status: StepStatus

Current status of the step execution

start_time: Option<Instant>

Timestamp when the step started execution

end_time: Option<Instant>

Timestamp when the step completed execution

duration: Option<Duration>

Total duration of step execution

read_count: usize

Number of items successfully read from the source

write_count: usize

Number of items successfully written to the destination

read_error_count: usize

Number of errors encountered during reading

process_count: usize

Number of items successfully processed and passed to the writer (excludes filtered items)

process_error_count: usize

Number of errors encountered during processing

filter_count: usize

Number of items filtered by the processor (processor returned Ok(None))

write_error_count: usize

Number of errors encountered during writing

read_duration: Duration

Cumulative time spent in the read phase across all chunks. Covers the whole per-chunk read loop, including the framework’s buffering, not just ItemReader::read. Only chunk-oriented steps populate this; tasklet steps leave it at zero.

process_duration: Duration

Cumulative time spent in the process phase across all chunks. Covers the whole per-chunk process loop, including collecting the results, not just ItemProcessor::process. Only chunk-oriented steps populate this; tasklet steps leave it at zero.

write_duration: Duration

Cumulative time spent in ItemWriter::write across all chunks, excluding the flush that follows it. Only chunk-oriented steps populate this; tasklet steps leave it at zero.

flush_duration: Duration

Cumulative time spent in ItemWriter::flush across all chunks, measured separately from StepExecution::write_duration so the cost of flushing once per chunk can be quantified. Only chunk-oriented steps populate this; tasklet steps leave it at zero.

Implementations

impl StepExecution

pub fn new(name: &str) -> Self

Creates a new StepExecution with the specified name.

Initializes all counters to zero and sets the status to Starting. A unique UUID is generated for this execution instance.

Parameters

• name: Human-readable name for the step

Examples

use spring_batch_rs::core::step::{StepExecution, StepStatus};

let step_execution = StepExecution::new("my-step");
assert_eq!(step_execution.name, "my-step");
assert_eq!(step_execution.status, StepStatus::Starting);
assert!(!step_execution.id.is_nil());

pub fn phase_summary(&self) -> String

Formats the per-phase timing breakdown as a single human-readable line.

Percentages are relative to the step’s total StepExecution::duration. When duration is None or zero — for instance before the step has run — every percentage is reported as 0% rather than NaN.

The four phases will not sum to exactly 100%. The remainder holds the writer’s open() and close() calls — which is where the CSV, JSON and XML writers perform their final flush — the teardown of each processed chunk, and the framework’s own bookkeeping. A large remainder is itself a useful signal.

Only chunk-oriented steps populate the four phase fields. Calling this on a tasklet step’s execution yields a line whose phases all read 0.0s (0%).

Examples

use spring_batch_rs::core::step::StepExecution;
use std::time::Duration;

let mut step_execution = StepExecution::new("load-postgres");
step_execution.duration = Some(Duration::from_secs(10));
step_execution.read_duration = Duration::from_secs(5);

let summary = step_execution.phase_summary();
assert!(summary.contains("read 5.0s (50%)"));

Trait Implementations

impl Clone for StepExecution

fn clone(&self) -> StepExecution

Returns a duplicate of the value.

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

Performs copy-assignment from source.