Struct GuardrailsFilter 

pub struct GuardrailsFilter { /* private fields */ }

Rejects requests matching string, regex, or PII rules against headers and/or body content.

YAML configuration

filter: guardrails
action: flag            # or "reject" (default)
rules:
  # Detect PII in a header
  - target: header
    name: "Authorization"
    contains: [ssn, credit_card, email]
  # Detect PII in body
  - target: body
    contains: [ssn, credit_card, phone, email]
  # Block SQL injection in body
  - target: body
    contains: "DROP TABLE"
  # Block requests from bad bots
  - target: header
    name: "User-Agent"
    pattern: "bad-bot.*"
  # Require body to look like JSON (reject if NOT matching)
  - target: body
    pattern: "^\\{.*\\}$"
    negate: true

Example

use praxis_filter::GuardrailsFilter;

let yaml: serde_yaml::Value = serde_yaml::from_str(
    r#"
rules:
  - target: header
    name: User-Agent
    contains: bad-bot
"#,
)
.unwrap();
let filter = GuardrailsFilter::from_config(&yaml).unwrap();
assert_eq!(filter.name(), "guardrails");

Implementations

impl GuardrailsFilter

pub fn from_config(config: &Value) -> Result<Box<dyn HttpFilter>, FilterError>

Create a guardrails filter from parsed YAML config.

Compiles all regex patterns at init time. Returns an error if a rule has an invalid regex, missing fields, or unknown target.

use praxis_filter::GuardrailsFilter;

let yaml: serde_yaml::Value = serde_yaml::from_str(
    r#"
rules:
  - target: body
    pattern: "SELECT.*FROM"
"#,
)
.unwrap();
let filter = GuardrailsFilter::from_config(&yaml).unwrap();
assert_eq!(filter.name(), "guardrails");

Errors

Returns FilterError if rules are empty or contain invalid regex.

Trait Implementations

impl HttpFilter for GuardrailsFilter

fn name(&self) -> &'static str

Unique name identifying this filter type (e.g. "router", "rate_limit").

fn request_body_access(&self) -> BodyAccess

Declares what access this filter needs to request bodies.

fn request_body_mode(&self) -> BodyMode

Declares the delivery mode for request body chunks.

fn on_request<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 mut HttpFilterContext<'life2>, ) -> Pin<Box<dyn Future<Output = Result<FilterAction, FilterError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Called for each incoming request, in pipeline order.

fn on_request_body<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 mut HttpFilterContext<'life2>, body: &'life3 mut Option<Bytes>, end_of_stream: bool, ) -> Pin<Box<dyn Future<Output = Result<FilterAction, FilterError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Called for each chunk of request body data, in pipeline order.

fn on_response<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 mut HttpFilterContext<'life2>, ) -> Pin<Box<dyn Future<Output = Result<FilterAction, FilterError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Called for each response, in reverse pipeline order.

fn response_body_access(&self) -> BodyAccess

Declares what access this filter needs to response bodies.

fn response_body_mode(&self) -> BodyMode

Declares the delivery mode for response body chunks.

fn needs_request_context(&self) -> bool

Whether this filter needs the original request context during body phases.

fn apply_insecure_options(&self, _options: &InsecureOptions)

Apply global InsecureOptions to this filter.

fn compression_config(&self) -> Option<&CompressionConfig>

Returns the compression configuration if this filter enables response compression.

fn on_response_body( &self, ctx: &mut HttpFilterContext<'_>, body: &mut Option<Bytes>, end_of_stream: bool, ) -> Result<FilterAction, FilterError>

Called for each chunk of response body data, in reverse pipeline order.