This Redis Lua script implements a sliding window rate limiter. It uses a Redis Sorted Set to store the timestamps of incoming requests within a defined time window. When a new request arrives, the script first removes a...

The script defines a `rate_limit` function that takes a `key_prefix`, a `limit`, and `window_seconds` as arguments. It performs input validation to ensure these parameters are of the correct type and value. It then calculates the `current_time_ms` and `window_start_ms`. A Redis Sorted Set, keyed by `key_prefix .. ':timestamps'`, is used to store request timestamps. The `ZREMRANGEBYSCORE` command atomically removes all timestamps older than `window_start_ms`. `ZCARD` then efficiently retrieves the current number of requests within the window. If `current_requests` is greater than or equal to `limit`, the function returns 0, indicating the rate limit is exceeded. Otherwise, the current timestamp is added to the sorted set using `ZADD`, and the key is given an expiration slightly longer than the window using `EXPIRE` to ensure automatic cleanup. The function then returns 1, allowing the request. The time complexity for each request is dominated by the Redis commands: `TIME`, `ZREMRANGEBYSCORE`, `ZCARD`, `ZADD`, and `EXPIRE`. In the worst case, `ZREMRANGEBYSCORE` might iterate through many old elements, but on average, its cost is amortized. The overall time complexity per request is effectively O(log N) or O(1) depending on the Redis command implementation details and the number of elements removed, where N is the number of requests in the window. The space complexity is O(K), where K is the number of requests within the `window_seconds`. Edge cases handled include invalid input parameters and the scenario where the sorted set is empty (the first request in a window), which correctly results in the request being allowed.

function rate_limit(key_prefix, limit, window_seconds): validate key_prefix, limit, window_seconds current_time_ms = get current time in milliseconds window_start_ms = current_time_ms - (window_seconds * 1000) timestamp_...

This Redis Lua script efficiently counts the number of keys in a Redis database that match a specified pattern. It leverages the `SCAN` command to iterate through keys incrementally, preventing long-running operations th...

The `count_keys_by_pattern` function takes a string `pattern` as input. It first validates that the pattern is a non-empty string. If invalid, it returns an error. Otherwise, it initializes a `count` to 0 and a `cursor` to '0'. The script then enters a `repeat-until` loop, which is essential for the `SCAN` command. Inside the loop, `redis.call('SCAN', cursor, 'MATCH', pattern, 'COUNT', 1000)` is invoked. This command returns a new cursor and a list of keys matching the pattern. The `COUNT` option is a hint to Redis about how many keys to return per iteration, aiming for a balance between efficiency and blocking time. The number of keys returned in the current iteration is added to the total `count`. The loop continues as long as the returned `cursor` is not '0', which signifies the end of the key iteration. Finally, the total `count` is returned. The time complexity is O(N), where N is the total number of keys in the database, because `SCAN` must visit all keys to ensure correctness. However, its space complexity is O(1) because it only stores the cursor and the count, and it processes keys in batches, minimizing memory usage. Edge cases include an empty or invalid pattern, which are handled by returning an error. If no keys match the pattern, the loop will complete, and the function will correctly return 0.

function count_keys_by_pattern(pattern): if pattern is not a string or is empty: return error 'Invalid pattern' count = 0 cursor = '0' repeat: result = redis.call('SCAN', cursor, 'MATCH', pattern, 'COUNT', 1000) cursor =...

This Redis Lua script manages a job queue, allowing workers to atomically fetch, process, and handle jobs. It uses Redis Lists to store pending jobs and a separate list for failed jobs. Jobs are processed one by one, wit...

The `processJob` function takes the names of the main queue, a failed queue, and the maximum retries. It uses `redis.call('LPOP', queue_name)` to atomically remove and retrieve a job from the left of the queue. If the queue is empty, it returns `nil`. It then decodes the job data (assuming JSON) and checks for malformed data or if the job has exceeded `max_retries`. In these cases, the job is moved to the `failed_queue_name` using `RPUSH`. If the job is valid and within retry limits, it simulates processing. If processing fails, the job's retry count is incremented, and it's re-enqueued using `RPUSH` to the main queue. If successful, the job data is returned. The time complexity is O(1) for `LPOP`, `RPUSH`, `ZCARD` (if used for retries), and `DEL` (if used for completion). JSON encoding/decoding can add overhead, but is typically considered constant for typical job sizes. Space complexity is O(J) where J is the size of a single job.

FUNCTION processJob(queue_name, failed_queue_name, max_retries): job_data_array = Redis.LPOP(queue_name) IF job_data_array IS null THEN RETURN null END IF job_data = job_data_array job_info = JSON.DECODE(job_data) IF job...

This script provides an atomic way to increment a counter stored in Redis. It uses the `INCRBY` command, which guarantees that even if multiple clients execute the script concurrently, the increment operation will be per...

The script defines a function `atomicIncrement` that takes a Redis key and an increment value. It first checks for invalid arguments, returning an error if either `key` or `increment` is missing. The core of the operation is `redis.call('INCRBY', key, increment)`, which atomically increases the value of the `key` by `increment`. Redis ensures this operation is atomic. The script then verifies that the result is indeed a number, indicating a successful increment. Finally, it returns the new value of the counter. The time complexity is O(1) because Redis commands like `INCRBY` are constant time operations. The space complexity is also O(1) as it only uses a few local variables.

FUNCTION atomicIncrement(key, increment): IF key is null OR increment is null THEN RETURN error 'Invalid arguments' END IF current_value = Redis.INCRBY(key, increment) IF type(current_value) is NOT number THEN RETURN err...

This Redis Lua script implements a sliding window counter for rate limiting. Unlike fixed window counters, it provides a more accurate measure of request rates by considering requests within a continuously moving time wi...

The `isSlidingWindowAllowed` function uses a Redis Sorted Set (`ZSET`) to store request timestamps for a given `key`. It first calculates the `current_time_ms` and `window_start_time_ms`. Then, it removes all timestamps from the ZSET that are older than `window_start_time_ms` using `ZREMRANGEBYSCORE`. After cleaning up old entries, it gets the current number of elements in the ZSET using `ZCARD`. If this count is already at or above the `limit`, the request is denied. Otherwise, the current timestamp is added to the ZSET using `ZADD`. A crucial step is to re-check the `ZCARD` after adding the new timestamp. If the count now exceeds the limit, the newly added timestamp is removed using `ZREM` to maintain accuracy. Finally, it ensures the ZSET has an expiry set to clean up keys that are no longer in use. The time complexity is O(log N) where N is the number of elements in the sorted set, due to `ZREMRANGEBYSCORE` and `ZADD`. However, in practice, the number of elements within a window is bounded by the limit, making it effectively O(log limit). Space complexity is O(N) where N is the number of requests within the window.

FUNCTION isSlidingWindowAllowed(key, limit, window_seconds): timestamps_key = 'sliding_window:' + key current_time_ms = GET_CURRENT_TIME_IN_MS() window_start_time_ms = current_time_ms - (window_seconds * 1000) Redis.ZREM...

This script implements a robust distributed lock mechanism in Redis, featuring re-entrancy. A re-entrant lock can be acquired multiple times by the same client without blocking itself, which is useful for recursive funct...

The `acquireLock` function first checks if the lock is already held by the `owner_id`. If so, it's a re-entrant acquisition, and the TTL is extended using `PSETEX`. If the lock is held by another owner, it checks the TTL. If the TTL is positive, the lock is valid and held by someone else, so it returns 0. If the TTL is non-positive (expired), it attempts to acquire the lock using `PSETEX` and then verifies ownership. If the lock is free, it uses `PSETEX` to atomically set the value and TTL, then verifies ownership. The `releaseLock` function checks if the lock is held by the `owner_id` and, if so, deletes it using `DEL`. This script uses `PSETEX` for atomic setting of value and TTL in milliseconds, which is crucial for preventing race conditions. Time complexity for both acquire and release is O(1) on average, assuming Redis operations are O(1). Space complexity is O(1) per lock key.

FUNCTION acquireLock(lock_key, owner_id, ttl_ms): current_owner = Redis.GET(lock_key) IF current_owner IS owner_id THEN Redis.PSETEX(lock_key, ttl_ms, owner_id) -- Extend TTL RETURN 1 ELSE IF current_owner IS NOT null TH...

This script provides basic session management functionality using Redis. It allows setting session data with an automatic expiration time and checking if a session is still active. This is fundamental for applications th...

The `setSession` function uses `redis.call('SET', session_key, session_data, 'EX', ttl_seconds)` to atomically set the session data and its expiration time. The `EX` option ensures that the key will be automatically deleted after `ttl_seconds`. The `isSessionValid` function uses `redis.call('GET', session_key)`. If `GET` returns `nil`, it means the key either never existed or has expired and been deleted by Redis. In this case, the session is considered invalid (returns 0). Otherwise, the session is considered valid (returns 1). Both operations are O(1) in time complexity as they involve single Redis commands. Space complexity is O(S) where S is the size of the session data.

FUNCTION setSession(session_key, session_data, ttl_seconds): result = Redis.SET(session_key, session_data, 'EX', ttl_seconds) IF result IS 'OK' THEN RETURN 'OK' ELSE RETURN error 'Failed to set session' END IF END FUNCTI...

This Redis Lua script implements a basic fixed window rate limiter. It tracks the number of requests made by a specific identifier (like a user ID or IP) within a defined time window. If the number of requests exceeds a...

The `isAllowed` function takes a `key`, `limit`, and `window_seconds`. It uses a Redis key prefixed with 'rate_limit:' to store the request count for the given `key`. If the counter key doesn't exist, it's the first request in the window; the script sets the count to 1, sets an expiry for the window, and returns 1 (allowed). If the counter exists, it checks if the current count exceeds the `limit`. If so, it returns 0 (denied). Otherwise, it increments the counter using `INCR`. If the incremented count is still within the limit, it returns 1. A safeguard `TTL` check ensures the expiry is set if it was somehow missing. The time complexity is O(1) due to Redis's constant-time operations. Space complexity is O(1) per unique `key` used.

FUNCTION isAllowed(key, limit, window_seconds): counter_key = 'rate_limit:' + key current_count = Redis.GET(counter_key) IF current_count IS null THEN Redis.SET(counter_key, 1) Redis.EXPIRE(counter_key, window_seconds) R...