Struct ErrorEvent 

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

Represents an error event with scope, error details, tags, and context.

JSON Serialization Format

ErrorEvent serializes to JSON with the following structure:

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

The scope field uses a tagged union format with a discriminator field named "scope". Supported scope variants are:

• "node": Requires kind (string) and step (u64)
• "scheduler": Requires step (u64)
• "runner": Requires session (string) and step (u64)
• "app": No additional fields

See docs/schemas/error_event.json for the complete JSON Schema specification.

Examples

Using constructors and builders:

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}));

// Serialize to JSON
let json_str = serde_json::to_string(&event).unwrap();

Fields

when: DateTime<Utc>

Timestamp at which the error occurred.

scope: ErrorScope

Scope identifying where in the workflow the error originated.

error: WeaveError

Structured error payload describing the failure.

tags: Vec<String>

Arbitrary string tags for filtering and categorization.

context: Value

Optional additional context data as a JSON value.

Implementations

impl ErrorEvent

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

Create a node-scoped error event.

Example

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

let err = ErrorEvent::node("my_node", 1, WeaveError::msg("Something failed"));

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

Create a scheduler-scoped error event.

Example

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

let err = ErrorEvent::scheduler(5, WeaveError::msg("Scheduling conflict"));

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

Create a runner-scoped error event.

Example

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

let err = ErrorEvent::runner("session_123", 10, WeaveError::msg("Runtime error"));

pub fn app(error: WeaveError) -> Self

Create an app-scoped error event.

Example

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

let err = ErrorEvent::app(WeaveError::msg("Application startup failed"));

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

Add multiple tags to this error event.

Example

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

let err = ErrorEvent::node("my_node", 1, WeaveError::msg("Invalid input"))
    .with_tags(vec!["validation".to_string(), "critical".to_string()]);

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

Add a single tag to this error event.

Example

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

let err = ErrorEvent::node("my_node", 1, WeaveError::msg("Invalid input"))
    .with_tag("validation");

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

Add context metadata to this error event.

Example

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

let err = ErrorEvent::node("my_node", 1, WeaveError::msg("Invalid input"))
    .with_context(json!({"field": "username", "value": ""}));

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