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

django_cfg/apps/integrations/grpc/serializers/testing.py

@@ -1,98 +1,106 @@
 """
-Pydantic serializers for gRPC Testing API.
+DRF serializers for gRPC Testing API.
 
 These serializers define the structure for testing endpoints
 that provide example payloads and test logs.
 """
 
-from typing import Any, Dict, List, Optional
+from rest_framework import serializers
 
-from pydantic import BaseModel, Field
 
-
-class GRPCExampleSerializer(BaseModel):
+class GRPCExampleSerializer(serializers.Serializer):
     """Example payload for a gRPC method."""
 
-    service: str = Field(..., description="Service name")
-    method: str = Field(..., description="Method name")
-    description: str = Field(..., description="Method description")
-    payload_example: Dict[str, Any] = Field(
-        ..., description="Example request payload"
-    )
-    expected_response: Dict[str, Any] = Field(
-        ..., description="Example expected response"
-    )
-    metadata_example: Dict[str, str] = Field(
-        default_factory=dict, description="Example metadata (headers)"
+    service = serializers.CharField(help_text="Service name")
+    method = serializers.CharField(help_text="Method name")
+    description = serializers.CharField(help_text="Method description")
+    payload_example = serializers.DictField(help_text="Example request payload")
+    expected_response = serializers.DictField(help_text="Example expected response")
+    metadata_example = serializers.DictField(
+        default=dict, help_text="Example metadata (headers)"
     )
 
 
-class GRPCExamplesListSerializer(BaseModel):
+class GRPCExamplesListSerializer(serializers.Serializer):
     """List of examples response."""
 
-    examples: List[GRPCExampleSerializer] = Field(
-        default_factory=list, description="List of examples"
+    examples = GRPCExampleSerializer(
+        many=True, default=list, help_text="List of examples"
     )
-    total_examples: int = Field(..., description="Total number of examples")
+    total_examples = serializers.IntegerField(help_text="Total number of examples")
 
 
-class GRPCTestLogSerializer(BaseModel):
+class GRPCTestLogSerializer(serializers.Serializer):
     """Single test log entry."""
 
-    request_id: str = Field(..., description="Request ID")
-    service: str = Field(..., description="Service name")
-    method: str = Field(..., description="Method name")
-    status: str = Field(..., description="Request status (success, error, etc.)")
-    grpc_status_code: Optional[str] = Field(
-        None, description="gRPC status code if available"
+    request_id = serializers.CharField(help_text="Request ID")
+    service = serializers.CharField(help_text="Service name")
+    method = serializers.CharField(help_text="Method name")
+    status = serializers.CharField(
+        help_text="Request status (success, error, etc.)"
+    )
+    grpc_status_code = serializers.CharField(
+        required=False, allow_null=True, help_text="gRPC status code if available"
+    )
+    error_message = serializers.CharField(
+        required=False, allow_null=True, help_text="Error message if failed"
+    )
+    duration_ms = serializers.IntegerField(
+        required=False, allow_null=True, help_text="Duration in milliseconds"
+    )
+    created_at = serializers.CharField(
+        help_text="Request timestamp (ISO format)"
+    )
+    user = serializers.CharField(
+        required=False, allow_null=True, help_text="User who made the request"
     )
-    error_message: Optional[str] = Field(None, description="Error message if failed")
-    duration_ms: Optional[int] = Field(None, description="Duration in milliseconds")
-    created_at: str = Field(..., description="Request timestamp (ISO format)")
-    user: Optional[str] = Field(None, description="User who made the request")
 
 
-class GRPCTestLogsSerializer(BaseModel):
+class GRPCTestLogsSerializer(serializers.Serializer):
     """List of test logs response."""
 
-    logs: List[GRPCTestLogSerializer] = Field(
-        default_factory=list, description="List of test logs"
+    logs = GRPCTestLogSerializer(many=True, default=list, help_text="List of test logs")
+    count = serializers.IntegerField(help_text="Number of logs returned")
+    total_available = serializers.IntegerField(help_text="Total logs available")
+    has_more = serializers.BooleanField(
+        default=False, help_text="Whether more logs are available"
     )
-    count: int = Field(..., description="Number of logs returned")
-    total_available: int = Field(..., description="Total logs available")
-    has_more: bool = Field(False, description="Whether more logs are available")
 
 
-class GRPCCallRequestSerializer(BaseModel):
+class GRPCCallRequestSerializer(serializers.Serializer):
     """Request to call a gRPC method (for future implementation)."""
 
-    service: str = Field(..., description="Service name to call")
-    method: str = Field(..., description="Method name to call")
-    payload: Dict[str, Any] = Field(..., description="Request payload")
-    metadata: Dict[str, str] = Field(
-        default_factory=dict, description="Request metadata (headers)"
+    service = serializers.CharField(help_text="Service name to call")
+    method = serializers.CharField(help_text="Method name to call")
+    payload = serializers.DictField(help_text="Request payload")
+    metadata = serializers.DictField(
+        default=dict, help_text="Request metadata (headers)"
+    )
+    timeout_ms = serializers.IntegerField(
+        default=5000, help_text="Request timeout in milliseconds"
     )
-    timeout_ms: int = Field(5000, description="Request timeout in milliseconds")
 
 
-class GRPCCallResponseSerializer(BaseModel):
+class GRPCCallResponseSerializer(serializers.Serializer):
     """Response from calling a gRPC method."""
 
-    success: bool = Field(..., description="Whether call was successful")
-    request_id: str = Field(..., description="Request ID for tracking")
-    service: str = Field(..., description="Service name")
-    method: str = Field(..., description="Method name")
-    status: str = Field(..., description="Request status")
-    grpc_status_code: str = Field(..., description="gRPC status code")
-    duration_ms: int = Field(..., description="Call duration in milliseconds")
-    response: Optional[str] = Field(
-        None, description="Response data if successful (JSON string)"
+    success = serializers.BooleanField(help_text="Whether call was successful")
+    request_id = serializers.CharField(help_text="Request ID for tracking")
+    service = serializers.CharField(help_text="Service name")
+    method = serializers.CharField(help_text="Method name")
+    status = serializers.CharField(help_text="Request status")
+    grpc_status_code = serializers.CharField(help_text="gRPC status code")
+    duration_ms = serializers.IntegerField(help_text="Call duration in milliseconds")
+    response = serializers.CharField(
+        required=False,
+        allow_null=True,
+        help_text="Response data if successful (JSON string)",
     )
-    error: Optional[str] = Field(None, description="Error message if failed")
-    metadata: Dict[str, str] = Field(
-        default_factory=dict, description="Response metadata"
+    error = serializers.CharField(
+        required=False, allow_null=True, help_text="Error message if failed"
     )
-    timestamp: str = Field(..., description="Response timestamp (ISO format)")
+    metadata = serializers.DictField(default=dict, help_text="Response metadata")
+    timestamp = serializers.CharField(help_text="Response timestamp (ISO format)")
 
 
 __all__ = [

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

@@ -17,6 +17,7 @@ from .config_helper import (
 from .discovery import ServiceDiscovery, discover_and_register_services
 from .grpc_client import DynamicGRPCClient
 from .monitoring_service import MonitoringService
+from .proto_files_manager import ProtoFilesManager
 from .service_registry import ServiceRegistryManager
 from .testing_service import TestingService
 
@@ -30,6 +31,7 @@ __all__ = [
     "MonitoringService",
     "TestingService",
     "DynamicGRPCClient",
+    "ProtoFilesManager",
     "get_grpc_config",
     "get_grpc_config_or_default",
     "is_grpc_enabled",

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

@@ -53,6 +53,10 @@ class ServiceDiscovery:
         # Get config from django-cfg using Pydantic2 pattern
         self.config = get_grpc_config()
 
+        logger.warning(f"🔍 ServiceDiscovery.__init__: config = {self.config}")
+        if self.config:
+            logger.warning(f"🔍 handlers_hook = {self.config.handlers_hook}")
+
         if self.config:
             self.auto_register = self.config.auto_register_apps
             self.enabled_apps = self.config.enabled_apps if self.config.auto_register_apps else []
@@ -452,11 +456,13 @@ class ServiceDiscovery:
             >>> if handlers_hook:
             ...     services = handlers_hook(server)
         """
+        logger.warning(f"🔍 get_handlers_hook called")
         if not self.config:
-            logger.debug("No gRPC config available")
+            logger.warning("❌ No gRPC config available")
             return None
 
         handlers_hook_path = self.config.handlers_hook
+        logger.warning(f"🔍 handlers_hook_path = '{handlers_hook_path}'")
 
         if not handlers_hook_path:
             logger.debug("No handlers_hook configured")

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

@@ -7,20 +7,13 @@ 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
+from .config_helper import get_grpc_server_config
 
 logger = get_logger("grpc.monitoring_service")
 
@@ -45,7 +38,7 @@ class MonitoringService:
             >>> health['status']
             'healthy'
         """
-        grpc_server_config = getattr(settings, "GRPC_SERVER", {})
+        grpc_server_config = get_grpc_server_config()
 
         if not grpc_server_config:
             raise ValueError("gRPC not configured")
@@ -57,39 +50,152 @@ class MonitoringService:
         # 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()
+        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.
+        Get overview statistics for gRPC requests with server information.
 
         Args:
             hours: Statistics period in hours (1-168)
 
         Returns:
-            Dictionary with overview statistics
+            Dictionary with overview statistics and server info
 
         Example:
             >>> service = MonitoringService()
             >>> stats = service.get_overview_statistics(hours=24)
-            >>> stats['total_requests']
+            >>> 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
 
-        overview = GRPCOverviewStatsSerializer(**stats)
-        return overview.model_dump()
+        # 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,
@@ -114,7 +220,7 @@ class MonitoringService:
             >>> queryset.count()
             25
         """
-        queryset = GRPCRequestLog.objects.all()
+        queryset = GRPCRequestLog.objects.select_related("user", "api_key").all()
 
         # Apply filters
         if service_name:
@@ -160,19 +266,19 @@ class MonitoringService:
 
         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=(
+            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.model_dump())
+            }
+            services_list.append(service_data)
 
         return services_list
 
@@ -217,20 +323,20 @@ class MonitoringService:
 
         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=(
+            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.model_dump())
+            }
+            methods_list.append(method_data)
 
         return methods_list