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

django_cfg/apps/integrations/grpc/views/config.py

@@ -0,0 +1,191 @@
+"""
+gRPC Configuration ViewSet.
+
+Provides REST API endpoints for viewing gRPC server configuration and status.
+"""
+
+from datetime import datetime
+
+from django_cfg.mixins import AdminAPIMixin
+from django_cfg.modules.django_logging import get_logger
+from drf_spectacular.utils import extend_schema
+from rest_framework import status, viewsets
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from ..models import GRPCRequestLog, GRPCServerStatus
+from ..serializers.config import GRPCConfigSerializer, GRPCServerInfoSerializer
+from ..services import ServiceDiscovery
+from ..services.config_helper import get_grpc_config, get_grpc_server_config
+
+logger = get_logger("grpc.config")
+
+
+class GRPCConfigViewSet(AdminAPIMixin, viewsets.ViewSet):
+    """
+    ViewSet for gRPC configuration and server information.
+
+    Provides endpoints for:
+    - Configuration view (settings)
+    - Server information (status, services, stats)
+
+    Requires admin authentication (JWT, Session, or Basic Auth).
+    """
+
+    @extend_schema(
+        tags=["gRPC Configuration"],
+        summary="Get gRPC configuration",
+        description="Returns current gRPC server configuration from Django settings.",
+        responses={
+            200: GRPCConfigSerializer,
+        },
+    )
+    @action(detail=False, methods=["get"], url_path="")
+    def config(self, request):
+        """Get gRPC configuration."""
+        try:
+            # Get gRPC config using Pydantic2 pattern
+            grpc_config = get_grpc_config()
+
+            if not grpc_config:
+                return Response(
+                    {"error": "gRPC not configured"},
+                    status=status.HTTP_404_NOT_FOUND,
+                )
+
+            # Count registered services and methods
+            discovery = ServiceDiscovery()
+            registered_services = discovery.get_registered_services()
+            services_count = len(registered_services)
+            methods_count = sum(
+                len(service.get("methods", [])) for service in registered_services
+            )
+
+            # Build config response from Pydantic models
+            config_data = {
+                "server": {
+                    "host": grpc_config.server.host,
+                    "port": grpc_config.server.port,
+                    "enabled": grpc_config.server.enabled,
+                    "max_workers": grpc_config.server.max_workers,
+                    "max_concurrent_rpcs": None,  # Not in current config
+                },
+                "framework": {
+                    "enabled": grpc_config.enabled,
+                    "auto_discover": grpc_config.auto_register_apps,
+                    "services_path": "apps.*.grpc_services",  # Convention
+                    "interceptors": grpc_config.server.interceptors,
+                },
+                "features": {
+                    "jwt_auth": grpc_config.auth.enabled,
+                    "request_logging": True,  # Always on
+                    "metrics": True,  # Always on
+                    "reflection": grpc_config.server.enable_reflection,
+                },
+                "registered_services": services_count,
+                "total_methods": methods_count,
+            }
+
+            serializer = GRPCConfigSerializer(**config_data)
+            return Response(serializer.model_dump())
+
+        except Exception as e:
+            logger.error(f"Config fetch error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Configuration"],
+        summary="Get server information",
+        description="Returns detailed information about gRPC server, services, and runtime statistics.",
+        responses={
+            200: GRPCServerInfoSerializer,
+        },
+    )
+    @action(detail=False, methods=["get"], url_path="server-info")
+    def server_info(self, request):
+        """Get gRPC server information."""
+        try:
+            # Get gRPC config using Pydantic2 pattern
+            grpc_config = get_grpc_config()
+
+            if not grpc_config:
+                return Response(
+                    {"error": "gRPC not configured"},
+                    status=status.HTTP_404_NOT_FOUND,
+                )
+
+            # Get registered services
+            discovery = ServiceDiscovery()
+            services = discovery.get_registered_services()
+
+            # Format services info
+            services_info = []
+            for service in services:
+                services_info.append(
+                    {
+                        "name": service.get("name"),
+                        "methods": service.get("methods", []),
+                        "full_name": service.get("full_name"),
+                        "description": service.get("description", ""),
+                    }
+                )
+
+            # Get interceptors info from config
+            interceptors = []
+            for interceptor_path in grpc_config.server.interceptors:
+                interceptor_name = interceptor_path.split(".")[-1]
+                interceptors.append(
+                    {
+                        "name": interceptor_name,
+                        "enabled": True,
+                    }
+                )
+
+            # Get statistics from GRPCRequestLog
+            stats = GRPCRequestLog.objects.get_statistics(hours=24)
+
+            # Server info from config
+            address = f"{grpc_config.server.host}:{grpc_config.server.port}"
+
+            # Get current server status from database
+            current_server = GRPCServerStatus.objects.get_current_server(address=address)
+
+            # Determine server status
+            if current_server and current_server.is_running:
+                server_status_str = current_server.status
+                started_at = current_server.started_at.isoformat() if current_server.started_at else None
+                uptime_seconds = current_server.uptime_seconds
+            else:
+                server_status_str = "stopped"
+                started_at = None
+                uptime_seconds = None
+
+            server_info_data = {
+                "server_status": server_status_str,
+                "address": address,
+                "started_at": started_at,
+                "uptime_seconds": uptime_seconds,
+                "services": services_info,
+                "interceptors": interceptors,
+                "stats": {
+                    "total_requests": stats.get("total_requests", 0),
+                    "success_rate": stats.get("success_rate", 0),
+                    "avg_duration_ms": stats.get("avg_duration", 0),
+                },
+            }
+
+            serializer = GRPCServerInfoSerializer(**server_info_data)
+            return Response(serializer.model_dump())
+
+        except Exception as e:
+            logger.error(f"Server info error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+__all__ = ["GRPCConfigViewSet"]

django_cfg/apps/integrations/grpc/views/monitoring.py

@@ -0,0 +1,388 @@
+"""
+gRPC Monitoring ViewSet.
+
+Provides REST API endpoints for monitoring gRPC request statistics.
+"""
+
+from datetime import datetime
+
+from django.conf import settings
+from django.db import models
+from django.db.models import Avg, Count, Max
+from django.db.models.functions import TruncDay, TruncHour
+from django_cfg.mixins import AdminAPIMixin
+from django_cfg.modules.django_logging import get_logger
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import OpenApiParameter, extend_schema
+from rest_framework import status, viewsets
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from ..models import GRPCRequestLog
+from ..serializers import (
+    GRPCHealthCheckSerializer,
+    GRPCOverviewStatsSerializer,
+    MethodListSerializer,
+    MethodStatsSerializer,
+    MonitoringServiceStatsSerializer,
+    ServiceListSerializer,
+)
+from ..serializers.service_registry import RecentRequestSerializer
+from ..services import MonitoringService
+
+logger = get_logger("grpc.monitoring")
+
+
+class GRPCMonitorViewSet(AdminAPIMixin, viewsets.GenericViewSet):
+    """
+    ViewSet for gRPC monitoring and statistics.
+
+    Provides comprehensive monitoring data for gRPC requests including:
+    - Health checks
+    - Overview statistics
+    - Recent requests
+    - Service-level statistics
+    - Method-level statistics
+    - Timeline data
+
+    Requires admin authentication (JWT, Session, or Basic Auth).
+    """
+
+    # Required for GenericViewSet
+    queryset = GRPCRequestLog.objects.none()  # Placeholder, actual queries in actions
+    serializer_class = RecentRequestSerializer  # Default serializer for schema
+
+    @extend_schema(
+        tags=["gRPC Monitoring"],
+        summary="Get gRPC health status",
+        description="Returns the current health status of the gRPC server.",
+        responses={
+            200: GRPCHealthCheckSerializer,
+            503: {"description": "Service unavailable"},
+        },
+    )
+    @action(detail=False, methods=["get"], url_path="health")
+    def health(self, request):
+        """Get health status of gRPC server."""
+        try:
+            service = MonitoringService()
+            health_data = service.get_health_status()
+            return Response(health_data)
+
+        except ValueError as e:
+            return Response(
+                {"error": str(e)},
+                status=status.HTTP_503_SERVICE_UNAVAILABLE,
+            )
+        except Exception as e:
+            logger.error(f"Health check error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Monitoring"],
+        summary="Get overview statistics",
+        description="Returns overview statistics for gRPC requests.",
+        parameters=[
+            OpenApiParameter(
+                name="hours",
+                type=OpenApiTypes.INT,
+                location=OpenApiParameter.QUERY,
+                description="Statistics period in hours (default: 24)",
+                required=False,
+            ),
+        ],
+        responses={
+            200: GRPCOverviewStatsSerializer,
+            400: {"description": "Invalid parameters"},
+        },
+    )
+    @action(detail=False, methods=["get"], url_path="overview")
+    def overview(self, request):
+        """Get overview statistics for gRPC requests."""
+        try:
+            hours = int(request.GET.get("hours", 24))
+
+            service = MonitoringService()
+            stats = service.get_overview_statistics(hours=hours)
+            return Response(stats)
+
+        except ValueError as e:
+            logger.warning(f"Overview stats validation error: {e}")
+            return Response(
+                {"error": str(e)}, status=status.HTTP_400_BAD_REQUEST
+            )
+        except Exception as e:
+            logger.error(f"Overview stats error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Monitoring"],
+        summary="Get recent requests",
+        description="Returns a list of recent gRPC requests with their details. Uses standard DRF pagination.",
+        parameters=[
+            OpenApiParameter(
+                name="service",
+                type=OpenApiTypes.STR,
+                location=OpenApiParameter.QUERY,
+                description="Filter by service name",
+                required=False,
+            ),
+            OpenApiParameter(
+                name="method",
+                type=OpenApiTypes.STR,
+                location=OpenApiParameter.QUERY,
+                description="Filter by method name",
+                required=False,
+            ),
+            OpenApiParameter(
+                name="status",
+                type=OpenApiTypes.STR,
+                location=OpenApiParameter.QUERY,
+                description="Filter by status (success, error, timeout, pending, cancelled)",
+                required=False,
+            ),
+        ],
+        responses={
+            200: RecentRequestSerializer,
+            400: {"description": "Invalid parameters"},
+        },
+    )
+    @action(detail=False, methods=["get"], url_path="requests")
+    def requests(self, request):
+        """Get recent gRPC requests."""
+        try:
+            service_filter = request.GET.get("service")
+            method_filter = request.GET.get("method")
+            status_filter = request.GET.get("status")
+
+            service = MonitoringService()
+            queryset = service.get_recent_requests(
+                service_name=service_filter,
+                method_name=method_filter,
+                status_filter=status_filter,
+            )
+
+            # Use DRF pagination
+            page = self.paginate_queryset(queryset)
+            if page is not None:
+                # Serialize paginated data
+                requests_list = []
+                for req in page:
+                    req_serializer = RecentRequestSerializer(
+                        id=req.id,
+                        request_id=req.request_id,
+                        service_name=req.service_name,
+                        method_name=req.method_name,
+                        status=req.status,
+                        duration_ms=req.duration_ms or 0,
+                        grpc_status_code=req.grpc_status_code or "",
+                        error_message=req.error_message or "",
+                        created_at=req.created_at.isoformat(),
+                        client_ip=req.client_ip or "",
+                    )
+                    requests_list.append(req_serializer.model_dump())
+                return self.get_paginated_response(requests_list)
+
+            # No pagination fallback
+            requests_list = []
+            for req in queryset[:100]:
+                req_serializer = RecentRequestSerializer(
+                    id=req.id,
+                    request_id=req.request_id,
+                    service_name=req.service_name,
+                    method_name=req.method_name,
+                    status=req.status,
+                    duration_ms=req.duration_ms or 0,
+                    grpc_status_code=req.grpc_status_code or "",
+                    error_message=req.error_message or "",
+                    created_at=req.created_at.isoformat(),
+                    client_ip=req.client_ip or "",
+                )
+                requests_list.append(req_serializer.model_dump())
+            return Response({"requests": requests_list, "count": len(requests_list)})
+
+        except ValueError as e:
+            logger.warning(f"Recent requests validation error: {e}")
+            return Response(
+                {"error": str(e)}, status=status.HTTP_400_BAD_REQUEST
+            )
+        except Exception as e:
+            logger.error(f"Recent requests error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Monitoring"],
+        summary="Get service statistics",
+        description="Returns statistics grouped by service.",
+        parameters=[
+            OpenApiParameter(
+                name="hours",
+                type=OpenApiTypes.INT,
+                location=OpenApiParameter.QUERY,
+                description="Statistics period in hours (default: 24)",
+                required=False,
+            ),
+        ],
+        responses={
+            200: ServiceListSerializer,
+            400: {"description": "Invalid parameters"},
+        },
+    )
+    @action(detail=False, methods=["get"], url_path="services", pagination_class=None)
+    def services(self, request):
+        """Get statistics per service."""
+        try:
+            hours = int(request.GET.get("hours", 24))
+
+            service = MonitoringService()
+            services_list = service.get_service_statistics(hours=hours)
+
+            response_data = {
+                "services": services_list,
+                "total_services": len(services_list),
+            }
+
+            return Response(response_data)
+
+        except ValueError as e:
+            logger.warning(f"Service stats validation error: {e}")
+            return Response(
+                {"error": str(e)}, status=status.HTTP_400_BAD_REQUEST
+            )
+        except Exception as e:
+            logger.error(f"Service stats error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Monitoring"],
+        summary="Get method statistics",
+        description="Returns statistics grouped by method.",
+        parameters=[
+            OpenApiParameter(
+                name="hours",
+                type=OpenApiTypes.INT,
+                location=OpenApiParameter.QUERY,
+                description="Statistics period in hours (default: 24)",
+                required=False,
+            ),
+            OpenApiParameter(
+                name="service",
+                type=OpenApiTypes.STR,
+                location=OpenApiParameter.QUERY,
+                description="Filter by service name",
+                required=False,
+            ),
+        ],
+        responses={
+            200: MethodListSerializer,
+            400: {"description": "Invalid parameters"},
+        },
+    )
+    @action(detail=False, methods=["get"], url_path="methods", pagination_class=None)
+    def methods(self, request):
+        """Get statistics per method."""
+        try:
+            hours = int(request.GET.get("hours", 24))
+            service_filter = request.GET.get("service")
+
+            service = MonitoringService()
+            methods_list = service.get_method_statistics(
+                service_name=service_filter,
+                hours=hours
+            )
+
+            response_data = {
+                "methods": methods_list,
+                "total_methods": len(methods_list),
+            }
+
+            serializer = MethodListSerializer(**response_data)
+            return Response(serializer.model_dump())
+
+        except ValueError as e:
+            logger.warning(f"Method stats validation error: {e}")
+            return Response(
+                {"error": str(e)}, status=status.HTTP_400_BAD_REQUEST
+            )
+        except Exception as e:
+            logger.error(f"Method stats error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Monitoring"],
+        summary="Get request timeline",
+        description="Returns hourly or daily breakdown of request counts for charts.",
+        parameters=[
+            OpenApiParameter(
+                name="hours",
+                type=OpenApiTypes.INT,
+                location=OpenApiParameter.QUERY,
+                description="Time period in hours (default: 24)",
+                required=False,
+            ),
+            OpenApiParameter(
+                name="interval",
+                type=OpenApiTypes.STR,
+                location=OpenApiParameter.QUERY,
+                description="Time interval: 'hour' or 'day' (default: hour)",
+                required=False,
+            ),
+        ],
+        responses={
+            200: {"description": "Timeline data"},
+            400: {"description": "Invalid parameters"},
+        },
+    )
+    @action(detail=False, methods=["get"], url_path="timeline")
+    def timeline(self, request):
+        """Get request timeline breakdown for charts."""
+        try:
+            hours = int(request.GET.get("hours", 24))
+            interval = request.GET.get("interval", "hour")
+
+            if interval not in ["hour", "day"]:
+                interval = "hour"
+
+            service = MonitoringService()
+            timeline_list = service.get_timeline_data(
+                hours=hours,
+                granularity=interval
+            )
+
+            response_data = {
+                "timeline": timeline_list,
+                "period_hours": hours,
+                "interval": interval,
+            }
+
+            return Response(response_data)
+
+        except ValueError as e:
+            logger.warning(f"Timeline validation error: {e}")
+            return Response(
+                {"error": str(e)}, status=status.HTTP_400_BAD_REQUEST
+            )
+        except Exception as e:
+            logger.error(f"Timeline error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+__all__ = ["GRPCMonitorViewSet"]