Struct ErrorEvent 

pub struct ErrorEvent {
    pub when: DateTime<Utc>,
    pub scope: ErrorScope,
    pub error: WeaveError,
    pub tags: Vec<String>,
    pub context: Value,
}

A workflow error event capturing scope, error payload, tags, and context.

Serializes to JSON with a tagged-union scope field:

{
  "when": "2025-11-02T10:30:00Z",
  "scope": { "scope": "node", "kind": "Parser", "step": 1 },
  "error": {
    "message": "Failed to parse input",
    "cause": { "message": "Invalid JSON syntax", "details": {"line": 3} }
  },
  "tags": ["validation"],
  "context": {"file": "/tmp/input.json"}
}

Scope variants: "node" (kind, step), "scheduler" (step), "runner" (session, step), "app".

See docs/schemas/error_event.json for the full JSON Schema.

Example

use weavegraph::channels::errors::{ErrorEvent, WeaveError};
use serde_json::json;

let event = ErrorEvent::node("Parser", 1, WeaveError::msg("Parse error"))
    .with_tag("validation")
    .with_context(json!({"line": 42}));

let json_str = serde_json::to_string(&event).unwrap();

Fields

when: DateTime<Utc>

Timestamp at which the error occurred.

scope: ErrorScope

Where in the workflow the error originated.

error: WeaveError

Structured error payload.

tags: Vec<String>

String tags for filtering and categorization.

context: Value

Optional structured context metadata.

Implementations

impl ErrorEvent

pub fn node<S: Into<String>>(kind: S, step: u64, error: WeaveError) -> Self

Creates a node-scoped error event.

pub fn scheduler(step: u64, error: WeaveError) -> Self

Creates a scheduler-scoped error event.

pub fn runner<S: Into<String>>(session: S, step: u64, error: WeaveError) -> Self

Creates a runner-scoped error event.

pub fn app(error: WeaveError) -> Self

Creates an app-scoped error event.

pub fn with_tags(self, tags: Vec<String>) -> Self

Replaces the tag list.

pub fn with_tag<S: Into<String>>(self, tag: S) -> Self

Appends a single tag.

pub fn with_context(self, context: Value) -> Self

Attaches context metadata.

Trait Implementations

impl Clone for ErrorEvent

fn clone(&self) -> ErrorEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ErrorEvent

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

Formats the value using the given formatter.

impl Default for ErrorEvent

fn default() -> ErrorEvent

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ErrorEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ErrorEvent

fn eq(&self, other: &ErrorEvent) -> 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 Serialize for ErrorEvent

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ErrorEvent

impl StructuralPartialEq for ErrorEvent