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

django_cfg/apps/integrations/grpc/services/commands/registry.py

@@ -0,0 +1,170 @@
+"""
+Global Service Registry for Streaming Services
+
+Provides a global registry to store and retrieve BidirectionalStreamingService instances.
+This enables same-process command sending from anywhere in the application.
+
+Usage:
+    # In your gRPC service initialization (handlers/__init__.py)
+    from django_cfg.apps.integrations.grpc.commands.registry import register_streaming_service
+
+    def grpc_handlers(server):
+        servicer = YourStreamingService()
+        register_streaming_service("your_service", servicer._streaming_service)
+        # ... rest of setup
+
+    # In your command client
+    from django_cfg.apps.integrations.grpc.commands.registry import get_streaming_service
+
+    service = get_streaming_service("your_service")
+    client = CommandClient(client_id="123", streaming_service=service)
+
+Documentation: See @commands/README.md § Global Service Registry
+"""
+
+import logging
+from threading import RLock
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+# Global registry of streaming services
+# Key: service name (e.g., "bots", "signals")
+# Value: BidirectionalStreamingService instance
+_streaming_services: Dict[str, Any] = {}
+
+# Thread-safe lock for registry access
+_registry_lock = RLock()
+
+
+def register_streaming_service(name: str, service: Any) -> None:
+    """
+    Register a streaming service in the global registry.
+
+    This should be called when the gRPC service is initialized,
+    typically in the grpc_handlers() function.
+
+    Args:
+        name: Service name (e.g., "bots", "signals", "notifications")
+        service: BidirectionalStreamingService instance
+
+    Example:
+        from your_app.grpc.server import YourStreamingService
+
+        def grpc_handlers(server):
+            servicer = YourStreamingService()
+            register_streaming_service("your_service", servicer._streaming_service)
+            # ... rest of setup
+    """
+    with _registry_lock:
+        if name in _streaming_services:
+            logger.warning(
+                f"Streaming service '{name}' already registered, overwriting"
+            )
+
+        _streaming_services[name] = service
+        logger.info(f"Registered streaming service: {name}")
+
+
+def get_streaming_service(name: str) -> Optional[Any]:
+    """
+    Get a streaming service from the global registry.
+
+    Args:
+        name: Service name
+
+    Returns:
+        BidirectionalStreamingService instance or None if not found
+
+    Example:
+        service = get_streaming_service("bots")
+        if service:
+            client = CommandClient(client_id="123", streaming_service=service)
+        else:
+            # Service not registered, will use cross-process mode
+            client = CommandClient(client_id="123", grpc_port=50051)
+    """
+    with _registry_lock:
+        service = _streaming_services.get(name)
+
+        if service is None:
+            logger.debug(
+                f"Streaming service '{name}' not found in registry. "
+                f"Available: {list(_streaming_services.keys())}"
+            )
+
+        return service
+
+
+def unregister_streaming_service(name: str) -> bool:
+    """
+    Unregister a streaming service from the global registry.
+
+    Args:
+        name: Service name
+
+    Returns:
+        True if service was unregistered, False if not found
+    """
+    with _registry_lock:
+        if name in _streaming_services:
+            del _streaming_services[name]
+            logger.info(f"Unregistered streaming service: {name}")
+            return True
+        return False
+
+
+def list_streaming_services() -> List[str]:
+    """
+    List all registered streaming service names.
+
+    Returns:
+        List of service names
+
+    Example:
+        >>> list_streaming_services()
+        ['bots', 'signals', 'notifications']
+    """
+    with _registry_lock:
+        return list(_streaming_services.keys())
+
+
+def is_registered(name: str) -> bool:
+    """
+    Check if a streaming service is registered.
+
+    Args:
+        name: Service name
+
+    Returns:
+        True if registered, False otherwise
+    """
+    with _registry_lock:
+        return name in _streaming_services
+
+
+def clear_registry() -> None:
+    """
+    Clear all registered services.
+
+    Warning: This should only be used in tests or during shutdown.
+    """
+    with _registry_lock:
+        count = len(_streaming_services)
+        _streaming_services.clear()
+        logger.info(f"Cleared {count} streaming services from registry")
+
+
+# Convenience alias for backward compatibility
+set_streaming_service = register_streaming_service
+
+
+__all__ = [
+    'register_streaming_service',
+    'get_streaming_service',
+    'unregister_streaming_service',
+    'list_streaming_services',
+    'is_registered',
+    'clear_registry',
+    'set_streaming_service',  # alias
+]

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

@@ -0,0 +1,39 @@
+"""
+gRPC service discovery and registry.
+
+This package provides tools for discovering and registering gRPC services
+in a distributed environment.
+
+**Components**:
+- discovery: Service discovery mechanisms
+- registry: Service registration and management
+
+**Usage Example**:
+```python
+from django_cfg.apps.integrations.grpc.services.discovery import (
+    ServiceDiscovery,
+    ServiceRegistry,
+)
+
+# Register service
+registry = ServiceRegistry()
+registry.register(service_name="my-service", host="localhost", port=50051)
+
+# Discover services
+discovery = ServiceDiscovery()
+services = discovery.discover_all()
+```
+
+Created: 2025-11-07
+Status: %%PRODUCTION%%
+"""
+
+# Export discovery components
+from .discovery import ServiceDiscovery, discover_and_register_services
+from .registry import ServiceRegistryManager
+
+__all__ = [
+    'ServiceDiscovery',
+    'ServiceRegistryManager',
+    'discover_and_register_services',
+]

django_cfg/apps/integrations/grpc/services/{discovery.py → discovery/discovery.py}

@@ -11,7 +11,7 @@ from django.apps import apps
 
 from django_cfg.modules.django_logging import get_logger
 
-from .config_helper import get_enabled_apps, get_grpc_config
+from ..management.config_helper import get_enabled_apps, get_grpc_config
 
 logger = get_logger("grpc.discovery")
 
@@ -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 []
@@ -439,68 +443,77 @@ class ServiceDiscovery:
             logger.error(f"Error extracting metadata from {service_class}: {e}", exc_info=True)
             return None
 
-    def get_handlers_hook(self) -> Optional[Any]:
+    def get_handlers_hooks(self) -> List[Any]:
         """
-        Get the handlers hook function from config.
+        Get the handlers hook function(s) from config.
 
         Returns:
-            Handlers hook function or None
+            List of handlers hook functions (empty list if none)
 
         Example:
             >>> discovery = ServiceDiscovery()
-            >>> handlers_hook = discovery.get_handlers_hook()
-            >>> if handlers_hook:
-            ...     services = handlers_hook(server)
+            >>> handlers_hooks = discovery.get_handlers_hooks()
+            >>> for hook in handlers_hooks:
+            ...     hook(server)
         """
+        logger.warning(f"🔍 get_handlers_hooks called")
         if not self.config:
-            logger.debug("No gRPC config available")
-            return None
-
-        handlers_hook_path = self.config.handlers_hook
-
-        if not handlers_hook_path:
-            logger.debug("No handlers_hook configured")
-            return None
+            logger.warning("❌ No gRPC config available")
+            return []
+
+        handlers_hook_paths = self.config.handlers_hook
+        logger.warning(f"🔍 handlers_hook_paths = '{handlers_hook_paths}'")
+
+        # Convert single string to list
+        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:
+            # 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}")
+                    continue
 
-        # 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
+                # Import the module containing the hook
+                module_path, func_name = handlers_hook_path.rsplit(".", 1)
+                module = importlib.import_module(module_path)
 
-        try:
-            # Import the module containing the hook
-            module_path, func_name = handlers_hook_path.rsplit(".", 1)
-            module = importlib.import_module(module_path)
+                # Get the hook function
+                handlers_hook = getattr(module, func_name)
 
-            # Get the hook function
-            handlers_hook = getattr(module, func_name)
+                if not callable(handlers_hook):
+                    logger.warning(f"handlers_hook {handlers_hook_path} is not callable")
+                    continue
 
-            if not callable(handlers_hook):
-                logger.warning(f"ROOT_HANDLERS_HOOK {handlers_hook_path} is not callable")
-                return None
+                logger.info(f"Loaded handlers hook: {handlers_hook_path}")
+                hooks.append(handlers_hook)
 
-            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}")
+                continue
+            except AttributeError as e:
+                logger.warning(f"Handlers hook function not found in {handlers_hook_path}: {e}")
+                logger.debug(f"This is optional - the hook function does not exist")
+                continue
+            except Exception as e:
+                logger.error(
+                    f"Error loading handlers hook {handlers_hook_path}: {e}",
+                    exc_info=True,
+                )
+                continue
 
-        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}")
-            logger.debug(f"This is optional - the hook function '{func_name}' does not exist in module '{module_path}'")
-            return None
-        except Exception as e:
-            logger.error(
-                f"Error loading handlers hook {handlers_hook_path}: {e}",
-                exc_info=True,
-            )
-            return None
+        return hooks
 
 
 def discover_and_register_services(server: Any) -> int:
@@ -534,15 +547,15 @@ def discover_and_register_services(server: Any) -> int:
     discovery = ServiceDiscovery()
     count = 0
 
-    # Try handlers hook first
-    handlers_hook = discovery.get_handlers_hook()
-    if handlers_hook:
+    # Try handlers hooks first (can be multiple)
+    handlers_hooks = discovery.get_handlers_hooks()
+    for hook in handlers_hooks:
         try:
-            handlers_hook(server)
-            logger.info("Successfully called handlers hook")
+            hook(server)
+            logger.info(f"Successfully called handlers hook: {hook.__name__}")
             count += 1  # We don't know exact count, but at least 1
         except Exception as e:
-            logger.error(f"Error calling handlers hook: {e}", exc_info=True)
+            logger.error(f"Error calling handlers hook {hook.__name__}: {e}", exc_info=True)
 
     # Discover and register services
     services = discovery.discover_services()

django_cfg/apps/integrations/grpc/services/{service_registry.py → discovery/registry.py}

@@ -10,7 +10,7 @@ from typing import Dict, List, Optional
 from django.db import models
 from django.db.models import Avg, Count
 
-from ..models import GRPCRequestLog, GRPCServerStatus
+from ...models import GRPCRequestLog, GRPCServerStatus
 from django_cfg.modules.django_logging import get_logger
 
 logger = get_logger("grpc.service_registry")
@@ -31,7 +31,7 @@ class ServiceRegistryManager:
 
     def get_current_server(self) -> Optional[GRPCServerStatus]:
         """
-        Get the currently running gRPC server instance.
+        Get the currently running gRPC server instance (SYNC).
 
         Returns:
             GRPCServerStatus instance if server is running, None otherwise
@@ -45,6 +45,22 @@ class ServiceRegistryManager:
             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 - Django 5.2).
+
+        Returns:
+            GRPCServerStatus instance if server is running, None otherwise
+        """
+        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.
@@ -100,7 +116,7 @@ class ServiceRegistryManager:
         self, service_name: str, hours: int = 24
     ) -> Dict:
         """
-        Get statistics for a specific service.
+        Get statistics for a specific service (SYNC).
 
         Args:
             service_name: Service name
@@ -142,9 +158,39 @@ class ServiceRegistryManager:
             "avg_duration_ms": round(stats["avg_duration"] or 0, 2),
         }
 
+    async def aget_service_statistics(
+        self, 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
+
+        Example:
+            >>> manager = ServiceRegistryManager()
+            >>> stats = await manager.aget_service_statistics("apps.CryptoService", hours=24)
+            >>> stats['total']
+            150
+            >>> stats['successful']
+            145
+            >>> stats['success_rate']
+            96.67
+        """
+        # Django 5.2: Native async aggregate is not available yet (Django 5.2 limitation)
+        # Use asgiref.sync.sync_to_async as recommended by Django docs
+        from asgiref.sync import sync_to_async
+
+        # Wrap the sync version in sync_to_async
+        return await sync_to_async(self.get_service_statistics)(service_name, hours)
+
     def get_all_services_with_stats(self, hours: int = 24) -> List[Dict]:
         """
-        Get all services with their statistics.
+        Get all services with their statistics (SYNC).
 
         Args:
             hours: Statistics period in hours (default: 24)
@@ -206,11 +252,84 @@ class ServiceRegistryManager:
 
         return services_with_stats
 
+    async def aget_all_services_with_stats(self, hours: int = 24) -> List[Dict]:
+        """
+        Get all services with their statistics (ASYNC - Django 5.2).
+
+        Args:
+            hours: Statistics period in hours (default: 24)
+
+        Returns:
+            List of services with statistics
+
+        Example:
+            >>> manager = ServiceRegistryManager()
+            >>> services = await manager.aget_all_services_with_stats(hours=24)
+            >>> services[0]['name']
+            'apps.CryptoService'
+            >>> services[0]['total_requests']
+            150
+        """
+        # Get all services (sync operation - from cache or filesystem)
+        services = self.get_all_services()
+        services_with_stats = []
+
+        # Django 5.2: Use sync_to_async for aggregate queries that aren't natively async yet
+        from asgiref.sync import sync_to_async
+
+        # Create async version of the aggregate operation
+        @sync_to_async
+        def get_service_stats_sync(service_name: str):
+            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"),
+                )
+            )
+
+        for service in services:
+            service_name = service.get("name")
+
+            # Get stats from GRPCRequestLog (async)
+            stats = await get_service_stats_sync(service_name)
+
+            # 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 ""
+
+            # Build dict directly
+            service_summary = {
+                "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)
+
+        return services_with_stats
+
     def get_service_methods_with_stats(
         self, service_name: str
     ) -> List[Dict]:
         """
-        Get all methods for a service with statistics.
+        Get all methods for a service with statistics (SYNC).
 
         Args:
             service_name: Service name
@@ -286,6 +405,97 @@ class ServiceRegistryManager:
 
         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 - Django 5.2).
+
+        Args:
+            service_name: Service name
+
+        Returns:
+            List of methods with statistics
+
+        Example:
+            >>> manager = ServiceRegistryManager()
+            >>> methods = await manager.aget_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 []
+
+        # Django 5.2: Use sync_to_async for complex queries with aggregates and values_list
+        from asgiref.sync import sync_to_async
+
+        @sync_to_async
+        def get_method_durations(svc_name: str, method_name: str):
+            return list(
+                GRPCRequestLog.objects.filter(
+                    service_name=svc_name,
+                    method_name=method_name,
+                    duration_ms__isnull=False,
+                ).values_list("duration_ms", flat=True)
+            )
+
+        @sync_to_async
+        def get_method_stats(svc_name: str, method_name: str):
+            return GRPCRequestLog.objects.filter(
+                service_name=svc_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"),
+            )
+
+        methods_list = []
+        for method_name in service.get("methods", []):
+            # Get durations for percentile calculation (async)
+            durations = await get_method_durations(service_name, method_name)
+
+            # Get aggregate stats (async)
+            stats = await get_method_stats(service_name, method_name)
+
+            # 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
+
+            # Build method stats dict
+            method_stats = {
+                "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,
+            }
+
+            # Build method summary dict
+            method_summary = {
+                "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)
+
+        return methods_list
+
     def _calculate_percentiles(self, values):
         """
         Calculate p50, p95, p99 percentiles.

django_cfg/apps/integrations/grpc/{interceptors → services/interceptors}/__init__.py

@@ -1,15 +1,17 @@
 """
-gRPC interceptors for logging, metrics, and error handling.
+gRPC interceptors for logging, metrics, error handling, and Centrifugo publishing.
 
 Provides production-ready interceptors for gRPC services.
 """
 
+from .centrifugo import CentrifugoInterceptor
 from .errors import ErrorHandlingInterceptor
 from .logging import LoggingInterceptor
 from .metrics import MetricsInterceptor, get_metrics, reset_metrics
 from .request_logger import RequestLoggerInterceptor
 
 __all__ = [
+    "CentrifugoInterceptor",
     "LoggingInterceptor",
     "MetricsInterceptor",
     "ErrorHandlingInterceptor",