use crate::telemetry::SecurityStore;
use axum::{
extract::Request,
http::StatusCode,
middleware::Next,
response::{IntoResponse, Response},
};
use dashmap::DashMap;
use std::net::IpAddr;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex, OnceLock};
use std::time::{Duration, Instant};
#[cfg(feature = "redis-rate-limit")]
mod redis;
#[cfg(feature = "redis-rate-limit")]
pub use redis::{RateLimitDecision, RedisRateLimitMode, RedisRateLimiter};
static RATE_LIMIT_STORE: OnceLock<DashMap<String, (Instant, AtomicU64)>> = OnceLock::new();
static RATE_LIMIT_ADMISSION: OnceLock<Mutex<AdmissionState>> = OnceLock::new();
const MAX_RATE_LIMIT_IDENTITIES: usize = 16_384;
const MAX_RATE_LIMIT_KEY_BYTES: usize = 256;
#[derive(Debug)]
struct AdmissionState {
last_cleanup: Instant,
longest_window: Duration,
}
impl Default for AdmissionState {
fn default() -> Self {
Self {
last_cleanup: Instant::now(),
longest_window: Duration::ZERO,
}
}
}
pub fn global_rate_limit_store() -> &'static DashMap<String, (Instant, AtomicU64)> {
RATE_LIMIT_STORE.get_or_init(DashMap::new)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum RateLimitBackend {
#[default]
Memory,
Distributed,
}
#[derive(Debug, Clone, thiserror::Error, PartialEq, Eq)]
#[non_exhaustive]
pub enum RateLimitError {
#[error("distributed rate limiting is not implemented; configure a real shared backend")]
DistributedBackendUnsupported,
#[error("invalid distributed rate-limit configuration: {0}")]
InvalidConfiguration(&'static str),
#[error("distributed rate-limit backend failed: {0}")]
Backend(String),
#[error("distributed rate-limit backend returned an invalid response")]
InvalidBackendResponse,
#[error("offline rate-limit mock is process-local and not distributed")]
OfflineMockIsNotDistributed,
}
#[derive(Debug, Clone)]
pub struct RateLimiter {
pub max_requests: u64,
pub window: Duration,
pub backend: RateLimitBackend,
store: Arc<DashMap<String, (Instant, AtomicU64)>>,
admission: Arc<Mutex<AdmissionState>>,
}
impl Default for RateLimiter {
fn default() -> Self {
Self {
max_requests: 120,
window: Duration::from_secs(60),
backend: RateLimitBackend::Memory,
store: Arc::new(DashMap::new()),
admission: Arc::new(Mutex::new(AdmissionState::default())),
}
}
}
impl RateLimiter {
pub fn new(max_requests: u64, window: Duration) -> Self {
Self {
max_requests,
window,
backend: RateLimitBackend::Memory,
store: Arc::new(DashMap::new()),
admission: Arc::new(Mutex::new(AdmissionState::default())),
}
}
#[deprecated(
since = "12.0.0",
note = "use try_with_distributed and handle the error"
)]
pub fn with_distributed(mut self) -> Self {
self.backend = RateLimitBackend::Distributed;
self
}
pub fn try_with_distributed(self) -> Result<Self, RateLimitError> {
Err(RateLimitError::DistributedBackendUnsupported)
}
pub fn check(&self, key: &str) -> bool {
if self.backend == RateLimitBackend::Distributed {
return true;
}
is_rate_limited_in(
&self.store,
&self.admission,
key,
self.max_requests,
self.window,
StoreKey::Client,
)
}
}
pub fn is_rate_limited(client_ip: &str, max_requests: u64, window_duration: Duration) -> bool {
is_rate_limited_in(
global_rate_limit_store(),
RATE_LIMIT_ADMISSION.get_or_init(|| Mutex::new(AdmissionState::default())),
client_ip,
max_requests,
window_duration,
StoreKey::ClientAndPolicy,
)
}
#[derive(Clone, Copy)]
enum StoreKey {
Client,
ClientAndPolicy,
}
impl StoreKey {
fn entry_key(self, client_ip: &str, max_requests: u64, window_duration: Duration) -> String {
match self {
Self::Client => client_ip.to_string(),
Self::ClientAndPolicy => format!(
"{max_requests}/{}ns/{client_ip}",
window_duration.as_nanos()
),
}
}
}
fn is_rate_limited_in(
store: &DashMap<String, (Instant, AtomicU64)>,
admission: &Mutex<AdmissionState>,
client_ip: &str,
max_requests: u64,
window_duration: Duration,
store_key: StoreKey,
) -> bool {
if max_requests == 0
|| window_duration.is_zero()
|| client_ip.is_empty()
|| client_ip.len() > MAX_RATE_LIMIT_KEY_BYTES
{
return record_block();
}
let Ok(mut admission) = admission.lock() else {
return record_block();
};
let now = Instant::now();
admission.longest_window = admission.longest_window.max(window_duration);
if now.saturating_duration_since(admission.last_cleanup)
>= admission.longest_window.min(Duration::from_secs(1))
{
store.retain(|_, (start, _)| {
now.saturating_duration_since(*start) < admission.longest_window
});
admission.last_cleanup = now;
}
let entry_key = store_key.entry_key(client_ip, max_requests, window_duration);
if !store.contains_key(&entry_key) && store.len() >= MAX_RATE_LIMIT_IDENTITIES {
return record_block();
}
let mut entry = store
.entry(entry_key)
.or_insert_with(|| (now, AtomicU64::new(0)));
let (start_time, count) = entry.value_mut();
if now.saturating_duration_since(*start_time) >= window_duration {
*start_time = now;
count.store(0, Ordering::Relaxed);
}
let current = count.load(Ordering::Relaxed);
if current >= max_requests {
return record_block();
}
count.store(current + 1, Ordering::Relaxed);
false
}
fn record_block() -> bool {
SecurityStore::global().inc_rate_limit_blocks();
true
}
fn peer_rate_limit_key(ip: IpAddr) -> String {
match ip.to_canonical() {
IpAddr::V4(address) => address.to_string(),
IpAddr::V6(address) => {
let [a, b, c, d, ..] = address.segments();
format!("{a:x}:{b:x}:{c:x}:{d:x}::/64")
}
}
}
pub async fn rate_limit_middleware(req: Request, next: Next) -> Response {
static LIMITER: OnceLock<RateLimiter> = OnceLock::new();
let Some(client_ip) = req
.extensions()
.get::<axum::extract::ConnectInfo<std::net::SocketAddr>>()
.map(|connect_info| peer_rate_limit_key(connect_info.0.ip()))
else {
return (
StatusCode::INTERNAL_SERVER_ERROR,
"Peer address unavailable; rate limiter is not safely configured",
)
.into_response();
};
if LIMITER.get_or_init(RateLimiter::default).check(&client_ip) {
return (
StatusCode::TOO_MANY_REQUESTS,
"Rate limit exceeded. Please try again later.",
)
.into_response();
}
next.run(req).await
}
#[cfg(test)]
mod tests;