Struct ProcessTrace 

pub struct ProcessTrace {
    pub id: TraceId,
    pub case_id: String,
    pub activities: Vec<ActivityId>,
    pub timestamps: Vec<HybridTimestamp>,
    pub durations: Vec<u32>,
    pub total_duration_ms: u64,
    pub start_time: HybridTimestamp,
    pub end_time: HybridTimestamp,
    pub is_complete: bool,
    pub variant_id: u32,
}

A process trace (case) containing a sequence of events.

Fields

id: TraceId

Unique trace identifier.

case_id: String

Case identifier (business key).

activities: Vec<ActivityId>

Sequence of activity IDs in execution order.

timestamps: Vec<HybridTimestamp>

Timestamps for each activity.

durations: Vec<u32>

Durations for each activity (ms).

total_duration_ms: u64

Total trace duration (ms).

start_time: HybridTimestamp

First event timestamp.

end_time: HybridTimestamp

Last event timestamp.

is_complete: bool

Whether trace is complete.

variant_id: u32

Variant identifier (for trace clustering).

Implementations

impl ProcessTrace

pub fn new(id: TraceId, case_id: impl Into<String>) -> Self

Create a new empty trace.

pub fn add_activity( &mut self, activity_id: ActivityId, timestamp: HybridTimestamp, duration_ms: u32, )

Add an activity to the trace.

pub fn len(&self) -> usize

Get trace length.

pub fn is_empty(&self) -> bool

Check if trace is empty.

pub fn get(&self, index: usize) -> Option<ActivityId>

Get activity at index.

pub fn edges(&self) -> impl Iterator<Item = (ActivityId, ActivityId)> + '_

Get edges (directly-follows pairs).

pub fn complete(&mut self)

Mark trace as complete.

Trait Implementations

impl Archive for ProcessTrace

where TraceId: Archive, String: Archive, Vec<ActivityId>: Archive, Vec<HybridTimestamp>: Archive, Vec<u32>: Archive, u64: Archive, HybridTimestamp: Archive, bool: Archive, u32: Archive,

type Archived = ArchivedProcessTrace

The archived representation of this type.

type Resolver = ProcessTraceResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for ProcessTrace

fn clone(&self) -> ProcessTrace

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProcessTrace

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

Formats the value using the given formatter.

impl<__D: Fallible + ?Sized> Deserialize<ProcessTrace, __D> for Archived<ProcessTrace>

where TraceId: Archive, Archived<TraceId>: Deserialize<TraceId, __D>, String: Archive, Archived<String>: Deserialize<String, __D>, Vec<ActivityId>: Archive, Archived<Vec<ActivityId>>: Deserialize<Vec<ActivityId>, __D>, Vec<HybridTimestamp>: Archive, Archived<Vec<HybridTimestamp>>: Deserialize<Vec<HybridTimestamp>, __D>, Vec<u32>: Archive, Archived<Vec<u32>>: Deserialize<Vec<u32>, __D>, u64: Archive, Archived<u64>: Deserialize<u64, __D>, HybridTimestamp: Archive, Archived<HybridTimestamp>: Deserialize<HybridTimestamp, __D>, bool: Archive, Archived<bool>: Deserialize<bool, __D>, u32: Archive, Archived<u32>: Deserialize<u32, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<ProcessTrace, __D::Error>

Deserializes using the given deserializer

impl<__S: Fallible + ?Sized> Serialize<__S> for ProcessTrace

where TraceId: Serialize<__S>, String: Serialize<__S>, Vec<ActivityId>: Serialize<__S>, Vec<HybridTimestamp>: Serialize<__S>, Vec<u32>: Serialize<__S>, u64: Serialize<__S>, HybridTimestamp: Serialize<__S>, bool: Serialize<__S>, u32: Serialize<__S>,

fn serialize(&self, serializer: &mut __S) -> Result<Self::Resolver, __S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.