Struct TrafficSplitPlugin 

pub struct TrafficSplitPlugin {
    rules: Vec<Rule>,
    timeout: Duration,
    client: Arc<OutboundClient>,
}

Steers matching requests to a weighted set of upstream targets, or lets them fall through to the route’s normal upstream.

Fields

rules: Vec<Rule>

timeout: Duration

Whole-call deadline per request the plugin proxies itself.

client: Arc<OutboundClient>

Shared pooled HTTP client (from PluginResources).

Implementations

impl TrafficSplitPlugin

pub fn from_config( config: &HashMap<String, Value>, resources: &Arc<PluginResources>, ) -> Result<Self, String>

Builds the plugin from node config. All match expressions are compiled here at config load (fail-fast), weights must be non-negative integers, and every rule needs at least one positively-weighted slot.

Accepted keys:

• rules (array, required, non-empty): evaluated in order; the first rule whose match passes is used.
  • match (array, optional): an APISIX triple-array condition (rules AND-ed, see crate::vars). Omit to match every request.
  • weighted_upstreams (array, required, non-empty): the weighted slots one of which is chosen by weighted round-robin. Each slot:
    • upstream (object, optional): {targets: [{host, port}], ...}. When present, this slot proxies matching requests to one of the targets (round-robin within the set). When absent, the slot is the “default” — matching requests fall through to the route’s normal upstream.
    • weight (integer >= 0, default 1): selection weight.
• timeout_ms (integer, default 60000): whole-call deadline for requests the plugin proxies itself.

type: traffic-split
config:
  timeout_ms: 60000
  rules:
    - match:
        - ["arg_canary", "==", "1"]
      weighted_upstreams:
        # 90% fall through to the route's normal upstream
        - weight: 90
        # 10% proxied to the canary target set
        - upstream:
            targets:
              - host: canary-backend
                port: 8080
          weight: 10

fn select_rule(&self, ctx: &Context) -> Option<&Rule>

Returns the first rule whose match passes (or that has no match), or None when no rule matches (→ passthrough to the normal upstream).

async fn proxy_to_target( &self, ctx: &mut Context, target: &Target, ) -> Result<(), (&'static str, String)>

Proxies the request to target, writing the backend reply onto ctx.response. Mirrors the upstream node: overrides the Host header with the target and forwards method/headers/body unchanged. On success returns Ok(()); on transport/timeout failure returns the gateway error code + message so the caller can prepare a 502.

Trait Implementations

impl Plugin for TrafficSplitPlugin

fn plugin_type(&self) -> &str

Unique identifier for the plugin type (e.g., “proxy-rewrite”, “upstream”).

fn execute<'life0, 'life1, 'async_trait>( &'life0 self, ctx: Context, _named_inputs: &'life1 HashMap<String, Value>, ) -> Pin<Box<dyn Future<Output = Result<PluginOutput, PluginExecutionError>> + Send + 'async_trait>>

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

Executes the plugin logic against the request/response context.