Compare commits
2 Commits
main
...
fix-dynami
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
c7292effd6 | ||
|
|
078ef3932f |
File diff suppressed because it is too large
Load Diff
@ -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)
|
||||
|
||||
@ -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(())
|
||||
|
||||
@ -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)));
|
||||
|
||||
@ -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)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -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"
|
||||
);
|
||||
}
|
||||
|
||||
@ -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,
|
||||
})
|
||||
},
|
||||
)
|
||||
|
||||
@ -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 {
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user