django-cfg 1.4.59__py3-none-any.whl → 1.4.61__py3-none-any.whl

django_cfg/apps/ipc/serializers/serializers.py

@@ -61,6 +61,7 @@ class OverviewStatsSerializer(serializers.Serializer):
         help_text="List of active RPC methods"
     )
     top_method = serializers.CharField(
+        required=False,
         allow_null=True,
         help_text="Most frequently called method"
     )
@@ -227,3 +228,116 @@ class MethodStatsSerializer(serializers.Serializer):
     total_calls = serializers.IntegerField(
         help_text="Total calls across all methods"
     )
+
+
+# Testing Serializers
+
+class TestRPCRequestSerializer(serializers.Serializer):
+    """Serializer for test RPC request input."""
+
+    method = serializers.CharField(
+        help_text="RPC method to call"
+    )
+    params = serializers.JSONField(
+        help_text="Parameters for the RPC call"
+    )
+    timeout = serializers.IntegerField(
+        default=10,
+        min_value=1,
+        max_value=60,
+        help_text="Timeout in seconds"
+    )
+
+
+class TestRPCResponseSerializer(serializers.Serializer):
+    """Serializer for test RPC response."""
+
+    success = serializers.BooleanField(
+        help_text="Whether the call was successful"
+    )
+    duration_ms = serializers.FloatField(
+        help_text="Call duration in milliseconds"
+    )
+    response = serializers.JSONField(
+        allow_null=True,
+        required=False,
+        help_text="Response data from RPC call"
+    )
+    error = serializers.CharField(
+        allow_null=True,
+        required=False,
+        help_text="Error message if failed"
+    )
+    correlation_id = serializers.CharField(
+        help_text="Correlation ID for tracking"
+    )
+
+
+class LoadTestRequestSerializer(serializers.Serializer):
+    """Serializer for load test request input."""
+
+    method = serializers.CharField(
+        help_text="RPC method to test"
+    )
+    total_requests = serializers.IntegerField(
+        min_value=1,
+        max_value=10000,
+        help_text="Total number of requests to send"
+    )
+    concurrency = serializers.IntegerField(
+        min_value=1,
+        max_value=100,
+        help_text="Number of concurrent requests"
+    )
+    params = serializers.JSONField(
+        required=False,
+        default=dict,
+        help_text="Parameters template for RPC calls"
+    )
+
+
+class LoadTestResponseSerializer(serializers.Serializer):
+    """Serializer for load test response."""
+
+    test_id = serializers.CharField(
+        help_text="Unique test ID"
+    )
+    started = serializers.BooleanField(
+        help_text="Whether test was started successfully"
+    )
+    message = serializers.CharField(
+        help_text="Status message"
+    )
+
+
+class LoadTestStatusSerializer(serializers.Serializer):
+    """Serializer for load test status."""
+
+    test_id = serializers.CharField(
+        allow_null=True,
+        help_text="Unique test ID"
+    )
+    running = serializers.BooleanField(
+        help_text="Whether test is currently running"
+    )
+    progress = serializers.IntegerField(
+        help_text="Number of completed requests"
+    )
+    total = serializers.IntegerField(
+        help_text="Total number of requests"
+    )
+    success_count = serializers.IntegerField(
+        help_text="Number of successful requests"
+    )
+    failed_count = serializers.IntegerField(
+        help_text="Number of failed requests"
+    )
+    avg_duration_ms = serializers.FloatField(
+        help_text="Average duration in milliseconds"
+    )
+    elapsed_time = serializers.FloatField(
+        help_text="Total elapsed time in seconds"
+    )
+    rps = serializers.FloatField(
+        help_text="Requests per second"
+    )

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

@@ -10,11 +10,11 @@ Works with or without django-cfg-rpc installed:
 """
 
 import json
-import logging
 from typing import Any, Dict, Optional, Type, TypeVar
 from uuid import uuid4
 
 import redis
+from django_cfg.modules.django_logging import get_logger
 
 from .exceptions import (
     HAS_DJANGO_CFG_RPC,
@@ -24,7 +24,7 @@ from .exceptions import (
     RPCTimeoutError,
 )
 
-logger = logging.getLogger(__name__)
+logger = get_logger("ipc.client")
 
 # Try to import Pydantic from django-cfg-rpc
 if HAS_DJANGO_CFG_RPC:
@@ -178,6 +178,9 @@ class DjangoCfgRPCClient:
         params: Any,
         result_model: Optional[Type[TResult]] = None,
         timeout: Optional[int] = None,
+        user: Optional[Any] = None,
+        caller_ip: Optional[str] = None,
+        user_agent: Optional[str] = None,
     ) -> Any:
         """
         Make synchronous RPC call to django-cfg-rpc server.
@@ -187,6 +190,9 @@ class DjangoCfgRPCClient:
             params: Pydantic model or dict with parameters
             result_model: Expected result model class (optional)
             timeout: Optional timeout override (seconds)
+            user: Django User instance for logging (optional)
+            caller_ip: IP address for logging (optional)
+            user_agent: User agent for logging (optional)
 
         Returns:
             Pydantic result model instance (if result_model provided) or dict
@@ -203,10 +209,13 @@ class DjangoCfgRPCClient:
             ...     params=NotificationRequest(user_id="123", type="info",
             ...                                 title="Hello", message="World"),
             ...     result_model=NotificationResponse,
-            ...     timeout=10
+            ...     timeout=10,
+            ...     user=request.user
             ... )
             >>> print(result.delivered)  # True/False
         """
+        import time
+
         timeout = timeout or self.default_timeout
 
         # Generate correlation ID
@@ -223,11 +232,13 @@ class DjangoCfgRPCClient:
         else:
             params_json = json.dumps({"data": params})
 
+        params_dict = json.loads(params_json)
+
         # Build RPC request payload
         request_payload = {
             "type": "rpc",
             "method": method,
-            "params": json.loads(params_json),  # Embedded as dict
+            "params": params_dict,  # Embedded as dict
             "correlation_id": cid,
             "reply_to": reply_key,  # Redis List key for response
             "timeout": timeout,
@@ -236,6 +247,25 @@ class DjangoCfgRPCClient:
         if self.log_calls:
             logger.debug(f"RPC call: {method} (cid={cid})")
 
+        # Start timing for logging
+        start_time = time.time()
+        log_entry = None
+
+        # Create log entry if logging enabled
+        try:
+            from ..logging import RPCLogger
+            log_entry = RPCLogger.create_log(
+                correlation_id=cid,
+                method=method,
+                params=params_dict,
+                user=user,
+                caller_ip=caller_ip,
+                user_agent=user_agent,
+            )
+        except Exception as e:
+            # Don't fail RPC call if logging fails
+            logger.warning(f"Failed to create RPC log: {e}")
+
         try:
             # Send request to Redis Stream
             message_id = self._redis.xadd(
@@ -253,7 +283,17 @@ class DjangoCfgRPCClient:
 
             if response_data is None:
                 # Timeout occurred
+                duration_ms = int((time.time() - start_time) * 1000)
                 logger.warning(f"RPC timeout: {method} (cid={cid}, timeout={timeout}s)")
+
+                # Log timeout
+                if log_entry:
+                    try:
+                        from ..logging import RPCLogger
+                        RPCLogger.mark_timeout(log_entry, timeout)
+                    except Exception:
+                        pass
+
                 raise RPCTimeoutError(
                     f"RPC call '{method}' timed out after {timeout}s",
                     method=method,
@@ -272,18 +312,57 @@ class DjangoCfgRPCClient:
             # Check response type
             if response_dict.get("type") == "error":
                 # Error response
+                duration_ms = int((time.time() - start_time) * 1000)
                 error_data = response_dict.get("error", {})
+
+                # Log error
+                if log_entry:
+                    try:
+                        from ..logging import RPCLogger
+                        RPCLogger.mark_failed(
+                            log_entry,
+                            error_data.get("code", "unknown"),
+                            error_data.get("message", "Unknown error"),
+                            duration_ms
+                        )
+                    except Exception:
+                        pass
+
                 raise RPCRemoteError(error_data)
 
             # Extract result
             result_data = response_dict.get("result")
 
             if result_data is None:
+                duration_ms = int((time.time() - start_time) * 1000)
+
+                # Log error
+                if log_entry:
+                    try:
+                        from ..logging import RPCLogger
+                        RPCLogger.mark_failed(
+                            log_entry,
+                            "internal_error",
+                            "Response has no result field",
+                            duration_ms
+                        )
+                    except Exception:
+                        pass
+
                 raise RPCRemoteError({
                     "code": "internal_error",
                     "message": "Response has no result field",
                 })
 
+            # Success - log it
+            duration_ms = int((time.time() - start_time) * 1000)
+            if log_entry:
+                try:
+                    from ..logging import RPCLogger
+                    RPCLogger.mark_success(log_entry, result_data, duration_ms)
+                except Exception:
+                    pass
+
             # Deserialize result if model provided
             if result_model and HAS_DJANGO_CFG_RPC:
                 try:

django_cfg/apps/ipc/services/logging.py

@@ -0,0 +1,239 @@
+"""
+RPC Logging helper for tracking RPC calls.
+
+Provides async-safe logging of RPC calls to database.
+"""
+
+import time
+from typing import Any, Dict, Optional
+from django.conf import settings
+from django_cfg.modules.django_logging import get_logger
+
+logger = get_logger("ipc.rpc")
+
+
+class RPCLogger:
+    """
+    Helper class for logging RPC calls to database.
+
+    Usage:
+        >>> log_entry = RPCLogger.create_log(
+        ...     correlation_id="abc123",
+        ...     method="send_notification",
+        ...     params={"user_id": "123"},
+        ...     user=request.user if authenticated else None
+        ... )
+        >>> # ... make RPC call ...
+        >>> RPCLogger.mark_success(log_entry, response_data, duration_ms=150)
+    """
+
+    @staticmethod
+    def is_logging_enabled() -> bool:
+        """
+        Check if RPC logging is enabled in settings.
+
+        Returns:
+            bool: True if logging is enabled
+        """
+        # Check if IPC app is installed
+        if 'django_cfg.apps.ipc' not in settings.INSTALLED_APPS:
+            return False
+
+        # Check if logging is explicitly disabled
+        if hasattr(settings, 'DJANGO_CFG_RPC'):
+            return settings.DJANGO_CFG_RPC.get('ENABLE_LOGGING', True)
+
+        return True
+
+    @staticmethod
+    def create_log(
+        correlation_id: str,
+        method: str,
+        params: Dict[str, Any],
+        user: Optional[Any] = None,
+        caller_ip: Optional[str] = None,
+        user_agent: Optional[str] = None,
+    ):
+        """
+        Create RPC log entry in pending state.
+
+        Args:
+            correlation_id: UUID correlation ID from RPC request
+            method: RPC method name
+            params: Parameters sent to RPC method
+            user: Django User instance (optional)
+            caller_ip: IP address of caller (optional)
+            user_agent: User agent string (optional)
+
+        Returns:
+            RPCLog instance or None if logging disabled
+        """
+        if not RPCLogger.is_logging_enabled():
+            return None
+
+        try:
+            from ..models import RPCLog
+
+            log_entry = RPCLog.objects.create(
+                correlation_id=correlation_id,
+                method=method,
+                params=params,
+                user=user,
+                caller_ip=caller_ip,
+                user_agent=user_agent,
+                status=RPCLog.StatusChoices.PENDING
+            )
+            return log_entry
+
+        except Exception as e:
+            logger.error(f"Failed to create RPC log: {e}", exc_info=True)
+            return None
+
+    @staticmethod
+    def mark_success(log_entry, response_data: Dict[str, Any], duration_ms: Optional[int] = None):
+        """
+        Mark RPC log as successful.
+
+        Args:
+            log_entry: RPCLog instance
+            response_data: Response data from RPC call
+            duration_ms: Duration in milliseconds (optional)
+        """
+        if log_entry is None:
+            return
+
+        try:
+            log_entry.mark_success(response_data, duration_ms)
+        except Exception as e:
+            logger.error(f"Failed to mark RPC log as success: {e}", exc_info=True)
+
+    @staticmethod
+    def mark_failed(log_entry, error_code: str, error_message: str, duration_ms: Optional[int] = None):
+        """
+        Mark RPC log as failed.
+
+        Args:
+            log_entry: RPCLog instance
+            error_code: Error code
+            error_message: Error message
+            duration_ms: Duration in milliseconds (optional)
+        """
+        if log_entry is None:
+            return
+
+        try:
+            log_entry.mark_failed(error_code, error_message, duration_ms)
+        except Exception as e:
+            logger.error(f"Failed to mark RPC log as failed: {e}", exc_info=True)
+
+    @staticmethod
+    def mark_timeout(log_entry, timeout_seconds: int):
+        """
+        Mark RPC log as timed out.
+
+        Args:
+            log_entry: RPCLog instance
+            timeout_seconds: Timeout duration in seconds
+        """
+        if log_entry is None:
+            return
+
+        try:
+            log_entry.mark_timeout(timeout_seconds)
+        except Exception as e:
+            logger.error(f"Failed to mark RPC log as timeout: {e}", exc_info=True)
+
+
+class RPCLogContext:
+    """
+    Context manager for automatically logging RPC calls.
+
+    Usage:
+        >>> with RPCLogContext(
+        ...     correlation_id="abc123",
+        ...     method="send_notification",
+        ...     params={"user_id": "123"}
+        ... ) as log_ctx:
+        ...     result = rpc.call(...)
+        ...     log_ctx.set_response(result)
+    """
+
+    def __init__(
+        self,
+        correlation_id: str,
+        method: str,
+        params: Dict[str, Any],
+        user: Optional[Any] = None,
+        caller_ip: Optional[str] = None,
+        user_agent: Optional[str] = None,
+    ):
+        """
+        Initialize RPC log context.
+
+        Args:
+            correlation_id: UUID correlation ID
+            method: RPC method name
+            params: Parameters for RPC call
+            user: Django User instance (optional)
+            caller_ip: IP address (optional)
+            user_agent: User agent string (optional)
+        """
+        self.correlation_id = correlation_id
+        self.method = method
+        self.params = params
+        self.user = user
+        self.caller_ip = caller_ip
+        self.user_agent = user_agent
+        self.log_entry = None
+        self.start_time = None
+        self.response = None
+
+    def __enter__(self):
+        """Start timing and create log entry."""
+        self.start_time = time.time()
+        self.log_entry = RPCLogger.create_log(
+            correlation_id=self.correlation_id,
+            method=self.method,
+            params=self.params,
+            user=self.user,
+            caller_ip=self.caller_ip,
+            user_agent=self.user_agent,
+        )
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Mark log as success or failed based on exception."""
+        if self.log_entry is None:
+            return False
+
+        duration_ms = int((time.time() - self.start_time) * 1000) if self.start_time else None
+
+        if exc_type is None:
+            # Success - use response if set
+            RPCLogger.mark_success(self.log_entry, self.response or {}, duration_ms)
+        else:
+            # Failed - extract error details
+            error_code = exc_type.__name__ if exc_type else 'unknown'
+            error_message = str(exc_val) if exc_val else 'Unknown error'
+
+            # Check if it's a timeout
+            if 'timeout' in error_code.lower():
+                timeout_seconds = duration_ms // 1000 if duration_ms else 30
+                RPCLogger.mark_timeout(self.log_entry, timeout_seconds)
+            else:
+                RPCLogger.mark_failed(self.log_entry, error_code, error_message, duration_ms)
+
+        # Don't suppress exceptions
+        return False
+
+    def set_response(self, response: Dict[str, Any]):
+        """
+        Set response data for successful call.
+
+        Args:
+            response: Response data from RPC call
+        """
+        self.response = response
+
+
+__all__ = ['RPCLogger', 'RPCLogContext']

django_cfg/apps/ipc/services/monitor.py

@@ -5,12 +5,13 @@ Reads RPC metrics from Redis DB 2 and provides statistics.
 """
 
 import json
-import logging
 from collections import defaultdict
 from datetime import datetime, timedelta
 from typing import Any, Dict, List
 
-logger = logging.getLogger(__name__)
+from django_cfg.modules.django_logging import get_logger
+
+logger = get_logger("ipc.monitor")
 
 # Cache timeout in seconds
 CACHE_TIMEOUT = 3  # 3 seconds to reduce Redis load
@@ -117,6 +118,7 @@ class RPCMonitor:
                     'redis_connected': True,
                     'total_requests_today': 0,
                     'active_methods': [],
+                    'top_method': None,
                     'avg_response_time_ms': 0,
                     'success_rate': 100.0,
                     'timestamp': datetime.now().isoformat(),
@@ -354,7 +356,7 @@ class RPCMonitor:
             stream_key = stream_key or self.config.request_stream
 
             # Validate stream_key (security: prevent Redis key injection)
-            ALLOWED_STREAMS = ['stream:requests', 'stream:responses']
+            ALLOWED_STREAMS = ['stream:requests', 'stream:responses', 'stream:rpc_requests', 'stream:rpc_responses']
             if stream_key not in ALLOWED_STREAMS:
                 logger.warning(f"Invalid stream key attempted: {stream_key}")
                 raise ValueError(f"Stream key not allowed: {stream_key}")