django-cfg 1.4.62__py3-none-any.whl → 1.4.64__py3-none-any.whl

django_cfg/apps/ipc/admin.py

@@ -1,232 +0,0 @@
-"""
-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",
-        "type_badge",  # NEW: Show RPC vs Event
-        "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", "is_event", "method", "created_at"],
-    search_fields=["method", "correlation_id", "user__username", "user__email", "error_message"],
-
-    # Autocomplete for user field
-    autocomplete_fields=["user"],
-
-    # 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("Type", ordering="is_event")
-    def type_badge(self, obj):
-        """Display badge showing if this is an RPC call or server event."""
-        if obj.is_event:
-            return self.html.badge(
-                "EVENT",
-                variant="info",
-                icon=Icons.NOTIFICATION  # or Icons.BROADCAST
-            )
-        else:
-            return self.html.badge(
-                "RPC",
-                variant="primary",
-                icon=Icons.API
-            )
-
-    @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/apps.py

@@ -1,98 +0,0 @@
-"""
-Django app configuration for IPC/RPC module.
-
-Provides RPC client and monitoring dashboard.
-"""
-
-import asyncio
-from django.apps import AppConfig
-from django.conf import settings
-
-
-class IPCConfig(AppConfig):
-    """
-    IPC/RPC application configuration.
-
-    Provides:
-    - RPC client for inter-service communication
-    - Monitoring dashboard with real-time stats
-    - DRF API endpoints for dashboard
-    - RPC log consumer (Redis Stream -> ORM)
-    """
-
-    default_auto_field = 'django.db.models.BigAutoField'
-    name = 'django_cfg.apps.ipc'
-    label = 'django_cfg_ipc'
-    verbose_name = 'IPC/RPC System'
-
-    def ready(self):
-        """Initialize app when Django starts."""
-        # Import monitor to ensure Redis connection is initialized
-        from .services import monitor  # noqa: F401
-
-        # Start RPC Log Consumer in background (if enabled)
-        self._start_rpc_log_consumer()
-
-    def _start_rpc_log_consumer(self):
-        """Start RPC Log Consumer to capture logs from WebSocket server."""
-        # Check if RPC logging consumer is enabled
-        enable_consumer = getattr(settings, 'DJANGO_CFG_RPC_LOG_CONSUMER_ENABLED', True)
-
-        if not enable_consumer:
-            return
-
-        # Check if we have RPC configuration
-        if not hasattr(settings, 'DJANGO_CFG_RPC'):
-            return
-
-        # Check if RPC is enabled (case-insensitive)
-        rpc_enabled = settings.DJANGO_CFG_RPC.get('ENABLED') or settings.DJANGO_CFG_RPC.get('enabled')
-        if not rpc_enabled:
-            return
-
-        try:
-            import threading
-            from .services.rpc_log_consumer import RPCLogConsumer
-
-            # Get Redis URL (case-insensitive)
-            redis_url = settings.DJANGO_CFG_RPC.get('REDIS_URL') or settings.DJANGO_CFG_RPC.get('redis_url', 'redis://localhost:6379/2')
-
-            consumer = RPCLogConsumer(
-                redis_url=redis_url,
-                stream_name="stream:rpc-logs",
-                consumer_group="django-rpc-loggers",
-                consumer_name="django-1",
-            )
-
-            # Run consumer in background thread with its own event loop
-            def run_consumer():
-                """Run consumer in background thread."""
-                try:
-                    # Create new event loop for this thread
-                    loop = asyncio.new_event_loop()
-                    asyncio.set_event_loop(loop)
-
-                    # Initialize and start consumer
-                    loop.run_until_complete(consumer.initialize())
-                    loop.run_until_complete(consumer.start())
-
-                    # Keep running
-                    loop.run_forever()
-
-                except Exception as e:
-                    from django_cfg.modules.django_logging import get_logger
-                    logger = get_logger("ipc.consumer")
-                    logger.error(f"RPC Log Consumer error: {e}", exc_info=True)
-
-            # Start in daemon thread (won't block Django shutdown)
-            thread = threading.Thread(target=run_consumer, daemon=True, name="rpc-log-consumer")
-            thread.start()
-
-            from django_cfg.modules.django_logging import get_logger
-            logger = get_logger("ipc.apps")
-            logger.info("✅ RPC Log Consumer started in background thread")
-
-        except Exception as e:
-            from django_cfg.modules.django_logging import get_logger
-            logger = get_logger("ipc.apps")
-            logger.warning(f"Failed to start RPC Log Consumer: {e}")

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

@@ -1,137 +0,0 @@
-# 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/migrations/0002_rpclog_is_event.py

@@ -1,23 +0,0 @@
-# Generated by Django 5.2.7 on 2025-10-24 07:41
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("django_cfg_ipc", "0001_initial"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="rpclog",
-            name="is_event",
-            field=models.BooleanField(
-                db_index=True,
-                default=False,
-                help_text="True if this is a server-to-client event (not a request-response RPC call)",
-                verbose_name="Is Event",
-            ),
-        ),
-    ]