Struct RateLimiter 

pub struct RateLimiter { /* private fields */ }

A configurable rate limiter for controlling request rates.

This rate limiter supports multiple strategies:

• Token bucket: Continuous token replenishment with burst capacity
• Fixed window: Fixed request count per time window
• Custom strategies via the RateLimitStrategy trait

Example

use riglr_core::util::{RateLimiter, RateLimitStrategyType};
use std::time::Duration;

// Default token bucket strategy
let rate_limiter = RateLimiter::new(10, Duration::from_secs(60));

// Check rate limit for a user
rate_limiter.check_rate_limit("user123")?;

// Use fixed window strategy
let fixed_limiter = RateLimiter::builder()
    .strategy(RateLimitStrategyType::FixedWindow)
    .max_requests(100)
    .time_window(Duration::from_secs(60))
    .build();

Implementations

impl RateLimiter

pub fn new(max_requests: usize, time_window: Duration) -> Self

Create a new rate limiter with the default token bucket strategy

pub fn with_strategy<S: RateLimitStrategy + 'static>(strategy: S) -> Self

Create a rate limiter with a custom strategy

pub fn builder() -> RateLimiterBuilder

Create a new rate limiter builder for advanced configuration

pub fn check_rate_limit(&self, client_id: &str) -> Result<(), ToolError>

Check if a client has exceeded the rate limit

Arguments

• client_id - Unique identifier for the client (e.g., IP address, user ID)

Returns

• Ok(()) if the request is allowed
• Err(ToolError::RateLimited) if the rate limit is exceeded

pub fn reset_client(&self, client_id: &str)

Reset rate limit for a specific client

pub fn clear_all(&self)

Clear all rate limit data

pub fn get_request_count(&self, client_id: &str) -> usize

Get current request count for a client

pub fn strategy_name(&self) -> &str

Get the name of the current strategy

Trait Implementations

impl Clone for RateLimiter

fn clone(&self) -> RateLimiter

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RateLimiter

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

Formats the value using the given formatter.