Skip to content

Add Discord rate limiting with exponential backoff and Redis coordination (#284) #288

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
mahek2016 wants to merge 2 commits into
base: main
Choose a base branch
from
Open

Add Discord rate limiting with exponential backoff and Redis coordination (#284) #288

Changes from 1 commit
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
fccce47
Add Discord rate limiting with exponential backoff and per-channel bu…
mahek2016 Feb 22, 2026
fe73e6a
Resolve merge conflict and finalize Discord rate limiting implementation
mahek2016 Feb 22, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
143 changes: 143 additions & 0 deletions docs/DISCORD_RATE_LIMITING.md
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,143 @@
Discord Rate Limiting System
Overview

This implementation adds robust Discord API rate limit handling with:

Automatic 429 detection

Exponential backoff retry logic (2^n + jitter)

@coderabbitai coderabbitai Bot Feb 22, 2026

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

⚠️ Potential issue | 🟡 Minor

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
# First, find the documentation file
find . -name "DISCORD_RATE_LIMITING.md" -type f

Repository: AOSSIE-Org/Devr.AI

Length of output: 93

🏁 Script executed:

#!/bin/bash
# Read the documentation file to see both lines and their context
if [ -f "docs/DISCORD_RATE_LIMITING.md" ]; then
  echo "=== Line 8 context (overview) ==="
  sed -n '1,15p' "docs/DISCORD_RATE_LIMITING.md"
  echo ""
  echo "=== Line 45 context (detail) ==="
  sed -n '40,50p' "docs/DISCORD_RATE_LIMITING.md"
fi

Repository: AOSSIE-Org/Devr.AI

Length of output: 642

🏁 Script executed:

#!/bin/bash
# Find rate_limiter.py and examine the backoff/delay calculation
find . -name "rate_limiter.py" -type f

Repository: AOSSIE-Org/Devr.AI

Length of output: 44

🏁 Script executed:

#!/bin/bash
# Once we locate rate_limiter.py, examine the backoff implementation
if find . -name "rate_limiter.py" -type f | grep -q .; then
  file_path=$(find . -name "rate_limiter.py" -type f | head -1)
  echo "=== Content of $file_path ==="
  wc -l "$file_path"
  echo ""
  # Search for backoff/delay/retry_after related code
  rg -n "retry_after|backoff|delay|2\s*\*\*|exponential" "$file_path" -A 3 -B 1
fi

Repository: AOSSIE-Org/Devr.AI

Length of output: 44

🏁 Script executed:

#!/bin/bash
# Search for files related to rate limiting
find . -type f -name "*rate*" -o -name "*limiter*" -o -name "*backoff*" | head -20

Repository: AOSSIE-Org/Devr.AI

Length of output: 165

🏁 Script executed:

#!/bin/bash
# Search for Python files that contain Discord-related code or rate limiting logic
rg -l "rate.limit|retry_after|backoff" --type py | head -10

Repository: AOSSIE-Org/Devr.AI

Length of output: 170

🏁 Script executed:

#!/bin/bash
# Check the repository structure to understand where implementation files are
ls -la
git ls-files | grep -E "\.(py|js|ts)$" | head -30

Repository: AOSSIE-Org/Devr.AI

Length of output: 3322

🏁 Script executed:

#!/bin/bash
# Search for Discord-related Python files
find . -type f -name "*.py" | xargs rg -l "discord|Discord" | head -20

Repository: AOSSIE-Org/Devr.AI

Length of output: 845

🏁 Script executed:

#!/bin/bash
# Check if rate_limiter.py exists anywhere in the repo
git ls-files | grep -i "rate_limit\|rate_limiter"

Repository: AOSSIE-Org/Devr.AI

Length of output: 91

🏁 Script executed:

#!/bin/bash
# Search more broadly for any backoff or exponential backoff implementation
rg -n "exponential|backoff|2\s*\*\*" --type py -i | head -30

Repository: AOSSIE-Org/Devr.AI

Length of output: 44

🏁 Script executed:

#!/bin/bash
# Check the Discord bot file for rate limiting implementation
echo "=== Checking bot.py ==="
wc -l ./backend/integrations/discord/bot.py
echo ""
rg -n "retry|backoff|rate|limit|429" ./backend/integrations/discord/bot.py -A 2

Repository: AOSSIE-Org/Devr.AI

Length of output: 128

🏁 Script executed:

#!/bin/bash
# Check views.py for rate limiting
echo "=== Checking views.py ==="
wc -l ./backend/integrations/discord/views.py
echo ""
rg -n "retry|backoff|rate|limit|429" ./backend/integrations/discord/views.py -A 2

Repository: AOSSIE-Org/Devr.AI

Length of output: 132

🏁 Script executed:

#!/bin/bash
# Check cogs.py for rate limiting
echo "=== Checking cogs.py ==="
wc -l ./backend/integrations/discord/cogs.py
echo ""
rg -n "retry|backoff|rate|limit|429" ./backend/integrations/discord/cogs.py -A 2

Repository: AOSSIE-Org/Devr.AI

Length of output: 953

🏁 Script executed:

#!/bin/bash
# Search the entire backend directory for any retry or backoff logic
echo "=== Searching backend/ for retry/backoff logic ==="
rg -n "def.*retry|def.*backoff|def.*rate" --type py backend/ | head -20

Repository: AOSSIE-Org/Devr.AI

Length of output: 800

🏁 Script executed:

#!/bin/bash
# Check the entire docs directory
echo "=== Files in docs directory ==="
ls -la docs/
echo ""
echo "=== Full content of DISCORD_RATE_LIMITING.md ==="
cat docs/DISCORD_RATE_LIMITING.md

Repository: AOSSIE-Org/Devr.AI

Length of output: 2835

🏁 Script executed:

#!/bin/bash
# Final search: look for any Python implementation that references the formulas
rg -n "2\^|2\s*\*\*|retry_after" --type py backend/ | head -20

Repository: AOSSIE-Org/Devr.AI

Length of output: 44

Align the two formula descriptions in the overview and retry mechanism sections.

Line 8 describes the algorithm as 2^n + jitter, while Line 45 describes it as delay = (2^attempt × retry_after) + jitter. These are mathematically distinct formulas. Clarify which formula is intended and update both sections to be consistent. Note: The referenced rate_limiter.py implementation does not currently exist in the repository, so alignment should be based on the intended design for this feature.

🤖 Prompt for AI Agents 
Verify each finding against the current code and only fix it if needed.

In `@docs/DISCORD_RATE_LIMITING.md` at line 8, The two formulas for exponential
backoff in the docs are inconsistent; choose the intended formula (either simple
exponential backoff delay = 2^n + jitter or the scaled form delay = (2^attempt ×
retry_after) + jitter) and update both the overview and the retry mechanism
sections to use that exact expression and wording, make the notation consistent
(use either n or attempt everywhere), and add a short note referring to the
planned rate_limiter.py implementation to ensure future code matches the
documented formula.


Configurable maximum retry attempts (default: 3)

Redis-based distributed rate limit tracking

Per-channel bucket isolation

Command queueing using per-channel asyncio locks

Minimal performance overhead when not rate limited

This ensures improved bot resilience and production readiness.

Architecture

Flow:

User Message
→ DiscordBot
→ Per-channel Lock (Queueing)
→ DiscordRateLimiter
→ Redis (Bucket Tracking)
→ Discord API

Retry Mechanism

When a 429 HTTPException occurs:

Extract retry_after from Discord response

Store reset timestamp in Redis:

discord_ratelimit:<channel_id>

Calculate exponential backoff:

delay = (2^attempt × retry_after) + jitter

Retry up to max_retries times (default = 3)

If retries are exhausted, an exception is raised.

Distributed Rate Limit Tracking

Redis is used to coordinate rate limits across multiple bot instances.

Key format:

discord_ratelimit:<bucket>

Where:

bucket = Discord channel ID

This ensures:

Only the affected channel waits

Other channels continue operating normally

Safe multi-instance deployments

Command Queueing

Per-channel asyncio.Lock ensures:

Sequential message processing per channel

No concurrent retry storms

Clean isolation of channel traffic

This acts as a lightweight queue system.

Performance Characteristics

When NOT rate limited:

Single Redis GET

No artificial sleep

Direct execution

Negligible overhead (<1ms)

When rate limited:

Controlled exponential backoff

Shared distributed coordination via Redis

Configuration

Environment variable required:

REDIS_URL=redis://localhost:6379

Ensure Redis service is running before starting the bot.

Testing

Unit tests cover:

Successful execution without rate limit

Retry behavior on 429

Exponential backoff growth

Maximum retry exhaustion

Redis key storage on 429

Delay enforcement

Run tests:

pytest tests/test_rate_limiter.py

Future Improvements

Per-endpoint bucket parsing from Discord headers

Prometheus metrics integration

Advanced distributed worker queue

Rate limit analytics dashboard

Issue Reference

Implements Issue #284

Adds production-grade Discord rate limiting with exponential backoff and distributed coordination.
Comment on lines +1 to +143

@coderabbitai coderabbitai Bot Feb 22, 2026

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🛠️ Refactor suggestion | 🟠 Major

The file contains no Markdown formatting and will render as an unstructured wall of plain text.

Despite the .md extension, there are no heading markers (#), no list markers (-/*/1.), no inline code spans (`), and no fenced code blocks (```). On GitHub and any Markdown renderer this will appear as undifferentiated prose with no visual hierarchy, making it effectively unusable as reference documentation.

📝 Proposed Markdown rewrite 
-Discord Rate Limiting System
-Overview
+# Discord Rate Limiting System
+
+## Overview
 
-This implementation adds robust Discord API rate limit handling with:
+This implementation adds robust Discord API rate-limit handling with:
 
-Automatic 429 detection
-Exponential backoff retry logic (2^n + jitter)
-Configurable maximum retry attempts (default: 3)
-Redis-based distributed rate limit tracking
-Per-channel bucket isolation
-Command queueing using per-channel asyncio locks
-Minimal performance overhead when not rate limited
+- Automatic 429 detection
+- Exponential backoff retry logic (`2^attempt × retry_after + jitter`)
+- Configurable maximum retry attempts (default: 3)
+- Redis-based distributed rate-limit tracking
+- Per-channel bucket isolation
+- Command queueing using per-channel asyncio locks
+- Minimal performance overhead when not rate limited
 
-This ensures improved bot resilience and production readiness.
+This ensures improved bot resilience and production readiness.
 
-Architecture
+## Architecture
 
-Flow:
+### Flow
 
-User Message
-→ DiscordBot
-→ Per-channel Lock (Queueing)
-→ DiscordRateLimiter
-→ Redis (Bucket Tracking)
-→ Discord API
+```
+User Message
+→ DiscordBot
+→ Per-channel Lock (Queueing)
+→ DiscordRateLimiter
+→ Redis (Bucket Tracking)
+→ Discord API
+```
 
-Retry Mechanism
+## Retry Mechanism
 
-When a 429 HTTPException occurs:
+When a 429 `HTTPException` occurs:
 
-Extract retry_after from Discord response
-Store reset timestamp in Redis:
-discord_ratelimit:<channel_id>
-Calculate exponential backoff:
-delay = (2^attempt × retry_after) + jitter
-Retry up to max_retries times (default = 3)
-If retries are exhausted, an exception is raised.
+1. Extract `retry_after` from the Discord response.
+2. Store the reset timestamp in Redis under key `discord_ratelimit:<channel_id>`.
+3. Calculate exponential backoff: `delay = (2^attempt × retry_after) + jitter`
+4. Retry up to `max_retries` times (default: 3).
+5. If retries are exhausted, raise an exception.
 
-Distributed Rate Limit Tracking
+## Distributed Rate Limit Tracking
 
-Redis is used to coordinate rate limits across multiple bot instances.
+Redis coordinates rate limits across multiple bot instances.
 
-Key format:
-discord_ratelimit:<bucket>
+**Key format:** `discord_ratelimit:<bucket>`
 
-Where:
-bucket = Discord channel ID
+Where `bucket` = Discord channel ID.
 
-This ensures:
-Only the affected channel waits
-Other channels continue operating normally
-Safe multi-instance deployments
+This ensures:
+- Only the affected channel waits.
+- Other channels continue operating normally.
+- Safe multi-instance deployments.
 
-Command Queueing
+## Command Queueing
 
-Per-channel asyncio.Lock ensures:
-Sequential message processing per channel
-No concurrent retry storms
-Clean isolation of channel traffic
+Per-channel `asyncio.Lock` ensures:
+- Sequential message processing per channel.
+- No concurrent retry storms.
+- Clean isolation of channel traffic.
 
-This acts as a lightweight queue system.
+This acts as a lightweight queue system.
 
-Performance Characteristics
+## Performance Characteristics
 
-When NOT rate limited:
-Single Redis GET
-No artificial sleep
-Direct execution
-Negligible overhead (<1ms)
+**When NOT rate limited:**
+- Single Redis `GET`
+- No artificial sleep
+- Direct execution
+- Negligible overhead (<1 ms)
 
-When rate limited:
-Controlled exponential backoff
-Shared distributed coordination via Redis
+**When rate limited:**
+- Controlled exponential backoff
+- Shared distributed coordination via Redis
 
-Configuration
+## Configuration
 
-Environment variable required:
-REDIS_URL=redis://localhost:6379
+Environment variable required:
 
-Ensure Redis service is running before starting the bot.
+```env
+REDIS_URL=redis://localhost:6379
+```
 
-Testing
+Ensure Redis is running before starting the bot.
 
-Unit tests cover:
-Successful execution without rate limit
-Retry behavior on 429
-Exponential backoff growth
-Maximum retry exhaustion
-Redis key storage on 429
-Delay enforcement
+## Testing
 
-Run tests:
-pytest tests/test_rate_limiter.py
+Unit tests cover:
+- Successful execution without rate limit
+- Retry behavior on 429
+- Exponential backoff growth
+- Maximum retry exhaustion
+- Redis key storage on 429
+- Delay enforcement
 
-Future Improvements
-Per-endpoint bucket parsing from Discord headers
-Prometheus metrics integration
-Advanced distributed worker queue
-Rate limit analytics dashboard
+Run tests:
 
-Issue Reference
-Implements Issue `#284`
-Adds production-grade Discord rate limiting with exponential backoff and distributed coordination.
+```bash
+pytest tests/test_rate_limiter.py
+```
+
+## Future Improvements
+
+- Per-endpoint bucket parsing from Discord headers
+- Prometheus metrics integration
+- Advanced distributed worker queue
+- Rate limit analytics dashboard
+
+## Issue Reference
+
+Implements [Issue `#284`](../../issues/284) — adds production-grade Discord rate limiting with exponential backoff and distributed coordination.
🧰 Tools
🪛 LanguageTool

[uncategorized] ~1-~1: If this is a compound adjective that modifies the following noun, use a hyphen.
Context: Discord Rate Limiting System Overview This implementation ad...

(EN_COMPOUND_ADJECTIVE_INTERNAL)

🤖 Prompt for AI Agents 
Verify each finding against the current code and only fix it if needed.

In `@docs/DISCORD_RATE_LIMITING.md` around lines 1 - 143, The document is plain
text despite .md; convert it into proper Markdown by adding headings (e.g., "##
Retry Mechanism", "## Distributed Rate Limit Tracking", "## Command Queueing",
"## Performance Characteristics", "## Configuration", "## Testing", "## Future
Improvements", "## Issue Reference"), convert flow and steps into ordered/list
items (e.g., the flow lines and the Retry Mechanism steps: "Extract
`retry_after`", "Store `discord_ratelimit:<channel_id>`", "Calculate backoff",
"Retry up to `max_retries`"), mark inline code and keys with backticks (e.g.,
`HTTPException`, `discord_ratelimit:<bucket>`, `asyncio.Lock`, `GET`), wrap env
var and command examples in fenced code blocks (e.g., ```env and ```bash for
REDIS_URL and pytest), and format short bullet lists (e.g., benefits and future
improvements) using "-" so the file renders with clear headings and lists.