django-cfg 1.4.46__py3-none-any.whl → 1.5.181__py3-none-any.whl

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

@@ -0,0 +1,274 @@
+"""
+Service Discovery for gRPC.
+
+Automatically discovers and registers gRPC services from Django apps.
+"""
+
+import importlib
+from typing import Any, Dict, List, Optional, Tuple
+
+from django.apps import apps
+
+from django_cfg.utils import get_logger
+
+from ..management.config_helper import get_grpc_config
+from .utils import (
+    is_grpc_service,
+    get_add_to_server_func,
+    extract_service_metadata,
+)
+
+logger = get_logger("grpc.discovery")
+
+
+class ServiceDiscovery:
+    """
+    Discovers gRPC services from Django applications.
+
+    Features:
+    - Auto-discovers services from enabled apps
+    - Supports custom service registration
+    - Configurable discovery paths
+    - Lazy loading support
+
+    Example:
+        ```python
+        from django_cfg.apps.integrations.grpc.services.discovery import ServiceDiscovery
+
+        discovery = ServiceDiscovery()
+        services = discovery.discover_services()
+
+        for service_class, add_to_server_func in services:
+            add_to_server_func(service_class.as_servicer(), server)
+        ```
+    """
+
+    def __init__(self):
+        """Initialize service discovery."""
+        self.config = get_grpc_config()
+
+        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 []
+            self.custom_services = self.config.custom_services
+        else:
+            self.auto_register = False
+            self.enabled_apps = []
+            self.custom_services = {}
+            logger.warning("gRPC config not found, service discovery disabled")
+
+        self.service_modules = [
+            "grpc_services",
+            "grpc_handlers",
+            "services.grpc",
+            "handlers.grpc",
+            "api.grpc",
+        ]
+
+    def discover_services(self) -> List[Tuple[Any, Any]]:
+        """
+        Discover all gRPC services.
+
+        Returns:
+            List of (service_class, add_to_server_func) tuples
+        """
+        discovered_services = []
+
+        if self.auto_register:
+            for app_label in self.enabled_apps:
+                services = self._discover_app_services(app_label)
+                discovered_services.extend(services)
+
+        for service_path in self.custom_services.values():
+            service = self._load_custom_service(service_path)
+            if service:
+                discovered_services.append(service)
+
+        logger.info(f"Discovered {len(discovered_services)} gRPC service(s)")
+        return discovered_services
+
+    def _discover_app_services(self, app_label: str) -> List[Tuple[Any, Any]]:
+        """Discover services from a Django app."""
+        services = []
+
+        try:
+            app_config = apps.get_app_config(app_label)
+        except LookupError:
+            logger.warning(
+                f"[gRPC Discovery] App '{app_label}' not found in INSTALLED_APPS. "
+                f"Either add it to INSTALLED_APPS or remove from grpc.enabled_apps in config"
+            )
+            return services
+
+        for module_name in self.service_modules:
+            full_module_path = f"{app_config.name}.{module_name}"
+
+            try:
+                module = importlib.import_module(full_module_path)
+                logger.debug(f"Found gRPC module: {full_module_path}")
+
+                app_services = self._extract_services_from_module(module, full_module_path)
+                services.extend(app_services)
+
+            except ImportError:
+                logger.debug(f"No gRPC module at {full_module_path}")
+                continue
+            except Exception as e:
+                logger.error(f"Error importing {full_module_path}: {e}", exc_info=True)
+                continue
+
+        if services:
+            logger.info(f"Discovered {len(services)} service(s) from app '{app_label}'")
+
+        return services
+
+    def _extract_services_from_module(
+        self, module: Any, module_path: str
+    ) -> List[Tuple[Any, Any]]:
+        """Extract gRPC services from a module."""
+        services = []
+
+        # Look for grpc_handlers() function
+        if hasattr(module, "grpc_handlers"):
+            handlers_func = getattr(module, "grpc_handlers")
+            if callable(handlers_func):
+                try:
+                    handlers = handlers_func(None)
+                    logger.info(f"Found grpc_handlers() in {module_path}")
+
+                    if isinstance(handlers, list):
+                        services.extend(handlers)
+                    else:
+                        logger.warning(
+                            f"grpc_handlers() in {module_path} did not return a list"
+                        )
+
+                except Exception as e:
+                    logger.error(
+                        f"Error calling grpc_handlers() in {module_path}: {e}",
+                        exc_info=True,
+                    )
+
+        # Look for individual service classes
+        for attr_name in dir(module):
+            if attr_name.startswith("_"):
+                continue
+
+            attr = getattr(module, attr_name)
+
+            if is_grpc_service(attr):
+                logger.debug(f"Found gRPC service class: {module_path}.{attr_name}")
+
+                add_to_server_func = get_add_to_server_func(attr, module_path)
+                if add_to_server_func:
+                    services.append((attr, add_to_server_func))
+
+        return services
+
+    def _load_custom_service(self, service_path: str) -> Optional[Tuple[Any, Any]]:
+        """Load a custom service from dotted path."""
+        try:
+            module_path, class_name = service_path.rsplit(".", 1)
+            module = importlib.import_module(module_path)
+            service_class = getattr(module, class_name)
+
+            add_to_server_func = get_add_to_server_func(service_class, module_path)
+            if not add_to_server_func:
+                logger.warning(f"Custom service {service_path} has no add_to_server function")
+                return None
+
+            logger.info(f"Loaded custom service: {service_path}")
+            return (service_class, add_to_server_func)
+
+        except ImportError as e:
+            logger.error(f"Failed to import custom service {service_path}: {e}")
+            return None
+        except AttributeError as e:
+            logger.error(f"Service class not found in {service_path}: {e}")
+            return None
+        except Exception as e:
+            logger.error(f"Error loading custom service {service_path}: {e}", exc_info=True)
+            return None
+
+    def get_registered_services(self) -> List[Dict[str, Any]]:
+        """Get list of registered services with metadata."""
+        services_metadata = []
+        discovered_services = self.discover_services()
+
+        for service_class, add_to_server_func in discovered_services:
+            metadata = extract_service_metadata(service_class)
+            if metadata:
+                services_metadata.append(metadata)
+
+        return services_metadata
+
+    def get_service_by_name(self, service_name: str) -> Optional[Dict[str, Any]]:
+        """Get service metadata by name."""
+        services = self.get_registered_services()
+        for service in services:
+            if service.get('name') == service_name:
+                return service
+        return None
+
+    def get_handlers_hooks(self) -> List[Any]:
+        """Get the handlers hook function(s) from config."""
+        logger.info(f"get_handlers_hooks: config={self.config}")
+
+        if not self.config:
+            logger.warning("No gRPC config available for handlers_hooks")
+            return []
+
+        handlers_hook_paths = self.config.handlers_hook
+        logger.info(f"get_handlers_hooks: handlers_hook_paths={handlers_hook_paths}")
+
+        if isinstance(handlers_hook_paths, str):
+            if not handlers_hook_paths:
+                logger.debug("No handlers_hook configured")
+                return []
+            handlers_hook_paths = [handlers_hook_paths]
+
+        hooks = []
+        for handlers_hook_path in handlers_hook_paths:
+            hook = self._load_handler_hook(handlers_hook_path)
+            if hook:
+                hooks.append(hook)
+
+        return hooks
+
+    def _load_handler_hook(self, handlers_hook_path: str) -> Optional[Any]:
+        """Load a single handler hook."""
+        # Resolve {ROOT_URLCONF} placeholder
+        if "{ROOT_URLCONF}" in handlers_hook_path:
+            try:
+                from django.conf import settings
+                root_urlconf = settings.ROOT_URLCONF
+                handlers_hook_path = handlers_hook_path.replace("{ROOT_URLCONF}", root_urlconf)
+                logger.debug(f"Resolved handlers_hook: {handlers_hook_path}")
+            except Exception as e:
+                logger.warning(f"Could not resolve {{ROOT_URLCONF}}: {e}")
+                return None
+
+        try:
+            module_path, func_name = handlers_hook_path.rsplit(".", 1)
+            module = importlib.import_module(module_path)
+            handlers_hook = getattr(module, func_name)
+
+            if not callable(handlers_hook):
+                logger.warning(f"handlers_hook {handlers_hook_path} is not callable")
+                return None
+
+            logger.info(f"Loaded handlers hook: {handlers_hook_path}")
+            return handlers_hook
+
+        except ImportError as e:
+            logger.warning(f"Failed to import handlers hook module {handlers_hook_path}: {e}")
+            return None
+        except AttributeError as e:
+            logger.warning(f"Handlers hook function not found in {handlers_hook_path}: {e}")
+            return None
+        except Exception as e:
+            logger.error(f"Error loading handlers hook {handlers_hook_path}: {e}", exc_info=True)
+            return None
+
+
+__all__ = ["ServiceDiscovery"]

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

@@ -0,0 +1,201 @@
+"""
+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 django_cfg.utils import get_logger
+
+from .statistics import (
+    calculate_percentiles,
+    get_service_statistics,
+    aget_service_statistics,
+    get_method_statistics,
+    aget_method_statistics,
+)
+
+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 (SYNC)."""
+        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
+
+    async def aget_current_server(self) -> Optional[GRPCServerStatus]:
+        """Get the currently running gRPC server instance (ASYNC)."""
+        try:
+            current_server = await GRPCServerStatus.objects.aget_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 .service_discovery import ServiceDiscovery
+        discovery = ServiceDiscovery()
+        return discovery.get_registered_services()
+
+    def get_service_by_name(self, service_name: str) -> Optional[Dict]:
+        """Get service metadata by service name."""
+        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 (SYNC)."""
+        return get_service_statistics(service_name, hours)
+
+    async def aget_service_statistics(self, service_name: str, hours: int = 24) -> Dict:
+        """Get statistics for a specific service (ASYNC)."""
+        return await aget_service_statistics(service_name, hours)
+
+    def get_all_services_with_stats(self, hours: int = 24) -> List[Dict]:
+        """Get all services with their statistics (SYNC)."""
+        services = self.get_all_services()
+        services_with_stats = []
+
+        for service in services:
+            service_name = service.get("name")
+            stats = self._get_service_summary_stats(service_name, hours)
+            service_summary = self._build_service_summary(service, service_name, stats)
+            services_with_stats.append(service_summary)
+
+        return services_with_stats
+
+    async def aget_all_services_with_stats(self, hours: int = 24) -> List[Dict]:
+        """Get all services with their statistics (ASYNC)."""
+        services = self.get_all_services()
+        services_with_stats = []
+
+        for service in services:
+            service_name = service.get("name")
+            stats = await self._aget_service_summary_stats(service_name, hours)
+            service_summary = self._build_service_summary(service, service_name, stats)
+            services_with_stats.append(service_summary)
+
+        return services_with_stats
+
+    def get_service_methods_with_stats(self, service_name: str) -> List[Dict]:
+        """Get all methods for a service with statistics (SYNC)."""
+        service = self.get_service_by_name(service_name)
+        if not service:
+            return []
+
+        methods_list = []
+        for method_name in service.get("methods", []):
+            method_stats = get_method_statistics(service_name, method_name)
+            method_summary = self._build_method_summary(service_name, method_name, method_stats)
+            methods_list.append(method_summary)
+
+        return methods_list
+
+    async def aget_service_methods_with_stats(self, service_name: str) -> List[Dict]:
+        """Get all methods for a service with statistics (ASYNC)."""
+        service = self.get_service_by_name(service_name)
+        if not service:
+            return []
+
+        methods_list = []
+        for method_name in service.get("methods", []):
+            method_stats = await aget_method_statistics(service_name, method_name)
+            method_summary = self._build_method_summary(service_name, method_name, method_stats)
+            methods_list.append(method_summary)
+
+        return methods_list
+
+    def is_server_running(self) -> bool:
+        """Check if gRPC server is currently running."""
+        return self.get_current_server() is not None
+
+    # Helper methods
+
+    def _get_service_summary_stats(self, service_name: str, hours: int) -> Dict:
+        """Get summary stats for a service (SYNC)."""
+        return (
+            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"),
+            )
+        )
+
+    async def _aget_service_summary_stats(self, service_name: str, hours: int) -> Dict:
+        """Get summary stats for a service (ASYNC)."""
+        return await (
+            GRPCRequestLog.objects.filter(service_name=service_name)
+            .recent(hours)
+            .aaggregate(
+                total=Count("id"),
+                successful=Count("id", filter=models.Q(status="success")),
+                avg_duration=Avg("duration_ms"),
+                last_activity=models.Max("created_at"),
+            )
+        )
+
+    def _build_service_summary(self, service: Dict, service_name: str, stats: Dict) -> Dict:
+        """Build service summary dict."""
+        total = stats["total"] or 0
+        successful = stats["successful"] or 0
+        success_rate = (successful / total * 100) if total > 0 else 0.0
+        package = service_name.split(".")[0] if "." in service_name else ""
+
+        return {
+            "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
+            ),
+        }
+
+    def _build_method_summary(self, service_name: str, method_name: str, stats: Dict) -> Dict:
+        """Build method summary dict."""
+        return {
+            "name": method_name,
+            "full_name": f"/{service_name}/{method_name}",
+            "service_name": service_name,
+            "request_type": "",
+            "response_type": "",
+            "stats": stats,
+        }
+
+
+__all__ = ["ServiceRegistryManager"]

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

@@ -0,0 +1,215 @@
+"""
+Statistics calculations for gRPC services.
+"""
+
+from typing import Dict, List, Tuple
+
+from django.db import models
+from django.db.models import Avg, Count
+
+from ...models import GRPCRequestLog
+
+
+def calculate_percentiles(values: List[float]) -> Tuple[float, float, float]:
+    """
+    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 get_service_statistics(service_name: str, hours: int = 24) -> Dict:
+    """
+    Get statistics for a specific service (SYNC).
+
+    Args:
+        service_name: Service name
+        hours: Statistics period in hours (default: 24)
+
+    Returns:
+        Dictionary with service statistics
+    """
+    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),
+    }
+
+
+async def aget_service_statistics(service_name: str, hours: int = 24) -> Dict:
+    """
+    Get statistics for a specific service (ASYNC - Django 5.2).
+
+    Args:
+        service_name: Service name
+        hours: Statistics period in hours (default: 24)
+
+    Returns:
+        Dictionary with service statistics
+    """
+    stats = await (
+        GRPCRequestLog.objects.filter(service_name=service_name)
+        .recent(hours)
+        .aaggregate(
+            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_method_statistics(service_name: str, method_name: str) -> Dict:
+    """
+    Get statistics for a specific method (SYNC).
+
+    Args:
+        service_name: Service name
+        method_name: Method name
+
+    Returns:
+        Dictionary with method statistics
+    """
+    # 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"),
+    )
+
+    p50, p95, p99 = calculate_percentiles(durations)
+
+    total = stats["total"] or 0
+    successful = stats["successful"] or 0
+    success_rate = (successful / total * 100) if total > 0 else 0.0
+
+    return {
+        "total_requests": total,
+        "successful": successful,
+        "errors": stats["errors"] or 0,
+        "success_rate": round(success_rate, 2),
+        "avg_duration_ms": round(stats["avg_duration"] or 0, 2),
+        "p50_duration_ms": p50,
+        "p95_duration_ms": p95,
+        "p99_duration_ms": p99,
+    }
+
+
+async def aget_method_statistics(service_name: str, method_name: str) -> Dict:
+    """
+    Get statistics for a specific method (ASYNC - Django 5.2).
+
+    Args:
+        service_name: Service name
+        method_name: Method name
+
+    Returns:
+        Dictionary with method statistics
+    """
+    # Get durations using async iteration
+    durations = [
+        duration async for duration in
+        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 = await GRPCRequestLog.objects.filter(
+        service_name=service_name,
+        method_name=method_name,
+    ).aaggregate(
+        total=Count("id"),
+        successful=Count("id", filter=models.Q(status="success")),
+        errors=Count("id", filter=models.Q(status="error")),
+        avg_duration=Avg("duration_ms"),
+    )
+
+    p50, p95, p99 = calculate_percentiles(durations)
+
+    total = stats["total"] or 0
+    successful = stats["successful"] or 0
+    success_rate = (successful / total * 100) if total > 0 else 0.0
+
+    return {
+        "total_requests": total,
+        "successful": successful,
+        "errors": stats["errors"] or 0,
+        "success_rate": round(success_rate, 2),
+        "avg_duration_ms": round(stats["avg_duration"] or 0, 2),
+        "p50_duration_ms": p50,
+        "p95_duration_ms": p95,
+        "p99_duration_ms": p99,
+    }
+
+
+__all__ = [
+    "calculate_percentiles",
+    "get_service_statistics",
+    "aget_service_statistics",
+    "get_method_statistics",
+    "aget_method_statistics",
+]