Struct RateLimit 

pub struct RateLimit<Inner = PipeHandle, Extractor = KeyExtractor, Clk = TimeClock> { /* private fields */ }

Token-bucket rate limiter. Generic over the inner handle, the extractor type, AND the clock — mirrors resilience::Retry<Inner, Clk>’s injected-clock seam so refill timing is deterministically testable. Clk defaults to TimeClock, the production monotonic clock, so every existing caller (RateLimit::new, RateLimitConfig, RateLimitFactory) is unaffected.

Sans-IO: the limiter owns no runtime and spawns no task. Map growth is bounded by caps.max_keys (LRU eviction on insert, inline on the call path). Proactive reclamation of idle buckets is the host’s job — call sweep_idle on whatever cadence fits (read caps.sweep_period for the recommended interval) from a proxima_core::time::interval loop on your own runtime. That keeps the primitive runtime-agnostic (prime, tokio, embassy, bare-metal — it neither knows nor cares which drives the host’s tick).

Implementations

impl<Inner, Extractor> RateLimit<Inner, Extractor, TimeClock>

pub fn new( inner: Inner, config: TokenBucketConfig, extractor: Extractor, ) -> Self

pub fn with_caps( inner: Inner, config: TokenBucketConfig, extractor: Extractor, caps: RateLimitCaps, ) -> Self

impl<Inner, Extractor, Clk> RateLimit<Inner, Extractor, Clk>

pub fn with_clock( inner: Inner, config: TokenBucketConfig, extractor: Extractor, caps: RateLimitCaps, clock: Clk, ) -> Self

Materialise with an explicit clock — the seam a deterministic test or example injects a fake clock through; production code goes via new / with_caps, which default Clk to TimeClock.

pub fn with_action(self, action: ExceededAction) -> Self

impl<Inner, Extractor, Clk: Clock> RateLimit<Inner, Extractor, Clk>

pub fn sweep_idle(&self)

Evict buckets idle longer than caps.idle_ttl. Sans-IO: the host calls this on its own cadence (the limiter spawns nothing). Bounded growth does not depend on it — caps.max_keys already caps the map via LRU eviction on insert; this just reclaims idle memory sooner.

impl RateLimit<PipeHandle, KeyExtractor, TimeClock>

pub fn from_spec(inner: PipeHandle, value: &Value) -> Result<Self, ProximaError>

Trait Implementations

impl<Extractor, Clk> Pipe for RateLimit<ThreadLocalPipeHandle, Extractor, Clk>

where Request<Bytes>: KeyOf<Extractor, Rejection = Response<Bytes>>, Extractor: Clone + Send + Sync + 'static, Clk: Clock + Send + Sync + 'static,

type In = Request<Bytes>

Input the pipe consumes.

type Out = Response<Bytes>

Output the pipe produces.

type Err = ProximaError

Error the pipe can fail with. Debug + 'static; Send is added only on the cross-core SendPipe form.

fn call( &self, input: Request<Bytes>, ) -> impl Future<Output = Result<Response<Bytes>, ProximaError>>

Apply the pipe. The returned future is NOT required to be Send.

impl<Inner, Extractor, Clk> SendPipe for RateLimit<Inner, Extractor, Clk>

where Inner: SendPipe + Clone + Send + Sync + 'static, Inner::In: KeyOf<Extractor, Rejection = Inner::Out> + Labeled + Send + 'static, Inner::Out: Send + 'static, Inner::Err: Send + 'static, Extractor: Clone + Send + Sync + 'static, Clk: Clock + Send + Sync + 'static,

type In = <Inner as SendPipe>::In

Input the pipe consumes.

type Out = <Inner as SendPipe>::Out

Output the pipe produces.

type Err = <Inner as SendPipe>::Err

Error the pipe can fail with — Send here so it can cross cores.

fn call( &self, input: Inner::In, ) -> impl Future<Output = Result<Inner::Out, Inner::Err>> + Send

Apply the pipe. The returned future IS Send.