django-cfg 1.4.58__py3-none-any.whl → 1.4.60__py3-none-any.whl

django_cfg/apps/ipc/admin.py

@@ -0,0 +1,212 @@
+"""
+Django Admin for IPC/RPC models.
+
+Uses PydanticAdmin with declarative configuration.
+"""
+
+import json
+
+from django.contrib import admin
+from django_cfg.modules.django_admin import (
+    AdminConfig,
+    BadgeField,
+    DateTimeField,
+    Icons,
+    UserField,
+    computed_field,
+)
+from django_cfg.modules.django_admin.base import PydanticAdmin
+
+from .models import RPCLog
+
+
+# Declarative configuration for RPCLog
+rpclog_config = AdminConfig(
+    model=RPCLog,
+
+    # Performance optimization
+    select_related=["user"],
+
+    # List display
+    list_display=[
+        "method",
+        "status",
+        "user",
+        "duration_ms",
+        "created_at",
+        "completed_at"
+    ],
+
+    # Auto-generated display methods
+    display_fields=[
+        BadgeField(
+            name="method",
+            title="RPC Method",
+            variant="info",
+            icon=Icons.API
+        ),
+        BadgeField(
+            name="status",
+            title="Status",
+            label_map={
+                "pending": "warning",
+                "success": "success",
+                "failed": "danger",
+                "timeout": "danger"
+            }
+        ),
+        UserField(
+            name="user",
+            title="User",
+            header=True  # Show with avatar
+        ),
+        DateTimeField(
+            name="created_at",
+            title="Created",
+            ordering="created_at"
+        ),
+        DateTimeField(
+            name="completed_at",
+            title="Completed",
+            ordering="completed_at"
+        ),
+    ],
+
+    # Filters
+    list_filter=["status", "method", "created_at"],
+    search_fields=["method", "correlation_id", "user__username", "user__email", "error_message"],
+
+    # Readonly fields (custom methods below)
+    readonly_fields=[
+        "id",
+        "correlation_id",
+        "created_at",
+        "completed_at",
+        "params_display",
+        "response_display",
+        "error_details_display"
+    ],
+
+    # Date hierarchy
+    date_hierarchy="created_at",
+
+    # Per page
+    list_per_page=50,
+)
+
+
+@admin.register(RPCLog)
+class RPCLogAdmin(PydanticAdmin):
+    """
+    RPC log admin with analytics and filtering.
+
+    Features:
+    - Color-coded status badges
+    - Duration display with performance indicators
+    - Formatted JSON for params/response
+    - Error details with highlighted display
+    """
+    config = rpclog_config
+
+    @computed_field("Duration", ordering="duration_ms")
+    def duration_display(self, obj):
+        """Display duration with color coding based on speed."""
+        if obj.duration_ms is None:
+            return self.html.empty()
+
+        # Color code based on duration
+        if obj.duration_ms < 100:
+            variant = "success"  # Fast
+            icon = Icons.SPEED
+        elif obj.duration_ms < 500:
+            variant = "warning"  # Moderate
+            icon = Icons.TIMER
+        else:
+            variant = "danger"  # Slow
+            icon = Icons.ERROR
+
+        return self.html.badge(
+            f"{obj.duration_ms}ms",
+            variant=variant,
+            icon=icon
+        )
+
+    def params_display(self, obj):
+        """Display formatted JSON params."""
+        if not obj.params:
+            return self.html.empty("No parameters")
+
+        try:
+            formatted = json.dumps(obj.params, indent=2)
+            return f'<pre style="background: #f5f5f5; padding: 10px; border-radius: 4px; max-height: 400px; overflow: auto; font-size: 12px; line-height: 1.5;">{formatted}</pre>'
+        except Exception:
+            return str(obj.params)
+
+    params_display.short_description = "Request Parameters"
+
+    def response_display(self, obj):
+        """Display formatted JSON response."""
+        if not obj.response:
+            return self.html.empty("No response")
+
+        try:
+            formatted = json.dumps(obj.response, indent=2)
+            return f'<pre style="background: #f5f5f5; padding: 10px; border-radius: 4px; max-height: 400px; overflow: auto; font-size: 12px; line-height: 1.5;">{formatted}</pre>'
+        except Exception:
+            return str(obj.response)
+
+    response_display.short_description = "Response Data"
+
+    def error_details_display(self, obj):
+        """Display error information if call failed."""
+        if not obj.is_failed:
+            return self.html.inline([
+                self.html.icon(Icons.CHECK_CIRCLE, size="sm"),
+                self.html.span("No errors", "text-green-600")
+            ])
+
+        details = []
+
+        if obj.error_code:
+            details.append(self.html.inline([
+                self.html.span("Error Code:", "font-semibold"),
+                self.html.badge(obj.error_code, variant="danger", icon=Icons.ERROR)
+            ], separator=" "))
+
+        if obj.error_message:
+            details.append(self.html.inline([
+                self.html.span("Message:", "font-semibold"),
+                self.html.span(obj.error_message, "text-red-600")
+            ], separator=" "))
+
+        return "<br>".join(details) if details else self.html.empty()
+
+    error_details_display.short_description = "Error Details"
+
+    # Fieldsets for detail view
+    def get_fieldsets(self, request, obj=None):
+        """Dynamic fieldsets based on object state."""
+        fieldsets = [
+            ("RPC Call Information", {
+                'fields': ('id', 'correlation_id', 'method', 'user', 'status')
+            }),
+            ("Request & Response", {
+                'fields': ('params_display', 'response_display'),
+                'classes': ('collapse',)
+            }),
+            ("Performance", {
+                'fields': ('duration_ms', 'created_at', 'completed_at')
+            }),
+            ("Metadata", {
+                'fields': ('caller_ip', 'user_agent'),
+                'classes': ('collapse',)
+            }),
+        ]
+
+        # Add error section only if failed
+        if obj and obj.is_failed:
+            fieldsets.insert(2, ("Error Details", {
+                'fields': ('error_details_display', 'error_code', 'error_message')
+            }))
+
+        return fieldsets

django_cfg/apps/ipc/migrations/0001_initial.py

@@ -0,0 +1,137 @@
+# Generated by Django 5.2.7 on 2025-10-23 12:12
+
+import django.db.models.deletion
+import django.utils.timezone
+import uuid
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="RPCLog",
+            fields=[
+                (
+                    "id",
+                    models.UUIDField(
+                        default=uuid.uuid4, editable=False, primary_key=True, serialize=False
+                    ),
+                ),
+                (
+                    "correlation_id",
+                    models.CharField(
+                        db_index=True,
+                        help_text="UUID from RPC request",
+                        max_length=100,
+                        verbose_name="Correlation ID",
+                    ),
+                ),
+                (
+                    "method",
+                    models.CharField(
+                        db_index=True,
+                        help_text="e.g., send_notification, workspace.file_changed",
+                        max_length=100,
+                        verbose_name="RPC Method",
+                    ),
+                ),
+                (
+                    "params",
+                    models.JSONField(
+                        help_text="Parameters sent to RPC method", verbose_name="Request Params"
+                    ),
+                ),
+                (
+                    "response",
+                    models.JSONField(
+                        blank=True,
+                        help_text="Result from RPC call",
+                        null=True,
+                        verbose_name="Response Data",
+                    ),
+                ),
+                (
+                    "status",
+                    models.CharField(
+                        choices=[
+                            ("pending", "Pending"),
+                            ("success", "Success"),
+                            ("failed", "Failed"),
+                            ("timeout", "Timeout"),
+                        ],
+                        db_index=True,
+                        default="pending",
+                        max_length=20,
+                        verbose_name="Status",
+                    ),
+                ),
+                (
+                    "error_code",
+                    models.CharField(
+                        blank=True, max_length=50, null=True, verbose_name="Error Code"
+                    ),
+                ),
+                (
+                    "error_message",
+                    models.TextField(blank=True, null=True, verbose_name="Error Message"),
+                ),
+                (
+                    "duration_ms",
+                    models.IntegerField(
+                        blank=True,
+                        help_text="Time taken for RPC call in milliseconds",
+                        null=True,
+                        verbose_name="Duration (ms)",
+                    ),
+                ),
+                (
+                    "caller_ip",
+                    models.GenericIPAddressField(blank=True, null=True, verbose_name="Caller IP"),
+                ),
+                ("user_agent", models.TextField(blank=True, null=True, verbose_name="User Agent")),
+                (
+                    "created_at",
+                    models.DateTimeField(
+                        db_index=True, default=django.utils.timezone.now, verbose_name="Created At"
+                    ),
+                ),
+                (
+                    "completed_at",
+                    models.DateTimeField(blank=True, null=True, verbose_name="Completed At"),
+                ),
+                (
+                    "user",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        related_name="rpc_logs",
+                        to=settings.AUTH_USER_MODEL,
+                        verbose_name="User",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "RPC Log",
+                "verbose_name_plural": "RPC Logs",
+                "ordering": ["-created_at"],
+                "indexes": [
+                    models.Index(fields=["method", "status"], name="django_cfg__method_916fd9_idx"),
+                    models.Index(
+                        fields=["status", "created_at"], name="django_cfg__status_ee629e_idx"
+                    ),
+                    models.Index(fields=["correlation_id"], name="django_cfg__correla_fc7bcf_idx"),
+                    models.Index(
+                        fields=["user", "created_at"], name="django_cfg__user_id_c33866_idx"
+                    ),
+                ],
+            },
+        ),
+    ]

django_cfg/apps/ipc/models.py

@@ -0,0 +1,221 @@
+"""
+IPC/RPC Models for logging and monitoring.
+
+Models:
+- RPCLog: Log of all RPC calls for debugging and analytics
+"""
+
+import uuid
+from django.conf import settings
+from django.db import models
+from django.utils import timezone
+
+
+class RPCLogManager(models.Manager):
+    """Custom manager for RPCLog model."""
+
+    def recent(self, hours=24):
+        """Get logs from last N hours."""
+        since = timezone.now() - timezone.timedelta(hours=hours)
+        return self.filter(created_at__gte=since)
+
+    def failed(self):
+        """Get failed RPC calls."""
+        return self.filter(status=RPCLog.StatusChoices.FAILED)
+
+    def by_method(self, method):
+        """Get logs for specific RPC method."""
+        return self.filter(method=method)
+
+    def stats_by_method(self):
+        """
+        Get statistics grouped by method.
+
+        Returns:
+            QuerySet with aggregated data per method
+        """
+        from django.db.models import Count, Avg, Max, Min
+
+        return self.values('method').annotate(
+            total_calls=Count('id'),
+            avg_duration_ms=Avg('duration_ms'),
+            max_duration_ms=Max('duration_ms'),
+            min_duration_ms=Min('duration_ms'),
+            success_count=Count('id', filter=models.Q(status='success')),
+            failed_count=Count('id', filter=models.Q(status='failed')),
+        ).order_by('-total_calls')
+
+
+class RPCLog(models.Model):
+    """
+    Log of RPC calls between Django and WebSocket server.
+
+    Used for:
+    - Debugging RPC communication
+    - Performance monitoring
+    - Analytics (most used methods, success rate)
+    - Audit trail (who called what and when)
+    """
+
+    class StatusChoices(models.TextChoices):
+        PENDING = 'pending', 'Pending'
+        SUCCESS = 'success', 'Success'
+        FAILED = 'failed', 'Failed'
+        TIMEOUT = 'timeout', 'Timeout'
+
+    # Primary key
+    id = models.UUIDField(
+        primary_key=True,
+        default=uuid.uuid4,
+        editable=False
+    )
+
+    # Correlation ID (matches RPC correlation_id)
+    correlation_id = models.CharField(
+        max_length=100,
+        db_index=True,
+        verbose_name="Correlation ID",
+        help_text="UUID from RPC request"
+    )
+
+    # User who initiated the call (optional)
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name='rpc_logs',
+        verbose_name="User"
+    )
+
+    # RPC method name
+    method = models.CharField(
+        max_length=100,
+        db_index=True,
+        verbose_name="RPC Method",
+        help_text="e.g., send_notification, workspace.file_changed"
+    )
+
+    # Request parameters (JSON)
+    params = models.JSONField(
+        verbose_name="Request Params",
+        help_text="Parameters sent to RPC method"
+    )
+
+    # Response data (JSON, nullable if failed)
+    response = models.JSONField(
+        null=True,
+        blank=True,
+        verbose_name="Response Data",
+        help_text="Result from RPC call"
+    )
+
+    # Status
+    status = models.CharField(
+        max_length=20,
+        choices=StatusChoices.choices,
+        default=StatusChoices.PENDING,
+        db_index=True,
+        verbose_name="Status"
+    )
+
+    # Error details (if failed)
+    error_code = models.CharField(
+        max_length=50,
+        null=True,
+        blank=True,
+        verbose_name="Error Code"
+    )
+    error_message = models.TextField(
+        null=True,
+        blank=True,
+        verbose_name="Error Message"
+    )
+
+    # Performance metrics
+    duration_ms = models.IntegerField(
+        null=True,
+        blank=True,
+        verbose_name="Duration (ms)",
+        help_text="Time taken for RPC call in milliseconds"
+    )
+
+    # Metadata
+    caller_ip = models.GenericIPAddressField(
+        null=True,
+        blank=True,
+        verbose_name="Caller IP"
+    )
+    user_agent = models.TextField(
+        null=True,
+        blank=True,
+        verbose_name="User Agent"
+    )
+
+    # Timestamps
+    created_at = models.DateTimeField(
+        default=timezone.now,
+        db_index=True,
+        verbose_name="Created At"
+    )
+    completed_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        verbose_name="Completed At"
+    )
+
+    # Custom manager
+    objects = RPCLogManager()
+
+    class Meta:
+        app_label = 'django_cfg_ipc'
+        verbose_name = "RPC Log"
+        verbose_name_plural = "RPC Logs"
+        ordering = ['-created_at']
+        indexes = [
+            models.Index(fields=['method', 'status']),
+            models.Index(fields=['status', 'created_at']),
+            models.Index(fields=['correlation_id']),
+            models.Index(fields=['user', 'created_at']),
+        ]
+
+    def __str__(self):
+        return f"{self.method} ({self.status}) - {self.created_at.strftime('%Y-%m-%d %H:%M:%S')}"
+
+    @property
+    def is_successful(self):
+        """Check if RPC call was successful."""
+        return self.status == self.StatusChoices.SUCCESS
+
+    @property
+    def is_failed(self):
+        """Check if RPC call failed."""
+        return self.status in [self.StatusChoices.FAILED, self.StatusChoices.TIMEOUT]
+
+    def mark_success(self, response_data, duration_ms=None):
+        """Mark RPC call as successful."""
+        self.status = self.StatusChoices.SUCCESS
+        self.response = response_data
+        self.completed_at = timezone.now()
+        if duration_ms is not None:
+            self.duration_ms = duration_ms
+        self.save()
+
+    def mark_failed(self, error_code, error_message, duration_ms=None):
+        """Mark RPC call as failed."""
+        self.status = self.StatusChoices.FAILED
+        self.error_code = error_code
+        self.error_message = error_message
+        self.completed_at = timezone.now()
+        if duration_ms is not None:
+            self.duration_ms = duration_ms
+        self.save()
+
+    def mark_timeout(self, timeout_seconds):
+        """Mark RPC call as timed out."""
+        self.status = self.StatusChoices.TIMEOUT
+        self.error_code = 'timeout'
+        self.error_message = f'RPC call timed out after {timeout_seconds}s'
+        self.completed_at = timezone.now()
+        self.duration_ms = timeout_seconds * 1000
+        self.save()

django_cfg/apps/ipc/serializers/__init__.py

@@ -4,10 +4,15 @@ Serializers for IPC/RPC module.
 
 from .serializers import (
     HealthCheckSerializer,
+    LoadTestRequestSerializer,
+    LoadTestResponseSerializer,
+    LoadTestStatusSerializer,
     MethodStatsSerializer,
     NotificationStatsSerializer,
     OverviewStatsSerializer,
     RecentRequestsSerializer,
+    TestRPCRequestSerializer,
+    TestRPCResponseSerializer,
 )
 
 __all__ = [
@@ -16,4 +21,9 @@ __all__ = [
     'RecentRequestsSerializer',
     'NotificationStatsSerializer',
     'MethodStatsSerializer',
+    'TestRPCRequestSerializer',
+    'TestRPCResponseSerializer',
+    'LoadTestRequestSerializer',
+    'LoadTestResponseSerializer',
+    'LoadTestStatusSerializer',
 ]