Enum EngineEventKind 

pub enum EngineEventKind {
    Accepted,
    PolicyRejected,
    Malformed,
    TransportFailure,
}

Stable engine event category for observability.

Variants

Accepted

Packet parsed and passed policy.

PolicyRejected

Packet parsed but was rejected by policy.

Malformed

Packet failed the codec boundary.

TransportFailure

Transport failed before codec parsing.

Implementations

impl EngineEventKind

pub const fn code(self) -> &'static str

Returns a stable machine-readable event kind code.

Examples found in repository

examples/service_ingest.rs (line 16)

fn main() -> Result<(), std::io::Error> {
    let input = b"N0CALL>APRS:>service online\nN1CALL>APRS:~opaque\nbad packet\n";
    let mut engine = Engine::new(Policy::strict());

    let packets = LineTransport::new(input).packets_with_limit(MAX_PACKET_LEN)?;

    for packet in packets {
        match engine.process_event(packet) {
            EngineEvent::Accepted(event) => {
                println!(
                    "event={} semantic={}",
                    event.kind().code(),
                    event.packet.summary().semantic
                );
            }
            EngineEvent::Rejected(event) => {
                println!(
                    "event={} code={} remediation={}",
                    event.kind().code(),
                    event.diagnostic.code,
                    event.diagnostic.remediation
                );
            }
            EngineEvent::Malformed(event) => {
                println!(
                    "event={} code={} raw_len={} raw_truncated={} remediation={}",
                    event.kind().code(),
                    event.diagnostic.code,
                    event.raw.len(),
                    event.raw_truncated,
                    event.diagnostic.remediation
                );
            }
        }
    }

    let counters = engine.counters();
    println!(
        "summary accepted={} rejected={} malformed={}",
        counters.accepted, counters.rejected, counters.malformed
    );

    Ok(())
}

Trait Implementations

impl Clone for EngineEventKind

fn clone(&self) -> EngineEventKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EngineEventKind

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

Formats the value using the given formatter.

impl PartialEq for EngineEventKind

fn eq(&self, other: &EngineEventKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for EngineEventKind

impl Eq for EngineEventKind

impl StructuralPartialEq for EngineEventKind