django-request-replay 0.1.1__tar.gz

django_request_replay-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sedra Zeidan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

django_request_replay-0.1.1/PKG-INFO

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: django-request-replay
+Version: 0.1.1
+Summary: Replay failed Django HTTP requests locally
+Author: Sedra Zeidan
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Django
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Django<7.0,>=6.1
+Requires-Dist: requests<3.0,>=2.32
+Dynamic: license-file
+
+# django-request-replay
+
+Replay failed Django HTTP requests locally.
+
+## The Problem
+
+Some Django errors are difficult to reproduce.
+
+A request may fail in production or staging, but reproducing the exact request locally can be difficult.
+
+`django-request-replay` captures failed requests and allows developers to replay them later.
+
+## How It Works
+
+```text
+HTTP Request
+     ↓
+Django Middleware
+     ↓
+Request fails
+     ↓
+Capture safely
+     ↓
+ReplayRequest
+     ↓
+Developer finds the request ID
+     ↓
+python manage.py replay_request <id>
+     ↓
+Request is replayed locally
+Installation
+Install the package with pip:
+pip install django-request-replay
+Add the app to INSTALLED_APPS:
+INSTALLED_APPS = [
+    ...
+    "django_request_replay",
+]
+Add the middleware:
+MIDDLEWARE = [
+    "django_request_replay.middleware.RequestReplayMiddleware",
+    ...
+]
+Run migrations:
+python manage.py migrate
+Configuration
+Add the following settings to your Django project:
+REPLAY_BASE_URL = "http://127.0.0.1:8000"
+REPLAY_ENABLED = True
+By default, the middleware captures:
+500
+502
+503
+504
+You can customize the captured status codes:
+REPLAY_STATUS_CODES = [500, 502, 503, 504]
+The request body is limited to 10 MB by default:
+MAX_BODY_SIZE = 10 * 1024 * 1024
+Usage
+List Captured Requests
+To see captured failed requests:
+python manage.py replay_requests
+Example:
+ID    METHOD    PATH                     STATUS
+------------------------------------------------
+12    POST      /api/payment/            500
+11    GET       /api/profile/            503
+10    POST      /api/orders/             500
+You can filter by status code:
+python manage.py replay_requests --status 500
+Limit the number of results:
+python manage.py replay_requests --limit 5
+Combine filters:
+python manage.py replay_requests --status 500 --limit 5
+Replay a Request
+Once you know the request ID:
+python manage.py replay_request 12
+Example:
+Replay completed: POST /api/payment/ -> 500 (0.145s)
+The request is sent again to the configured REPLAY_BASE_URL.
+Verbose Mode
+Use --verbose to see additional response information:
+python manage.py replay_request 12 --verbose
+Example:
+Replay completed: POST /api/payment/ -> 500 (0.145s)
+
+Response status: 500
+Content-Type: text/html
+Response size: 4218 bytes
+Security
+Sensitive request data is redacted before being stored.
+Sensitive Headers
+The following headers are redacted by default:
+Authorization
+Cookie
+Set-Cookie
+X-API-Key
+Sensitive Body Fields
+The following JSON fields are redacted:
+password
+token
+secret
+api_key
+Example:
+{
+    "username": "sedra",
+    "password": "[REDACTED]",
+    "token": "[REDACTED]"
+}
+Nested JSON objects and lists are also handled recursively.
+Sensitive authentication headers are not sent during replay.
+Large Request Bodies
+Request bodies larger than the configured limit are not stored.
+Instead, the request is marked as truncated:
+body_truncated = True
+This helps prevent the replay database from growing unexpectedly because of very large request bodies.
+Replay Protection
+Replayed requests include a special header:
+X-Django-Replay: 1
+The middleware detects this header and does not capture the replayed request again.
+This prevents an infinite capture loop:
+Replay request
+     ↓
+Fails again
+     ↓
+Captured again
+     ↓
+Replayed again
+     ↓
+...
+Testing
+Run the test suite with:
+python example/manage.py test django_request_replay
+The project includes tests for:
+Request redaction
+Header redaction
+Nested JSON redaction
+Failed request capture
+Exception capture
+5xx responses
+Body truncation
+Query parameters
+Replay behavior
+Sensitive headers
+Replay loop prevention
+Management commands
+Disabled replay
+Connection errors
+Project Structure
+
+django-request-replay/
+│
+├── django_request_replay/
+│   ├── middleware.py
+│   ├── models.py
+│   ├── redaction.py
+│   ├── replay.py
+│   ├── admin.py
+│   ├── tests.py
+│   └── management/
+│       └── commands/
+│           ├── replay_request.py
+│           └── replay_requests.py
+│
+├── example/
+│   ├── manage.py
+│   └── config/
+│
+├── pyproject.toml
+├── README.md
+└── .gitignore
+Roadmap
+[ ] Configurable redaction rules
+[ ] Request retention and cleanup command
+[ ] Better query parameter preservation
+[ ] Structured logging
+[ ] GitHub Actions CI
+[ ] PyPI release
+[ ] More Django version compatibility
+[ ] Response comparison
+[ ] Advanced replay options
+License
+MIT

django_request_replay-0.1.1/README.md

@@ -0,0 +1,183 @@
+# django-request-replay
+
+Replay failed Django HTTP requests locally.
+
+## The Problem
+
+Some Django errors are difficult to reproduce.
+
+A request may fail in production or staging, but reproducing the exact request locally can be difficult.
+
+`django-request-replay` captures failed requests and allows developers to replay them later.
+
+## How It Works
+
+```text
+HTTP Request
+     ↓
+Django Middleware
+     ↓
+Request fails
+     ↓
+Capture safely
+     ↓
+ReplayRequest
+     ↓
+Developer finds the request ID
+     ↓
+python manage.py replay_request <id>
+     ↓
+Request is replayed locally
+Installation
+Install the package with pip:
+pip install django-request-replay
+Add the app to INSTALLED_APPS:
+INSTALLED_APPS = [
+    ...
+    "django_request_replay",
+]
+Add the middleware:
+MIDDLEWARE = [
+    "django_request_replay.middleware.RequestReplayMiddleware",
+    ...
+]
+Run migrations:
+python manage.py migrate
+Configuration
+Add the following settings to your Django project:
+REPLAY_BASE_URL = "http://127.0.0.1:8000"
+REPLAY_ENABLED = True
+By default, the middleware captures:
+500
+502
+503
+504
+You can customize the captured status codes:
+REPLAY_STATUS_CODES = [500, 502, 503, 504]
+The request body is limited to 10 MB by default:
+MAX_BODY_SIZE = 10 * 1024 * 1024
+Usage
+List Captured Requests
+To see captured failed requests:
+python manage.py replay_requests
+Example:
+ID    METHOD    PATH                     STATUS
+------------------------------------------------
+12    POST      /api/payment/            500
+11    GET       /api/profile/            503
+10    POST      /api/orders/             500
+You can filter by status code:
+python manage.py replay_requests --status 500
+Limit the number of results:
+python manage.py replay_requests --limit 5
+Combine filters:
+python manage.py replay_requests --status 500 --limit 5
+Replay a Request
+Once you know the request ID:
+python manage.py replay_request 12
+Example:
+Replay completed: POST /api/payment/ -> 500 (0.145s)
+The request is sent again to the configured REPLAY_BASE_URL.
+Verbose Mode
+Use --verbose to see additional response information:
+python manage.py replay_request 12 --verbose
+Example:
+Replay completed: POST /api/payment/ -> 500 (0.145s)
+
+Response status: 500
+Content-Type: text/html
+Response size: 4218 bytes
+Security
+Sensitive request data is redacted before being stored.
+Sensitive Headers
+The following headers are redacted by default:
+Authorization
+Cookie
+Set-Cookie
+X-API-Key
+Sensitive Body Fields
+The following JSON fields are redacted:
+password
+token
+secret
+api_key
+Example:
+{
+    "username": "sedra",
+    "password": "[REDACTED]",
+    "token": "[REDACTED]"
+}
+Nested JSON objects and lists are also handled recursively.
+Sensitive authentication headers are not sent during replay.
+Large Request Bodies
+Request bodies larger than the configured limit are not stored.
+Instead, the request is marked as truncated:
+body_truncated = True
+This helps prevent the replay database from growing unexpectedly because of very large request bodies.
+Replay Protection
+Replayed requests include a special header:
+X-Django-Replay: 1
+The middleware detects this header and does not capture the replayed request again.
+This prevents an infinite capture loop:
+Replay request
+     ↓
+Fails again
+     ↓
+Captured again
+     ↓
+Replayed again
+     ↓
+...
+Testing
+Run the test suite with:
+python example/manage.py test django_request_replay
+The project includes tests for:
+Request redaction
+Header redaction
+Nested JSON redaction
+Failed request capture
+Exception capture
+5xx responses
+Body truncation
+Query parameters
+Replay behavior
+Sensitive headers
+Replay loop prevention
+Management commands
+Disabled replay
+Connection errors
+Project Structure
+
+django-request-replay/
+│
+├── django_request_replay/
+│   ├── middleware.py
+│   ├── models.py
+│   ├── redaction.py
+│   ├── replay.py
+│   ├── admin.py
+│   ├── tests.py
+│   └── management/
+│       └── commands/
+│           ├── replay_request.py
+│           └── replay_requests.py
+│
+├── example/
+│   ├── manage.py
+│   └── config/
+│
+├── pyproject.toml
+├── README.md
+└── .gitignore
+Roadmap
+[ ] Configurable redaction rules
+[ ] Request retention and cleanup command
+[ ] Better query parameter preservation
+[ ] Structured logging
+[ ] GitHub Actions CI
+[ ] PyPI release
+[ ] More Django version compatibility
+[ ] Response comparison
+[ ] Advanced replay options
+License
+MIT

django_request_replay-0.1.1/django_request_replay/admin.py

@@ -0,0 +1,17 @@
+from django.contrib import admin
+
+from .models import ReplayRequest
+
+
+@admin.register(ReplayRequest)
+class ReplayRequestAdmin(admin.ModelAdmin):
+    list_display = (
+        "id",
+        "method",
+        "path",
+        "status_code",
+        "body_truncated",
+        "created_at",
+    )
+    list_filter = ("status_code", "body_truncated", "method")
+    search_fields = ("path", "method")

django_request_replay-0.1.1/django_request_replay/apps.py

@@ -0,0 +1,9 @@
+from pathlib import Path
+
+from django.apps import AppConfig
+
+
+class DjangoRequestReplayConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "django_request_replay"
+    path = str(Path(__file__).resolve().parent)

django_request_replay-0.1.1/django_request_replay/management/commands/replay_request.py

@@ -0,0 +1,53 @@
+from django.core.management.base import BaseCommand, CommandError
+import requests
+from django_request_replay.replay import replay_request
+from django_request_replay.models import ReplayRequest
+
+
+class Command(BaseCommand):
+    help = "Replay a captured Django request"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "replay_request_id",
+            type=int,
+        )
+        parser.add_argument(
+           "--verbose",
+           action="store_true",
+           help="Print detailed information about the replayed request and response",)
+
+    def handle(self, *args, **options):
+        replay_request_id = options["replay_request_id"]
+
+        if not ReplayRequest.objects.filter(
+            id=replay_request_id
+        ).exists():
+            raise CommandError(
+                f"ReplayRequest with id {replay_request_id} does not exist."
+            )
+        captured_request = ReplayRequest.objects.get(
+           id=replay_request_id
+         )
+        try:
+          response = replay_request(replay_request_id)
+        except requests.exceptions.ConnectionError:
+         raise CommandError(
+        "Could not connect to the replay server. "
+        "Make sure Django is running and REPLAY_BASE_URL is correct."
+            )
+
+        self.stdout.write(
+          self.style.SUCCESS(
+           f"Replay completed: "
+           f"{captured_request.method} "
+           f"{captured_request.path} "
+           f"-> {response.status_code} "
+           f"({response.replay_elapsed_time:.3f}s)"
+          )
+        )
+        if options["verbose"]:
+          self.stdout.write("")
+          self.stdout.write(f"Response status: {response.status_code}")
+          self.stdout.write(f"Content-Type: {response.headers.get('Content-Type')}")
+          self.stdout.write(f"Response size: {len(response.content)} bytes")

django_request_replay-0.1.1/django_request_replay/management/commands/replay_requests.py

@@ -0,0 +1,33 @@
+from django.core.management.base import BaseCommand
+
+from django_request_replay.models import ReplayRequest
+
+
+class Command(BaseCommand):
+    help = "List captured failed requests"
+
+    def handle(self, *args, **options):
+        requests = ReplayRequest.objects.order_by("-created_at")
+
+        if not requests.exists():
+            self.stdout.write("No captured requests found.")
+            return
+
+        self.stdout.write(
+            f"{'ID':<6}"
+            f"{'METHOD':<10}"
+            f"{'PATH':<40}"
+            f"{'STATUS':<10}"
+            f"CREATED"
+        )
+
+        self.stdout.write("-" * 90)
+
+        for request in requests:
+            self.stdout.write(
+                f"{request.id:<6}"
+                f"{request.method:<10}"
+                f"{request.path:<40}"
+                f"{request.status_code:<10}"
+                f"{request.created_at}"
+            )

django_request_replay-0.1.1/django_request_replay/middleware.py

@@ -0,0 +1,59 @@
+from .models import ReplayRequest
+from .redaction import redact_headers , redact_body
+from django.conf import settings
+
+class RequestReplayMiddleware:
+    def __init__(self, get_response):
+      self.get_response = get_response
+
+      self.status_codes = getattr(
+        settings,
+        "REPLAY_STATUS_CODES",
+        [500, 502, 503, 504],
+          )
+
+      self.max_body_size = getattr(
+        settings,
+        "MAX_BODY_SIZE",
+        10 * 1024 * 1024,
+      )
+    def _get_body(self, request):
+      body = request.body
+      if len(body) > self.max_body_size:
+        return "", True
+      return redact_body(
+              body.decode("utf-8", errors="replace")
+          ), False
+    def _save_request(self, request, status_code):
+      body, body_truncated = self._get_body(request)
+
+      user = getattr(request, "user", None)
+
+      ReplayRequest.objects.create(
+        method=request.method,
+        path=request.path,
+        query_params=request.GET.dict(),
+        headers=redact_headers(request.headers),
+        body=body,
+        body_truncated=body_truncated,
+        status_code=status_code,
+        user_id=(
+            str(user.pk)
+            if user is not None and user.is_authenticated
+            else None
+        ),
+           )
+    def __call__(self, request):
+      if request.headers.get("X-Django-Replay") == "1":
+        return self.get_response(request)
+      try:
+        response = self.get_response(request)
+
+      except Exception:
+        self._save_request(request, 500)
+        raise
+
+      if response.status_code in self.status_codes:
+        self._save_request(request, response.status_code)
+      return response
+

django_request_replay-0.1.1/django_request_replay/migrations/0001_initial.py

@@ -0,0 +1,28 @@
+# Generated by Django 6.1.1 on 2026-09-25 22:51
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='ReplayRequest',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('method', models.CharField(max_length=10)),
+                ('path', models.CharField(max_length=500)),
+                ('query_params', models.JSONField(default=dict)),
+                ('headers', models.JSONField(default=dict)),
+                ('body', models.TextField(blank=True)),
+                ('status_code', models.PositiveIntegerField()),
+                ('user_id', models.CharField(blank=True, max_length=255, null=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+            ],
+        ),
+    ]

django_request_replay-0.1.1/django_request_replay/migrations/0002_replayrequest_body_truncated.py

@@ -0,0 +1,18 @@
+# Generated by Django 6.1.1 on 2026-09-27 23:15
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('django_request_replay', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='replayrequest',
+            name='body_truncated',
+            field=models.BooleanField(default=False),
+        ),
+    ]

django_request_replay-0.1.1/django_request_replay/models.py

@@ -0,0 +1,17 @@
+from django.db import models
+
+
+class ReplayRequest(models.Model):
+    method = models.CharField(max_length=10)
+    path = models.CharField(max_length=500)
+    query_params = models.JSONField(default=dict)
+    headers = models.JSONField(default=dict)
+    body = models.TextField(blank=True)
+    body_truncated = models.BooleanField(default=False)
+    status_code = models.PositiveIntegerField()
+    user_id = models.CharField(
+        max_length=255,
+        null=True,
+        blank=True,
+    )
+    created_at = models.DateTimeField(auto_now_add=True)