django-cfg 1.4.21__py3-none-any.whl → 1.4.24__py3-none-any.whl

django_cfg/apps/api/health/views.py

@@ -6,16 +6,16 @@ Built-in health monitoring endpoints that auto-configure from DjangoConfig.
 
 import os
 import time
-import psutil
 from datetime import datetime
-from typing import Dict, Any
+from typing import Any, Dict
 
-from django.http import JsonResponse
-from django.views import View
-from django.db import connections
-from django.core.cache import cache
+import psutil
 from django.conf import settings
+from django.core.cache import cache
+from django.db import connections
+from django.http import JsonResponse
 from django.utils import timezone
+from django.views import View
 
 from django_cfg.core.integration import get_current_version
 
@@ -30,14 +30,14 @@ class HealthCheckView(View):
     - System resources
     - Configuration status
     """
-    
+
     def get(self, request):
         """Return comprehensive health check data."""
         # Get DjangoConfig instance
         try:
             from django.conf import settings
             config = getattr(settings, 'config', None)
-            
+
             health_data = {
                 "status": "healthy",
                 "timestamp": timezone.now().isoformat(),
@@ -47,13 +47,13 @@ class HealthCheckView(View):
             }
         except Exception:
             health_data = {
-                "status": "healthy", 
+                "status": "healthy",
                 "timestamp": timezone.now().isoformat(),
                 "service": "Django CFG",
                 "version": get_current_version(),
                 "checks": {}
             }
-        
+
         # Database connectivity check
         try:
             db_status = self._check_databases()
@@ -64,19 +64,19 @@ class HealthCheckView(View):
                 "error": str(e)
             }
             health_data["status"] = "unhealthy"
-        
+
         # Cache availability check
         try:
             cache_status = self._check_cache()
             health_data["checks"]["cache"] = cache_status
         except Exception as e:
             health_data["checks"]["cache"] = {
-                "status": "error", 
+                "status": "error",
                 "error": str(e)
             }
             if health_data["status"] != "unhealthy":
                 health_data["status"] = "degraded"
-        
+
         # System resources check
         try:
             system_status = self._check_system_resources()
@@ -86,84 +86,84 @@ class HealthCheckView(View):
                 "status": "error",
                 "error": str(e)
             }
-        
+
         # Environment info
         health_data["environment"] = {
             "debug": getattr(settings, 'DEBUG', False),
             "django_env": os.getenv("DJANGO_ENV", "development"),
             "python_version": f"{os.sys.version_info.major}.{os.sys.version_info.minor}.{os.sys.version_info.micro}",
         }
-        
+
         # Return appropriate HTTP status
         status_code = 200
         if health_data["status"] == "unhealthy":
             status_code = 503
         elif health_data["status"] == "degraded":
             status_code = 200  # Still operational
-        
+
         return JsonResponse(health_data, status=status_code)
-    
+
     def _check_databases(self) -> Dict[str, Any]:
         """Check all configured database connections."""
         db_results = {}
-        
+
         # Get all configured databases
         database_names = list(getattr(settings, 'DATABASES', {}).keys())
-        
+
         for db_name in database_names:
             try:
                 start_time = time.time()
                 conn = connections[db_name]
-                
+
                 with conn.cursor() as cursor:
                     cursor.execute("SELECT 1")
                     cursor.fetchone()
-                
+
                 response_time = (time.time() - start_time) * 1000  # ms
-                
+
                 db_results[db_name] = {
                     "status": "healthy",
                     "response_time_ms": round(response_time, 2),
                     "engine": conn.settings_dict.get("ENGINE", "unknown"),
                 }
-                
+
             except Exception as e:
                 db_results[db_name] = {
                     "status": "error",
                     "error": str(e)[:100],  # Truncate long errors
                 }
-        
+
         # Overall database status
         all_healthy = all(
-            db["status"] == "healthy" 
+            db["status"] == "healthy"
             for db in db_results.values()
         ) if db_results else False
-        
+
         return {
             "status": "healthy" if all_healthy else "error",
             "databases": db_results,
             "total_databases": len(db_results),
         }
-    
+
     def _check_cache(self) -> Dict[str, Any]:
         """Check cache connectivity and performance."""
         try:
             test_key = "django_cfg_health_check"
             test_value = f"test_{int(time.time())}"
-            
+
             # Test cache write
             start_time = time.time()
             cache.set(test_key, test_value, timeout=60)
             write_time = (time.time() - start_time) * 1000
-            
+
             # Test cache read
             start_time = time.time()
             cached_value = cache.get(test_key)
             read_time = (time.time() - start_time) * 1000
-            
+
             # Cleanup
             cache.delete(test_key)
-            
+
             if cached_value == test_value:
                 return {
                     "status": "healthy",
@@ -176,29 +176,29 @@ class HealthCheckView(View):
                     "status": "error",
                     "error": "Cache read/write mismatch"
                 }
-                
+
         except Exception as e:
             return {
                 "status": "error",
                 "error": str(e)
             }
-    
+
     def _check_system_resources(self) -> Dict[str, Any]:
         """Check system resource usage."""
         try:
             # CPU usage
             cpu_percent = psutil.cpu_percent(interval=1)
-            
+
             # Memory usage
             memory = psutil.virtual_memory()
-            
+
             # Disk usage
             disk = psutil.disk_usage('/')
-            
+
             # System uptime
             boot_time = datetime.fromtimestamp(psutil.boot_time())
             uptime = datetime.now() - boot_time
-            
+
             return {
                 "status": "healthy",
                 "cpu": {
@@ -222,7 +222,7 @@ class HealthCheckView(View):
                 },
                 "process_count": len(psutil.pids()),
             }
-            
+
         except Exception as e:
             return {
                 "status": "error",
@@ -232,7 +232,7 @@ class HealthCheckView(View):
 
 class QuickHealthView(View):
     """Quick health check for load balancers."""
-    
+
     def get(self, request):
         """Return minimal health status."""
         try:
@@ -240,12 +240,12 @@ class QuickHealthView(View):
             conn = connections["default"]
             with conn.cursor() as cursor:
                 cursor.execute("SELECT 1")
-            
+
             return JsonResponse({
                 "status": "ok",
                 "timestamp": timezone.now().isoformat(),
             })
-            
+
         except Exception as e:
             return JsonResponse({
                 "status": "error",

django_cfg/{modules/django_ipc_client → apps/ipc}/__init__.py

@@ -28,13 +28,13 @@ Example:
     ... )
 """
 
-from .client import DjangoCfgRPCClient, get_rpc_client
-from .config import DjangoCfgRPCConfig
-from .exceptions import (
-    RPCTimeoutError,
-    RPCRemoteError,
-    RPCConnectionError,
+from .services.client.client import DjangoCfgRPCClient, get_rpc_client
+from .services.client.config import DjangoCfgRPCConfig
+from .services.client.exceptions import (
     RPCConfigurationError,
+    RPCConnectionError,
+    RPCRemoteError,
+    RPCTimeoutError,
 )
 
 __all__ = [

django_cfg/apps/ipc/apps.py

@@ -0,0 +1,28 @@
+"""
+Django app configuration for IPC/RPC module.
+
+Provides RPC client and monitoring dashboard.
+"""
+
+from django.apps import AppConfig
+
+
+class IPCConfig(AppConfig):
+    """
+    IPC/RPC application configuration.
+
+    Provides:
+    - RPC client for inter-service communication
+    - Monitoring dashboard with real-time stats
+    - DRF API endpoints for dashboard
+    """
+
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'django_cfg.apps.ipc'
+    label = 'django_cfg_ipc'
+    verbose_name = 'IPC/RPC System'
+
+    def ready(self):
+        """Initialize app when Django starts."""
+        # Import monitor to ensure Redis connection is initialized
+        from .services import monitor  # noqa: F401

django_cfg/apps/ipc/serializers/__init__.py

@@ -0,0 +1,19 @@
+"""
+Serializers for IPC/RPC module.
+"""
+
+from .serializers import (
+    HealthCheckSerializer,
+    MethodStatsSerializer,
+    NotificationStatsSerializer,
+    OverviewStatsSerializer,
+    RecentRequestsSerializer,
+)
+
+__all__ = [
+    'HealthCheckSerializer',
+    'OverviewStatsSerializer',
+    'RecentRequestsSerializer',
+    'NotificationStatsSerializer',
+    'MethodStatsSerializer',
+]

django_cfg/apps/ipc/serializers/serializers.py

@@ -0,0 +1,229 @@
+"""
+Serializers for RPC Dashboard API.
+
+DRF serializers for consistent API responses with type hints.
+"""
+
+
+from rest_framework import serializers
+
+
+class HealthCheckSerializer(serializers.Serializer):
+    """Serializer for health check response."""
+
+    redis_connected = serializers.BooleanField(
+        help_text="Whether Redis is connected"
+    )
+    stream_exists = serializers.BooleanField(
+        help_text="Whether the request stream exists"
+    )
+    stream_length = serializers.IntegerField(
+        help_text="Number of entries in the stream"
+    )
+    consumer_group_exists = serializers.BooleanField(
+        required=False,
+        default=False,
+        help_text="Whether the consumer group exists"
+    )
+    recent_activity = serializers.BooleanField(
+        help_text="Whether there was recent activity (last 5 min)"
+    )
+    last_request_time = serializers.CharField(
+        required=False,
+        allow_null=True,
+        default=None,
+        help_text="ISO timestamp of last request"
+    )
+    error = serializers.CharField(
+        required=False,
+        allow_null=True,
+        help_text="Error message if any"
+    )
+
+
+class OverviewStatsSerializer(serializers.Serializer):
+    """Serializer for overview statistics."""
+
+    redis_connected = serializers.BooleanField(
+        required=False,
+        help_text="Whether Redis is connected"
+    )
+    total_requests_today = serializers.IntegerField(
+        help_text="Total requests processed today"
+    )
+    total_requests_hour = serializers.IntegerField(
+        required=False,
+        default=0,
+        help_text="Total requests in the last hour"
+    )
+    active_methods = serializers.ListField(
+        child=serializers.CharField(),
+        help_text="List of active RPC methods"
+    )
+    top_method = serializers.CharField(
+        allow_null=True,
+        help_text="Most frequently called method"
+    )
+    method_counts = serializers.DictField(
+        required=False,
+        help_text="Count of requests per method"
+    )
+    avg_response_time_ms = serializers.FloatField(
+        help_text="Average response time in milliseconds"
+    )
+    success_rate = serializers.FloatField(
+        help_text="Success rate percentage"
+    )
+    error_rate = serializers.FloatField(
+        required=False,
+        default=0.0,
+        help_text="Error rate percentage"
+    )
+    timestamp = serializers.CharField(
+        required=False,
+        help_text="ISO timestamp of the stats"
+    )
+    error = serializers.CharField(
+        required=False,
+        allow_null=True,
+        help_text="Error message if any"
+    )
+
+
+class RPCRequestSerializer(serializers.Serializer):
+    """Serializer for individual RPC request."""
+
+    id = serializers.CharField(
+        required=False,
+        help_text="Stream entry ID"
+    )
+    request_id = serializers.CharField(
+        required=False,
+        help_text="Unique request ID"
+    )
+    timestamp = serializers.CharField(
+        help_text="ISO timestamp of the request"
+    )
+    method = serializers.CharField(
+        allow_null=True,
+        help_text="RPC method name"
+    )
+    params = serializers.DictField(
+        allow_null=True,
+        required=False,
+        help_text="Request parameters"
+    )
+    correlation_id = serializers.CharField(
+        allow_null=True,
+        required=False,
+        help_text="Correlation ID for tracking"
+    )
+    source = serializers.CharField(
+        allow_null=True,
+        required=False,
+        help_text="Source of the request"
+    )
+
+
+class RecentRequestsSerializer(serializers.Serializer):
+    """Serializer for recent requests response."""
+
+    requests = serializers.ListField(
+        child=RPCRequestSerializer(),
+        help_text="List of recent RPC requests"
+    )
+    count = serializers.IntegerField(
+        help_text="Number of requests returned"
+    )
+    total_available = serializers.IntegerField(
+        help_text="Total number of requests available"
+    )
+
+
+class NotificationTypeStatsSerializer(serializers.Serializer):
+    """Serializer for notification type statistics."""
+
+    user_activity = serializers.IntegerField(default=0)
+    system_alert = serializers.IntegerField(default=0)
+    error_notification = serializers.IntegerField(default=0)
+    info_message = serializers.IntegerField(default=0)
+
+
+class NotificationStatsSerializer(serializers.Serializer):
+    """Serializer for notification statistics."""
+
+    total_sent = serializers.IntegerField(
+        help_text="Total notifications sent"
+    )
+    delivery_rate = serializers.FloatField(
+        help_text="Delivery success rate percentage"
+    )
+    by_type = serializers.DictField(
+        required=False,
+        help_text="Breakdown by notification type"
+    )
+    recent = serializers.ListField(
+        required=False,
+        help_text="Recent notifications"
+    )
+    last_sent = serializers.CharField(
+        allow_null=True,
+        required=False,
+        help_text="ISO timestamp of last notification"
+    )
+    timestamp = serializers.CharField(
+        required=False,
+        help_text="ISO timestamp of the stats"
+    )
+    error = serializers.CharField(
+        required=False,
+        allow_null=True,
+        help_text="Error message if any"
+    )
+
+
+class MethodStatSerializer(serializers.Serializer):
+    """Serializer for individual method statistics."""
+
+    method = serializers.CharField(
+        help_text="RPC method name"
+    )
+    count = serializers.IntegerField(
+        help_text="Number of calls"
+    )
+    percentage = serializers.FloatField(
+        help_text="Percentage of total calls"
+    )
+    avg_time_ms = serializers.FloatField(
+        required=False,
+        help_text="Average execution time in milliseconds"
+    )
+    avg_time = serializers.FloatField(
+        required=False,
+        help_text="Average execution time (alternative field)"
+    )
+    success_rate = serializers.FloatField(
+        required=False,
+        default=100.0,
+        help_text="Success rate percentage"
+    )
+    last_called = serializers.CharField(
+        allow_null=True,
+        required=False,
+        help_text="ISO timestamp of last call"
+    )
+
+
+class MethodStatsSerializer(serializers.Serializer):
+    """Serializer for method statistics response."""
+
+    methods = serializers.ListField(
+        child=MethodStatSerializer(),
+        help_text="List of method statistics"
+    )
+    count = serializers.IntegerField(
+        help_text="Total number of methods"
+    )
+    total_calls = serializers.IntegerField(
+        help_text="Total calls across all methods"
+    )

django_cfg/apps/ipc/services/__init__.py

@@ -0,0 +1,7 @@
+"""
+Services for IPC/RPC module.
+"""
+
+from .monitor import RPCMonitor
+
+__all__ = ['RPCMonitor']

django_cfg/apps/ipc/services/client/__init__.py

@@ -0,0 +1,23 @@
+"""
+RPC Client services for IPC module.
+"""
+
+from .client import DjangoCfgRPCClient
+from .config import DjangoCfgRPCConfig
+from .exceptions import (
+    RPCConnectionError,
+    RPCError,
+    RPCInternalError,
+    RPCInvalidMethodError,
+    RPCTimeoutError,
+)
+
+__all__ = [
+    'DjangoCfgRPCClient',
+    'DjangoCfgRPCConfig',
+    'RPCError',
+    'RPCConnectionError',
+    'RPCTimeoutError',
+    'RPCInvalidMethodError',
+    'RPCInternalError',
+]

django_cfg/{modules/django_ipc_client → apps/ipc/services/client}/client.py

@@ -9,18 +9,19 @@ Works with or without django-cfg-rpc installed:
 - Without django-cfg-rpc: Basic dict-based communication
 """
 
-import redis
 import json
 import logging
+from typing import Any, Dict, Optional, Type, TypeVar
 from uuid import uuid4
-from typing import Optional, TypeVar, Type, Any, Dict
+
+import redis
 
 from .exceptions import (
-    RPCTimeoutError,
-    RPCRemoteError,
-    RPCConnectionError,
-    RPCConfigurationError,
     HAS_DJANGO_CFG_RPC,
+    RPCConfigurationError,
+    RPCConnectionError,
+    RPCRemoteError,
+    RPCTimeoutError,
 )
 
 logger = logging.getLogger(__name__)

django_cfg/{modules/django_ipc_client → apps/ipc/services/client}/exceptions.py

@@ -5,7 +5,7 @@ Provides specific exception types for better error handling and debugging.
 Works independently or with django-cfg-rpc models.
 """
 
-from typing import Optional, Any
+from typing import Any, Optional
 
 # Try to import RPCError from django-cfg-rpc if available
 try:

django_cfg/{modules/django_ipc_client/dashboard → apps/ipc/services}/monitor.py

@@ -5,11 +5,10 @@ Reads RPC metrics from Redis DB 2 and provides statistics.
 """
 
 import json
-import time
 import logging
-from typing import Dict, List, Any, Optional
-from datetime import datetime, timedelta
 from collections import defaultdict
+from datetime import datetime, timedelta
+from typing import Any, Dict, List
 
 logger = logging.getLogger(__name__)
 
@@ -35,18 +34,30 @@ class RPCMonitor:
         Args:
             redis_client: Optional Redis client. If not provided, creates from config.
         """
-        # Import config once
-        from ..config import DjangoCfgRPCConfig
-        self.config = DjangoCfgRPCConfig()
+        from .client.config import DjangoCfgRPCConfig
+        from django_cfg.core import get_current_config
+
+        # Try to get config from django-cfg global state first
+        django_cfg_config = get_current_config()
+
+        if django_cfg_config and hasattr(django_cfg_config, 'django_ipc') and django_cfg_config.django_ipc:
+            # Use config from django-cfg DjangoConfig
+            self.config = django_cfg_config.django_ipc
+            logger.debug(f"RPCMonitor initialized from django-cfg config: {self.config.redis_url}")
+        else:
+            # Fallback to default config
+            self.config = DjangoCfgRPCConfig()
+            logger.warning("Django-CFG config not found, using default RPC config")
 
         self.redis_client = redis_client or self._create_redis_client()
 
     def _create_redis_client(self):
         """Create Redis client from config."""
         try:
-            import redis
             from urllib.parse import urlparse
 
+            import redis
+
             # Use instance config (already loaded in __init__)
             parsed = urlparse(self.config.redis_url)
 
@@ -243,6 +254,24 @@ class RPCMonitor:
             logger.error(f"Error getting notification stats: {e}")
             return self._error_response(str(e))
 
+    def get_total_requests_count(self) -> int:
+        """
+        Get total number of requests in the stream.
+
+        Returns:
+            Total count of requests in the stream
+        """
+        if not self.redis_client:
+            return 0
+
+        try:
+            # Get stream length
+            stream_len = self.redis_client.xlen(self.config.request_stream)
+            return stream_len or 0
+        except Exception as e:
+            logger.error(f"Error getting total requests count: {e}")
+            return 0
+
     def get_method_stats(self) -> List[Dict[str, Any]]:
         """
         Get statistics grouped by RPC method.