django-webhook-subscriber 1.0.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

django_webhook_subscriber/management/commands/webhook.py

@@ -0,0 +1,169 @@
+"""webhook command for Django Webhook Subscriber."""
+
+import json
+import time
+
+from django.core.management.base import BaseCommand, CommandError
+from django_webhook_subscriber.models import WebhookSubscriber
+from django_webhook_subscriber.sessions import create_webhook_session
+from django_webhook_subscriber.utils import generate_headers
+
+
+class Command(BaseCommand):
+    help = "Test webhook endpoints"
+
+    def add_arguments(self, parser):
+
+        parser.add_argument(
+            "--subscriber-id",
+            "-s",
+            type=int,
+            help="Test specific subscriber by ID",
+        )
+        parser.add_argument(
+            "--all",
+            "-a",
+            action="store_true",
+            help="Test all active subscribers",
+        )
+        parser.add_argument(
+            "--timeout",
+            "-t",
+            type=int,
+            default=10,
+            help="Test timeout in seconds (default: 10)",
+        )
+        parser.add_argument(
+            "--method",
+            "-m",
+            choices=["HEAD", "GET", "POST"],
+            default="HEAD",
+            help="HTTP method to use for testing (default: HEAD)",
+        )
+        parser.add_argument(
+            "--payload",
+            "-p",
+            type=str,
+            help="JSON payload for POST requests",
+        )
+
+    def handle(self, *args, **options):
+        subscribers = self.get_subscribers(options)
+
+        if not subscribers:
+            raise CommandError("No subscribers found to test.")
+
+        self.stderr.write(f"Testing {subscribers.count()} subscriber(s)...")
+
+        results = []
+        with create_webhook_session() as session:
+            for subscriber in subscribers:
+                result = self.test_subscriber(session, subscriber, options)
+                results.append(result)
+
+        self.print_results(results)
+
+    def get_subscribers(self, options):
+        qs = WebhookSubscriber.objects.filter(is_active=True)
+        if options.get("subscriber_id"):
+            qs = qs.filter(id=options["subscriber_id"])
+        elif options.get("all"):
+            return qs
+        else:
+            raise CommandError("Please specify --subscriber-id or --all.")
+
+    def test_subscriber(self, session, subscriber, options):
+        start_time = time.time()
+        method = options["method"]
+        timeout = min(options["timeout"], subscriber.timeout)
+
+        self.stdout.write(
+            f"Testing {subscriber.name} ({subscriber.target_url})..."
+        )
+
+        try:
+            headers = generate_headers(subscriber)
+
+            if method == "POST" and options.get("payload"):
+                try:
+                    payload = json.loads(options["payload"])
+                except json.JSONDecodeError as e:
+                    return {
+                        "subscriber": subscriber,
+                        "success": False,
+                        "error": f"Invalid JSON payload: {e=}",
+                        "duration_ms": 0,
+                    }
+                response = session.post(
+                    subscriber.target_url,
+                    json=payload,
+                    headers=headers,
+                    timeout=timeout,
+                )
+            elif method == "GET":
+                response = session.get(
+                    subscriber.target_url,
+                    headers=headers,
+                    timeout=timeout,
+                )
+            else:  # HEAD or default
+                response = session.head(
+                    subscriber.target_url,
+                    headers=headers,
+                    timeout=timeout,
+                )
+
+            duration_ms = int((time.time() - start_time) * 1000)
+
+            return {
+                "subscriber": subscriber,
+                "success": True,
+                "status_code": response.status_code,
+                "duration_ms": duration_ms,
+                "headers": dict(response.headers),
+                "error": None,
+            }
+
+        except Exception as e:
+            duration_ms = int((time.time() - start_time) * 1000)
+            return {
+                "subscriber": subscriber,
+                "success": False,
+                "status_code": None,
+                "duration_ms": duration_ms,
+                "error": f"{e=}",
+            }
+
+    def print_results(self, results):
+        self.stdout.write("\n" + "=" * 60)
+        self.stdout.write("TEST RESULTS")
+        self.stdout.write("=" * 60)
+
+        successful = 0
+        failed = 0
+
+        for result in results:
+            subscriber = result["subscriber"]
+
+            if result["success"]:
+                successful += 1
+                style = self.style.SUCCESS
+                status = (
+                    f"✓ {result['status_code']} ({result['duration_ms']}ms)"
+                )
+            else:
+                failed += 1
+                style = self.style.ERROR
+                status = f"✗ {result['error']} ({result['duration_ms']}ms)"
+
+            self.stdout.write(style(f"{subscriber.name}: {status}"))
+
+        self.stdout.write("\n" + "-" * 60)
+        self.stdout.write(
+            f"Total: {len(results)} | Success: {successful} | Failed: {failed}"
+        )
+
+        if failed > 0:
+            self.stdout.write(
+                self.style.WARNING(f"⚠ {failed} endpoint(s) failed testing")
+            )

django_webhook_subscriber/management/commands/webhook_cache.py

@@ -0,0 +1,173 @@
+"""webhook_cache command for Django Webhook Subscriber."""
+
+from django.contrib.contenttypes.models import ContentType
+from django.core.management.base import BaseCommand, CommandError
+from django_webhook_subscriber.delivery import (
+    clear_webhook_cache,
+    get_webhook_cache_stats,
+    warm_webhook_cache,
+)
+
+
+class Command(BaseCommand):
+    help = "Manage webhook cache operations"
+
+    def add_arguments(self, parser):
+        subparsers = parser.add_subparsers(dest="action", help="Cache actions")
+
+        # Clear command
+        clear_parser = subparsers.add_parser(
+            "clear", help="Clear webhook cache"
+        )
+        clear_parser.add_argument(
+            "--content-type",
+            "-c",
+            type=str,
+            help="Clear cache for specific content type "
+            "(app_label.model_name)",
+        )
+        clear_parser.add_argument(
+            "--event",
+            "-e",
+            type=str,
+            help="Clear cache for specific event name",
+        )
+
+        # Stats command
+        subparsers.add_parser("stats", help="Show cache statistics")
+
+        # List command
+        list_parser = subparsers.add_parser("list", help="List cached keys")
+        list_parser.add_argument(
+            "--show-empty",
+            action="store_true",
+            help="Show keys that are not cached",
+        )
+
+        # Warm command
+        subparsers.add_parser("warm", help="Pre-warm the cache")
+
+    def handle(self, *args, **options):
+        """Handle the command based on the provided action."""
+
+        action = options.get("action")
+
+        if not action:
+            self.print_help("manage.py", "webhook_cache")
+            return
+
+        if action == "clear":
+            self.handle_clear(options)
+        elif action == "stats":
+            self.handle_stats()
+        elif action == "list":
+            self.handle_list(options)
+        elif action == "warm":
+            self.handle_warm()
+
+    def handle_clear(self, options):
+        """Clear webhook cache with optional filtering."""
+
+        content_type = None
+        if options["content_type"]:
+            try:
+                app_label, model_name = options["content_type"].split(".")
+                content_type = ContentType.objects.get(
+                    app_label=app_label, model=model_name
+                )
+
+            except (ValueError, ContentType.DoesNotExist):
+                raise CommandError(
+                    f'Invalid content type: {options["content_type"]}'
+                )
+
+        clear_webhook_cache(
+            content_type=content_type,
+            event_name=options.get("event"),
+        )
+
+        if content_type and options.get("event"):
+            self.stdout.write(
+                self.style.SUCCESS(
+                    f"Cleared cache for {content_type} - {options['event']}"
+                )
+            )
+        elif content_type:
+            self.stdout.write(
+                self.style.SUCCESS(f"Cleared cache for {content_type}")
+            )
+        elif options.get("event"):
+            self.stdout.write(
+                self.style.SUCCESS(
+                    f"Cleared cache for event '{options['event']}'"
+                )
+            )
+        else:
+            self.stdout.write(self.style.SUCCESS("Cleared all webhook cache"))
+
+    def handle_stats(self):
+        """Show detailed cache statistics."""
+        try:
+            stats = get_webhook_cache_stats()
+
+            self.stdout.write(self.style.SUCCESS("Webhook Cache Statistics"))
+
+            self.stdout.write("-" * 40)
+            self.stdout.write(
+                f"Total possible keys: {stats['total_possible_keys']}"
+            )
+            self.stdout.write(f"Actually cached keys: {stats['cached_keys']}")
+            self.stdout.write(
+                f"Cache hit ratio: {stats['cache_hit_ratio']:.1f}"
+            )
+            self.stdout.write(
+                "Total cached subscriptions: "
+                f"{stats['total_cached_subscriptions']}"
+            )
+
+            if stats["key_details"]:
+                self.stdout.write("\nDetailed breakdown:")
+                for detail in stats["key_details"]:
+                    status = "CACHED" if detail["is_cached"] else "NOT CACHED"
+                    self.stdout.write(
+                        f"  {detail['key']}: {status} "
+                        f"({detail['subscription_count']} subscriptions)"
+                    )
+
+        except Exception as e:
+            raise CommandError(f"Error getting cache stats: {e=}")
+
+    def handle_list(self, options):
+        """List all webhook cache keys."""
+
+        try:
+            stats = get_webhook_cache_stats()
+            show_empty = options.get("show_empty", False)
+
+            for detail in stats["key_details"]:
+                if not show_empty and not detail["is_cached"]:
+                    continue
+
+                status = "CACHED" if detail["is_cached"] else "NOT CACHED"
+                self.stdout.write(
+                    f"{detail['key']}: {status} "
+                    f"({detail['subscription_count']} subscriptions)"
+                )
+
+        except Exception as e:
+            raise CommandError(f"Error listing cache keys: {e=}")
+
+    def handle_warm(self):
+        """Pre-warm the webhook cache."""
+
+        try:
+            result = warm_webhook_cache()
+            self.stdout.write(
+                self.style.SUCCESS(
+                    f"Cache warmed for {result['warmed']} subscription "
+                    "combinations."
+                )
+            )
+
+        except Exception as e:
+            raise CommandError(f"Error warming cache: {e=}")

django_webhook_subscriber/management/commands/webhook_logs.py

@@ -0,0 +1,226 @@
+"""webhook_logs command for Django Webhook Subscriber."""
+
+from datetime import timedelta
+
+from django.core.management.base import BaseCommand
+from django.db import models, transaction
+from django.utils import timezone
+from django_webhook_subscriber.conf import rest_webhook_settings
+from django_webhook_subscriber.models import (
+    WebhookDeliveryLog,
+)
+
+
+class Command(BaseCommand):
+    help = "Manage webhook delivery logs"
+
+    def add_arguments(self, parser):
+
+        subparsers = parser.add_subparsers(dest="action", help="Log actions")
+
+        # Cleanup command
+        cleanup_parser = subparsers.add_parser(
+            "cleanup", help="Clean up old logs"
+        )
+        cleanup_parser.add_argument(
+            "--days",
+            type=int,
+            help="Keep logs newer than N days (overrides settings)",
+        )
+        cleanup_parser.add_argument(
+            "--subscription-id",
+            "-s",
+            type=int,
+            help="Clean logs for specific subscription by ID",
+        )
+        cleanup_parser.add_argument(
+            "--dry-run",
+            "-d",
+            action="store_true",
+            help="Show what would be deleted without actually deleting",
+        )
+
+        # Stats command
+        stats_parser = subparsers.add_parser(
+            "stats", help="Show log statistics"
+        )
+        stats_parser.add_argument(
+            "--days",
+            type=int,
+            default=30,
+            help="Show stats for last N days (default: 30)",
+        )
+
+        # Error command
+        errors_parser = subparsers.add_parser(
+            "errors", help="Show recent error logs"
+        )
+        errors_parser.add_argument(
+            "--limit",
+            type=int,
+            default=10,
+            help="Number of recent errors to show (default: 10)",
+        )
+
+    def handle(self, *args, **options):
+        action = options.get("action")
+
+        if not action:
+            self.print_help("manage.py", "webhook_logs")
+            return
+
+        if action == "cleanup":
+            self.handle_cleanup(options)
+        elif action == "stats":
+            self.handle_stats(options)
+        elif action == "errors":
+            self.handle_errors(options)
+
+    def handle_cleanup(self, options):
+        """Clean up old webhook logs."""
+        retention_days = (
+            options.get("days") or rest_webhook_settings.LOG_RETENTION_DAYS
+        )
+        cutoff_date = timezone.now() - timedelta(days=retention_days)
+
+        query = WebhookDeliveryLog.objects.filter(created_at__lte=cutoff_date)
+
+        if options.get("subscription_id"):
+            query = query.filter(subscription_id=options["subscription_id"])
+
+        total_count = query.count()
+        if total_count == 0:
+            self.stdout.write(self.style.SUCCESS("No old logs to clean up"))
+            return
+
+        if options.get("dry_run"):
+            self.stdout.write(
+                self.style.WARNING(
+                    f"DRY RUN: Would delete {total_count} logs older than "
+                    f"{cutoff_date}"
+                )
+            )
+            return
+
+        # Delete in batches to avoid memory issues
+        batch_size = 1000
+        total_deleted = 0
+        with transaction.atomic():
+            while True:
+                batch_ids = list(
+                    query.values_list("id", flat=True)[:batch_size]
+                )
+                if not batch_ids:
+                    break
+
+                deleted_count = WebhookDeliveryLog.objects.filter(
+                    id__in=batch_ids
+                ).delete()[0]
+                total_deleted += deleted_count
+
+                self.stdout.write(
+                    f"Deleted {deleted_count} logs (total: {total_deleted})"
+                )
+
+        self.stdout.write(
+            self.style.SUCCESS(
+                f"Cleanup completed. Deleted {total_deleted} logs older than "
+                f"{cutoff_date}"
+            )
+        )
+
+    def handle_stats(self, options):
+        """Show webhook log statistics."""
+
+        days = options["days"]
+        since_date = timezone.now() - timedelta(days=days)
+
+        logs = WebhookDeliveryLog.objects.filter(created_at__gte=since_date)
+
+        total_logs = logs.count()
+        successful_logs = logs.filter(
+            response_status__gte=200, response_status__lt=300
+        ).count()
+        error_logs = logs.exclude(
+            response_status__gte=200, response_status__lt=300
+        ).count()
+
+        # Success rate
+        success_rate = (
+            (successful_logs / total_logs * 100) if total_logs > 0 else 0
+        )
+
+        # Top failing subscriptions
+        failing_subs = (
+            logs.exclude(response_status__gte=200, response_status__lt=300)
+            .values(
+                "subscription__subscriber__name", "subscription__event_name"
+            )
+            .annotate(error_count=models.Count("id"))
+            .order_by("-error_count")[:5]
+        )
+
+        # Average response time
+        avg_duration = (
+            logs.exclude(delivery_duration_ms__isnull=True).aggregate(
+                avg_duration=models.Avg("delivery_duration_ms")
+            )["avg_duration"]
+            or 0
+        )
+
+        self.stdout.write(
+            self.style.SUCCESS(f"Webhook Statistics (Last {days} days)")
+        )
+        self.stdout.write("-" * 50)
+        self.stdout.write(f"Total deliveries: {total_logs}")
+        self.stdout.write(f"Successful: {successful_logs}")
+        self.stdout.write(f"Failed: {error_logs}")
+        self.stdout.write(f"Success rate: {success_rate:.1f}%")
+
+        if avg_duration:
+            self.stdout.write(f"Average response time: {avg_duration:.0f}ms")
+
+        if failing_subs:
+            self.stdout.write("\nTop failing subscriptions:")
+            for sub in failing_subs:
+                self.stdout.write(
+                    f"  {sub['subscription__subscriber__name']} - "
+                    f"{sub['subscription__event_name']}: {sub['error_count']} "
+                    "errors"
+                )
+
+    def handle_errors(self, options):
+        """Show recent webhook errors."""
+
+        limit = options["limit"]
+
+        error_logs = (
+            WebhookDeliveryLog.objects.exclude(
+                response_status__gte=200, response_status__lt=300
+            )
+            .select_related("subscription", "subscription__subscriber")
+            .order_by("-created_at")[:limit]
+        )
+
+        if not error_logs:
+            self.stdout.write(self.style.SUCCESS("No recent errors found"))
+            return
+
+        self.stdout.write(
+            self.style.ERROR(f"Recent Webhook Errors (Last {limit})")
+        )
+        self.stdout.write("-" * 60)
+
+        for log in error_logs:
+            subscriber_name = log.subscription.subscriber.name
+            event_name = log.subscription.event_name
+
+            if log.error_message:
+                error_info = f"Exception: {log.error_message[:100]}"
+            else:
+                error_info = f"HTTP {log.response_status}"
+
+            self.stdout.write(
+                f"{log.created_at.strftime('%Y-%m-%d %H:%M')} | "
+                f"{subscriber_name} - {event_name} | {error_info}"
+            )