Enum Action 

pub enum Action {
    Log {
        level: LogLevel,
        message: String,
    },
    Emit {
        event_type: String,
        payload: Value,
    },
    SetContext {
        key: String,
        value: Value,
    },
    IncrementCounter {
        name: String,
        amount: i64,
    },
    Alert {
        severity: AlertSeverity,
        title: String,
        message: String,
    },
    Throttle {
        key: String,
        max_per_second: f64,
    },
    Reject {
        reason: String,
        code: u32,
    },
    Redirect {
        target_node: Option<NodeId>,
        target_tags: Vec<String>,
    },
    Scale {
        resource: String,
        direction: ScaleDirection,
        amount: u32,
    },
    Custom {
        action_type: String,
        params: HashMap<String, Value>,
    },
    Chain(Vec<Action>),
    Noop,
}

Action types that can be executed when rules match

Variants

Log

Log a message

Fields

level: LogLevel

Severity level at which to log the message

message: String

Text content of the log entry

Emit

Emit an event

Fields

event_type: String

Identifier for the type of event being emitted

payload: Value

Arbitrary JSON data attached to the event

SetContext

Set a context value

Fields

key: String

Context key to set

value: Value

JSON value to store under the key

IncrementCounter

Increment a counter

Fields

name: String

Name of the counter to increment

amount: i64

Amount by which to increment the counter

Alert

Send alert/notification

Fields

severity: AlertSeverity

Severity level of the alert

title: String

Short human-readable title for the alert

message: String

Detailed description of the alert

Throttle

Throttle/rate limit

Fields

key: String

Identifier key used to track the rate limit bucket

max_per_second: f64

Maximum number of requests allowed per second

Reject

Reject request

Fields

reason: String

Human-readable explanation for the rejection

code: u32

Numeric error code returned with the rejection

Redirect

Redirect to another node

Fields

target_node: Option<NodeId>

Specific node to redirect to, if known

target_tags: Vec<String>

Tags used to select a target node when no specific node is given

Scale

Scale resources

Fields

resource: String

Name of the resource to scale

direction: ScaleDirection

Whether to scale up or down

amount: u32

Magnitude of the scaling adjustment

Custom

Execute custom action

Fields

action_type: String

Identifier for the custom action type

params: HashMap<String, Value>

Key-value parameters passed to the custom action handler

Chain(Vec<Action>)

Chain multiple actions

Noop

No action (useful for monitoring rules)

Implementations

impl Action

pub fn log(level: LogLevel, message: impl Into<String>) -> Self

Create a log action

pub fn emit(event_type: impl Into<String>, payload: Value) -> Self

Create an emit action

pub fn set_context(key: impl Into<String>, value: Value) -> Self

Create a set context action

pub fn alert( severity: AlertSeverity, title: impl Into<String>, message: impl Into<String>, ) -> Self

Create an alert action

pub fn reject(reason: impl Into<String>, code: u32) -> Self

Create a reject action

pub fn redirect_to_tags(tags: Vec<String>) -> Self

Create a redirect action

pub fn chain(actions: Vec<Action>) -> Self

Create a chain of actions

pub fn action_count(&self) -> usize

Count total actions (including nested)

Trait Implementations

impl Clone for Action

fn clone(&self) -> Action

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Action

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

Formats the value using the given formatter.

impl PartialEq for Action

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