Struct Policy 

pub struct Policy {
    pub name: String,
    pub rate_limit: Option<RateLimit>,
    pub rate_limits: Vec<RateLimitRule>,
    pub timeouts: Option<Timeouts>,
    pub dry_run: bool,
    pub token_budget: Option<TokenBudget>,
    pub anomaly: Option<AnomalyPolicy>,
    pub adaptive: Option<AdaptiveRateLimit>,
}

Named reusable rule bundle (rate limit, timeouts, …); attachable at several scopes. Plugin-backed phases arrive with the M3 plugin system.

Fields

name: String

rate_limit: Option<RateLimit>

rate_limits: Vec<RateLimitRule>

Stacked GCRA rate-limit rules (DW-017). Each rule stacks one or more windows (e.g. s AND hour); a request is admitted only if EVERY window of EVERY applicable rule allows it. The legacy single-window rate_limit field above still applies when set (see its mapping in the rate-limiter module docs); use rate_limits for new configs.

timeouts: Option<Timeouts>

dry_run: bool

Monitor mode (DW-041) for this bundle’s rate-limit rules: they still EVALUATE (their GCRA buckets advance exactly as if enforcing, so denial rates reflect what enforcement would do), but a request they would deny is LOGGED and counted (dwara_policy_dry_run_total{phase="rate_limit"} + a dwara::policy warn event) and PROCEEDS — no 429, and none of the rule’s X-RateLimit-* headers on the response. LIVE policies attached to the same request still enforce: the flag mutes only this bundle’s own denials. The flag sits on the named bundle (not on each policies: [...] attachment list entry) because rate limits attach BY NAME at the five precedence levels — marking the bundle dries every attachment of it uniformly. Timeouts carry no rejection and are unaffected.

token_budget: Option<TokenBudget>

AI token budget (DW-078): caps provider-reported tokens per minute and/or priced cost per UTC day for the budget holder. Distinct from every rule above: those count REQUESTS, this counts TOKENS. Resolution follows the frozen precedence chain (consumer > route > service > listener > global) with the MOST SPECIFIC level’s budget governing (a limit-of-totals, not an AND-composed rule). scope: consumer (default) keys the budget to each attaching consumer; scope: policy makes one SHARED (team) budget keyed by the policy name. Consumers with no binding budget are unlimited.

anomaly: Option<AnomalyPolicy>

Anomaly scoring (DW-090): lightweight statistical detection of abusive request patterns (header entropy, request-shape outliers). When enabled, every matched request is scored against the configured signals; a score at or above threshold is blocked (403 anomaly_blocked) unless dry_run is set (scored and logged, request proceeds). Resolution follows the frozen precedence chain (consumer > route > service > listener > global); every level with an attachment applies and the applicable rules AND together. Absent (the default): no anomaly scoring.

adaptive: Option<AdaptiveRateLimit>

Adaptive + origin-driven rate-limit tuning (DW-089): an EWMA of upstream error rate and latency dynamically scales this policy’s rate-limit quotas, and upstream-originated signals (Retry-After) trigger an immediate backoff for the advertised window. The adaptive factor is bounded [min_factor, max_factor] (never 0, never unbounded); tightening under stress is faster than relaxing when healthy (asymmetric). Absent (the default): no adaptive tuning, the policy’s quotas apply as configured.

Trait Implementations

impl Clone for Policy

fn clone(&self) -> Policy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Policy

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Policy

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Policy

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Policy

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

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 Policy