Struct ParserHealth 

pub struct ParserHealth {
    pub total_events: u64,
    pub parsed_events: u64,
    pub partial_events: u64,
    pub ignored_events: u64,
    pub control_events: u64,
    pub unknown_events: u64,
    pub parse_errors: u64,
}

Parser health statistics

Fields

total_events: u64

Total number of events processed

parsed_events: u64

Number of events successfully parsed and displayed

partial_events: u64

Number of partial/delta events (streaming content displayed incrementally)

ignored_events: u64

Number of events ignored (malformed JSON, unknown events, etc.)

control_events: u64

Number of control events (state management, no user output)

unknown_events: u64

Number of unknown event types (valid JSON but unhandled)

parse_errors: u64

Number of JSON parse errors (malformed JSON)

Implementations

impl ParserHealth

pub fn new() -> Self

Create a new health tracker

pub const fn record_parsed(&mut self)

Record a parsed event

pub const fn record_ignored(&mut self)

Record an ignored event

pub const fn record_unknown_event(&mut self)

Record an unknown event type (valid JSON but unhandled)

Unknown events are valid JSON that the parser deserialized successfully but doesn’t have specific handling for. These should not trigger health warnings as they represent future/new event types, not parser errors.

pub const fn record_parse_error(&mut self)

Record a parse error (malformed JSON)

pub const fn record_control_event(&mut self)

Record a control event (state management with no user-facing output)

Control events are valid JSON that represent state transitions rather than user-facing content. They should not be counted as “ignored” for health monitoring purposes.

pub const fn record_partial_event(&mut self)

Record a partial/delta event (streaming content displayed incrementally)

Partial events represent streaming content that is shown to the user in real-time as deltas. These are NOT errors and should not trigger health warnings. They are tracked separately to show streaming activity.

pub fn parse_error_percentage(&self) -> f64

Get the percentage of parse errors (excluding unknown events)

Returns percentage using integer-safe arithmetic to avoid precision loss warnings.

pub fn parse_error_percentage_int(&self) -> u32

Get the percentage of parse errors as a rounded integer.

This is for display purposes where a whole number is sufficient.

pub fn is_concerning(&self) -> bool

Check if the parser health is concerning

Only returns true if there are actual parse errors (malformed JSON), not just unknown event types. Unknown events are valid JSON that we don’t have specific handling for, which is not a health concern.

pub fn warning(&self, parser_name: &str, colors: Colors) -> Option<String>

Get a warning message if health is concerning

Trait Implementations

impl Clone for ParserHealth

fn clone(&self) -> ParserHealth

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParserHealth

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

Formats the value using the given formatter.

impl Default for ParserHealth

fn default() -> ParserHealth

Returns the “default value” for a type.

impl Copy for ParserHealth