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

django_cfg/apps/integrations/grpc/utils/proto_gen.py

@@ -0,0 +1,423 @@
+"""
+Proto file generation utilities.
+
+Helps generate .proto files from Django models.
+"""
+
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from django.apps import apps
+from django.conf import settings
+from django.db import models
+
+logger = logging.getLogger(__name__)
+
+
+class ProtoFieldMapper:
+    """
+    Maps Django model fields to Protobuf types.
+
+    Example:
+        ```python
+        mapper = ProtoFieldMapper()
+        proto_type = mapper.get_proto_type(model_field)
+        # 'string', 'int32', 'bool', etc.
+        ```
+    """
+
+    # Django field -> Proto type mapping
+    FIELD_TYPE_MAP = {
+        models.CharField: "string",
+        models.TextField: "string",
+        models.EmailField: "string",
+        models.URLField: "string",
+        models.SlugField: "string",
+        models.UUIDField: "string",
+        models.IntegerField: "int32",
+        models.BigIntegerField: "int64",
+        models.SmallIntegerField: "int32",
+        models.PositiveIntegerField: "uint32",
+        models.PositiveBigIntegerField: "uint64",
+        models.PositiveSmallIntegerField: "uint32",
+        models.FloatField: "float",
+        models.DecimalField: "string",  # Decimal as string to avoid precision loss
+        models.BooleanField: "bool",
+        models.DateField: "string",  # ISO 8601 date string
+        models.DateTimeField: "string",  # ISO 8601 datetime string
+        models.TimeField: "string",  # ISO 8601 time string
+        models.DurationField: "string",  # Duration as string
+        models.JSONField: "string",  # JSON as string
+        models.BinaryField: "bytes",
+        models.FileField: "string",  # File path/URL
+        models.ImageField: "string",  # Image path/URL
+    }
+
+    def get_proto_type(self, field: models.Field) -> str:
+        """
+        Get Protobuf type for Django field.
+
+        Args:
+            field: Django model field
+
+        Returns:
+            Protobuf type string
+
+        Example:
+            >>> field = models.CharField(max_length=100)
+            >>> mapper.get_proto_type(field)
+            'string'
+        """
+        field_class = type(field)
+
+        # Check for foreign key
+        if isinstance(field, models.ForeignKey):
+            return "int64"  # ID of related object
+
+        # Check for many-to-many
+        if isinstance(field, models.ManyToManyField):
+            return "repeated int64"  # IDs of related objects
+
+        # Check for one-to-one
+        if isinstance(field, models.OneToOneField):
+            return "int64"  # ID of related object
+
+        # Check field type map
+        for django_field_type, proto_type in self.FIELD_TYPE_MAP.items():
+            if isinstance(field, django_field_type):
+                return proto_type
+
+        # Default to string
+        logger.warning(f"Unknown field type {field_class.__name__}, defaulting to string")
+        return "string"
+
+    def is_repeated(self, field: models.Field) -> bool:
+        """
+        Check if field should be repeated in proto.
+
+        Args:
+            field: Django model field
+
+        Returns:
+            True if field should be repeated
+        """
+        return isinstance(field, models.ManyToManyField)
+
+    def is_optional(self, field: models.Field) -> bool:
+        """
+        Check if field should be optional in proto.
+
+        Args:
+            field: Django model field
+
+        Returns:
+            True if field should be optional
+        """
+        return field.null or field.blank or hasattr(field, "default")
+
+
+class ProtoGenerator:
+    """
+    Generates .proto files from Django models.
+
+    Features:
+    - Auto-generates message definitions
+    - Handles field types
+    - Supports relationships
+    - Configurable naming conventions
+
+    Example:
+        ```python
+        from myapp.models import User
+
+        generator = ProtoGenerator()
+        proto_content = generator.generate_message(User)
+
+        # Write to file
+        with open('user.proto', 'w') as f:
+            f.write(proto_content)
+        ```
+    """
+
+    def __init__(self, package_prefix: str = "", field_naming: str = "snake_case"):
+        """
+        Initialize proto generator.
+
+        Args:
+            package_prefix: Package prefix for proto files
+            field_naming: Field naming convention ('snake_case' or 'camelCase')
+        """
+        self.package_prefix = package_prefix
+        self.field_naming = field_naming
+        self.mapper = ProtoFieldMapper()
+
+    def generate_message(
+        self,
+        model: type,
+        include_id: bool = True,
+        include_timestamps: bool = True,
+    ) -> str:
+        """
+        Generate protobuf message for Django model.
+
+        Args:
+            model: Django model class
+            include_id: Include id field
+            include_timestamps: Include created_at/updated_at fields
+
+        Returns:
+            Proto message definition string
+
+        Example:
+            >>> from myapp.models import User
+            >>> generator = ProtoGenerator()
+            >>> print(generator.generate_message(User))
+            message User {
+              int64 id = 1;
+              string username = 2;
+              string email = 3;
+            }
+        """
+        message_name = model.__name__
+        lines = [f"message {message_name} {{"]
+
+        field_number = 1
+
+        # Add id field
+        if include_id:
+            lines.append(f"  int64 id = {field_number};")
+            field_number += 1
+
+        # Add model fields
+        for field in model._meta.get_fields():
+            # Skip reverse relations
+            if field.auto_created and not field.concrete:
+                continue
+
+            # Skip many-to-many for now (handle separately)
+            if isinstance(field, models.ManyToManyField):
+                continue
+
+            # Get field info
+            field_name = self._format_field_name(field.name)
+            proto_type = self.mapper.get_proto_type(field)
+            is_optional = self.mapper.is_optional(field)
+
+            # Build field definition
+            if is_optional and not field.primary_key:
+                field_def = f"  optional {proto_type} {field_name} = {field_number};"
+            else:
+                field_def = f"  {proto_type} {field_name} = {field_number};"
+
+            lines.append(field_def)
+            field_number += 1
+
+        # Add timestamp fields if requested
+        if include_timestamps:
+            if hasattr(model, "created_at"):
+                lines.append(f"  string created_at = {field_number};")
+                field_number += 1
+            if hasattr(model, "updated_at"):
+                lines.append(f"  string updated_at = {field_number};")
+                field_number += 1
+
+        lines.append("}")
+
+        return "\n".join(lines)
+
+    def generate_service(
+        self,
+        service_name: str,
+        model: type,
+        methods: Optional[List[str]] = None,
+    ) -> str:
+        """
+        Generate protobuf service definition.
+
+        Args:
+            service_name: Service name
+            model: Django model class
+            methods: List of methods to include (default: CRUD)
+
+        Returns:
+            Proto service definition string
+
+        Example:
+            >>> from myapp.models import User
+            >>> generator = ProtoGenerator()
+            >>> print(generator.generate_service("UserService", User))
+            service UserService {
+              rpc Create(CreateUserRequest) returns (User);
+              rpc Get(GetUserRequest) returns (User);
+              rpc Update(UpdateUserRequest) returns (User);
+              rpc Delete(DeleteUserRequest) returns (Empty);
+              rpc List(ListUserRequest) returns (ListUserResponse);
+            }
+        """
+        if methods is None:
+            methods = ["Create", "Get", "Update", "Delete", "List"]
+
+        model_name = model.__name__
+        lines = [f"service {service_name} {{"]
+
+        for method in methods:
+            if method == "Create":
+                lines.append(f"  rpc Create(Create{model_name}Request) returns ({model_name});")
+            elif method == "Get":
+                lines.append(f"  rpc Get(Get{model_name}Request) returns ({model_name});")
+            elif method == "Update":
+                lines.append(f"  rpc Update(Update{model_name}Request) returns ({model_name});")
+            elif method == "Delete":
+                lines.append(f"  rpc Delete(Delete{model_name}Request) returns (google.protobuf.Empty);")
+            elif method == "List":
+                lines.append(f"  rpc List(List{model_name}Request) returns (List{model_name}Response);")
+
+        lines.append("}")
+
+        return "\n".join(lines)
+
+    def generate_proto_file(
+        self,
+        models_list: List[type],
+        service_name: Optional[str] = None,
+        output_path: Optional[Path] = None,
+    ) -> str:
+        """
+        Generate complete .proto file for models.
+
+        Args:
+            models_list: List of Django model classes
+            service_name: Optional service name
+            output_path: Optional output file path
+
+        Returns:
+            Complete proto file content
+
+        Example:
+            >>> from myapp.models import User, Post
+            >>> generator = ProtoGenerator()
+            >>> content = generator.generate_proto_file(
+            ...     [User, Post],
+            ...     service_name="MyAppService"
+            ... )
+        """
+        lines = [
+            'syntax = "proto3";',
+            "",
+        ]
+
+        # Add package
+        if self.package_prefix:
+            lines.append(f"package {self.package_prefix};")
+            lines.append("")
+
+        # Add imports
+        lines.append('import "google/protobuf/empty.proto";')
+        lines.append("")
+
+        # Add messages
+        for model in models_list:
+            message = self.generate_message(model)
+            lines.append(message)
+            lines.append("")
+
+        # Add service if requested
+        if service_name and models_list:
+            service = self.generate_service(service_name, models_list[0])
+            lines.append(service)
+            lines.append("")
+
+        content = "\n".join(lines)
+
+        # Write to file if path provided
+        if output_path:
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(content)
+            logger.info(f"Generated proto file: {output_path}")
+
+        return content
+
+    def _format_field_name(self, name: str) -> str:
+        """
+        Format field name according to naming convention.
+
+        Args:
+            name: Original field name
+
+        Returns:
+            Formatted field name
+        """
+        if self.field_naming == "camelCase":
+            parts = name.split("_")
+            return parts[0] + "".join(p.capitalize() for p in parts[1:])
+        else:
+            # snake_case (default)
+            return name
+
+
+def generate_proto_for_app(app_label: str, output_dir: Optional[Path] = None) -> int:
+    """
+    Generate proto files for all models in an app.
+
+    Args:
+        app_label: Django app label
+        output_dir: Output directory (default: protos/)
+
+    Returns:
+        Number of proto files generated
+
+    Example:
+        ```python
+        from django_cfg.apps.integrations.grpc.utils.proto_gen import generate_proto_for_app
+
+        count = generate_proto_for_app('myapp')
+        print(f"Generated {count} proto file(s)")
+        ```
+    """
+    # Get output directory
+    if output_dir is None:
+        grpc_proto_config = getattr(settings, "GRPC_PROTO", {})
+        output_dir_str = grpc_proto_config.get("output_dir", "protos")
+        output_dir = Path(output_dir_str)
+
+    # Get app config
+    try:
+        app_config = apps.get_app_config(app_label)
+    except LookupError:
+        logger.error(f"App '{app_label}' not found")
+        return 0
+
+    # Get models
+    models_list = [
+        model for model in app_config.get_models()
+        if not model._meta.abstract
+    ]
+
+    if not models_list:
+        logger.warning(f"No models found in app '{app_label}'")
+        return 0
+
+    # Generate proto file
+    generator = ProtoGenerator(
+        package_prefix=app_label,
+        field_naming="snake_case",
+    )
+
+    output_path = output_dir / f"{app_label}.proto"
+
+    generator.generate_proto_file(
+        models_list,
+        service_name=f"{app_label.capitalize()}Service",
+        output_path=output_path,
+    )
+
+    logger.info(f"Generated proto file for app '{app_label}' with {len(models_list)} model(s)")
+    return 1
+
+
+__all__ = [
+    "ProtoFieldMapper",
+    "ProtoGenerator",
+    "generate_proto_for_app",
+]

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

@@ -0,0 +1,15 @@
+"""
+Views for gRPC monitoring API.
+"""
+
+from .config import GRPCConfigViewSet
+from .monitoring import GRPCMonitorViewSet
+from .services import GRPCServiceViewSet
+from .testing import GRPCTestingViewSet
+
+__all__ = [
+    "GRPCMonitorViewSet",
+    "GRPCConfigViewSet",
+    "GRPCServiceViewSet",
+    "GRPCTestingViewSet",
+]

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

@@ -0,0 +1,217 @@
+"""
+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)
+            return Response(serializer.model_dump())
+        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)
+            return Response(serializer.model_dump())
+        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)
+            return Response(serializer.model_dump())
+        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)
+            return Response(serializer.model_dump())
+        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)
+            return Response(serializer.model_dump())
+        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)
+            return Response(serializer.model_dump())
+        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)
+            return Response(serializer.model_dump())
+        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"]