Struct lib_wc::sync::MultiRateLimiter

pub struct MultiRateLimiter<K> { /* private fields */ }

MultiRateLimiter enables key-based rate limiting, where each key has its own RateLimiter.

This behavior is useful when you want to throttle a set of keys independently, for example you may have a web crawler that wants to throttle its requests to each domain independently.

Examples

use lib_wc::sync::MultiRateLimiter;
use anyhow::Result;
use std::time::{Duration, Instant};
use std::sync::Arc;
use futures::future::join_all;
use std::sync::atomic::AtomicUsize;
use std::sync::atomic::Ordering::SeqCst;

#[tokio::main]
async fn main() -> Result<()> {
   let rate_limiter = Arc::new(MultiRateLimiter::new(Duration::from_millis(50)));
   static COUNT: AtomicUsize = AtomicUsize::new(0);
   let start = Instant::now();

   // Spawn 10 tasks, each with a different key
   join_all(
      (0..10).map(|key| {
        let rate_limiter = rate_limiter.clone();
       tokio::spawn(async move {
         rate_limiter.throttle(key % 5, || async {
           COUNT.fetch_add(1, SeqCst);
         }).await;
      })
   })).await;

   // The rate limiter should have throttled the first 5 keys to 1 per 50ms
   assert!(start.elapsed().as_millis() >= 49);

   // All the keys should have been processed
   assert_eq!(COUNT.load(SeqCst), 10);
   Ok(())
}

Implementations

impl<K: Eq + Hash + Clone> MultiRateLimiter<K>

pub fn new(period: Duration) -> Self

Creates a new MultiRateLimiter.

pub async fn throttle<Fut, F, T>(&self, key: K, f: F) -> Twhere Fut: Future<Output = T>, F: FnOnce() -> Fut,

Throttles the execution of a function based on a key. Throttling is key-specific, so multiple keys can be throttled independently.

Uses an exponential backoff to wait for dashmap::DashMap shards to become available.

Examples

use lib_wc::sync::MultiRateLimiter;
use anyhow::Result;
use std::sync::Arc;

async fn do_work() { /* some computation */ }

async fn throttle_by_key(the_key: u32, limiter: Arc<MultiRateLimiter<u32>>) {
   limiter.throttle(the_key, || do_work()).await
}