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

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

@@ -0,0 +1,397 @@
+"""
+Monitoring Service.
+
+Provides business logic for gRPC monitoring and statistics.
+"""
+
+from datetime import datetime
+from typing import Dict, List, Optional
+
+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 .config_helper import get_grpc_server_config
+
+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 = get_grpc_server_config()
+
+        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
+
+        return {
+            "status": "healthy" if enabled else "stopped",
+            "server_host": grpc_server_config.host,
+            "server_port": grpc_server_config.port,
+            "enabled": enabled,
+            "timestamp": datetime.now().isoformat(),
+        }
+
+    def get_overview_statistics(self, hours: int = 24) -> Dict:
+        """
+        Get overview statistics for gRPC requests with server information.
+
+        Args:
+            hours: Statistics period in hours (1-168)
+
+        Returns:
+            Dictionary with overview statistics and server info
+
+        Example:
+            >>> service = MonitoringService()
+            >>> stats = service.get_overview_statistics(hours=24)
+            >>> stats['total']
+            1000
+            >>> stats['server']['is_running']
+            True
+        """
+        hours = min(max(hours, 1), 168)  # 1 hour to 1 week
+
+        # Get request statistics
+        stats = GRPCRequestLog.objects.get_statistics(hours=hours)
+        stats["period_hours"] = hours
+
+        # Get server information
+        server_info = self._get_server_info_for_overview(hours=hours)
+        stats["server"] = server_info
+
+        return stats
+
+    def _get_server_info_for_overview(self, hours: int) -> Dict:
+        """
+        Get server information for overview endpoint.
+
+        Args:
+            hours: Statistics period for service stats
+
+        Returns:
+            Dictionary with server information including services
+        """
+        from ..services import ServiceDiscovery
+
+        # Get current server status
+        current_server = GRPCServerStatus.objects.get_current_server()
+
+        if not current_server:
+            # No server running
+            grpc_server_config = get_grpc_server_config()
+            return {
+                "status": "stopped",
+                "is_running": False,
+                "host": grpc_server_config.host if grpc_server_config else "[::]",
+                "port": grpc_server_config.port if grpc_server_config else 50051,
+                "address": f"{grpc_server_config.host}:{grpc_server_config.port}" if grpc_server_config else "[::]:50051",
+                "pid": None,
+                "started_at": None,
+                "uptime_seconds": 0,
+                "uptime_display": "Not running",
+                "registered_services_count": 0,
+                "enable_reflection": False,
+                "enable_health_check": False,
+                "last_heartbeat": None,
+                "services": [],
+                "services_healthy": True,
+            }
+
+        # Get service statistics for the period
+        service_stats_qs = (
+            GRPCRequestLog.objects.recent(hours)
+            .values("service_name")
+            .annotate(
+                total=Count("id"),
+                errors=Count("id", filter=models.Q(status="error")),
+            )
+        )
+
+        # Create service stats lookup
+        service_stats_lookup = {
+            stat["service_name"]: stat for stat in service_stats_qs
+        }
+
+        # Get registered services from service discovery
+        discovery = ServiceDiscovery()
+        registered_services = discovery.get_registered_services()
+
+        # Build services list with stats
+        services_list = []
+        total_errors = 0
+
+        for service in registered_services:
+            service_name = service.get("name", "")
+            full_name = service.get("full_name", service_name)
+            methods = service.get("methods", [])
+
+            # Get stats for this service
+            stats = service_stats_lookup.get(full_name, {"total": 0, "errors": 0})
+            request_count = stats.get("total", 0)
+            error_count = stats.get("errors", 0)
+            success_rate = (
+                ((request_count - error_count) / request_count * 100)
+                if request_count > 0
+                else 100.0
+            )
+
+            total_errors += error_count
+
+            services_list.append({
+                "name": service_name,
+                "full_name": full_name,
+                "methods_count": len(methods),
+                "request_count": request_count,
+                "error_count": error_count,
+                "success_rate": round(success_rate, 2),
+            })
+
+        # Sort by request count
+        services_list.sort(key=lambda x: x["request_count"], reverse=True)
+
+        # Determine if all services are healthy (no errors in period)
+        services_healthy = total_errors == 0
+
+        return {
+            "status": current_server.status,
+            "is_running": current_server.is_running,
+            "host": current_server.host,
+            "port": current_server.port,
+            "address": current_server.address,
+            "pid": current_server.pid,
+            "started_at": current_server.started_at,
+            "uptime_seconds": current_server.uptime_seconds,
+            "uptime_display": current_server.uptime_display,
+            "registered_services_count": len(services_list),
+            "enable_reflection": current_server.enable_reflection,
+            "enable_health_check": current_server.enable_health_check,
+            "last_heartbeat": current_server.last_heartbeat,
+            "services": services_list,
+            "services_healthy": services_healthy,
+        }
+
+    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.select_related("user", "api_key").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 = {
+                "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)
+
+        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 = {
+                "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)
+
+        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/proto_files_manager.py

@@ -0,0 +1,268 @@
+"""
+Proto Files Manager Service.
+
+Handles proto file operations: scanning, reading, generating, archiving.
+"""
+
+import io
+import zipfile
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from django.conf import settings
+from django_cfg.modules.django_logging import get_logger
+
+from .config_helper import get_grpc_config
+
+logger = get_logger("grpc.proto_files_manager")
+
+
+class ProtoFilesManager:
+    """
+    Service for managing proto files.
+
+    Handles:
+    - Scanning proto directory
+    - Reading proto files
+    - Generating proto files from Django models
+    - Creating zip archives
+    """
+
+    def __init__(self):
+        """Initialize proto files manager."""
+        self.grpc_config = get_grpc_config()
+
+    def get_proto_dir(self) -> Path:
+        """
+        Get proto files directory path.
+
+        Returns:
+            Path to proto files directory
+        """
+        if self.grpc_config and self.grpc_config.proto and self.grpc_config.proto.output_dir:
+            proto_dir = Path(settings.BASE_DIR) / self.grpc_config.proto.output_dir
+        else:
+            proto_dir = Path(settings.MEDIA_ROOT) / "protos"
+
+        return proto_dir
+
+    def scan_proto_files(self, request=None) -> List[Dict]:
+        """
+        Scan proto directory and return list of proto files with metadata.
+
+        Args:
+            request: Optional Django request object for building download URLs
+
+        Returns:
+            List of dicts with proto file metadata:
+            {
+                "app_label": str,
+                "filename": str,
+                "size_bytes": int,
+                "package": str,
+                "messages_count": int,
+                "services_count": int,
+                "created_at": float,
+                "modified_at": float,
+                "download_url": str (if request provided),
+            }
+        """
+        proto_dir = self.get_proto_dir()
+
+        if not proto_dir.exists():
+            logger.warning(f"Proto directory does not exist: {proto_dir}")
+            return []
+
+        proto_files = []
+        for proto_file in proto_dir.glob("*.proto"):
+            try:
+                metadata = self._parse_proto_file(proto_file)
+                if metadata:
+                    # Add download URL if request provided
+                    if request:
+                        from django.urls import reverse
+                        from django_cfg.core.state import get_current_config
+
+                        app_label = metadata['app_label']
+                        config = get_current_config()
+
+                        # Use api_url from config (respects HTTPS behind reverse proxy)
+                        # Falls back to request.build_absolute_uri if config not available
+                        if config and hasattr(config, 'api_url'):
+                            path = reverse('django_cfg_grpc:proto-files-detail', kwargs={'pk': app_label})
+                            download_url = f"{config.api_url}{path}"
+                        else:
+                            download_url = request.build_absolute_uri(
+                                reverse('django_cfg_grpc:proto-files-detail', kwargs={'pk': app_label})
+                            )
+
+                        metadata['download_url'] = download_url
+
+                    proto_files.append(metadata)
+            except Exception as e:
+                logger.error(f"Error reading proto file {proto_file}: {e}")
+                continue
+
+        return proto_files
+
+    def _parse_proto_file(self, proto_file: Path) -> Optional[Dict]:
+        """
+        Parse proto file and extract metadata.
+
+        Args:
+            proto_file: Path to proto file
+
+        Returns:
+            Dict with proto file metadata or None if failed
+        """
+        try:
+            stat = proto_file.stat()
+            content = proto_file.read_text()
+
+            # Parse proto file for metadata
+            package = ""
+            messages_count = 0
+            services_count = 0
+
+            for line in content.split("\n"):
+                line = line.strip()
+                if line.startswith("package "):
+                    package = line.replace("package ", "").replace(";", "").strip()
+                elif line.startswith("message "):
+                    messages_count += 1
+                elif line.startswith("service "):
+                    services_count += 1
+
+            # Extract app_label from filename (crypto.proto -> crypto)
+            app_label = proto_file.stem
+
+            return {
+                "app_label": app_label,
+                "filename": proto_file.name,
+                "size_bytes": stat.st_size,
+                "package": package,
+                "messages_count": messages_count,
+                "services_count": services_count,
+                "created_at": stat.st_ctime,
+                "modified_at": stat.st_mtime,
+            }
+
+        except Exception as e:
+            logger.error(f"Error parsing proto file {proto_file}: {e}")
+            return None
+
+    def get_proto_file(self, app_label: str) -> Optional[Path]:
+        """
+        Get path to proto file for specific app.
+
+        Args:
+            app_label: App label (e.g., 'crypto')
+
+        Returns:
+            Path to proto file or None if not found
+        """
+        proto_dir = self.get_proto_dir()
+        proto_file = proto_dir / f"{app_label}.proto"
+
+        if proto_file.exists():
+            return proto_file
+
+        logger.warning(f"Proto file not found for app '{app_label}'")
+        return None
+
+    def create_zip_archive(self) -> Optional[bytes]:
+        """
+        Create zip archive with all proto files.
+
+        Returns:
+            Zip archive bytes or None if failed
+        """
+        proto_dir = self.get_proto_dir()
+
+        if not proto_dir.exists():
+            logger.error(f"Proto directory does not exist: {proto_dir}")
+            return None
+
+        try:
+            # Create zip in memory
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
+                proto_files = list(proto_dir.glob("*.proto"))
+
+                if not proto_files:
+                    logger.warning("No proto files found to archive")
+                    return None
+
+                for proto_file in proto_files:
+                    zip_file.write(proto_file, arcname=proto_file.name)
+                    logger.debug(f"Added to archive: {proto_file.name}")
+
+            zip_buffer.seek(0)
+            return zip_buffer.read()
+
+        except Exception as e:
+            logger.error(f"Error creating zip archive: {e}", exc_info=True)
+            return None
+
+    def generate_protos(self, apps: Optional[List[str]] = None, force: bool = False) -> Dict:
+        """
+        Generate proto files for specified apps.
+
+        Args:
+            apps: List of app labels (uses enabled_apps from config if None)
+            force: Force regeneration even if proto file exists
+
+        Returns:
+            Dict with generation results:
+            {
+                "status": "success" | "failed",
+                "generated": List[str],  # Successfully generated app labels
+                "generated_count": int,
+                "errors": List[Dict],  # Errors for failed apps
+            }
+        """
+        from ..utils.proto_gen import generate_proto_for_app
+
+        # Determine which apps to generate for
+        if not apps:
+            if self.grpc_config and self.grpc_config.enabled_apps:
+                apps = self.grpc_config.enabled_apps
+            else:
+                logger.error("No apps specified and no enabled_apps in config")
+                return {
+                    "status": "failed",
+                    "generated": [],
+                    "generated_count": 0,
+                    "errors": [{"app": "N/A", "error": "No apps specified"}],
+                }
+
+        generated = []
+        errors = []
+
+        for app_label in apps:
+            try:
+                logger.info(f"Generating proto for app: {app_label}")
+                count = generate_proto_for_app(app_label)
+
+                if count > 0:
+                    generated.append(app_label)
+                    logger.info(f"Successfully generated proto for {app_label}")
+                else:
+                    error_msg = "No models found"
+                    logger.warning(f"No models found in app {app_label}")
+                    errors.append({"app": app_label, "error": error_msg})
+
+            except Exception as e:
+                error_msg = str(e)
+                logger.error(f"Proto generation error for {app_label}: {error_msg}", exc_info=True)
+                errors.append({"app": app_label, "error": error_msg})
+
+        return {
+            "status": "success" if generated else "failed",
+            "generated": generated,
+            "generated_count": len(generated),
+            "errors": errors,
+        }
+
+
+__all__ = ["ProtoFilesManager"]