Compare commits

...

2 Commits

Author SHA1 Message Date
Kasun Talwatta
c7292effd6
fixed proto gen issue
Signed-off-by: Kasun Talwatta <kasun.talwatta@gmail.com>
2026-03-27 18:41:59 +13:00
Kasun Talwatta
078ef3932f
adding support to handle limit field to override with dynamic metadata information value. also fixed ext-proc metadata as previously it was wrapped in Arc and wasn't able to process with CEL. fixed the tests to reflect.
Signed-off-by: Kasun Talwatta <kasun.talwatta@gmail.com>
2026-03-27 18:23:46 +13:00
8 changed files with 996 additions and 311 deletions

File diff suppressed because it is too large Load Diff

View File

@ -743,6 +743,17 @@ func (this *TrafficPolicySpec_RemoteRateLimit_Entry) UnmarshalJSON(b []byte) err
return ResourceUnmarshaler.Unmarshal(bytes.NewReader(b), this)
}
// MarshalJSON is a custom marshaler for TrafficPolicySpec_RemoteRateLimit_LimitOverride
func (this *TrafficPolicySpec_RemoteRateLimit_LimitOverride) MarshalJSON() ([]byte, error) {
str, err := ResourceMarshaler.MarshalToString(this)
return []byte(str), err
}
// UnmarshalJSON is a custom unmarshaler for TrafficPolicySpec_RemoteRateLimit_LimitOverride
func (this *TrafficPolicySpec_RemoteRateLimit_LimitOverride) UnmarshalJSON(b []byte) error {
return ResourceUnmarshaler.Unmarshal(bytes.NewReader(b), this)
}
// MarshalJSON is a custom marshaler for TrafficPolicySpec_LocalRateLimit
func (this *TrafficPolicySpec_LocalRateLimit) MarshalJSON() ([]byte, error) {
str, err := ResourceMarshaler.MarshalToString(this)

View File

@ -57,7 +57,7 @@ pub enum Error {
#[apply(schema!)]
#[derive(Default, ::cel::DynamicType)]
pub struct ExtProcDynamicMetadata(serde_json::Map<String, JsonValue>);
pub struct ExtProcDynamicMetadata(pub(crate) serde_json::Map<String, JsonValue>);
#[allow(warnings)]
#[allow(clippy::derive_partial_eq_without_eq)]
@ -724,8 +724,7 @@ impl ExtProcInstance {
// Get or create metadata container, merging with existing metadata
let mut dynamic_metadata = req
.extensions_mut()
.remove::<Arc<ExtProcDynamicMetadata>>()
.map(|arc| (*arc).clone())
.remove::<ExtProcDynamicMetadata>()
.unwrap_or_default();
// Merge new fields into existing metadata
@ -737,7 +736,7 @@ impl ExtProcInstance {
}
if !dynamic_metadata.0.is_empty() {
req.extensions_mut().insert(Arc::new(dynamic_metadata));
req.extensions_mut().insert(dynamic_metadata);
}
Ok(())

View File

@ -1271,7 +1271,6 @@ fn test_dynamic_metadata_extraction() {
mod extract_dynamic_metadata_tests {
use std::collections::HashMap;
use std::sync::Arc;
use prost_wkt_types::value::Kind;
use prost_wkt_types::{Struct, Value};
@ -1299,7 +1298,7 @@ mod extract_dynamic_metadata_tests {
let extracted = req
.extensions()
.get::<Arc<ExtProcDynamicMetadata>>()
.get::<ExtProcDynamicMetadata>()
.expect("metadata should be in extensions");
assert_eq!(
extracted.0.get("user_id"),
@ -1319,7 +1318,7 @@ mod extract_dynamic_metadata_tests {
.into_iter()
.collect(),
);
req.extensions_mut().insert(Arc::new(existing));
req.extensions_mut().insert(existing);
let metadata = Struct {
fields: [(
@ -1332,10 +1331,7 @@ mod extract_dynamic_metadata_tests {
};
ExtProcInstance::extract_dynamic_metadata(Some(&mut req), &metadata).unwrap();
let extracted = req
.extensions()
.get::<Arc<ExtProcDynamicMetadata>>()
.unwrap();
let extracted = req.extensions().get::<ExtProcDynamicMetadata>().unwrap();
assert_eq!(extracted.0.len(), 2);
assert_eq!(
extracted.0.get("existing"),
@ -1359,7 +1355,7 @@ mod extract_dynamic_metadata_tests {
.into_iter()
.collect(),
);
req.extensions_mut().insert(Arc::new(existing));
req.extensions_mut().insert(existing);
let metadata = Struct {
fields: [(
@ -1372,10 +1368,7 @@ mod extract_dynamic_metadata_tests {
};
ExtProcInstance::extract_dynamic_metadata(Some(&mut req), &metadata).unwrap();
let extracted = req
.extensions()
.get::<Arc<ExtProcDynamicMetadata>>()
.unwrap();
let extracted = req.extensions().get::<ExtProcDynamicMetadata>().unwrap();
assert_eq!(extracted.0.len(), 1);
assert_eq!(
extracted.0.get("key"),
@ -1410,12 +1403,7 @@ mod extract_dynamic_metadata_tests {
ExtProcInstance::extract_dynamic_metadata(Some(&mut req), &metadata).unwrap();
assert!(
req
.extensions()
.get::<Arc<ExtProcDynamicMetadata>>()
.is_none()
);
assert!(req.extensions().get::<ExtProcDynamicMetadata>().is_none());
}
#[test]
@ -1451,10 +1439,7 @@ mod extract_dynamic_metadata_tests {
ExtProcInstance::extract_dynamic_metadata(Some(&mut req), &metadata).unwrap();
let extracted = req
.extensions()
.get::<Arc<ExtProcDynamicMetadata>>()
.unwrap();
let extracted = req.extensions().get::<ExtProcDynamicMetadata>().unwrap();
assert_eq!(extracted.0.len(), 3);
assert_eq!(
@ -1497,10 +1482,7 @@ mod extract_dynamic_metadata_tests {
};
ExtProcInstance::extract_dynamic_metadata(Some(&mut req), &metadata2).unwrap();
let extracted = req
.extensions()
.get::<Arc<ExtProcDynamicMetadata>>()
.unwrap();
let extracted = req.extensions().get::<ExtProcDynamicMetadata>().unwrap();
assert_eq!(extracted.0.len(), 2);
assert_eq!(extracted.0.get("key1"), Some(&serde_json::json!("value1")));
assert_eq!(extracted.0.get("key2"), Some(&serde_json::json!(true)));

View File

@ -20,6 +20,7 @@ mod tests;
#[allow(clippy::derive_partial_eq_without_eq)]
pub mod proto {
pub use protos::envoy::service::common::v3::HeaderValue;
pub use protos::envoy::service::ratelimit::v3::rate_limit_descriptor::RateLimitOverride;
pub use protos::envoy::service::ratelimit::v3::*;
}
@ -73,6 +74,16 @@ pub struct Descriptor(pub String, pub cel::Expression);
#[apply(schema!)]
pub struct DescriptorSet(pub Vec<DescriptorEntry>);
/// Dynamic rate limit override configuration.
/// This maps to
/// When set, evaluates the CEL expression against the request context
/// to extract rate limit override values from ext-proc metadata.
#[derive(Debug, Clone)]
pub struct LimitOverride {
/// Parsed CEL expression (e.g., "extproc.rate_limit")
pub expression: Arc<cel::Expression>,
}
#[apply(schema!)]
pub struct DescriptorEntry {
#[serde(deserialize_with = "de_descriptors")]
@ -81,6 +92,9 @@ pub struct DescriptorEntry {
#[serde(default)]
#[serde(rename = "type")]
pub limit_type: RateLimitType,
/// Optional limit override from metadata (set via XDS, not local config)
#[serde(skip)]
pub limit_override: Option<LimitOverride>,
}
#[derive(serde::Deserialize)]
@ -181,9 +195,16 @@ impl RemoteRateLimit {
limit_type,
kv_pairs.join(", ")
);
// evaluate limit override if configured
let limit = desc_entry
.limit_override
.as_ref()
.and_then(|lo| Self::eval_limit_override(req, lo));
descriptors.push(RateLimitDescriptor {
entries: rl_entries,
limit: None,
limit,
hits_addend: cost,
});
} else {
@ -405,12 +426,94 @@ impl RemoteRateLimit {
Some(rl_entries)
}
/// Evaluate a limit override expression against the request context.
/// returns `Some(RateLimitOverride)` if the expression evaluates successfully
/// and contains valid `requests_per_unit` and `unit` fields.
/// returns `None` if evaluation fails, metadata is missing, or fields are invalid.
fn eval_limit_override(
req: &Request,
limit_override: &LimitOverride,
) -> Option<proto::RateLimitOverride> {
let exec = cel::Executor::new_request(req);
match exec.eval(&limit_override.expression) {
Ok(value) => {
// the CEL result should be a map with requests_per_unit and unit
let map = match value.json() {
Ok(serde_json::Value::Object(m)) => m,
Ok(other) => {
trace!("ratelimit limit_override: expected object, got {:?}", other);
return None;
},
Err(e) => {
trace!("ratelimit limit_override: failed to convert to JSON: {}", e);
return None;
},
};
// extract requests_per_unit
let requests_per_unit = match map.get("requests_per_unit") {
Some(serde_json::Value::Number(n)) => n.as_u64().and_then(|v| v.try_into().ok()),
_ => {
trace!("ratelimit limit_override: missing or invalid requests_per_unit field");
return None;
},
}?;
// extract unit and convert to RateLimitUnit enum
let unit = match map.get("unit") {
Some(serde_json::Value::String(s)) => Self::parse_rate_limit_unit(s),
Some(serde_json::Value::Number(n)) => {
// Allow numeric unit values too
n.as_i64().and_then(|v| v.try_into().ok())
},
_ => {
trace!("ratelimit limit_override: missing or invalid unit field");
return None;
},
}?;
trace!(
"ratelimit limit_override: evaluated to requests_per_unit={}, unit={}",
requests_per_unit, unit
);
Some(proto::RateLimitOverride {
requests_per_unit,
unit,
})
},
Err(e) => {
trace!(
"ratelimit limit_override: failed to evaluate expression {:?}: {}",
limit_override.expression, e
);
None
},
}
}
/// parse a unit string to its corresponding RateLimitUnit enum value.
fn parse_rate_limit_unit(s: &str) -> Option<i32> {
match s.to_uppercase().as_str() {
"SECOND" => Some(proto::RateLimitUnit::Second as i32),
"MINUTE" => Some(proto::RateLimitUnit::Minute as i32),
"HOUR" => Some(proto::RateLimitUnit::Hour as i32),
"DAY" => Some(proto::RateLimitUnit::Day as i32),
"MONTH" => Some(proto::RateLimitUnit::Month as i32),
"YEAR" => Some(proto::RateLimitUnit::Year as i32),
_ => {
trace!("ratelimit limit_override: unknown unit string: {}", s);
None
},
}
}
pub fn expressions(&self) -> impl Iterator<Item = &Expression> {
self
.descriptors
.0
.iter()
.flat_map(|v| v.entries.iter().map(|v| &v.1))
self.descriptors.0.iter().flat_map(|v| {
let entry_exprs = v.entries.iter().map(|e| &e.1);
let override_expr = v.limit_override.iter().map(|lo| lo.expression.as_ref());
entry_exprs.chain(override_expr)
})
}
}

View File

@ -30,6 +30,31 @@ fn make_descriptor_entry(entries: Vec<(&str, &str)>, limit_type: RateLimitType)
DescriptorEntry {
entries: Arc::new(descriptors),
limit_type,
limit_override: None,
}
}
/// Helper: build a `DescriptorEntry` with a limit override expression.
fn make_descriptor_entry_with_limit_override(
entries: Vec<(&str, &str)>,
limit_type: RateLimitType,
expr: &str,
) -> DescriptorEntry {
let descriptors: Vec<Descriptor> = entries
.into_iter()
.map(|(key, expr)| {
Descriptor(
key.to_string(),
cel::Expression::new_strict(expr).expect("valid CEL expression"),
)
})
.collect();
DescriptorEntry {
entries: Arc::new(descriptors),
limit_type,
limit_override: Some(LimitOverride {
expression: Arc::new(cel::Expression::new_strict(expr).expect("valid CEL expression")),
}),
}
}
@ -748,3 +773,483 @@ fn build_request_jwt_sub_descriptor_evaluates_with_materialization() {
assert_eq!(request.descriptors[0].entries[0].key, "user");
assert_eq!(request.descriptors[0].entries[0].value, "rate-limit-user");
}
// --- Limit Override tests ---
use crate::http::ext_proc::ExtProcDynamicMetadata;
/// When a descriptor has a limit_override and the metadata contains valid
/// rate limit values, `build_request` should include the RateLimitOverride.
#[test]
fn build_request_limit_override_from_extproc_metadata() {
let entry = make_descriptor_entry_with_limit_override(
vec![("user", r#""test-user""#)],
RateLimitType::Requests,
"extproc.rate_limit",
);
let rl = make_rate_limit(vec![entry]);
let mut req = ::http::Request::builder()
.method(::http::Method::POST)
.uri("http://example.com/mcp")
.body(crate::http::Body::empty())
.unwrap();
// Insert ext-proc metadata with rate limit override values
let mut metadata = ExtProcDynamicMetadata::default();
metadata.0.insert(
"rate_limit".to_string(),
serde_json::json!({
"requests_per_unit": 50,
"unit": "SECOND"
}),
);
req.extensions_mut().insert(metadata);
let result = rl.build_request(&req, RateLimitType::Requests, None);
assert!(
result.is_some(),
"expected Some when metadata contains valid rate limit"
);
let request = result.unwrap();
assert_eq!(request.descriptors.len(), 1);
let limit = request.descriptors[0].limit.as_ref();
assert!(limit.is_some(), "expected limit override to be set");
let limit = limit.unwrap();
assert_eq!(limit.requests_per_unit, 50);
assert_eq!(limit.unit, proto::RateLimitUnit::Second as i32);
}
/// When metadata does not contain the expected path, no override is sent.
#[test]
fn build_request_limit_override_missing_metadata() {
let entry = make_descriptor_entry_with_limit_override(
vec![("user", r#""test-user""#)],
RateLimitType::Requests,
"extproc.rate_limit",
);
let rl = make_rate_limit(vec![entry]);
let req = ::http::Request::builder()
.method(::http::Method::POST)
.uri("http://example.com/mcp")
.body(crate::http::Body::empty())
.unwrap();
// No ext-proc metadata inserted
let result = rl.build_request(&req, RateLimitType::Requests, None);
assert!(
result.is_some(),
"request should still succeed without metadata"
);
let request = result.unwrap();
assert_eq!(request.descriptors.len(), 1);
// No limit override should be set
assert!(
request.descriptors[0].limit.is_none(),
"expected no limit override when metadata is missing"
);
}
/// When limit_override uses a nested path like `extproc.tenant.limit`, it should
/// correctly traverse the metadata structure.
#[test]
fn build_request_limit_override_nested_path() {
let entry = make_descriptor_entry_with_limit_override(
vec![("user", r#""test-user""#)],
RateLimitType::Requests,
"extproc.tenant.limit",
);
let rl = make_rate_limit(vec![entry]);
let mut req = ::http::Request::builder()
.method(::http::Method::POST)
.uri("http://example.com/mcp")
.body(crate::http::Body::empty())
.unwrap();
// Insert nested ext-proc metadata
let mut metadata = ExtProcDynamicMetadata::default();
metadata.0.insert(
"tenant".to_string(),
serde_json::json!({
"limit": {
"requests_per_unit": 100,
"unit": "MINUTE"
}
}),
);
req.extensions_mut().insert(metadata);
let result = rl.build_request(&req, RateLimitType::Requests, None);
assert!(result.is_some());
let request = result.unwrap();
let limit = request.descriptors[0].limit.as_ref();
assert!(limit.is_some(), "expected nested limit override to be set");
let limit = limit.unwrap();
assert_eq!(limit.requests_per_unit, 100);
assert_eq!(limit.unit, proto::RateLimitUnit::Minute as i32);
}
/// Test all supported unit string conversions.
#[test]
fn build_request_limit_override_unit_mapping() {
for (unit_str, expected_unit) in [
("SECOND", proto::RateLimitUnit::Second),
("MINUTE", proto::RateLimitUnit::Minute),
("HOUR", proto::RateLimitUnit::Hour),
("DAY", proto::RateLimitUnit::Day),
("MONTH", proto::RateLimitUnit::Month),
("YEAR", proto::RateLimitUnit::Year),
] {
let entry = make_descriptor_entry_with_limit_override(
vec![("user", r#""test-user""#)],
RateLimitType::Requests,
"extproc.rate_limit",
);
let rl = make_rate_limit(vec![entry]);
let mut req = ::http::Request::builder()
.method(::http::Method::POST)
.uri("http://example.com/mcp")
.body(crate::http::Body::empty())
.unwrap();
let mut metadata = ExtProcDynamicMetadata::default();
metadata.0.insert(
"rate_limit".to_string(),
serde_json::json!({
"requests_per_unit": 10,
"unit": unit_str
}),
);
req.extensions_mut().insert(metadata);
let result = rl.build_request(&req, RateLimitType::Requests, None);
assert!(result.is_some(), "expected Some for unit {}", unit_str);
let request = result.unwrap();
let limit = request.descriptors[0].limit.as_ref().unwrap();
assert_eq!(
limit.unit, expected_unit as i32,
"unit {} should map to {:?}",
unit_str, expected_unit
);
}
}
/// Backward compatibility: when no limit_override is configured, no override is sent.
#[test]
fn build_request_no_limit_override_configured() {
// Use the regular helper without limit_override
let entry = make_descriptor_entry(vec![("user", r#""test-user""#)], RateLimitType::Requests);
let rl = make_rate_limit(vec![entry]);
let mut req = ::http::Request::builder()
.method(::http::Method::POST)
.uri("http://example.com/mcp")
.body(crate::http::Body::empty())
.unwrap();
// Even if metadata exists, no override should be sent without config
let mut metadata = ExtProcDynamicMetadata::default();
metadata.0.insert(
"rate_limit".to_string(),
serde_json::json!({
"requests_per_unit": 50,
"unit": "SECOND"
}),
);
req.extensions_mut().insert(metadata);
let result = rl.build_request(&req, RateLimitType::Requests, None);
assert!(result.is_some());
let request = result.unwrap();
assert!(
request.descriptors[0].limit.is_none(),
"no limit_override config means no override sent"
);
}
/// When the unit value is numeric (enum value), it should be accepted.
#[test]
fn build_request_limit_override_numeric_unit() {
let entry = make_descriptor_entry_with_limit_override(
vec![("user", r#""test-user""#)],
RateLimitType::Requests,
"extproc.rate_limit",
);
let rl = make_rate_limit(vec![entry]);
let mut req = ::http::Request::builder()
.method(::http::Method::POST)
.uri("http://example.com/mcp")
.body(crate::http::Body::empty())
.unwrap();
let mut metadata = ExtProcDynamicMetadata::default();
metadata.0.insert(
"rate_limit".to_string(),
serde_json::json!({
"requests_per_unit": 25,
"unit": 2 // MINUTE = 2
}),
);
req.extensions_mut().insert(metadata);
let result = rl.build_request(&req, RateLimitType::Requests, None);
assert!(result.is_some());
let request = result.unwrap();
let limit = request.descriptors[0].limit.as_ref().unwrap();
assert_eq!(limit.requests_per_unit, 25);
assert_eq!(limit.unit, proto::RateLimitUnit::Minute as i32);
}
/// When requests_per_unit is missing, no override is sent.
#[test]
fn build_request_limit_override_missing_requests_per_unit() {
let entry = make_descriptor_entry_with_limit_override(
vec![("user", r#""test-user""#)],
RateLimitType::Requests,
"extproc.rate_limit",
);
let rl = make_rate_limit(vec![entry]);
let mut req = ::http::Request::builder()
.method(::http::Method::POST)
.uri("http://example.com/mcp")
.body(crate::http::Body::empty())
.unwrap();
let mut metadata = ExtProcDynamicMetadata::default();
metadata.0.insert(
"rate_limit".to_string(),
serde_json::json!({
"unit": "SECOND"
// Missing requests_per_unit
}),
);
req.extensions_mut().insert(metadata);
let result = rl.build_request(&req, RateLimitType::Requests, None);
assert!(result.is_some());
assert!(
result.unwrap().descriptors[0].limit.is_none(),
"missing requests_per_unit should result in no override"
);
}
/// When unit is missing, no override is sent.
#[test]
fn build_request_limit_override_missing_unit() {
let entry = make_descriptor_entry_with_limit_override(
vec![("user", r#""test-user""#)],
RateLimitType::Requests,
"extproc.rate_limit",
);
let rl = make_rate_limit(vec![entry]);
let mut req = ::http::Request::builder()
.method(::http::Method::POST)
.uri("http://example.com/mcp")
.body(crate::http::Body::empty())
.unwrap();
let mut metadata = ExtProcDynamicMetadata::default();
metadata.0.insert(
"rate_limit".to_string(),
serde_json::json!({
"requests_per_unit": 50
// Missing unit
}),
);
req.extensions_mut().insert(metadata);
let result = rl.build_request(&req, RateLimitType::Requests, None);
assert!(result.is_some());
assert!(
result.unwrap().descriptors[0].limit.is_none(),
"missing unit should result in no override"
);
}
/// Multiple rateLimits entries, each with its own limit_override pointing to different metadata paths.
/// This simulates the user config:
/// ```yaml
/// rateLimits:
/// - actions: [{descriptorKey: tier}]
/// limit:
/// dynamicMetadata: {metadataKey: {key: extproc, path: [{key: tier_limit}]}}
/// - actions: [{descriptorKey: api}]
/// limit:
/// dynamicMetadata: {metadataKey: {key: extproc, path: [{key: api_limit}]}}
/// ```
#[test]
fn build_request_multiple_rate_limits_with_different_overrides() {
// Create two descriptors, each with different limit_override expressions
let tier_entry = make_descriptor_entry_with_limit_override(
vec![("tier", r#""premium""#)],
RateLimitType::Requests,
"extproc.tier_limit",
);
let api_entry = make_descriptor_entry_with_limit_override(
vec![("api", r#""v1""#)],
RateLimitType::Requests,
"extproc.api_limit",
);
let rl = make_rate_limit(vec![tier_entry, api_entry]);
let mut req = ::http::Request::builder()
.method(::http::Method::POST)
.uri("http://example.com/mcp")
.body(crate::http::Body::empty())
.unwrap();
// Insert ext-proc metadata with both limit overrides
let mut metadata = ExtProcDynamicMetadata::default();
metadata.0.insert(
"tier_limit".to_string(),
serde_json::json!({
"requests_per_unit": 100,
"unit": "MINUTE"
}),
);
metadata.0.insert(
"api_limit".to_string(),
serde_json::json!({
"requests_per_unit": 1000,
"unit": "HOUR"
}),
);
req.extensions_mut().insert(metadata);
let result = rl.build_request(&req, RateLimitType::Requests, None);
assert!(result.is_some());
let request = result.unwrap();
// Should have 2 descriptors, each with its own limit override
assert_eq!(request.descriptors.len(), 2);
// First descriptor: tier_limit (100/MINUTE)
let tier_limit = request.descriptors[0].limit.as_ref();
assert!(
tier_limit.is_some(),
"tier descriptor should have limit override"
);
let tier_limit = tier_limit.unwrap();
assert_eq!(tier_limit.requests_per_unit, 100);
assert_eq!(tier_limit.unit, proto::RateLimitUnit::Minute as i32);
// Second descriptor: api_limit (1000/HOUR)
let api_limit = request.descriptors[1].limit.as_ref();
assert!(
api_limit.is_some(),
"api descriptor should have limit override"
);
let api_limit = api_limit.unwrap();
assert_eq!(api_limit.requests_per_unit, 1000);
assert_eq!(api_limit.unit, proto::RateLimitUnit::Hour as i32);
}
/// Multiple rateLimits where only some have limit overrides in metadata.
/// Descriptors without matching metadata should still be sent, just without override.
#[test]
fn build_request_multiple_rate_limits_partial_overrides() {
let tier_entry = make_descriptor_entry_with_limit_override(
vec![("tier", r#""standard""#)],
RateLimitType::Requests,
"extproc.tier_limit",
);
let api_entry = make_descriptor_entry_with_limit_override(
vec![("api", r#""v2""#)],
RateLimitType::Requests,
"extproc.api_limit", // This won't be in metadata
);
let rl = make_rate_limit(vec![tier_entry, api_entry]);
let mut req = ::http::Request::builder()
.method(::http::Method::POST)
.uri("http://example.com/mcp")
.body(crate::http::Body::empty())
.unwrap();
// Only insert tier_limit, not api_limit
let mut metadata = ExtProcDynamicMetadata::default();
metadata.0.insert(
"tier_limit".to_string(),
serde_json::json!({
"requests_per_unit": 50,
"unit": "SECOND"
}),
);
req.extensions_mut().insert(metadata);
let result = rl.build_request(&req, RateLimitType::Requests, None);
assert!(result.is_some());
let request = result.unwrap();
assert_eq!(request.descriptors.len(), 2);
// First descriptor has override
let tier_limit = request.descriptors[0].limit.as_ref();
assert!(tier_limit.is_some());
assert_eq!(tier_limit.unwrap().requests_per_unit, 50);
// Second descriptor has no override (metadata path not found)
assert!(
request.descriptors[1].limit.is_none(),
"api descriptor should have no override when metadata missing"
);
}
/// Mix of descriptors with and without limit_override config.
#[test]
fn build_request_multiple_rate_limits_mixed_config() {
// First descriptor has limit_override configured
let with_override = make_descriptor_entry_with_limit_override(
vec![("tier", r#""gold""#)],
RateLimitType::Requests,
"extproc.tier_limit",
);
// Second descriptor has NO limit_override configured (uses static RLS limits)
let without_override =
make_descriptor_entry(vec![("region", r#""us-east""#)], RateLimitType::Requests);
let rl = make_rate_limit(vec![with_override, without_override]);
let mut req = ::http::Request::builder()
.method(::http::Method::POST)
.uri("http://example.com/mcp")
.body(crate::http::Body::empty())
.unwrap();
let mut metadata = ExtProcDynamicMetadata::default();
metadata.0.insert(
"tier_limit".to_string(),
serde_json::json!({
"requests_per_unit": 200,
"unit": "MINUTE"
}),
);
req.extensions_mut().insert(metadata);
let result = rl.build_request(&req, RateLimitType::Requests, None);
assert!(result.is_some());
let request = result.unwrap();
assert_eq!(request.descriptors.len(), 2);
// First descriptor has override from metadata
let tier_limit = request.descriptors[0].limit.as_ref();
assert!(tier_limit.is_some());
assert_eq!(tier_limit.unwrap().requests_per_unit, 200);
// Second descriptor has no override (not configured)
assert!(
request.descriptors[1].limit.is_none(),
"descriptor without limit_override config should have no override"
);
}

View File

@ -1467,6 +1467,13 @@ impl TryFrom<&proto::agent::TrafficPolicySpec> for TrafficPolicy {
)
})
.collect();
// parse limit_override if present
let limit_override =
d.limit_override
.as_ref()
.map(|lo| http::remoteratelimit::LimitOverride {
expression: Arc::new(cel::Expression::new_permissive(&lo.expression)),
});
Ok(http::remoteratelimit::DescriptorEntry {
entries: Arc::new(entries),
limit_type: match tps::remote_rate_limit::Type::try_from(d.r#type)
@ -1479,6 +1486,7 @@ impl TryFrom<&proto::agent::TrafficPolicySpec> for TrafficPolicy {
http::localratelimit::RateLimitType::Tokens
},
},
limit_override,
})
},
)

View File

@ -621,11 +621,21 @@ message TrafficPolicySpec {
message Descriptor {
repeated Entry entries = 1;
Type type = 2;
optional LimitOverride limit_override = 3;
}
message Entry {
string key = 1;
string value = 2; // CEL expr
}
// Dynamic rate limit override evaluated from request context.
// when set, the proxy evaluates the CEL expression and sends
// a `RateLimitOverride` to RLS, allowing per-request limit customization.
message LimitOverride {
// CEL expression evaluated against the request context.
// must resolve to an object with "requests_per_unit" (int) and "unit" (string).
// e.g: "extproc.dynamic_rate_limit",
string expression = 1;
}
FailureMode failure_mode = 4;
}
message LocalRateLimit {