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

django_cfg/apps/integrations/grpc/services/monitoring_service.py

@@ -0,0 +1,291 @@
+"""
+Monitoring Service.
+
+Provides business logic for gRPC monitoring and statistics.
+"""
+
+from datetime import datetime
+from typing import Dict, List, Optional
+
+from django.conf import settings
+from django.db import models
+from django.db.models import Avg, Count, Max
+from django.db.models.functions import TruncDay, TruncHour
+from django_cfg.modules.django_logging import get_logger
+
+from ..models import GRPCRequestLog, GRPCServerStatus
+from ..serializers import (
+    GRPCHealthCheckSerializer,
+    GRPCOverviewStatsSerializer,
+    MethodStatsSerializer,
+    MonitoringServiceStatsSerializer,
+)
+from ..serializers.service_registry import RecentRequestSerializer
+
+logger = get_logger("grpc.monitoring_service")
+
+
+class MonitoringService:
+    """
+    Service for gRPC monitoring operations.
+
+    Provides methods to retrieve health status, statistics, and monitoring data.
+    """
+
+    def get_health_status(self) -> Dict:
+        """
+        Get gRPC server health status.
+
+        Returns:
+            Dictionary with health status data
+
+        Example:
+            >>> service = MonitoringService()
+            >>> health = service.get_health_status()
+            >>> health['status']
+            'healthy'
+        """
+        grpc_server_config = getattr(settings, "GRPC_SERVER", {})
+
+        if not grpc_server_config:
+            raise ValueError("gRPC not configured")
+
+        # Check if server is actually running
+        current_server = GRPCServerStatus.objects.get_current_server()
+        is_running = current_server and current_server.is_running
+
+        # Ensure enabled is always boolean, not None
+        enabled = bool(is_running) if is_running is not None else False
+
+        health_data = GRPCHealthCheckSerializer(
+            status="healthy" if enabled else "stopped",
+            server_host=grpc_server_config.get("host", "[::]"),
+            server_port=grpc_server_config.get("port", 50051),
+            enabled=enabled,
+            timestamp=datetime.now().isoformat(),
+        )
+
+        return health_data.model_dump()
+
+    def get_overview_statistics(self, hours: int = 24) -> Dict:
+        """
+        Get overview statistics for gRPC requests.
+
+        Args:
+            hours: Statistics period in hours (1-168)
+
+        Returns:
+            Dictionary with overview statistics
+
+        Example:
+            >>> service = MonitoringService()
+            >>> stats = service.get_overview_statistics(hours=24)
+            >>> stats['total_requests']
+            1000
+        """
+        hours = min(max(hours, 1), 168)  # 1 hour to 1 week
+
+        stats = GRPCRequestLog.objects.get_statistics(hours=hours)
+        stats["period_hours"] = hours
+
+        overview = GRPCOverviewStatsSerializer(**stats)
+        return overview.model_dump()
+
+    def get_recent_requests(
+        self,
+        service_name: Optional[str] = None,
+        method_name: Optional[str] = None,
+        status_filter: Optional[str] = None,
+    ):
+        """
+        Get recent gRPC requests queryset.
+
+        Args:
+            service_name: Filter by service name
+            method_name: Filter by method name
+            status_filter: Filter by status (success/error)
+
+        Returns:
+            Queryset of GRPCRequestLog (pagination handled by DRF)
+
+        Example:
+            >>> service = MonitoringService()
+            >>> queryset = service.get_recent_requests(status_filter='error')
+            >>> queryset.count()
+            25
+        """
+        queryset = GRPCRequestLog.objects.all()
+
+        # Apply filters
+        if service_name:
+            queryset = queryset.filter(service_name=service_name)
+        if method_name:
+            queryset = queryset.filter(method_name=method_name)
+        if status_filter:
+            queryset = queryset.filter(status=status_filter)
+
+        return queryset.order_by("-created_at")
+
+    def get_service_statistics(self, hours: int = 24) -> List[Dict]:
+        """
+        Get statistics per service.
+
+        Args:
+            hours: Statistics period in hours
+
+        Returns:
+            List of service statistics
+
+        Example:
+            >>> service = MonitoringService()
+            >>> services = service.get_service_statistics(hours=24)
+            >>> services[0]['service_name']
+            'apps.CryptoService'
+        """
+        hours = min(max(hours, 1), 168)
+
+        # Get service statistics
+        service_stats = (
+            GRPCRequestLog.objects.recent(hours)
+            .values("service_name")
+            .annotate(
+                total=Count("id"),
+                successful=Count("id", filter=models.Q(status="success")),
+                errors=Count("id", filter=models.Q(status="error")),
+                avg_duration_ms=Avg("duration_ms"),
+                last_activity_at=Max("created_at"),
+            )
+            .order_by("-total")
+        )
+
+        services_list = []
+        for stats in service_stats:
+            service_data = MonitoringServiceStatsSerializer(
+                service_name=stats["service_name"],
+                total=stats["total"],
+                successful=stats["successful"],
+                errors=stats["errors"],
+                avg_duration_ms=round(stats["avg_duration_ms"] or 0, 2),
+                last_activity_at=(
+                    stats["last_activity_at"].isoformat()
+                    if stats["last_activity_at"]
+                    else None
+                ),
+            )
+            services_list.append(service_data.model_dump())
+
+        return services_list
+
+    def get_method_statistics(
+        self, service_name: Optional[str] = None, hours: int = 24
+    ) -> List[Dict]:
+        """
+        Get statistics per method.
+
+        Args:
+            service_name: Filter by service name
+            hours: Statistics period in hours
+
+        Returns:
+            List of method statistics
+
+        Example:
+            >>> service = MonitoringService()
+            >>> methods = service.get_method_statistics(service_name='apps.CryptoService')
+            >>> methods[0]['method_name']
+            'GetCoin'
+        """
+        hours = min(max(hours, 1), 168)
+
+        queryset = GRPCRequestLog.objects.recent(hours)
+
+        if service_name:
+            queryset = queryset.filter(service_name=service_name)
+
+        # Get method statistics
+        method_stats = (
+            queryset.values("service_name", "method_name")
+            .annotate(
+                total=Count("id"),
+                successful=Count("id", filter=models.Q(status="success")),
+                errors=Count("id", filter=models.Q(status="error")),
+                avg_duration_ms=Avg("duration_ms"),
+                last_activity_at=Max("created_at"),  # Add missing field
+            )
+            .order_by("-total")
+        )
+
+        methods_list = []
+        for stats in method_stats:
+            method_data = MethodStatsSerializer(
+                service_name=stats["service_name"],
+                method_name=stats["method_name"],
+                total=stats["total"],
+                successful=stats["successful"],
+                errors=stats["errors"],
+                avg_duration_ms=round(stats["avg_duration_ms"] or 0, 2),
+                last_activity_at=(
+                    stats["last_activity_at"].isoformat()
+                    if stats["last_activity_at"]
+                    else None
+                ),
+            )
+            methods_list.append(method_data.model_dump())
+
+        return methods_list
+
+    def get_timeline_data(self, hours: int = 24, granularity: str = "hour") -> List[Dict]:
+        """
+        Get timeline data for requests.
+
+        Args:
+            hours: Period in hours
+            granularity: 'hour' or 'day'
+
+        Returns:
+            List of timeline data points
+
+        Example:
+            >>> service = MonitoringService()
+            >>> timeline = service.get_timeline_data(hours=24, granularity='hour')
+            >>> timeline[0]['timestamp']
+            '2025-01-01T12:00:00'
+        """
+        hours = min(max(hours, 1), 168)
+
+        # Choose truncation function
+        if granularity == "day" or hours > 48:
+            trunc_func = TruncDay
+            time_format = "%Y-%m-%d"
+        else:
+            trunc_func = TruncHour
+            time_format = "%Y-%m-%d %H:00"
+
+        # Get timeline data
+        timeline_data = (
+            GRPCRequestLog.objects.recent(hours)
+            .annotate(period=trunc_func("created_at"))
+            .values("period")
+            .annotate(
+                total=Count("id"),
+                successful=Count("id", filter=models.Q(status="success")),
+                errors=Count("id", filter=models.Q(status="error")),
+                avg_duration=Avg("duration_ms"),
+            )
+            .order_by("period")
+        )
+
+        timeline_list = []
+        for data in timeline_data:
+            timeline_list.append({
+                "timestamp": data["period"].strftime(time_format),
+                "total": data["total"],
+                "successful": data["successful"],
+                "errors": data["errors"],
+                "avg_duration_ms": round(data["avg_duration"] or 0, 2),
+            })
+
+        return timeline_list
+
+
+__all__ = ["MonitoringService"]

django_cfg/apps/integrations/grpc/services/service_registry.py

@@ -0,0 +1,328 @@
+"""
+Service Registry Manager.
+
+Provides business logic for accessing and managing registered gRPC services.
+Acts as a bridge between the running gRPC server and the REST API.
+"""
+
+from typing import Dict, List, Optional
+
+from django.db import models
+from django.db.models import Avg, Count
+
+from ..models import GRPCRequestLog, GRPCServerStatus
+from ..serializers.service_registry import (
+    MethodStatsSerializer,
+    MethodSummarySerializer,
+    ServiceSummarySerializer,
+)
+from django_cfg.modules.django_logging import get_logger
+
+logger = get_logger("grpc.service_registry")
+
+
+class ServiceRegistryManager:
+    """
+    Manager for accessing registered gRPC services.
+
+    This class provides methods to retrieve service metadata from the running
+    gRPC server instance stored in the database.
+
+    Example:
+        >>> manager = ServiceRegistryManager()
+        >>> services = manager.get_all_services()
+        >>> service = manager.get_service_by_name("apps.CryptoService")
+    """
+
+    def get_current_server(self) -> Optional[GRPCServerStatus]:
+        """
+        Get the currently running gRPC server instance.
+
+        Returns:
+            GRPCServerStatus instance if server is running, None otherwise
+        """
+        try:
+            current_server = GRPCServerStatus.objects.get_current_server()
+            if current_server and current_server.is_running:
+                return current_server
+            return None
+        except Exception as e:
+            logger.error(f"Error getting current server: {e}", exc_info=True)
+            return None
+
+    def get_all_services(self) -> List[Dict]:
+        """
+        Get all registered services from the running gRPC server.
+
+        Returns:
+            List of service metadata dictionaries
+
+        Example:
+            >>> manager = ServiceRegistryManager()
+            >>> services = manager.get_all_services()
+            >>> len(services)
+            1
+            >>> services[0]['name']
+            'apps.CryptoService'
+        """
+        current_server = self.get_current_server()
+        if not current_server:
+            logger.debug("No running gRPC server found")
+            return []
+
+        return current_server.registered_services or []
+
+    def get_service_by_name(self, service_name: str) -> Optional[Dict]:
+        """
+        Get service metadata by service name.
+
+        Args:
+            service_name: Full service name (e.g., "apps.CryptoService")
+
+        Returns:
+            Service metadata dictionary or None if not found
+
+        Example:
+            >>> manager = ServiceRegistryManager()
+            >>> service = manager.get_service_by_name("apps.CryptoService")
+            >>> service['name']
+            'apps.CryptoService'
+            >>> service['methods']
+            ['GetCoin', 'ListCoins', ...]
+        """
+        services = self.get_all_services()
+        return next((s for s in services if s.get("name") == service_name), None)
+
+    def get_service_statistics(
+        self, service_name: str, hours: int = 24
+    ) -> Dict:
+        """
+        Get statistics for a specific service.
+
+        Args:
+            service_name: Service name
+            hours: Statistics period in hours (default: 24)
+
+        Returns:
+            Dictionary with service statistics
+
+        Example:
+            >>> manager = ServiceRegistryManager()
+            >>> stats = manager.get_service_statistics("apps.CryptoService", hours=24)
+            >>> stats['total']
+            150
+            >>> stats['successful']
+            145
+            >>> stats['success_rate']
+            96.67
+        """
+        stats = (
+            GRPCRequestLog.objects.filter(service_name=service_name)
+            .recent(hours)
+            .aggregate(
+                total=Count("id"),
+                successful=Count("id", filter=models.Q(status="success")),
+                errors=Count("id", filter=models.Q(status="error")),
+                avg_duration=Avg("duration_ms"),
+            )
+        )
+
+        total = stats["total"] or 0
+        successful = stats["successful"] or 0
+        success_rate = (successful / total * 100) if total > 0 else 0.0
+
+        return {
+            "total": total,
+            "successful": successful,
+            "errors": stats["errors"] or 0,
+            "success_rate": round(success_rate, 2),
+            "avg_duration_ms": round(stats["avg_duration"] or 0, 2),
+        }
+
+    def get_all_services_with_stats(self, hours: int = 24) -> List[Dict]:
+        """
+        Get all services with their statistics.
+
+        Args:
+            hours: Statistics period in hours (default: 24)
+
+        Returns:
+            List of services with statistics
+
+        Example:
+            >>> manager = ServiceRegistryManager()
+            >>> services = manager.get_all_services_with_stats(hours=24)
+            >>> services[0]['name']
+            'apps.CryptoService'
+            >>> services[0]['total_requests']
+            150
+        """
+        services = self.get_all_services()
+        services_with_stats = []
+
+        for service in services:
+            service_name = service.get("name")
+
+            # Get stats from GRPCRequestLog
+            stats = (
+                GRPCRequestLog.objects.filter(service_name=service_name)
+                .recent(hours)
+                .aggregate(
+                    total=Count("id"),
+                    successful=Count("id", filter=models.Q(status="success")),
+                    avg_duration=Avg("duration_ms"),
+                    last_activity=models.Max("created_at"),
+                )
+            )
+
+            # Calculate success rate
+            total = stats["total"] or 0
+            successful = stats["successful"] or 0
+            success_rate = (successful / total * 100) if total > 0 else 0.0
+
+            # Extract package name
+            package = service_name.split(".")[0] if "." in service_name else ""
+
+            # Validate and serialize data
+            service_summary = ServiceSummarySerializer(
+                name=service_name,
+                full_name=service.get("full_name", f"/{service_name}"),
+                package=package,
+                methods_count=len(service.get("methods", [])),
+                total_requests=total,
+                success_rate=round(success_rate, 2),
+                avg_duration_ms=round(stats["avg_duration"] or 0, 2),
+                last_activity_at=(
+                    stats["last_activity"].isoformat()
+                    if stats["last_activity"]
+                    else None
+                ),
+            )
+
+            services_with_stats.append(service_summary.model_dump())
+
+        return services_with_stats
+
+    def get_service_methods_with_stats(
+        self, service_name: str
+    ) -> List[Dict]:
+        """
+        Get all methods for a service with statistics.
+
+        Args:
+            service_name: Service name
+
+        Returns:
+            List of methods with statistics
+
+        Example:
+            >>> manager = ServiceRegistryManager()
+            >>> methods = manager.get_service_methods_with_stats("apps.CryptoService")
+            >>> methods[0]['name']
+            'GetCoin'
+            >>> methods[0]['stats']['total_requests']
+            50
+        """
+        service = self.get_service_by_name(service_name)
+        if not service:
+            return []
+
+        methods_list = []
+        for method_name in service.get("methods", []):
+            # Get durations for percentile calculation
+            durations = list(
+                GRPCRequestLog.objects.filter(
+                    service_name=service_name,
+                    method_name=method_name,
+                    duration_ms__isnull=False,
+                ).values_list("duration_ms", flat=True)
+            )
+
+            # Get aggregate stats
+            stats = GRPCRequestLog.objects.filter(
+                service_name=service_name,
+                method_name=method_name,
+            ).aggregate(
+                total=Count("id"),
+                successful=Count("id", filter=models.Q(status="success")),
+                errors=Count("id", filter=models.Q(status="error")),
+                avg_duration=Avg("duration_ms"),
+            )
+
+            # Calculate percentiles
+            p50, p95, p99 = self._calculate_percentiles(durations)
+
+            # Calculate success rate
+            total = stats["total"] or 0
+            successful = stats["successful"] or 0
+            success_rate = (successful / total * 100) if total > 0 else 0.0
+
+            # Create stats object first
+            method_stats = MethodStatsSerializer(
+                service_name=service_name,
+                method_name=method_name,
+                total=total,
+                successful=successful,
+                errors=stats["errors"] or 0,
+                avg_duration_ms=round(stats["avg_duration"] or 0, 2),
+                p50_duration_ms=p50,
+                p95_duration_ms=p95,
+                p99_duration_ms=p99,
+            )
+
+            # Validate and serialize method with stats
+            method_summary = MethodSummarySerializer(
+                name=method_name,
+                full_name=f"/{service_name}/{method_name}",
+                service_name=service_name,
+                request_type="",
+                response_type="",
+                stats=method_stats,
+            )
+
+            methods_list.append(method_summary.model_dump())
+
+        return methods_list
+
+    def _calculate_percentiles(self, values):
+        """
+        Calculate p50, p95, p99 percentiles.
+
+        Args:
+            values: List of numeric values
+
+        Returns:
+            Tuple of (p50, p95, p99)
+        """
+        if not values:
+            return 0.0, 0.0, 0.0
+
+        sorted_values = sorted(values)
+        n = len(sorted_values)
+
+        p50_idx = int(n * 0.50)
+        p95_idx = int(n * 0.95)
+        p99_idx = int(n * 0.99)
+
+        return (
+            float(sorted_values[p50_idx] if p50_idx < n else 0),
+            float(sorted_values[p95_idx] if p95_idx < n else 0),
+            float(sorted_values[p99_idx] if p99_idx < n else 0),
+        )
+
+    def is_server_running(self) -> bool:
+        """
+        Check if gRPC server is currently running.
+
+        Returns:
+            True if server is running, False otherwise
+
+        Example:
+            >>> manager = ServiceRegistryManager()
+            >>> manager.is_server_running()
+            True
+        """
+        return self.get_current_server() is not None
+
+
+__all__ = ["ServiceRegistryManager"]