Struct TaskEventsRuleFilter 

pub struct TaskEventsRuleFilter {
    pub target: Option<String>,
    pub min_level: Option<Level>,
    pub field_filters: Vec<FieldPredicate>,
}

Parsed predicate from a task-events:<expr> rule check field.

Semantics: after the verify TaskRun completes, call task.events with these params. Any match means the rule is violated.

Grammar

expr       := [target] (WS field-pred)*
target     := word-without-'='          e.g. "cargo::rustc"
field-pred := key '=' scalar-value
key        := "level" | "min_level"     special: parsed as Level
            | dotted-path               e.g. "error.code", "file.path"
scalar     := bare-number | "true" | "false" | bare-string

Examples

"task-events:cargo::rustc error.code=E0308"
  → target: cargo::rustc, field: error.code == "E0308"

"task-events:clippy::warning level=error"
  → target: clippy::warning, min_level: Error

"task-events:cargo::rustc"
  → target: cargo::rustc, any level, any field

Fields

target: Option<String>

Event target prefix, e.g. "cargo::rustc" or "clippy::warning".

When set, the evaluator passes this as the target param to task.events, which does a prefix match. None means any target.

min_level: Option<Level>

Minimum severity to include. None defaults to warn at the call site so rule checks don’t fire on debug/trace noise.

field_filters: Vec<FieldPredicate>

Field equality predicates. The evaluator ANDs them: all must match.

Implementations

impl TaskEventsRuleFilter

pub fn matches_fields(&self, fields: &Value) -> bool

Returns true when all field predicates match the given event fields JSON object. An empty field_filters list always returns true.

The gnome verify pass calls this after fetching events via task.events (which already pre-filters by target and min_level). The combined protocol is:

1. Call task.events(run_id, target=filter.target, min_level=...).
2. For each returned event, call filter.matches_fields(&event.fields).
3. If any event passes → rule violated; if none pass → satisfied.

This client-side pass is necessary because task.events only supports a single jsonpath server-side filter; AND-ing multiple field predicates is done here.

pub fn parse(expr: &str) -> Result<Self, ParseError>

Parse the part of a rule check string after stripping "task-events:".

Returns Err if any token fails to parse (e.g. malformed key=value).

pub fn parse_check_field(check: &str) -> Result<Self, ParseError>

Parse a full task-events:<expr> string (including the prefix).

Trait Implementations

impl Clone for TaskEventsRuleFilter

fn clone(&self) -> TaskEventsRuleFilter

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TaskEventsRuleFilter

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TaskEventsRuleFilter

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for TaskEventsRuleFilter

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for TaskEventsRuleFilter

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for TaskEventsRuleFilter