Rate limiting with sliding window in Redis - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Sliding Window Rate Limit: Count Requests in Last Minute

Given a Redis sorted set where each member is a timestamp of a user request, which command returns the count of requests made in the last 60 seconds?

Redis

ZCOUNT user:123:requests -inf +inf

A ZCOUNT user:123:requests (current_timestamp - 60) current_timestamp

B ZCOUNT user:123:requests (current_timestamp - 60) +inf

C ZCOUNT user:123:requests -inf (current_timestamp - 60)

D ZCOUNT user:123:requests current_timestamp (current_timestamp + 60)

💡 Hint

Use ZCOUNT with a score range to count timestamps within the last 60 seconds.

ZCOUNT with the range from (current_timestamp - 60) to current_timestamp counts all requests in the last 60 seconds. Using +inf or -inf incorrectly includes timestamps outside the window.

📝 Syntax

intermediate

Identify the Correct Redis Command Syntax for Sliding Window Cleanup

Which Redis command syntax correctly removes all request timestamps older than 60 seconds from the sorted set 'user:123:requests'?

A ZREMRANGEBYSCORE user:123:requests (current_timestamp - 60)

B ZREMRANGEBYSCORE user:123:requests (current_timestamp - 60) +inf

C ZREMRANGEBYSCORE user:123:requests -inf (current_timestamp - 60)

D ZREMRANGEBYSCORE user:123:requests -inf current_timestamp

💡 Hint

You want to remove all timestamps less than (current_timestamp - 60).

ZREMRANGEBYSCORE with range -inf to (current_timestamp - 60) removes all older timestamps. Other options either remove wrong ranges or have syntax errors.

❓ optimization

advanced

Optimize Sliding Window Rate Limiting with Redis Lua Script

Which Lua script snippet atomically adds the current timestamp to a sorted set, removes timestamps older than 60 seconds, and returns the count of requests in the last 60 seconds?

A redis.call('ZADD', KEYS[1], ARGV[1], ARGV[1]); redis.call('ZREMRANGEBYSCORE', KEYS[1], '-inf', ARGV[1] + 60); return redis.call('ZCOUNT', KEYS[1], ARGV[1] - 60, ARGV[1])

B redis.call('ZADD', KEYS[1], ARGV[1], ARGV[1]); redis.call('ZREMRANGEBYSCORE', KEYS[1], ARGV[1] - 60, '+inf'); return redis.call('ZCOUNT', KEYS[1], ARGV[1] - 60, ARGV[1])

C redis.call('ZADD', KEYS[1], ARGV[1], ARGV[1]); redis.call('ZREMRANGEBYSCORE', KEYS[1], '-inf', ARGV[1] - 60); return redis.call('ZCOUNT', KEYS[1], '-inf', ARGV[1])

D redis.call('ZADD', KEYS[1], ARGV[1], ARGV[1]); redis.call('ZREMRANGEBYSCORE', KEYS[1], '-inf', ARGV[1] - 60); return redis.call('ZCOUNT', KEYS[1], ARGV[1] - 60, ARGV[1])

💡 Hint

Remove timestamps older than (current_timestamp - 60) and count timestamps in the last 60 seconds.

Option D correctly removes old timestamps and counts requests in the last 60 seconds. Other options remove wrong ranges or count incorrectly.

🔧 Debug

advanced

Debug Sliding Window Rate Limiting: Unexpected High Count

A developer uses this Redis command to count requests in the last 60 seconds:

ZCOUNT user:123:requests -inf (current_timestamp - 60)

but notices the count is unexpectedly high. What is the cause?

A The command syntax is invalid and causes a runtime error.

B The command counts timestamps older than (current_timestamp - 60) instead of newer ones.

C The command counts timestamps newer than (current_timestamp - 60) correctly.

D The command counts timestamps between (current_timestamp - 60) and +inf correctly.

💡 Hint

Check the score range used in ZCOUNT and what it includes.

Using -inf to (current_timestamp - 60) counts all timestamps older than 60 seconds ago, causing a high count. The correct range should be from (current_timestamp - 60) to current_timestamp.

🧠 Conceptual

expert

Why Use Sliding Window Rate Limiting Over Fixed Window?

Which statement best explains the advantage of sliding window rate limiting compared to fixed window rate limiting?

A Sliding window provides a smoother and more accurate limit by counting requests in a moving time frame, avoiding bursts at window edges.

B Fixed window rate limiting uses sorted sets, while sliding window uses simple counters.

C Fixed window rate limiting counts requests continuously without resetting, unlike sliding window.

D Sliding window is easier to implement and requires less memory than fixed window.

💡 Hint

Think about how requests are counted over time in both methods.

Sliding window counts requests in a continuously moving time frame, preventing sudden bursts at window boundaries that fixed windows allow. This makes it more precise and fair.