Struct RateLimiter

pub struct RateLimiter { /* private fields */ }

In-memory rate limiter that manages token buckets for different endpoints Thread-safe but not cross-process

Implementations

impl RateLimiter

pub fn new() -> Self

Examples found in repository

examples/rate_limiter_test.rs (line 10)

async fn main() -> Result<()> {
    env_logger::init();

    let rate_limiter = rate_limiter::RateLimiter::new();

    for i in 1..=5 {
        let _ = rate_limiter.wait("func1", 1.0, 15).await?;
        println!("call {}, time: {}", i, chrono::Local::now());
    }

    sleep(Duration::from_secs(5));

    for i in 1..=20 {
        let _ = rate_limiter.wait("func1", 1.0, 15).await?;
        println!("call {}, time: {}", i, chrono::Local::now());
    }

    sleep(Duration::from_secs(15));


    for i in 1..=20 {
        let _ = rate_limiter.wait("func1", 1.0, 15).await?;
        println!("call {}, time: {}", i, chrono::Local::now());
    }

    Ok(())
}

pub async fn wait( &self, identifier: &str, rate: f64, burst: u32, ) -> Result<RateLimitGuard>

Wait for a token to become available for the given endpoint and return a guard When the guard is dropped, record_response will be called automatically

Examples found in repository

examples/rate_limiter_test.rs (line 13)

async fn main() -> Result<()> {
    env_logger::init();

    let rate_limiter = rate_limiter::RateLimiter::new();

    for i in 1..=5 {
        let _ = rate_limiter.wait("func1", 1.0, 15).await?;
        println!("call {}, time: {}", i, chrono::Local::now());
    }

    sleep(Duration::from_secs(5));

    for i in 1..=20 {
        let _ = rate_limiter.wait("func1", 1.0, 15).await?;
        println!("call {}, time: {}", i, chrono::Local::now());
    }

    sleep(Duration::from_secs(15));


    for i in 1..=20 {
        let _ = rate_limiter.wait("func1", 1.0, 15).await?;
        println!("call {}, time: {}", i, chrono::Local::now());
    }

    Ok(())
}

examples/sellers_v1_use_raw_api.rs (line 18)

async fn main() -> Result<()> {
    let spapi_config = SpapiConfig::from_env()?;
    let spapi_client = SpapiClient::new(spapi_config.clone())?;
    {
        // Internally refresh the access token and create a configuration
        // Configuration must be created for each API call
        let configuration = spapi_client.create_configuration().await?;

        // Wait for rate limit before making the API call
        // When _guard is dropped, the rate limiter will mark the api call as having received a response
        let _guard = spapi_client
            .limiter()
            .wait("get_marketplace_participations", 0.016, 15)
            .await?;

        // Call the API to get marketplace participations
        let res = get_marketplace_participations(&configuration).await?;
        
        println!("Marketplace Participations: {:#?}", res);
    }
    Ok(())
}

pub async fn wait_for_token( &self, identifier: &str, rate: f64, burst: u32, ) -> Result<()>

👎Deprecated since 0.1.4: Use wait() instead.

Wait for a token to become available for the given endpoint This method will block until a token is available

pub async fn check_token_availability(&self, identifier: &str) -> Result<bool>

Check if a token is available without consuming it

pub async fn get_token_status(&self) -> Result<HashMap<String, (f64, f64, u32)>>

Get current token status for all endpoints Returns (tokens, rate, burst) for each endpoint

pub async fn reset(&self)

Reset all rate limiting state (useful for testing)

pub async fn active_buckets_count(&self) -> usize

Get the number of active buckets

pub async fn record_response(&self, identifier: &str) -> Result<()>

👎Deprecated since 0.1.4: Use wait() instead.

Record that a response was received for the given endpoint This updates the last_response_time used for enforcing minimum intervals

Trait Implementations

impl Default for RateLimiter

fn default() -> Self

Returns the “default value” for a type.