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

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

@@ -0,0 +1,255 @@
+"""
+gRPC API Keys ViewSet.
+
+Provides REST API endpoints for viewing API keys.
+Create/Update/Delete operations handled through Django Admin.
+"""
+
+from django.db.models import Count, Q, Sum
+from django.utils import timezone
+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 GrpcApiKey
+from ..serializers.api_keys import (
+    ApiKeyListSerializer,
+    ApiKeySerializer,
+    ApiKeyStatsSerializer,
+)
+
+logger = get_logger("grpc.api_keys")
+
+
+class GRPCApiKeyViewSet(AdminAPIMixin, viewsets.GenericViewSet):
+    """
+    ViewSet for gRPC API Keys (Read-Only).
+
+    Provides listing and statistics for API keys.
+    Create/Update/Delete operations are handled through Django Admin.
+
+    Requires admin authentication (JWT, Session, or Basic Auth).
+    """
+
+    queryset = GrpcApiKey.objects.none()
+    serializer_class = ApiKeySerializer
+
+    @extend_schema(
+        tags=["gRPC API Keys"],
+        summary="List API keys",
+        description="Returns a list of all API keys with their details. Uses standard DRF pagination.",
+        parameters=[
+            OpenApiParameter(
+                name="is_active",
+                type=OpenApiTypes.BOOL,
+                location=OpenApiParameter.QUERY,
+                description="Filter by active status",
+                required=False,
+            ),
+            OpenApiParameter(
+                name="key_type",
+                type=OpenApiTypes.STR,
+                location=OpenApiParameter.QUERY,
+                description="Filter by key type (service, cli, webhook, internal, development)",
+                required=False,
+            ),
+            OpenApiParameter(
+                name="user_id",
+                type=OpenApiTypes.INT,
+                location=OpenApiParameter.QUERY,
+                description="Filter by user ID",
+                required=False,
+            ),
+        ],
+        responses={
+            200: ApiKeySerializer(many=True),
+            400: {"description": "Invalid parameters"},
+        },
+    )
+    def list(self, request):
+        """List all API keys."""
+        try:
+            # Build queryset with filters
+            queryset = GrpcApiKey.objects.select_related("user", "created_by").all()
+
+            # Apply filters
+            is_active = request.GET.get("is_active")
+            if is_active is not None:
+                is_active_bool = is_active.lower() in ("true", "1", "yes")
+                queryset = queryset.filter(is_active=is_active_bool)
+
+            key_type = request.GET.get("key_type")
+            if key_type:
+                queryset = queryset.filter(key_type=key_type)
+
+            user_id = request.GET.get("user_id")
+            if user_id:
+                queryset = queryset.filter(user_id=user_id)
+
+            # Order by most recently created
+            queryset = queryset.order_by("-created_at")
+
+            # Paginate
+            page = self.paginate_queryset(queryset)
+            if page is not None:
+                # Serialize paginated data
+                results = []
+                for key in page:
+                    results.append({
+                        "id": key.id,
+                        "name": key.name,
+                        "key_type": key.key_type,
+                        "masked_key": key.masked_key,
+                        "is_active": key.is_active,
+                        "is_valid": key.is_valid,
+                        "user_id": key.user.id,
+                        "username": key.user.username,
+                        "user_email": key.user.email,
+                        "request_count": key.request_count,
+                        "last_used_at": key.last_used_at,
+                        "expires_at": key.expires_at,
+                        "created_at": key.created_at,
+                        "created_by": key.created_by.username if key.created_by else None,
+                    })
+                return self.get_paginated_response(results)
+
+            # No pagination fallback
+            results = []
+            for key in queryset[:100]:
+                results.append({
+                    "id": key.id,
+                    "name": key.name,
+                    "key_type": key.key_type,
+                    "masked_key": key.masked_key,
+                    "is_active": key.is_active,
+                    "is_valid": key.is_valid,
+                    "user_id": key.user.id,
+                    "username": key.user.username,
+                    "user_email": key.user.email,
+                    "request_count": key.request_count,
+                    "last_used_at": key.last_used_at,
+                    "expires_at": key.expires_at,
+                    "created_at": key.created_at,
+                    "created_by": key.created_by.username if key.created_by else None,
+                })
+
+            return Response({"results": results, "count": len(results)})
+
+        except ValueError as e:
+            logger.warning(f"API keys list validation error: {e}")
+            return Response(
+                {"error": str(e)}, status=status.HTTP_400_BAD_REQUEST
+            )
+        except Exception as e:
+            logger.error(f"API keys list error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC API Keys"],
+        summary="Get API key details",
+        description="Returns detailed information about a specific API key.",
+        responses={
+            200: ApiKeySerializer,
+            404: {"description": "API key not found"},
+        },
+    )
+    def retrieve(self, request, pk=None):
+        """Get details of a specific API key."""
+        try:
+            key = GrpcApiKey.objects.select_related("user", "created_by").get(pk=pk)
+
+            data = {
+                "id": key.id,
+                "name": key.name,
+                "key_type": key.key_type,
+                "masked_key": key.masked_key,
+                "is_active": key.is_active,
+                "is_valid": key.is_valid,
+                "user_id": key.user.id,
+                "username": key.user.username,
+                "user_email": key.user.email,
+                "request_count": key.request_count,
+                "last_used_at": key.last_used_at,
+                "expires_at": key.expires_at,
+                "created_at": key.created_at,
+                "created_by": key.created_by.username if key.created_by else None,
+            }
+
+            serializer = ApiKeySerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+
+        except GrpcApiKey.DoesNotExist:
+            return Response(
+                {"error": "API key not found"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+        except Exception as e:
+            logger.error(f"API key retrieve error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC API Keys"],
+        summary="Get API keys statistics",
+        description="Returns overall statistics about API keys usage.",
+        responses={
+            200: ApiKeyStatsSerializer,
+        },
+    )
+    @action(detail=False, methods=["get"], url_path="stats")
+    def stats(self, request):
+        """Get API keys statistics."""
+        try:
+            # Total keys
+            total_keys = GrpcApiKey.objects.count()
+
+            # Active keys
+            active_keys = GrpcApiKey.objects.filter(is_active=True).count()
+
+            # Expired keys
+            expired_keys = GrpcApiKey.objects.filter(
+                Q(is_active=True) & Q(expires_at__lt=timezone.now())
+            ).count()
+
+            # Total requests across all keys
+            total_requests = GrpcApiKey.objects.aggregate(
+                total=Sum("request_count")
+            )["total"] or 0
+
+            # Keys by type
+            keys_by_type_qs = GrpcApiKey.objects.values("key_type").annotate(
+                count=Count("id")
+            )
+            keys_by_type = {item["key_type"]: item["count"] for item in keys_by_type_qs}
+
+            stats_data = {
+                "total_keys": total_keys,
+                "active_keys": active_keys,
+                "expired_keys": expired_keys,
+                "total_requests": total_requests,
+                "keys_by_type": keys_by_type,
+            }
+
+            serializer = ApiKeyStatsSerializer(data=stats_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+
+        except Exception as e:
+            logger.error(f"API keys stats error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+__all__ = ["GRPCApiKeyViewSet"]

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

@@ -0,0 +1,224 @@
+"""
+gRPC Charts ViewSet.
+
+Provides REST API endpoints for chart data and statistics visualization.
+Uses ChartGeneratorService for all data generation logic.
+"""
+
+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 ..serializers.charts import (
+    DashboardChartsSerializer,
+    ErrorDistributionChartSerializer,
+    RequestVolumeChartSerializer,
+    ResponseTimeChartSerializer,
+    ServerLifecycleChartSerializer,
+    ServerUptimeChartSerializer,
+    ServiceActivityChartSerializer,
+)
+from ..services.chart_generator import ChartGeneratorService
+
+logger = get_logger("grpc.charts")
+
+
+class GRPCChartsViewSet(AdminAPIMixin, viewsets.ViewSet):
+    """
+    ViewSet for gRPC charts and statistics visualization.
+
+    Provides endpoints for:
+    - Server uptime over time
+    - Request volume trends
+    - Response time metrics
+    - Service activity comparison
+    - Server lifecycle events
+    - Error distribution
+    - Combined dashboard data
+
+    All endpoints support time range filtering via 'hours' query parameter.
+    """
+
+    TIME_RANGE_PARAM = OpenApiParameter(
+        name="hours",
+        type=OpenApiTypes.INT,
+        location=OpenApiParameter.QUERY,
+        description="Time range in hours (default: 24, max: 720)",
+        required=False,
+    )
+
+    def _validate_hours(self, hours_str: str) -> int:
+        """Validate and normalize hours parameter."""
+        try:
+            hours = int(hours_str)
+            return min(max(hours, 1), 720)  # 1 hour to 30 days
+        except (ValueError, TypeError):
+            return 24
+
+    @extend_schema(
+        tags=["gRPC Charts"],
+        summary="Get server uptime chart data",
+        description="Returns time-series data showing number of running servers over time.",
+        parameters=[TIME_RANGE_PARAM],
+        responses={200: ServerUptimeChartSerializer},
+    )
+    @action(detail=False, methods=["get"], url_path="server-uptime")
+    def server_uptime(self, request):
+        """Get server uptime chart data."""
+        try:
+            hours = self._validate_hours(request.GET.get("hours", "24"))
+            data = ChartGeneratorService.generate_server_uptime_data(hours)
+            serializer = ServerUptimeChartSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+        except Exception as e:
+            logger.error(f"Server uptime chart error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Charts"],
+        summary="Get request volume chart data",
+        description="Returns time-series data showing request volume and success rates.",
+        parameters=[TIME_RANGE_PARAM],
+        responses={200: RequestVolumeChartSerializer},
+    )
+    @action(detail=False, methods=["get"], url_path="request-volume")
+    def request_volume(self, request):
+        """Get request volume chart data."""
+        try:
+            hours = self._validate_hours(request.GET.get("hours", "24"))
+            data = ChartGeneratorService.generate_request_volume_data(hours)
+            serializer = RequestVolumeChartSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+        except Exception as e:
+            logger.error(f"Request volume chart error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Charts"],
+        summary="Get response time chart data",
+        description="Returns time-series data showing response time statistics (avg, P50, P95, P99).",
+        parameters=[TIME_RANGE_PARAM],
+        responses={200: ResponseTimeChartSerializer},
+    )
+    @action(detail=False, methods=["get"], url_path="response-time")
+    def response_time(self, request):
+        """Get response time chart data."""
+        try:
+            hours = self._validate_hours(request.GET.get("hours", "24"))
+            data = ChartGeneratorService.generate_response_time_data(hours)
+            serializer = ResponseTimeChartSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+        except Exception as e:
+            logger.error(f"Response time chart error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Charts"],
+        summary="Get service activity chart data",
+        description="Returns comparison data showing activity across all services.",
+        parameters=[TIME_RANGE_PARAM],
+        responses={200: ServiceActivityChartSerializer},
+    )
+    @action(detail=False, methods=["get"], url_path="service-activity")
+    def service_activity(self, request):
+        """Get service activity chart data."""
+        try:
+            hours = self._validate_hours(request.GET.get("hours", "24"))
+            data = ChartGeneratorService.generate_service_activity_data(hours)
+            serializer = ServiceActivityChartSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+        except Exception as e:
+            logger.error(f"Service activity chart error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Charts"],
+        summary="Get server lifecycle events",
+        description="Returns timeline of server start/stop/error events.",
+        parameters=[TIME_RANGE_PARAM],
+        responses={200: ServerLifecycleChartSerializer},
+    )
+    @action(detail=False, methods=["get"], url_path="server-lifecycle")
+    def server_lifecycle(self, request):
+        """Get server lifecycle events."""
+        try:
+            hours = self._validate_hours(request.GET.get("hours", "24"))
+            data = ChartGeneratorService.generate_server_lifecycle_data(hours)
+            serializer = ServerLifecycleChartSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+        except Exception as e:
+            logger.error(f"Server lifecycle chart error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Charts"],
+        summary="Get error distribution chart data",
+        description="Returns distribution of error types across services.",
+        parameters=[TIME_RANGE_PARAM],
+        responses={200: ErrorDistributionChartSerializer},
+    )
+    @action(detail=False, methods=["get"], url_path="error-distribution")
+    def error_distribution(self, request):
+        """Get error distribution chart data."""
+        try:
+            hours = self._validate_hours(request.GET.get("hours", "24"))
+            data = ChartGeneratorService.generate_error_distribution_data(hours)
+            serializer = ErrorDistributionChartSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+        except Exception as e:
+            logger.error(f"Error distribution chart error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Charts"],
+        summary="Get all dashboard charts data",
+        description="Returns combined data for all charts in one request (optimized).",
+        parameters=[TIME_RANGE_PARAM],
+        responses={200: DashboardChartsSerializer},
+    )
+    @action(detail=False, methods=["get"], url_path="dashboard")
+    def dashboard(self, request):
+        """Get all dashboard charts data in one request."""
+        try:
+            hours = self._validate_hours(request.GET.get("hours", "24"))
+            data = ChartGeneratorService.generate_dashboard_data(hours)
+            serializer = DashboardChartsSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+        except Exception as e:
+            logger.error(f"Dashboard charts error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+__all__ = ["GRPCChartsViewSet"]

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

@@ -0,0 +1,193 @@
+"""
+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_concurrent_streams": grpc_config.server.max_concurrent_streams,
+                    "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": {
+                    "api_key_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(data=config_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+
+        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(data=server_info_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+
+        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"]