Sliding Window Log Rate Limiter: A Precision Approach to Request Management

The Sliding Window Log Rate Limiter is an advanced technique for managing request rates with greater accuracy than traditional methods. This approach leverages Redis’s speed and reliability to create an efficient system for tracking and limiting requests within a rolling time window.

Implementation Overview

The Sliding Window Log Rate Limiter uses Redis commands such as HSET, HEXPIRE, and HLEN to maintain a dynamic log of requests. This method allows for smooth application of rate limits without abrupt resets at fixed intervals.

Key Components

1. Time Window Definition: A rolling time period is established, such as the last second, minute, or hour.
2. Request Tracking: Each incoming request is logged with a precise timestamp.
3. Expired Entry Removal: The system continuously cleans up entries older than the current time window.
4. Limit Enforcement: New requests are evaluated against the count of remaining entries in the log.

Java Implementation with Redis

The implementation utilizes Jedis, a popular Java client for Redis, to interact with the database and manage rate limiting operations.

Setting Up the Rate Limiter

javapublic class SlidingWindowLogRateLimiter {
    private final Jedis jedis;
    private final int windowSize;
    private final int limit;

    public SlidingWindowLogRateLimiter(Jedis jedis, long windowSize, int limit) {
        this.jedis = jedis;
        this.limit = limit;
        this.windowSize = windowSize;
    }
}

Core Functionality

The isAllowed method is the heart of the rate limiter:

javapublic boolean isAllowed(String clientId) {
    String key = "rate_limit:" + clientId;
    long requestCount = jedis.hlen(key);
    boolean isAllowed = requestCount < limit;
    
    if (isAllowed) {
        String fieldKey = UUID.randomUUID().toString();
        Transaction transaction = jedis.multi();
        transaction.hset(key, fieldKey, "");
        transaction.hexpire(key, windowSize, fieldKey);
        var result = transaction.exec();
        
        if (result.isEmpty()) {
            throw new IllegalStateException("Empty result from Redis transaction");
        }
    }
    
    return isAllowed;
}

This method checks if a new request is within the limit, and if so, logs it in Redis using a transaction to ensure atomicity.

Testing the Rate Limiter

To ensure reliability, the Sliding Window Log Rate Limiter is tested using Redis TestContainers, JUnit 5, and AssertJ. These tools allow for comprehensive testing of various scenarios.

Test Scenarios

1. Requests Within Limit: Verifies that requests within the defined limit are allowed.
2. Exceeding Limit: Ensures requests beyond the limit are denied.
3. Window Reset: Checks if new requests are allowed after the time window resets.
4. Multiple Clients: Confirms independent handling of different clients.
5. Gradual Allowance: Tests the dynamic nature of the sliding window.
6. Denied Request Handling: Verifies that denied requests do not affect the count.

Advantages of the Sliding Window Log Approach

• Precision: Offers more accurate rate limiting compared to fixed window methods.
• Smooth Transitions: Avoids abrupt resets at interval boundaries.
• Flexibility: Easily adaptable to various time windows and limit requirements.
• Efficiency: Utilizes Redis’s performance capabilities for real-time processing.

Conclusion

The Sliding Window Log Rate Limiter provides a robust solution for managing request rates in distributed systems. By combining the power of Redis with a well-designed Java implementation, it offers a flexible and precise method for enforcing rate limits. This approach is particularly valuable in scenarios where smooth, continuous rate limiting is crucial for maintaining system stability and fairness.

Read more such articles from our Newsletter here.