Struct MemoryStorage 

pub struct MemoryStorage { /* private fields */ }

In-memory storage with garbage collection.

Uses DashMap for thread-safe concurrent access and includes configurable garbage collection to prevent unbounded memory growth.

Example

use skp_ratelimit::storage::{MemoryStorage, GcConfig};
use std::time::Duration;

// Default GC (every 10000 requests)
let storage = MemoryStorage::new();

// Custom GC interval
let storage = MemoryStorage::with_gc(GcConfig::on_duration(Duration::from_secs(60)));

// Manual GC only
let storage = MemoryStorage::with_gc(GcConfig::manual());
storage.run_gc().await;

Implementations

impl MemoryStorage

pub fn new() -> Self

Create a new memory storage with default GC configuration.

pub fn with_gc(gc_config: GcConfig) -> Self

Create a new memory storage with custom GC configuration.

pub async fn run_gc(&self)

Manually trigger garbage collection.

pub fn len(&self) -> usize

Get the number of entries currently stored.

pub fn is_empty(&self) -> bool

Check if the storage is empty.

pub fn clear(&self)

Clear all entries.

Trait Implementations

impl Debug for MemoryStorage

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for MemoryStorage

fn default() -> Self

Returns the “default value” for a type.

impl Drop for MemoryStorage

fn drop(&mut self)

Executes the destructor for this type.

impl Storage for MemoryStorage

async fn get(&self, key: &str) -> Result<Option<StorageEntry>>

Get an entry by key.

async fn set(&self, key: &str, entry: StorageEntry, ttl: Duration) -> Result<()>

Set an entry with a TTL.

async fn delete(&self, key: &str) -> Result<()>

Delete an entry.

async fn increment( &self, key: &str, delta: u64, window_start: u64, ttl: Duration, ) -> Result<u64>

Atomically increment a counter.

async fn execute_atomic<F, T>( &self, key: &str, ttl: Duration, operation: F, ) -> Result<T>

where F: FnOnce(Option<StorageEntry>) -> (StorageEntry, T) + Send, T: Send,

Execute an atomic read-modify-write operation.

async fn compare_and_swap( &self, key: &str, expected: Option<&StorageEntry>, new: StorageEntry, ttl: Duration, ) -> Result<bool>

Compare-and-swap operation.