Struct KeyedRateLimiter 

pub struct KeyedRateLimiter<K>
where
    K: Hash + Eq,
{ /* private fields */ }

Provides rate limiting for multiple contexts at the same time

This can use e.g. IP address as a Key. Internally this is a DashMap of TokenBucket instances that are created on demand using a prototype TokenBucket to copy initial state from. Uses LazyLru logic under the hood to keep the amount of items under control.

Implementations

impl<K> KeyedRateLimiter<K>

where K: Hash + Eq,

pub fn new( target_capacity: usize, prototype_bucket: TokenBucket, shard_amount: usize, ) -> Self

Creates a new KeyedRateLimiter with a specified target capacity and shard amount for the underlying DashMap. This uses a LazyLRU style eviction policy, so actual memory consumption will be <= 2 * target_capacity.

shard_amount must be greater than 0 and be a power of two; otherwise this function panics. target_capacity must be >= shard_amount; otherwise this function panics.

pub fn current_tokens(&self, key: impl Borrow<K>) -> Option<u64>

Fetches amount of tokens available for key.

Returns None if no bucket exists for the key provided

pub fn consume_tokens(&self, key: K, request_size: u64) -> Result<u64, u64>

Consumes request_size tokens from a bucket at given key.

On success, returns Ok(amount of tokens left in the bucket) On failure, returns Err(amount of tokens missing to fill request) If no bucket exists at key, a new bucket will be allocated, and normal policy will be applied to it Outdated buckets may be evicted on an LRU basis.

pub fn len_approx(&self) -> usize

Returns approximate amount of entries in the datastructure. Should be within ~10% of the true amount.

pub fn set_shrink_interval(&mut self, interval: usize)

Set the auto-shrink interval. Set to 0 to disable shrinking. During writes we want to check for length, but not too often to reduce probability of lock contention, so keeping this large is good for perf (at cost of memory use)

pub fn shrink_interval(&self) -> usize

Get the auto-shrink interval.