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 29)

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

    let rate_limiter = RateLimiter::new();

    if let Err(e) = call_api_with_error(1, &rate_limiter, false).await {
        println!("Call 1 failed: {}", e);
    }

    if let Err(e) = call_api_with_error(2, &rate_limiter, true).await {
        println!("Call 2 failed: {}", e);
    }

    if let Err(e) = call_api_with_error(3, &rate_limiter, false).await {
        println!("Call 3 failed: {}", e);
    }

    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 10)

async fn call_api_with_error(
    i: usize,
    rate_limiter: &RateLimiter,
    should_fail: bool,
) -> Result<()> {
    let guard = rate_limiter.wait("func1", 0.1, 1).await?;

    println!("API call {} start at: {}", i, chrono::Local::now());

    if should_fail {
        return Err(anyhow::anyhow!("API call failed"));
    }

    tokio::time::sleep(Duration::from_secs(1)).await;
    println!("API call {} end at  : {}", i, chrono::Local::now());

    guard.mark_response().await;
    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 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

Trait Implementations

impl Default for RateLimiter

fn default() -> Self

Returns the “default value” for a type.