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

django_cfg/apps/grpc/management/commands/rungrpc.py

@@ -0,0 +1,302 @@
+"""
+Django management command to run gRPC server.
+
+Usage:
+    python manage.py rungrpc
+    python manage.py rungrpc --host 0.0.0.0 --port 50051
+    python manage.py rungrpc --workers 20
+"""
+
+import logging
+import signal
+import sys
+from concurrent import futures
+
+import grpc
+from django.conf import settings
+from django.core.management.base import BaseCommand
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    """
+    Run gRPC server with auto-discovered services.
+
+    Features:
+    - Auto-discovers and registers services
+    - Configurable host, port, and workers
+    - Health check support
+    - Reflection support
+    - Graceful shutdown
+    - Signal handling
+    """
+
+    help = "Run gRPC server"
+
+    def add_arguments(self, parser):
+        """Add command arguments."""
+        parser.add_argument(
+            "--host",
+            type=str,
+            default=None,
+            help="Server host (default: from settings or [::])",
+        )
+        parser.add_argument(
+            "--port",
+            type=int,
+            default=None,
+            help="Server port (default: from settings or 50051)",
+        )
+        parser.add_argument(
+            "--workers",
+            type=int,
+            default=None,
+            help="Max worker threads (default: from settings or 10)",
+        )
+        parser.add_argument(
+            "--no-reflection",
+            action="store_true",
+            help="Disable server reflection",
+        )
+        parser.add_argument(
+            "--no-health-check",
+            action="store_true",
+            help="Disable health check service",
+        )
+
+    def handle(self, *args, **options):
+        """Run gRPC server."""
+        # Get configuration
+        grpc_server_config = getattr(settings, "GRPC_SERVER", {})
+
+        # Get server parameters
+        host = options["host"] or grpc_server_config.get("host", "[::]")
+        port = options["port"] or grpc_server_config.get("port", 50051)
+        max_workers = options["workers"] or grpc_server_config.get("max_workers", 10)
+
+        # Server options
+        enable_reflection = not options["no_reflection"] and grpc_server_config.get(
+            "enable_reflection", False
+        )
+        enable_health_check = not options["no_health_check"] and grpc_server_config.get(
+            "enable_health_check", True
+        )
+
+        # gRPC options
+        grpc_options = self._build_grpc_options(grpc_server_config)
+
+        # Create server
+        self.stdout.write(self.style.SUCCESS(f"Creating gRPC server with {max_workers} workers..."))
+        server = grpc.server(
+            futures.ThreadPoolExecutor(max_workers=max_workers),
+            options=grpc_options,
+            interceptors=self._build_interceptors(),
+        )
+
+        # Add health check
+        if enable_health_check:
+            self._add_health_check(server)
+
+        # Discover and register services
+        self.stdout.write("Discovering services...")
+        service_count = self._register_services(server)
+
+        if service_count == 0:
+            self.stdout.write(
+                self.style.WARNING(
+                    "No services registered. "
+                    "Make sure you have services defined in your apps."
+                )
+            )
+        else:
+            self.stdout.write(
+                self.style.SUCCESS(f"Registered {service_count} service(s)")
+            )
+
+        # Add reflection
+        if enable_reflection:
+            self._add_reflection(server)
+            self.stdout.write(self.style.SUCCESS("Server reflection enabled"))
+
+        # Bind server
+        address = f"{host}:{port}"
+        server.add_insecure_port(address)
+
+        # Start server
+        self.stdout.write(self.style.SUCCESS(f"\nStarting gRPC server on {address}..."))
+        self.stdout.write(self.style.SUCCESS(f"Health check: {'enabled' if enable_health_check else 'disabled'}"))
+        self.stdout.write(self.style.SUCCESS(f"Reflection: {'enabled' if enable_reflection else 'disabled'}"))
+        self.stdout.write("")
+
+        server.start()
+
+        # Setup signal handlers for graceful shutdown
+        self._setup_signal_handlers(server)
+
+        # Keep server running
+        try:
+            self.stdout.write(self.style.SUCCESS("✅ gRPC server is running..."))
+            self.stdout.write("Press CTRL+C to stop")
+            server.wait_for_termination()
+        except KeyboardInterrupt:
+            self.stdout.write("\nShutting down...")
+            server.stop(grace=5)
+            self.stdout.write(self.style.SUCCESS("Server stopped"))
+
+    def _build_grpc_options(self, config: dict) -> list:
+        """
+        Build gRPC server options from configuration.
+
+        Args:
+            config: GRPC_SERVER configuration dict
+
+        Returns:
+            List of gRPC options tuples
+        """
+        options = []
+
+        # Message size limits
+        max_send = config.get("max_send_message_length", 4 * 1024 * 1024)
+        max_receive = config.get("max_receive_message_length", 4 * 1024 * 1024)
+
+        options.append(("grpc.max_send_message_length", max_send))
+        options.append(("grpc.max_receive_message_length", max_receive))
+
+        # Keepalive settings
+        keepalive_time = config.get("keepalive_time_ms", 7200000)
+        keepalive_timeout = config.get("keepalive_timeout_ms", 20000)
+
+        options.append(("grpc.keepalive_time_ms", keepalive_time))
+        options.append(("grpc.keepalive_timeout_ms", keepalive_timeout))
+        options.append(("grpc.http2.max_pings_without_data", 0))
+
+        return options
+
+    def _build_interceptors(self) -> list:
+        """
+        Build server interceptors from configuration.
+
+        Returns:
+            List of interceptor instances
+        """
+        grpc_framework_config = getattr(settings, "GRPC_FRAMEWORK", {})
+        interceptor_paths = grpc_framework_config.get("SERVER_INTERCEPTORS", [])
+
+        interceptors = []
+
+        for interceptor_path in interceptor_paths:
+            try:
+                # Import interceptor class
+                module_path, class_name = interceptor_path.rsplit(".", 1)
+
+                import importlib
+                module = importlib.import_module(module_path)
+                interceptor_class = getattr(module, class_name)
+
+                # Instantiate interceptor
+                interceptor = interceptor_class()
+                interceptors.append(interceptor)
+
+                logger.debug(f"Loaded interceptor: {class_name}")
+
+            except Exception as e:
+                logger.error(f"Failed to load interceptor {interceptor_path}: {e}")
+
+        return interceptors
+
+    def _add_health_check(self, server):
+        """
+        Add health check service to server.
+
+        Args:
+            server: gRPC server instance
+        """
+        try:
+            from grpc_health.v1 import health, health_pb2_grpc
+
+            # Create health servicer
+            health_servicer = health.HealthServicer()
+
+            # Mark all services as serving
+            health_servicer.set("", health_pb2.HealthCheckResponse.SERVING)
+
+            # Add to server
+            health_pb2_grpc.add_HealthServicer_to_server(health_servicer, server)
+
+            logger.info("Health check service added")
+
+        except ImportError:
+            logger.warning(
+                "grpcio-health-checking not installed. "
+                "Install with: pip install grpcio-health-checking"
+            )
+        except Exception as e:
+            logger.error(f"Failed to add health check service: {e}")
+
+    def _add_reflection(self, server):
+        """
+        Add reflection service to server.
+
+        Args:
+            server: gRPC server instance
+        """
+        try:
+            from grpc_reflection.v1alpha import reflection
+
+            # Get service names
+            service_names = [
+                desc.full_name
+                for desc in server._state.generic_handlers[0].service_name()
+            ] if hasattr(server, '_state') and hasattr(server._state, 'generic_handlers') else []
+
+            # Add reflection
+            reflection.enable_server_reflection(service_names, server)
+
+            logger.info("Server reflection enabled")
+
+        except ImportError:
+            logger.warning(
+                "grpcio-reflection not installed. "
+                "Install with: pip install grpcio-reflection"
+            )
+        except Exception as e:
+            logger.error(f"Failed to enable server reflection: {e}")
+
+    def _register_services(self, server) -> int:
+        """
+        Discover and register services to server.
+
+        Args:
+            server: gRPC server instance
+
+        Returns:
+            Number of services registered
+        """
+        try:
+            from django_cfg.modules.django_grpc.services import discover_and_register_services
+
+            count = discover_and_register_services(server)
+            return count
+
+        except Exception as e:
+            logger.error(f"Failed to register services: {e}", exc_info=True)
+            self.stdout.write(
+                self.style.ERROR(f"Error registering services: {e}")
+            )
+            return 0
+
+    def _setup_signal_handlers(self, server):
+        """
+        Setup signal handlers for graceful shutdown.
+
+        Args:
+            server: gRPC server instance
+        """
+        def handle_signal(sig, frame):
+            self.stdout.write(f"\nReceived signal {sig}, shutting down...")
+            server.stop(grace=5)
+            sys.exit(0)
+
+        signal.signal(signal.SIGINT, handle_signal)
+        signal.signal(signal.SIGTERM, handle_signal)

django_cfg/apps/grpc/managers/__init__.py

@@ -0,0 +1,10 @@
+"""
+Managers for gRPC app models.
+"""
+
+from .grpc_request_log import GRPCRequestLogManager, GRPCRequestLogQuerySet
+
+__all__ = [
+    "GRPCRequestLogManager",
+    "GRPCRequestLogQuerySet",
+]

django_cfg/apps/grpc/managers/grpc_request_log.py

@@ -0,0 +1,310 @@
+"""
+GRPCRequestLog Manager.
+
+Custom QuerySet and Manager for GRPCRequestLog model.
+"""
+
+from django.db import models
+from django.utils import timezone
+
+
+class GRPCRequestLogQuerySet(models.QuerySet):
+    """Custom QuerySet for GRPCRequestLog with filtering helpers."""
+
+    def pending(self):
+        """Get all pending logs."""
+        return self.filter(status="pending")
+
+    def successful(self):
+        """Get all successful logs."""
+        return self.filter(status="success")
+
+    def error(self):
+        """Get all error logs."""
+        return self.filter(status="error")
+
+    def cancelled(self):
+        """Get all cancelled logs."""
+        return self.filter(status="cancelled")
+
+    def timeout(self):
+        """Get all timeout logs."""
+        return self.filter(status="timeout")
+
+    def authenticated(self):
+        """Get logs for authenticated requests."""
+        return self.filter(is_authenticated=True)
+
+    def for_service(self, service_name: str):
+        """Get logs for specific service."""
+        return self.filter(service_name=service_name)
+
+    def for_method(self, method_name: str):
+        """Get logs for specific method."""
+        return self.filter(method_name=method_name)
+
+    def for_user(self, user):
+        """Get logs for specific user."""
+        return self.filter(user=user)
+
+    def recent(self, hours: int = 24):
+        """Get logs from recent hours."""
+        cutoff = timezone.now() - timezone.timedelta(hours=hours)
+        return self.filter(created_at__gte=cutoff)
+
+    def completed(self):
+        """Get all completed logs (success, error, cancelled, timeout)."""
+        return self.exclude(status="pending")
+
+    def by_performance(self):
+        """Order by duration (fastest first)."""
+        return self.filter(duration_ms__isnull=False).order_by("duration_ms")
+
+    def slow_requests(self, threshold_ms: int = 1000):
+        """Get slow requests (above threshold)."""
+        return self.filter(duration_ms__gt=threshold_ms)
+
+
+class GRPCRequestLogManager(models.Manager):
+    """Custom Manager for GRPCRequestLog."""
+
+    def get_queryset(self):
+        """Return custom QuerySet."""
+        return GRPCRequestLogQuerySet(self.model, using=self._db)
+
+    def pending(self):
+        """Get pending logs."""
+        return self.get_queryset().pending()
+
+    def successful(self):
+        """Get successful logs."""
+        return self.get_queryset().successful()
+
+    def error(self):
+        """Get error logs."""
+        return self.get_queryset().error()
+
+    def cancelled(self):
+        """Get cancelled logs."""
+        return self.get_queryset().cancelled()
+
+    def timeout(self):
+        """Get timeout logs."""
+        return self.get_queryset().timeout()
+
+    def authenticated(self):
+        """Get authenticated requests."""
+        return self.get_queryset().authenticated()
+
+    def for_service(self, service_name: str):
+        """Get logs for service."""
+        return self.get_queryset().for_service(service_name)
+
+    def for_method(self, method_name: str):
+        """Get logs for method."""
+        return self.get_queryset().for_method(method_name)
+
+    def for_user(self, user):
+        """Get logs for user."""
+        return self.get_queryset().for_user(user)
+
+    def recent(self, hours: int = 24):
+        """Get recent logs."""
+        return self.get_queryset().recent(hours)
+
+    def slow_requests(self, threshold_ms: int = 1000):
+        """Get slow requests."""
+        return self.get_queryset().slow_requests(threshold_ms)
+
+    def get_statistics(self, hours: int = 24):
+        """
+        Get request statistics for recent period.
+
+        Args:
+            hours: Number of hours to analyze
+
+        Returns:
+            Dictionary with statistics
+        """
+        recent_logs = self.recent(hours)
+
+        total = recent_logs.count()
+        successful = recent_logs.successful().count()
+        errors = recent_logs.error().count()
+        cancelled = recent_logs.cancelled().count()
+        timeout_count = recent_logs.timeout().count()
+
+        success_rate = (successful / total * 100) if total > 0 else 0
+
+        avg_duration = recent_logs.filter(
+            duration_ms__isnull=False
+        ).aggregate(
+            models.Avg("duration_ms")
+        )["duration_ms__avg"] or 0
+
+        p95_duration = None
+        if total > 0:
+            # Calculate 95th percentile
+            sorted_durations = list(
+                recent_logs.filter(duration_ms__isnull=False)
+                .order_by("duration_ms")
+                .values_list("duration_ms", flat=True)
+            )
+            if sorted_durations:
+                p95_index = int(len(sorted_durations) * 0.95)
+                p95_duration = sorted_durations[p95_index] if p95_index < len(sorted_durations) else sorted_durations[-1]
+
+        return {
+            "total": total,
+            "successful": successful,
+            "errors": errors,
+            "cancelled": cancelled,
+            "timeout": timeout_count,
+            "success_rate": round(success_rate, 2),
+            "avg_duration_ms": round(avg_duration, 2),
+            "p95_duration_ms": round(p95_duration, 2) if p95_duration else None,
+        }
+
+    def mark_success(
+        self,
+        log_instance,
+        duration_ms: int | None = None,
+        response_size: int | None = None,
+        response_data: dict | None = None,
+    ):
+        """
+        Mark request as successful.
+
+        Args:
+            log_instance: GRPCRequestLog instance
+            duration_ms: Duration in milliseconds
+            response_size: Response size in bytes
+            response_data: Response data
+        """
+        from ..models import GRPCRequestLog
+
+        log_instance.status = GRPCRequestLog.StatusChoices.SUCCESS
+        log_instance.grpc_status_code = "OK"
+        log_instance.completed_at = timezone.now()
+
+        if duration_ms is not None:
+            log_instance.duration_ms = duration_ms
+
+        if response_size is not None:
+            log_instance.response_size = response_size
+
+        if response_data is not None:
+            log_instance.response_data = response_data
+
+        log_instance.save(
+            update_fields=[
+                "status",
+                "grpc_status_code",
+                "completed_at",
+                "duration_ms",
+                "response_size",
+                "response_data",
+            ]
+        )
+
+    def mark_error(
+        self,
+        log_instance,
+        grpc_status_code: str,
+        error_message: str,
+        error_details: dict | None = None,
+        duration_ms: int | None = None,
+    ):
+        """
+        Mark request as failed.
+
+        Args:
+            log_instance: GRPCRequestLog instance
+            grpc_status_code: gRPC status code
+            error_message: Error message
+            error_details: Additional error details
+            duration_ms: Duration in milliseconds
+        """
+        from ..models import GRPCRequestLog
+
+        log_instance.status = GRPCRequestLog.StatusChoices.ERROR
+        log_instance.grpc_status_code = grpc_status_code
+        log_instance.error_message = error_message
+        log_instance.completed_at = timezone.now()
+
+        if error_details is not None:
+            log_instance.error_details = error_details
+
+        if duration_ms is not None:
+            log_instance.duration_ms = duration_ms
+
+        log_instance.save(
+            update_fields=[
+                "status",
+                "grpc_status_code",
+                "error_message",
+                "error_details",
+                "completed_at",
+                "duration_ms",
+            ]
+        )
+
+    def mark_cancelled(
+        self,
+        log_instance,
+        duration_ms: int | None = None,
+    ):
+        """
+        Mark request as cancelled.
+
+        Args:
+            log_instance: GRPCRequestLog instance
+            duration_ms: Duration in milliseconds
+        """
+        from ..models import GRPCRequestLog
+
+        log_instance.status = GRPCRequestLog.StatusChoices.CANCELLED
+        log_instance.grpc_status_code = "CANCELLED"
+        log_instance.completed_at = timezone.now()
+
+        if duration_ms is not None:
+            log_instance.duration_ms = duration_ms
+
+        log_instance.save(
+            update_fields=["status", "grpc_status_code", "completed_at", "duration_ms"]
+        )
+
+    def mark_timeout(
+        self,
+        log_instance,
+        duration_ms: int | None = None,
+    ):
+        """
+        Mark request as timed out.
+
+        Args:
+            log_instance: GRPCRequestLog instance
+            duration_ms: Duration in milliseconds
+        """
+        from ..models import GRPCRequestLog
+
+        log_instance.status = GRPCRequestLog.StatusChoices.TIMEOUT
+        log_instance.grpc_status_code = "DEADLINE_EXCEEDED"
+        log_instance.error_message = "Request timed out"
+        log_instance.completed_at = timezone.now()
+
+        if duration_ms is not None:
+            log_instance.duration_ms = duration_ms
+
+        log_instance.save(
+            update_fields=[
+                "status",
+                "grpc_status_code",
+                "error_message",
+                "completed_at",
+                "duration_ms",
+            ]
+        )
+
+
+__all__ = ["GRPCRequestLogManager", "GRPCRequestLogQuerySet"]

django_cfg/apps/grpc/migrations/0001_initial.py

@@ -0,0 +1,69 @@
+# Generated manually for django_cfg.apps.grpc
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='GRPCRequestLog',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('request_id', models.CharField(db_index=True, help_text='Unique request identifier (UUID)', max_length=100, unique=True)),
+                ('service_name', models.CharField(db_index=True, help_text='gRPC service name (e.g., myapp.UserService)', max_length=200)),
+                ('method_name', models.CharField(db_index=True, help_text='gRPC method name (e.g., GetUser)', max_length=200)),
+                ('full_method', models.CharField(db_index=True, help_text='Full method path (e.g., /myapp.UserService/GetUser)', max_length=400)),
+                ('request_size', models.IntegerField(blank=True, help_text='Request size in bytes', null=True)),
+                ('response_size', models.IntegerField(blank=True, help_text='Response size in bytes', null=True)),
+                ('request_data', models.JSONField(blank=True, help_text='Request data (if logged)', null=True)),
+                ('response_data', models.JSONField(blank=True, help_text='Response data (if logged)', null=True)),
+                ('status', models.CharField(choices=[('pending', 'Pending'), ('success', 'Success'), ('error', 'Error'), ('cancelled', 'Cancelled'), ('timeout', 'Timeout')], db_index=True, default='pending', help_text='Current status of request', max_length=20)),
+                ('grpc_status_code', models.CharField(blank=True, db_index=True, help_text='gRPC status code (OK, CANCELLED, INVALID_ARGUMENT, etc.)', max_length=50, null=True)),
+                ('error_message', models.TextField(blank=True, help_text='Error message if failed', null=True)),
+                ('error_details', models.JSONField(blank=True, help_text='Additional error details', null=True)),
+                ('duration_ms', models.IntegerField(blank=True, help_text='Total duration in milliseconds', null=True)),
+                ('is_authenticated', models.BooleanField(db_index=True, default=False, help_text='Whether request was authenticated')),
+                ('client_ip', models.GenericIPAddressField(blank=True, help_text='Client IP address', null=True)),
+                ('user_agent', models.TextField(blank=True, help_text='User agent from metadata', null=True)),
+                ('peer', models.CharField(blank=True, help_text='gRPC peer information', max_length=200, null=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True, db_index=True, help_text='When request was received')),
+                ('completed_at', models.DateTimeField(blank=True, db_index=True, help_text='When request completed (success/error)', null=True)),
+                ('user', models.ForeignKey(blank=True, help_text='Authenticated user (if applicable)', null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='grpc_request_logs', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'verbose_name': 'gRPC Request Log',
+                'verbose_name_plural': 'gRPC Request Logs',
+                'db_table': 'django_cfg_grpc_request_log',
+                'ordering': ['-created_at'],
+            },
+        ),
+        migrations.AddIndex(
+            model_name='grpcrequestlog',
+            index=models.Index(fields=['service_name', '-created_at'], name='django_cfg__service_4c4a8e_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='grpcrequestlog',
+            index=models.Index(fields=['method_name', '-created_at'], name='django_cfg__method__8e1a7c_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='grpcrequestlog',
+            index=models.Index(fields=['status', '-created_at'], name='django_cfg__status_f3d9a1_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='grpcrequestlog',
+            index=models.Index(fields=['user', '-created_at'], name='django_cfg__user_id_9c2b4f_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='grpcrequestlog',
+            index=models.Index(fields=['grpc_status_code', '-created_at'], name='django_cfg__grpc_st_a7e5c2_idx'),
+        ),
+    ]