Crate skp_ratelimit 

Advanced, modular rate limiting library for Rust.

skp_ratelimit provides a comprehensive rate limiting solution with:

• Multiple Algorithms: GCRA, Token Bucket, Leaky Bucket, Sliding Log, and more
• Pluggable Storage: In-memory with GC, Redis with connection pooling
• Per-Route Quotas: Different limits for different endpoints
• Composite Keys: Rate limit by IP + Path, User + API Key, etc.
• Framework Integration: Axum and Actix-web middleware

Quick Start

use skp_ratelimit::{GCRA, Quota, MemoryStorage, Algorithm};
use std::time::Duration;

#[tokio::main]
async fn main() {
    // Create storage and algorithm
    let storage = MemoryStorage::new();
    let algorithm = GCRA::new();
    let quota = Quota::per_second(10).with_burst(15);

    // Check and record a request
    let decision = algorithm.check_and_record(&storage, "user:123", &quota).await.unwrap();

    if decision.is_allowed() {
        println!("Request allowed! {} remaining", decision.info().remaining);
    } else {
        println!("Rate limited! Retry after {:?}", decision.info().retry_after);
    }
}

Algorithms

Algorithm	Best For	Memory	Feature Flag
GCRA	Precise rate control	Low	gcra
Token Bucket	Bursty traffic	Low	default
Leaky Bucket	Smooth output	Low	leaky-bucket
Sliding Log	Precision critical	High	sliding-log
Sliding Window	General purpose	Low	default
Fixed Window	Simple use cases	Low	default
Concurrent	Limit parallelism	Low	concurrent

Feature Flags

• memory (default): In-memory storage with garbage collection
• redis: Redis storage backend
• axum: Axum middleware integration
• gcra: GCRA algorithm
• leaky-bucket: Leaky Bucket algorithm
• sliding-log: Sliding Log algorithm
• concurrent: Concurrent request limiter

Re-exports

pub use algorithm::Algorithm;

pub use decision::Decision;

pub use decision::DecisionMetadata;

pub use decision::RateLimitInfo;

pub use error::ConfigError;

pub use error::ConnectionError;

pub use error::RateLimitError;

pub use error::Result;

pub use error::StorageError;

pub use key::CompositeKey;

pub use key::FnKey;

pub use key::GlobalKey;

pub use key::Key;

pub use key::StaticKey;

pub use manager::RateLimitManager;

pub use manager::RateLimitManagerBuilder;

pub use manager::RouteConfig;

pub use quota::Quota;

pub use quota::QuotaBuilder;

pub use storage::Storage;

pub use storage::StorageEntry;

pub use policy::CompositePolicy;

pub use policy::CreditPolicy;

pub use policy::DefaultPolicy;

pub use policy::PenaltyPolicy;

pub use policy::Policy;

pub use extensions::RateLimitExt;

pub use extensions::RateLimitResponse;

pub use headers::RateLimitHeaders;

pub use algorithm::FixedWindow;

pub use algorithm::SlidingWindow;

pub use algorithm::TokenBucket;

pub use algorithm::GCRA;

pub use algorithm::LeakyBucket;

pub use algorithm::SlidingLog;

pub use algorithm::ConcurrentLimiter;

pub use storage::GcConfig;

pub use storage::GcInterval;

pub use storage::MemoryStorage;

Modules

algorithm

Rate limiting algorithm trait and implementations.

decision

Decision types for rate limiting results.

error

Error types for rate limiting operations.

extensions

Request extensions for accessing rate limit info in handlers.

headers

HTTP headers for rate limiting.

key

Key extraction for rate limiting.

manager

Rate limit manager for per-route configuration.

policy

Policy engine for advanced rate limiting decisions.

prelude

Prelude module for convenient imports.

quota

Quota configuration for rate limiting.

storage

Storage backend trait and implementations.