django-cfg 1.4.120__py3-none-any.whl → 1.5.2__py3-none-any.whl

django_cfg/apps/dashboard/views/overview_views.py

@@ -8,6 +8,7 @@ Endpoint for complete dashboard overview:
 import logging
 from datetime import datetime
 
+from django.db import transaction
 from drf_spectacular.utils import extend_schema
 from rest_framework import status, viewsets
 
@@ -32,6 +33,11 @@ class OverviewViewSet(AdminAPIMixin, viewsets.GenericViewSet):
 
     serializer_class = DashboardOverviewSerializer
 
+    @transaction.non_atomic_requests
+    def dispatch(self, request, *args, **kwargs):
+        """Disable atomic requests for this viewset."""
+        return super().dispatch(request, *args, **kwargs)
+
     @extend_schema(
         summary="Get dashboard overview",
         description="Retrieve complete dashboard data including stats, health, actions, and metrics",
@@ -40,24 +46,19 @@ class OverviewViewSet(AdminAPIMixin, viewsets.GenericViewSet):
     )
     @action(detail=False, methods=['get'], url_path='', url_name='overview')
     def overview(self, request):
-        """
-        Get complete dashboard overview.
-
-        Returns all dashboard data in a single request:
-        - Statistics cards
-        - System health status
-        - Quick actions
-        - Recent activity
-        - System metrics
-        - User statistics
-        """
+        """Get complete dashboard overview."""
         try:
             stats_service = StatisticsService()
             health_service = SystemHealthService()
             charts_service = ChartsService()
 
-            # Get app statistics and convert to list format
-            app_stats_dict = stats_service.get_app_statistics()
+            # Get app statistics - wrapped in try/except since it queries all models
+            try:
+                app_stats_dict = stats_service.get_app_statistics()
+            except Exception as e:
+                logger.error(f"Error getting app stats: {e}")
+                app_stats_dict = {'apps': {}}
+
             app_statistics_list = [
                 {
                     'app_name': app_label,

django_cfg/apps/grpc/__init__.py

@@ -0,0 +1,9 @@
+"""
+django_cfg.apps.grpc
+
+gRPC integration for django-cfg with Django ORM, JWT auth, monitoring, and admin interface.
+"""
+
+default_app_config = 'django_cfg.apps.grpc.apps.GRPCAppConfig'
+
+__version__ = '1.0.0'

django_cfg/apps/grpc/admin/__init__.py

@@ -0,0 +1,11 @@
+"""
+Admin interface for gRPC app.
+"""
+
+from .config import grpcrequestlog_config
+from .grpc_request_log import GRPCRequestLogAdmin
+
+__all__ = [
+    "GRPCRequestLogAdmin",
+    "grpcrequestlog_config",
+]

django_cfg/apps/{tasks → grpc}/admin/config.py

@@ -1,5 +1,5 @@
 """
-Admin configuration for Task models.
+Admin configuration for gRPC models.
 
 Declarative AdminConfig using PydanticAdmin patterns.
 """
@@ -12,87 +12,78 @@ from django_cfg.modules.django_admin import (
     UserField,
 )
 
-from ..models import TaskLog
+from ..models import GRPCRequestLog
 
 
-# Declarative configuration for TaskLog
-tasklog_config = AdminConfig(
-    model=TaskLog,
-
+# Declarative configuration for GRPCRequestLog
+grpcrequestlog_config = AdminConfig(
+    model=GRPCRequestLog,
     # Performance optimization
     select_related=["user"],
 
     # List display
     list_display=[
-        "task_name",
-        "queue_badge",
-        "status_badge",
+        "full_method",
+        "service_badge",
+        "method_badge",
+        "status",
+        "grpc_status_code_display",
         "user",
         "duration_display",
-        "retry_count",
         "created_at",
-        "completed_at",
+        "completed_at"
     ],
 
     # Auto-generated display methods
     display_fields=[
-        BadgeField(
-            name="queue_name",
-            title="Queue",
-            variant="info",
-            icon=Icons.LAYERS,
-        ),
+        BadgeField(name="service_name", title="Service", variant="info", icon=Icons.API),
+        BadgeField(name="method_name", title="Method", variant="secondary", icon=Icons.CODE),
         BadgeField(
             name="status",
             title="Status",
             label_map={
-                "queued": "secondary",
-                "in_progress": "info",
-                "completed": "success",
-                "failed": "danger",
-                "canceled": "warning",
+                "pending": "warning",
+                "success": "success",
+                "error": "danger",
+                "cancelled": "secondary",
+                "timeout": "danger",
             },
         ),
         UserField(name="user", title="User", header=True),
         DateTimeField(name="created_at", title="Created", ordering="created_at"),
-        DateTimeField(name="started_at", title="Started", ordering="started_at"),
         DateTimeField(name="completed_at", title="Completed", ordering="completed_at"),
     ],
-
     # Filters
-    list_filter=["status", "task_name", "queue_name", "created_at"],
+    list_filter=["status", "grpc_status_code", "service_name", "method_name", "is_authenticated", "created_at"],
     search_fields=[
-        "job_id",
-        "task_name",
-        "worker_id",
-        "error_message",
+        "request_id",
+        "service_name",
+        "method_name",
+        "full_method",
         "user__username",
         "user__email",
+        "error_message",
+        "client_ip",
     ],
-
     # Autocomplete for user field
     autocomplete_fields=["user"],
-
     # Readonly fields
     readonly_fields=[
         "id",
-        "job_id",
+        "request_id",
         "created_at",
-        "started_at",
         "completed_at",
-        "duration_ms",
-        "worker_id",
+        "request_data_display",
+        "response_data_display",
+        "error_details_display",
+        "performance_stats_display",
+        "client_info_display",
     ],
-
     # Date hierarchy
     date_hierarchy="created_at",
-
     # Per page
     list_per_page=50,
-
-    # Ordering
-    ordering=["-created_at"],
 )
 
 
-__all__ = ["tasklog_config"]
+__all__ = ["grpcrequestlog_config"]

django_cfg/apps/grpc/admin/grpc_request_log.py

@@ -0,0 +1,252 @@
+"""
+gRPC Request Log Admin.
+
+PydanticAdmin for GRPCRequestLog model with custom computed fields.
+"""
+
+import json
+
+from django.contrib import admin
+from django_cfg.modules.django_admin import Icons, computed_field
+from django_cfg.modules.django_admin.base import PydanticAdmin
+
+from ..models import GRPCRequestLog
+from .config import grpcrequestlog_config
+
+
+@admin.register(GRPCRequestLog)
+class GRPCRequestLogAdmin(PydanticAdmin):
+    """
+    gRPC request log admin with analytics and filtering.
+
+    Features:
+    - Color-coded status badges
+    - Performance metrics visualization
+    - Duration display with performance indicators
+    - Formatted JSON for request/response data
+    - Error details with highlighted display
+    """
+
+    config = grpcrequestlog_config
+
+    @computed_field("Service", ordering="service_name")
+    def service_badge(self, obj):
+        """Display service name as badge."""
+        return self.html.badge(obj.service_name, variant="info", icon=Icons.API)
+
+    @computed_field("Method", ordering="method_name")
+    def method_badge(self, obj):
+        """Display method name as badge."""
+        return self.html.badge(obj.method_name, variant="secondary", icon=Icons.CODE)
+
+    @computed_field("gRPC Status", ordering="grpc_status_code")
+    def grpc_status_code_display(self, obj):
+        """Display gRPC status code with color coding."""
+        if not obj.grpc_status_code:
+            return self.html.empty()
+
+        # Color code based on status
+        if obj.grpc_status_code == "OK":
+            variant = "success"
+            icon = Icons.CHECK_CIRCLE
+        elif obj.grpc_status_code in ["CANCELLED", "DEADLINE_EXCEEDED"]:
+            variant = "warning"
+            icon = Icons.TIMER
+        else:
+            variant = "danger"
+            icon = Icons.ERROR
+
+        return self.html.badge(obj.grpc_status_code, variant=variant, icon=icon)
+
+    @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 < 1000:
+            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 request_data_display(self, obj):
+        """Display formatted JSON request data."""
+        if not obj.request_data:
+            return self.html.empty("No request data logged")
+
+        try:
+            formatted = json.dumps(obj.request_data, indent=2)
+            return self.html.code_block(formatted, language="json", max_height="400px")
+        except Exception:
+            return str(obj.request_data)
+
+    request_data_display.short_description = "Request Data"
+
+    def response_data_display(self, obj):
+        """Display formatted JSON response data."""
+        if not obj.response_data:
+            return self.html.empty("No response data logged")
+
+        try:
+            formatted = json.dumps(obj.response_data, indent=2)
+            return self.html.code_block(formatted, language="json", max_height="400px")
+        except Exception:
+            return str(obj.response_data)
+
+    response_data_display.short_description = "Response Data"
+
+    def error_details_display(self, obj):
+        """Display error information if request failed."""
+        if obj.is_successful or obj.status == "pending":
+            return self.html.inline(
+                self.html.icon(Icons.CHECK_CIRCLE, size="sm"),
+                self.html.text("No errors", variant="success"),
+                separator=" "
+            )
+
+        # gRPC status code
+        code_line = self.html.key_value(
+            "gRPC Status",
+            self.html.badge(obj.grpc_status_code, variant="danger", icon=Icons.ERROR)
+        ) if obj.grpc_status_code else None
+
+        # Error message
+        msg_line = self.html.key_value(
+            "Message",
+            self.html.text(obj.error_message, variant="danger")
+        ) if obj.error_message else None
+
+        # Error details
+        details_line = None
+        if obj.error_details:
+            try:
+                formatted = json.dumps(obj.error_details, indent=2)
+                details_line = self.html.key_value(
+                    "Details",
+                    self.html.code_block(formatted, language="json", max_height="200px")
+                )
+            except Exception:
+                pass
+
+        return self.html.breakdown(code_line, msg_line, details_line) if (code_line or msg_line) else self.html.empty()
+
+    error_details_display.short_description = "Error Details"
+
+    def performance_stats_display(self, obj):
+        """Display performance statistics."""
+        # Duration
+        duration_line = self.html.key_value(
+            "Duration",
+            self.html.number(obj.duration_ms, suffix="ms") if obj.duration_ms else "N/A"
+        )
+
+        # Request size
+        request_size_line = self.html.key_value(
+            "Request Size",
+            self.html.number(obj.request_size, suffix=" bytes") if obj.request_size else "N/A"
+        )
+
+        # Response size
+        response_size_line = self.html.key_value(
+            "Response Size",
+            self.html.number(obj.response_size, suffix=" bytes") if obj.response_size else "N/A"
+        )
+
+        # Authentication
+        auth_line = self.html.key_value(
+            "Authenticated",
+            self.html.badge("Yes" if obj.is_authenticated else "No",
+                          variant="success" if obj.is_authenticated else "secondary")
+        )
+
+        return self.html.breakdown(duration_line, request_size_line, response_size_line, auth_line)
+
+    performance_stats_display.short_description = "Performance Statistics"
+
+    def client_info_display(self, obj):
+        """Display client information."""
+        # Client IP
+        ip_line = self.html.key_value(
+            "Client IP",
+            obj.client_ip if obj.client_ip else "N/A"
+        )
+
+        # User Agent
+        ua_line = self.html.key_value(
+            "User Agent",
+            obj.user_agent if obj.user_agent else "N/A"
+        )
+
+        # Peer
+        peer_line = self.html.key_value(
+            "Peer",
+            self.html.text(obj.peer, variant="secondary") if obj.peer else "N/A"
+        )
+
+        return self.html.breakdown(ip_line, ua_line, peer_line)
+
+    client_info_display.short_description = "Client Information"
+
+    # Fieldsets for detail view
+    def get_fieldsets(self, request, obj=None):
+        """Dynamic fieldsets based on object state."""
+        fieldsets = [
+            (
+                "Request Information",
+                {"fields": ("id", "request_id", "full_method", "service_name", "method_name", "status")},
+            ),
+            (
+                "User Context",
+                {"fields": ("user", "is_authenticated")},
+            ),
+            (
+                "Performance",
+                {"fields": ("performance_stats_display", "duration_ms", "created_at", "completed_at")},
+            ),
+            (
+                "Client Information",
+                {"fields": ("client_info_display", "client_ip", "user_agent", "peer"), "classes": ("collapse",)},
+            ),
+        ]
+
+        # Add request/response data sections if available
+        if obj and obj.request_data:
+            fieldsets.insert(
+                3,
+                (
+                    "Request Data",
+                    {"fields": ("request_data_display",), "classes": ("collapse",)},
+                ),
+            )
+
+        if obj and obj.response_data:
+            fieldsets.insert(
+                4,
+                (
+                    "Response Data",
+                    {"fields": ("response_data_display",), "classes": ("collapse",)},
+                ),
+            )
+
+        # Add error section only if failed
+        if obj and not obj.is_successful and obj.status != "pending":
+            fieldsets.insert(
+                5,
+                (
+                    "Error Details",
+                    {"fields": ("error_details_display", "grpc_status_code", "error_message", "error_details")},
+                ),
+            )
+
+        return fieldsets
+
+
+__all__ = ["GRPCRequestLogAdmin"]

django_cfg/apps/grpc/apps.py

@@ -0,0 +1,28 @@
+"""
+Django app configuration for gRPC integration.
+"""
+
+from django.apps import AppConfig
+
+
+class GRPCAppConfig(AppConfig):
+    """
+    Django app config for gRPC integration.
+
+    Provides:
+    - gRPC server with Django ORM integration
+    - JWT authentication
+    - Request logging to database
+    - Admin interface for monitoring
+    - REST API for metrics
+    """
+
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'django_cfg.apps.grpc'
+    verbose_name = 'gRPC Integration'
+
+    def ready(self):
+        """Called when Django starts."""
+        # Import signal handlers if needed
+        # from . import signals
+        pass

django_cfg/apps/grpc/auth/__init__.py

@@ -0,0 +1,9 @@
+"""
+gRPC authentication components.
+
+Provides JWT authentication for gRPC services.
+"""
+
+from .jwt_auth import JWTAuthInterceptor
+
+__all__ = ["JWTAuthInterceptor"]