django-cfg 1.4.48__py3-none-any.whl → 1.5.7__py3-none-any.whl

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

@@ -0,0 +1,288 @@
+"""
+Manager for GRPCServerStatus model.
+
+Provides convenient methods for server lifecycle management.
+"""
+
+import os
+import socket
+from typing import Optional
+
+from django.db import models
+from django.utils import timezone
+
+
+class GRPCServerStatusManager(models.Manager):
+    """
+    Manager for GRPCServerStatus model.
+
+    Provides methods for:
+    - Starting/stopping server tracking
+    - Getting current server status
+    - Cleaning up stale records
+    """
+
+    def start_server(
+        self,
+        host: str,
+        port: int,
+        pid: int = None,
+        max_workers: int = 10,
+        enable_reflection: bool = False,
+        enable_health_check: bool = True,
+    ):
+        """
+        Start tracking a new server instance.
+
+        Args:
+            host: Server host address
+            port: Server port
+            pid: Process ID (defaults to current process)
+            max_workers: Maximum worker threads
+            enable_reflection: Whether reflection is enabled
+            enable_health_check: Whether health check is enabled
+
+        Returns:
+            GRPCServerStatus instance
+
+        Example:
+            >>> status = GRPCServerStatus.objects.start_server(
+            ...     host="[::]",
+            ...     port=50051,
+            ...     pid=12345
+            ... )
+            >>> status.is_running
+            True
+        """
+        if pid is None:
+            pid = os.getpid()
+
+        hostname = socket.gethostname()
+        address = f"{host}:{port}"
+        instance_id = f"{hostname}:{port}:{pid}"
+
+        # Mark any existing server at this address as stopped
+        self.stop_servers_at_address(address)
+
+        # Create new server status
+        status = self.create(
+            instance_id=instance_id,
+            host=host,
+            port=port,
+            address=address,
+            pid=pid,
+            hostname=hostname,
+            status=self.model.StatusChoices.STARTING,
+            max_workers=max_workers,
+            enable_reflection=enable_reflection,
+            enable_health_check=enable_health_check,
+        )
+
+        return status
+
+    def get_current_server(self, address: str = None) -> Optional["GRPCServerStatus"]:
+        """
+        Get the currently running server.
+
+        Args:
+            address: Optional address filter (host:port)
+
+        Returns:
+            GRPCServerStatus instance or None
+
+        Example:
+            >>> server = GRPCServerStatus.objects.get_current_server()
+            >>> if server and server.is_running:
+            ...     print(f"Server running for {server.uptime_display}")
+        """
+        queryset = self.filter(
+            status__in=[
+                self.model.StatusChoices.STARTING,
+                self.model.StatusChoices.RUNNING,
+            ]
+        )
+
+        if address:
+            queryset = queryset.filter(address=address)
+
+        # Get most recent
+        server = queryset.order_by("-started_at").first()
+
+        # Verify it's actually running
+        if server and server.is_running:
+            return server
+
+        return None
+
+    def get_running_servers(self):
+        """
+        Get all currently running servers.
+
+        Returns:
+            QuerySet of running servers
+
+        Example:
+            >>> servers = GRPCServerStatus.objects.get_running_servers()
+            >>> for server in servers:
+            ...     print(f"{server.address}: {server.uptime_display}")
+        """
+        running_servers = []
+
+        # Get servers marked as running
+        candidates = self.filter(
+            status__in=[
+                self.model.StatusChoices.STARTING,
+                self.model.StatusChoices.RUNNING,
+            ]
+        ).order_by("-started_at")
+
+        # Verify each one is actually running
+        for server in candidates:
+            if server.is_running:
+                running_servers.append(server.id)
+
+        return self.filter(id__in=running_servers)
+
+    def stop_server(self, pid: int = None, address: str = None):
+        """
+        Stop tracking a server instance.
+
+        Args:
+            pid: Process ID to stop
+            address: Address to stop (alternative to pid)
+
+        Example:
+            >>> GRPCServerStatus.objects.stop_server(pid=12345)
+        """
+        if pid:
+            servers = self.filter(pid=pid)
+        elif address:
+            servers = self.filter(address=address)
+        else:
+            # Stop current process
+            pid = os.getpid()
+            servers = self.filter(pid=pid)
+
+        servers = servers.filter(
+            status__in=[
+                self.model.StatusChoices.STARTING,
+                self.model.StatusChoices.RUNNING,
+            ]
+        )
+
+        for server in servers:
+            server.mark_stopped()
+
+    def stop_servers_at_address(self, address: str):
+        """
+        Stop all servers at a specific address.
+
+        Args:
+            address: Server address (host:port)
+
+        Example:
+            >>> GRPCServerStatus.objects.stop_servers_at_address("[::]:50051")
+        """
+        servers = self.filter(
+            address=address,
+            status__in=[
+                self.model.StatusChoices.STARTING,
+                self.model.StatusChoices.RUNNING,
+            ],
+        )
+
+        for server in servers:
+            server.mark_stopped("Replaced by new server instance")
+
+    def cleanup_stale_servers(self, hours: int = 24):
+        """
+        Mark stale servers as stopped.
+
+        A server is considered stale if:
+        - Status is STARTING or RUNNING
+        - Last heartbeat is older than threshold
+        - Process is not alive
+
+        Args:
+            hours: Hours without heartbeat to consider stale
+
+        Returns:
+            Number of servers cleaned up
+
+        Example:
+            >>> count = GRPCServerStatus.objects.cleanup_stale_servers()
+            >>> print(f"Cleaned up {count} stale servers")
+        """
+        from django.utils import timezone
+        from datetime import timedelta
+
+        threshold = timezone.now() - timedelta(hours=hours)
+
+        stale_servers = self.filter(
+            status__in=[
+                self.model.StatusChoices.STARTING,
+                self.model.StatusChoices.RUNNING,
+            ],
+            last_heartbeat__lt=threshold,
+        )
+
+        count = 0
+        for server in stale_servers:
+            if not server.is_running:
+                server.mark_stopped("Stale server (no heartbeat)")
+                count += 1
+
+        return count
+
+    def get_server_by_pid(self, pid: int) -> Optional["GRPCServerStatus"]:
+        """
+        Get server by process ID.
+
+        Args:
+            pid: Process ID
+
+        Returns:
+            GRPCServerStatus instance or None
+        """
+        return (
+            self.filter(pid=pid)
+            .order_by("-started_at")
+            .first()
+        )
+
+    def get_statistics(self):
+        """
+        Get statistics about server instances.
+
+        Returns:
+            Dictionary with statistics
+
+        Example:
+            >>> stats = GRPCServerStatus.objects.get_statistics()
+            >>> print(f"Total servers: {stats['total_servers']}")
+            >>> print(f"Currently running: {stats['running_servers']}")
+        """
+        running_servers = self.get_running_servers()
+
+        return {
+            "total_servers": self.count(),
+            "running_servers": running_servers.count(),
+            "stopped_servers": self.filter(
+                status=self.model.StatusChoices.STOPPED
+            ).count(),
+            "error_servers": self.filter(
+                status=self.model.StatusChoices.ERROR
+            ).count(),
+            "running_list": [
+                {
+                    "address": server.address,
+                    "pid": server.pid,
+                    "uptime_seconds": server.uptime_seconds,
+                    "started_at": server.started_at.isoformat(),
+                }
+                for server in running_servers
+            ],
+        }
+
+
+__all__ = ["GRPCServerStatusManager"]

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

@@ -0,0 +1,69 @@
+# Generated manually for django_cfg.apps.integrations.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'),
+        ),
+    ]

django_cfg/apps/integrations/grpc/migrations/0002_rename_django_cfg__service_4c4a8e_idx_django_cfg__service_584308_idx_and_more.py

@@ -0,0 +1,38 @@
+# Generated by Django 5.2.7 on 2025-11-01 13:48
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("grpc", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.RenameIndex(
+            model_name="grpcrequestlog",
+            new_name="django_cfg__service_584308_idx",
+            old_name="django_cfg__service_4c4a8e_idx",
+        ),
+        migrations.RenameIndex(
+            model_name="grpcrequestlog",
+            new_name="django_cfg__method__5e704d_idx",
+            old_name="django_cfg__method__8e1a7c_idx",
+        ),
+        migrations.RenameIndex(
+            model_name="grpcrequestlog",
+            new_name="django_cfg__status_a564a8_idx",
+            old_name="django_cfg__status_f3d9a1_idx",
+        ),
+        migrations.RenameIndex(
+            model_name="grpcrequestlog",
+            new_name="django_cfg__user_id_f2ada7_idx",
+            old_name="django_cfg__user_id_9c2b4f_idx",
+        ),
+        migrations.RenameIndex(
+            model_name="grpcrequestlog",
+            new_name="django_cfg__grpc_st_fea09f_idx",
+            old_name="django_cfg__grpc_st_a7e5c2_idx",
+        ),
+    ]