django-cfg 1.4.116__py3-none-any.whl → 1.5.8__py3-none-any.whl

django_cfg/apps/integrations/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/integrations/grpc/apps.py

@@ -0,0 +1,108 @@
+"""
+Django app configuration for gRPC integration.
+"""
+
+from __future__ import annotations
+
+import os
+
+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.integrations.grpc'
+    verbose_name = 'gRPC Integration'
+
+    def ready(self):
+        """
+        Called when Django starts.
+
+        Validates that all required gRPC dependencies are installed.
+        """
+        # Only check dependencies if we're running a command that needs gRPC
+        # (avoid breaking migrations, shell, etc.)
+        self._check_dependencies_if_needed()
+
+        # Import signal handlers if needed
+        # from . import signals
+
+    def _check_dependencies_if_needed(self):
+        """
+        Check gRPC dependencies only when running gRPC-related commands.
+
+        Skips check for:
+        - Migrations (makemigrations, migrate)
+        - Shell commands (shell, shell_plus)
+        - Test discovery (test --help)
+        - Django checks (check)
+        - Management command listing (help)
+        """
+        import sys
+
+        # Get command name from sys.argv
+        if len(sys.argv) < 2:
+            return
+
+        command = sys.argv[1]
+
+        # Commands that don't need gRPC dependencies
+        skip_commands = [
+            'makemigrations',
+            'migrate',
+            'shell',
+            'shell_plus',
+            'check',
+            'help',
+            'test',
+            'collectstatic',
+            'createsuperuser',
+            'changepassword',
+            'showmigrations',
+            'sqlmigrate',
+            'inspectdb',
+        ]
+
+        # Skip check for these commands
+        if command in skip_commands:
+            return
+
+        # Also skip if running tests (pytest, nose, etc.)
+        if 'test' in sys.argv or 'pytest' in sys.argv[0]:
+            return
+
+        # Skip if DJANGO_SKIP_GRPC_CHECK environment variable is set
+        if os.environ.get('DJANGO_SKIP_GRPC_CHECK', '').lower() in ('1', 'true', 'yes'):
+            return
+
+        # For 'rungrpc' command, perform strict check
+        if command == 'rungrpc':
+            from ._cfg import check_grpc_dependencies
+            try:
+                check_grpc_dependencies(raise_on_missing=True)
+            except Exception as e:
+                # Print error and exit
+                print(str(e))
+                sys.exit(1)
+
+        # For other commands, perform silent check (just import validation)
+        # This ensures basic imports work but doesn't block the command
+        else:
+            from ._cfg import check_grpc_dependencies
+            try:
+                # Silent check - only validates that checker itself works
+                check_grpc_dependencies(raise_on_missing=False)
+            except Exception:
+                # Silently ignore - don't break other commands
+                pass

django_cfg/apps/integrations/grpc/auth/__init__.py

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

django_cfg/apps/integrations/grpc/auth/jwt_auth.py

@@ -0,0 +1,295 @@
+"""
+JWT Authentication Interceptor for gRPC.
+
+Handles JWT token verification and Django user authentication for gRPC requests.
+"""
+
+import logging
+from typing import Any, Callable, Optional
+
+import grpc
+from django.conf import settings
+from django.contrib.auth import get_user_model
+
+logger = logging.getLogger(__name__)
+
+User = get_user_model()
+
+
+class JWTAuthInterceptor(grpc.ServerInterceptor):
+    """
+    gRPC interceptor for JWT authentication.
+
+    Features:
+    - Extracts JWT token from metadata
+    - Verifies token signature and expiration
+    - Loads Django user from token
+    - Sets user on request context
+    - Supports public methods whitelist
+    - Handles authentication errors gracefully
+
+    Example:
+        ```python
+        # In Django settings (auto-configured by django-cfg)
+        GRPC_FRAMEWORK = {
+            "SERVER_INTERCEPTORS": [
+                "django_cfg.apps.integrations.grpc.auth.JWTAuthInterceptor",
+            ]
+        }
+        ```
+
+    Token Format:
+        Authorization: Bearer <jwt_token>
+    """
+
+    def __init__(self):
+        """Initialize JWT authentication interceptor."""
+        self.grpc_auth_config = getattr(settings, "GRPC_AUTH", {})
+        self.enabled = self.grpc_auth_config.get("enabled", True)
+        self.require_auth = self.grpc_auth_config.get("require_auth", True)
+        self.token_header = self.grpc_auth_config.get("token_header", "authorization")
+        self.token_prefix = self.grpc_auth_config.get("token_prefix", "Bearer")
+        self.public_methods = self.grpc_auth_config.get("public_methods", [
+            "/grpc.health.v1.Health/Check",
+            "/grpc.health.v1.Health/Watch",
+        ])
+
+        # JWT settings
+        self.jwt_secret_key = self.grpc_auth_config.get("jwt_secret_key") or settings.SECRET_KEY
+        self.jwt_algorithm = self.grpc_auth_config.get("jwt_algorithm", "HS256")
+        self.jwt_verify_exp = self.grpc_auth_config.get("jwt_verify_exp", True)
+        self.jwt_leeway = self.grpc_auth_config.get("jwt_leeway", 0)
+
+    def intercept_service(self, continuation: Callable, handler_call_details: grpc.HandlerCallDetails) -> grpc.RpcMethodHandler:
+        """
+        Intercept gRPC service call for authentication.
+
+        Args:
+            continuation: Function to invoke the next interceptor or handler
+            handler_call_details: Details about the RPC call
+
+        Returns:
+            RPC method handler (possibly wrapped with auth)
+        """
+        # Skip if auth is disabled
+        if not self.enabled:
+            return continuation(handler_call_details)
+
+        # Check if method is public
+        method_name = handler_call_details.method
+        if method_name in self.public_methods:
+            logger.debug(f"Public method accessed: {method_name}")
+            return continuation(handler_call_details)
+
+        # Extract token from metadata
+        token = self._extract_token(handler_call_details.invocation_metadata)
+
+        # If no token and auth is required, abort
+        if not token:
+            if self.require_auth:
+                logger.warning(f"Missing authentication token for {method_name}")
+                return self._abort_unauthenticated(
+                    "Authentication token is required"
+                )
+            else:
+                # Allow anonymous access
+                logger.debug(f"No token provided for {method_name}, allowing anonymous access")
+                return continuation(handler_call_details)
+
+        # Verify token and get user
+        user = self._verify_token(token)
+
+        if not user:
+            if self.require_auth:
+                logger.warning(f"Invalid authentication token for {method_name}")
+                return self._abort_unauthenticated(
+                    "Invalid or expired authentication token"
+                )
+            else:
+                # Allow anonymous access even with invalid token
+                return continuation(handler_call_details)
+
+        # Add user to context and continue
+        logger.debug(f"Authenticated user {user.id} for {method_name}")
+        return self._continue_with_user(continuation, handler_call_details, user)
+
+    def _extract_token(self, metadata: tuple) -> Optional[str]:
+        """
+        Extract JWT token from gRPC metadata.
+
+        Args:
+            metadata: gRPC invocation metadata
+
+        Returns:
+            JWT token string or None
+        """
+        if not metadata:
+            return None
+
+        # Convert metadata to dict
+        metadata_dict = dict(metadata)
+
+        # Get authorization header (case-insensitive)
+        auth_header = None
+        for key, value in metadata_dict.items():
+            if key.lower() == self.token_header.lower():
+                auth_header = value
+                break
+
+        if not auth_header:
+            return None
+
+        # Extract token from "Bearer <token>" format
+        if auth_header.startswith(f"{self.token_prefix} "):
+            return auth_header[len(self.token_prefix) + 1:]
+        elif self.token_prefix == "":
+            # No prefix expected
+            return auth_header
+        else:
+            # Invalid format
+            logger.warning(f"Invalid authorization header format: {auth_header[:20]}...")
+            return None
+
+    def _verify_token(self, token: str) -> Optional[User]:
+        """
+        Verify JWT token and return user.
+
+        Args:
+            token: JWT token string
+
+        Returns:
+            Django User instance or None
+        """
+        try:
+            import jwt
+
+            # Decode JWT token
+            payload = jwt.decode(
+                token,
+                self.jwt_secret_key,
+                algorithms=[self.jwt_algorithm],
+                options={
+                    "verify_exp": self.jwt_verify_exp,
+                },
+                leeway=self.jwt_leeway,
+            )
+
+            # Extract user ID from payload
+            user_id = payload.get("user_id")
+            if not user_id:
+                logger.warning("Token missing user_id claim")
+                return None
+
+            # Load user from database
+            try:
+                user = User.objects.get(pk=user_id)
+                if not user.is_active:
+                    logger.warning(f"Inactive user {user_id} attempted to authenticate")
+                    return None
+                return user
+            except User.DoesNotExist:
+                logger.warning(f"User {user_id} from token does not exist")
+                return None
+
+        except jwt.ExpiredSignatureError:
+            logger.warning("JWT token has expired")
+            return None
+        except jwt.InvalidTokenError as e:
+            logger.warning(f"Invalid JWT token: {e}")
+            return None
+        except ImportError:
+            logger.error("PyJWT library not installed. Install with: pip install PyJWT")
+            return None
+        except Exception as e:
+            logger.error(f"Unexpected error verifying token: {e}")
+            return None
+
+    def _continue_with_user(
+        self,
+        continuation: Callable,
+        handler_call_details: grpc.HandlerCallDetails,
+        user: User,
+    ) -> grpc.RpcMethodHandler:
+        """
+        Continue RPC with authenticated user in context.
+
+        Args:
+            continuation: Function to invoke next interceptor or handler
+            handler_call_details: Details about the RPC call
+            user: Authenticated Django user
+
+        Returns:
+            RPC method handler with user context
+        """
+        # Get the handler
+        handler = continuation(handler_call_details)
+
+        if handler is None:
+            return None
+
+        # Wrap the handler to inject user into context
+        def wrapped_unary_unary(request, context):
+            # Set user on context for access in service methods
+            context.user = user
+            return handler.unary_unary(request, context)
+
+        def wrapped_unary_stream(request, context):
+            context.user = user
+            return handler.unary_stream(request, context)
+
+        def wrapped_stream_unary(request_iterator, context):
+            context.user = user
+            return handler.stream_unary(request_iterator, context)
+
+        def wrapped_stream_stream(request_iterator, context):
+            context.user = user
+            return handler.stream_stream(request_iterator, context)
+
+        # Return wrapped handler based on type
+        return grpc.unary_unary_rpc_method_handler(
+            wrapped_unary_unary,
+            request_deserializer=handler.request_deserializer,
+            response_serializer=handler.response_serializer,
+        ) if handler.unary_unary else (
+            grpc.unary_stream_rpc_method_handler(
+                wrapped_unary_stream,
+                request_deserializer=handler.request_deserializer,
+                response_serializer=handler.response_serializer,
+            ) if handler.unary_stream else (
+                grpc.stream_unary_rpc_method_handler(
+                    wrapped_stream_unary,
+                    request_deserializer=handler.request_deserializer,
+                    response_serializer=handler.response_serializer,
+                ) if handler.stream_unary else (
+                    grpc.stream_stream_rpc_method_handler(
+                        wrapped_stream_stream,
+                        request_deserializer=handler.request_deserializer,
+                        response_serializer=handler.response_serializer,
+                    ) if handler.stream_stream else None
+                )
+            )
+        )
+
+    def _abort_unauthenticated(self, message: str) -> grpc.RpcMethodHandler:
+        """
+        Return handler that aborts with UNAUTHENTICATED status.
+
+        Args:
+            message: Error message
+
+        Returns:
+            RPC method handler that aborts
+        """
+        def abort(*args, **kwargs):
+            context = args[1] if len(args) > 1 else None
+            if context:
+                context.abort(grpc.StatusCode.UNAUTHENTICATED, message)
+
+        return grpc.unary_unary_rpc_method_handler(
+            abort,
+            request_deserializer=lambda x: x,
+            response_serializer=lambda x: x,
+        )
+
+
+__all__ = ["JWTAuthInterceptor"]

django_cfg/apps/integrations/grpc/interceptors/__init__.py

@@ -0,0 +1,19 @@
+"""
+gRPC interceptors for logging, metrics, and error handling.
+
+Provides production-ready interceptors for gRPC services.
+"""
+
+from .errors import ErrorHandlingInterceptor
+from .logging import LoggingInterceptor
+from .metrics import MetricsInterceptor, get_metrics, reset_metrics
+from .request_logger import RequestLoggerInterceptor
+
+__all__ = [
+    "LoggingInterceptor",
+    "MetricsInterceptor",
+    "ErrorHandlingInterceptor",
+    "RequestLoggerInterceptor",
+    "get_metrics",
+    "reset_metrics",
+]