Struct RateLimitBuilder 

pub struct RateLimitBuilder { /* private fields */ }

Builder pattern implementation for creating rate limit instances.

This struct provides a convenient way to configure and create rate limit instances with various options such as clustering, custom buckets, and distributed storage. It extracts necessary dependencies from the configuration context and maintains shared references to components like clocks, storage, and locks.

Implementations

impl RateLimitBuilder

pub fn new(&self, builder_id: String) -> RateLimitBuilderInstance

Creates a new builder instance for configuring a rate limiter.

Arguments

• builder_id - A string identifier for the rate limit instance.

Returns

A new RateLimitBuilderInstance configured in local mode by default. It allows for further configuration before building the final RateLimitInstance. The returned instance inherits all the configuration and dependencies from this builder.

Additional methods provided:

• buckets: Allows custom quotas configuration as per-policy, per-SLA, or per-user grouping.
• clustered: Enables distributed, cross-node rate limiting by invoking .clustered(timer) before .build(). This requires a distributed storage client and configures the limiter for quota sharing across a cluster.
• shared: Enables sharing the rate limit across different policy instances
• build: Creates a new RateLimitInstance.

Example

// Local mode (single node, in-memory):
let local_limiter = builder
    .new("unique-id".to_string())
    .build()?;

// Cluster mode (multi-node, distributed quota):
let custom_buckets = vec![
    (
        "default".to_string(),
        vec![
            Tier {
                period_in_millis: 60000,
                requests: 120,
            },
        ],
    ),
];

let timer = clock.period(Duration::from_secs(5));

let cluster_limiter = builder
    .new("unique-id".to_string())
    .buckets(custom_buckets)
    .clustered(timer)
    .build()?;

// Shared mode (across policy instances):
let shared_limiter = builder
    .new("unique-id".to_string())
    .shared()
    .build()?;

Trait Implementations

impl FromContext<ConfigureContext> for RateLimitBuilder

type Error = Infallible

fn from_context(context: &ConfigureContext) -> Result<Self, Self::Error>

fn from_context_always(context: &C) -> Self

where Self: FromContext<C, E, Error = Infallible>,