Struct RateLimiter 

pub struct RateLimiter { /* private fields */ }

Rate limiter for controlling API request rates

Uses the governor crate to implement a token bucket algorithm for rate limiting API requests, with one independent bucket per RateLimitClass. See the module documentation for the enforced budget of each class.

Implementations

impl RateLimiter

pub fn new(config: &RateLimiterConfig) -> Self

Creates a new rate limiter from configuration

The non-trading bucket honors the configured budget exactly: it admits config.max_requests requests per config.period_seconds, with config.burst_size burst capacity (replenishing one cell every period_seconds / max_requests). The trading and historical buckets use stricter, fixed budgets derived from IG’s published limits and are independent of the configured budget. See the module documentation.

Arguments

• config - Rate limiter configuration containing max requests, period, and burst size

Returns

A new RateLimiter instance

Example

use ig_client::application::config::RateLimiterConfig;
use ig_client::application::rate_limiter::RateLimiter;

let config = RateLimiterConfig {
    max_requests: 60,
    period_seconds: 60,
    burst_size: 10,
};

// Non-trading admits 60 requests/minute (one cell per second, +burst).
let limiter = RateLimiter::new(&config);

pub async fn wait_for(&self, class: RateLimitClass)

Waits until a request in the given class can be made according to its rate limit.

Uses governor’s async scheduler (until_ready): the future is parked until a slot is available rather than busy-polling. Each class has an independent bucket, so waiting on one class never blocks another.

Example

use ig_client::application::rate_limiter::RateLimitClass;
limiter.wait_for(RateLimitClass::Trading).await;
// Place order here

pub fn check_for(&self, class: RateLimitClass) -> bool

Checks if a request in the given class can be made immediately without waiting.

Returns

• true if a request can be made immediately
• false if that class’s rate limit has been reached

pub async fn wait(&self)

Waits until a non-trading request can be made according to the rate limit

Convenience wrapper over wait_for with RateLimitClass::NonTrading. Blocks (asynchronously) until the rate limiter allows the request to proceed.

Example

limiter.wait().await;
// Make API request here

pub fn check(&self) -> bool

Checks if a non-trading request can be made immediately without waiting

Convenience wrapper over check_for with RateLimitClass::NonTrading.

Returns

• true if a request can be made immediately
• false if the rate limit has been reached

Example

if limiter.check() {
    // Make API request
} else {
    // Wait or handle rate limit
}

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.