Struct EventRecorder

Source

pub struct EventRecorder { /* private fields */ }

Expand description

Thread-safe session recorder for time-travel debugging. Records events and state checkpoints during a recording session. Only one session can be active at a time.

Implementations§

Source §

impl EventRecorder

Source

pub fn new(max_events: usize) -> Self

Creates a new recorder with the given maximum event capacity.

use victauri_core::EventRecorder;

let recorder = EventRecorder::new(1000);
assert!(!recorder.is_recording());
assert_eq!(recorder.event_count(), 0);

Source

pub fn start(&self, session_id: String) -> Result<()>

Starts a new recording session; returns Err if one is already active.

§Errors

Returns VictauriError::RecordingAlreadyActive if a session is already in progress.

§Examples

use victauri_core::EventRecorder;

let recorder = EventRecorder::new(1000);
recorder.start("session-1".to_string()).unwrap();
assert!(recorder.is_recording());

Source

pub fn start_session(&self, session_id: String) -> Result<u64>

start, returning the new recording’s generation — the token for record_event_if and stop_if_generation.

§Errors

Returns VictauriError::RecordingAlreadyActive if a session is already in progress.

Source

pub fn stop(&self) -> Option<RecordedSession>

Stops the active recording and returns the completed session, or None if not recording.

§Examples

use victauri_core::EventRecorder;

let recorder = EventRecorder::new(1000);
recorder.start("session-1".to_string()).unwrap();
let session = recorder.stop().expect("should return session");
assert_eq!(session.id, "session-1");
assert!(!recorder.is_recording());

Source

pub fn is_recording(&self) -> bool

Returns true if a recording session is currently active.

Source

pub fn generation(&self) -> Option<u64>

Generation of the active recording, or None if not recording.

Source

pub fn record_event(&self, event: AppEvent)

Appends an event to the active recording, evicting the oldest if at capacity.

Source

pub fn record_event_if(&self, generation: u64, event: AppEvent) -> bool

record_event, but only into the recording of generation. A reader that captured the generation before a slow read (the webview drain) must not append what it read into a recording started after it — those events predate it. Returns whether the event was recorded.

Source

pub fn checkpoint( &self, id: String, label: Option<String>, state: Value, ) -> Result<()>

Creates a named state checkpoint at the current event index; returns Err if not recording.

§Errors

Returns VictauriError::NoActiveRecording if no session is in progress.

Source

pub fn active_session_id(&self) -> Option<String>

Session id of the active recording, or None if not recording.

Source

pub fn stop_if_session(&self, session_id: &str) -> Option<RecordedSession>

Stop the active recording only if it is the session session_id (a caller that started a recording must not stop a different one someone else started after it ended).

The id check and the stop happen under one lock: checked and stopped separately, a stop + start by someone else in between made this stop the OTHER recording. Session ids are caller-chosen and may repeat, so an owner that must never stop a later recording with the same id should hold its generation and use stop_if_generation.

Source

pub fn stop_if_generation(&self, generation: u64) -> Option<RecordedSession>

Stop the active recording only if it is the one of generation (atomically).

Source

pub fn started_at(&self) -> Option<DateTime<Utc>>

When the active recording started, or None if not recording.

Source

pub fn latest_event_timestamp(&self) -> Option<DateTime<Utc>>

Timestamp of the newest event in the active recording (or its start time if it has no events yet); None if not recording. A caller pulling more events can read strictly after this to avoid re-recording what is already there.

Source

pub fn event_count(&self) -> usize

Returns the number of events recorded so far, or 0 if not recording.

Source

pub fn checkpoint_count(&self) -> usize

Returns the number of checkpoints created so far, or 0 if not recording.

Source

pub fn events_since(&self, index: usize) -> Vec<RecordedEvent>

Returns all events with an index >= the given value. Falls back to the last stopped session if no active recording.

Source

pub fn events_between( &self, from: DateTime<Utc>, to: DateTime<Utc>, ) -> Vec<RecordedEvent>

Returns events whose timestamps fall within the given inclusive range. Falls back to the last stopped session if no active recording.

Source

pub fn get_checkpoints(&self) -> Vec<StateCheckpoint>

Returns all checkpoints from the active recording session. Falls back to the last stopped session if no active recording.

Source

pub fn events_between_checkpoints( &self, from_checkpoint_id: &str, to_checkpoint_id: &str, ) -> Result<Vec<RecordedEvent>>

Returns events recorded between two named checkpoints. Falls back to the last stopped session if no active recording.

§Errors

VictauriError::NoActiveRecording if no session is active and no last session exists.
VictauriError::CheckpointNotFound if either checkpoint ID does not exist.

Source

pub fn export(&self) -> Option<RecordedSession>

Snapshot the current recording as a session WITHOUT stopping it. Falls back to the last stopped session if no active recording.

Source

pub fn import(&self, session: RecordedSession)

Import a previously exported session, replacing any active recording.

The imported session is fully caller-controlled, so its collections are clamped to the configured caps (keeping the most recent entries) before becoming active — an oversized session cannot inflate resident memory past max_events/max_checkpoints (audit #19), and a crafted event index of usize::MAX cannot overflow the counter (audit #18).

Source

pub fn import_if_idle(&self, session: RecordedSession) -> Result<u64>

import, but only if no recording is active — checked and replaced under one lock, so a recording started concurrently is never silently discarded. Returns the imported recording’s generation.