django-cfg 1.4.120__py3-none-any.whl → 1.5.2__py3-none-any.whl

django_cfg/apps/grpc/interceptors/logging.py

@@ -0,0 +1,270 @@
+"""
+Logging Interceptor for gRPC.
+
+Provides comprehensive logging for gRPC requests and responses.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Callable
+
+import grpc
+
+logger = logging.getLogger(__name__)
+
+
+class LoggingInterceptor(grpc.ServerInterceptor):
+    """
+    gRPC interceptor for request/response logging.
+
+    Features:
+    - Logs all incoming requests
+    - Logs response status and timing
+    - Logs errors and exceptions
+    - Structured logging with metadata
+    - Performance tracking
+
+    Example:
+        ```python
+        # In Django settings (auto-configured in dev mode)
+        GRPC_FRAMEWORK = {
+            "SERVER_INTERCEPTORS": [
+                "django_cfg.apps.grpc.interceptors.LoggingInterceptor",
+            ]
+        }
+        ```
+
+    Log Format:
+        [gRPC] METHOD | STATUS | TIME | DETAILS
+    """
+
+    def intercept_service(
+        self,
+        continuation: Callable,
+        handler_call_details: grpc.HandlerCallDetails,
+    ) -> grpc.RpcMethodHandler:
+        """
+        Intercept gRPC service call for logging.
+
+        Args:
+            continuation: Function to invoke the next interceptor or handler
+            handler_call_details: Details about the RPC call
+
+        Returns:
+            RPC method handler with logging
+        """
+        method_name = handler_call_details.method
+        peer = self._extract_peer(handler_call_details.invocation_metadata)
+
+        # Log incoming request
+        logger.info(f"[gRPC] ➡️  {method_name} | peer={peer}")
+
+        # Get handler and wrap it
+        handler = continuation(handler_call_details)
+
+        if handler is None:
+            logger.warning(f"[gRPC] ⚠️  {method_name} | No handler found")
+            return None
+
+        # Wrap handler methods to log responses
+        return self._wrap_handler(handler, method_name, peer)
+
+    def _wrap_handler(
+        self,
+        handler: grpc.RpcMethodHandler,
+        method_name: str,
+        peer: str,
+    ) -> grpc.RpcMethodHandler:
+        """
+        Wrap handler to add logging.
+
+        Args:
+            handler: Original RPC method handler
+            method_name: gRPC method name
+            peer: Client peer information
+
+        Returns:
+            Wrapped RPC method handler
+        """
+        def wrap_unary_unary(behavior):
+            def wrapper(request, context):
+                start_time = time.time()
+                try:
+                    response = behavior(request, context)
+                    duration = (time.time() - start_time) * 1000  # ms
+                    logger.info(
+                        f"[gRPC] ✅ {method_name} | "
+                        f"status=OK | "
+                        f"time={duration:.2f}ms | "
+                        f"peer={peer}"
+                    )
+                    return response
+                except Exception as e:
+                    duration = (time.time() - start_time) * 1000  # ms
+                    logger.error(
+                        f"[gRPC] ❌ {method_name} | "
+                        f"status=ERROR | "
+                        f"time={duration:.2f}ms | "
+                        f"error={type(e).__name__}: {str(e)} | "
+                        f"peer={peer}",
+                        exc_info=True
+                    )
+                    raise
+            return wrapper
+
+        def wrap_unary_stream(behavior):
+            def wrapper(request, context):
+                start_time = time.time()
+                message_count = 0
+                try:
+                    for response in behavior(request, context):
+                        message_count += 1
+                        yield response
+                    duration = (time.time() - start_time) * 1000  # ms
+                    logger.info(
+                        f"[gRPC] ✅ {method_name} (stream) | "
+                        f"status=OK | "
+                        f"messages={message_count} | "
+                        f"time={duration:.2f}ms | "
+                        f"peer={peer}"
+                    )
+                except Exception as e:
+                    duration = (time.time() - start_time) * 1000  # ms
+                    logger.error(
+                        f"[gRPC] ❌ {method_name} (stream) | "
+                        f"status=ERROR | "
+                        f"messages={message_count} | "
+                        f"time={duration:.2f}ms | "
+                        f"error={type(e).__name__}: {str(e)} | "
+                        f"peer={peer}",
+                        exc_info=True
+                    )
+                    raise
+            return wrapper
+
+        def wrap_stream_unary(behavior):
+            def wrapper(request_iterator, context):
+                start_time = time.time()
+                message_count = 0
+                try:
+                    # Count messages
+                    requests = []
+                    for req in request_iterator:
+                        message_count += 1
+                        requests.append(req)
+
+                    # Process
+                    response = behavior(iter(requests), context)
+                    duration = (time.time() - start_time) * 1000  # ms
+                    logger.info(
+                        f"[gRPC] ✅ {method_name} (client stream) | "
+                        f"status=OK | "
+                        f"messages={message_count} | "
+                        f"time={duration:.2f}ms | "
+                        f"peer={peer}"
+                    )
+                    return response
+                except Exception as e:
+                    duration = (time.time() - start_time) * 1000  # ms
+                    logger.error(
+                        f"[gRPC] ❌ {method_name} (client stream) | "
+                        f"status=ERROR | "
+                        f"messages={message_count} | "
+                        f"time={duration:.2f}ms | "
+                        f"error={type(e).__name__}: {str(e)} | "
+                        f"peer={peer}",
+                        exc_info=True
+                    )
+                    raise
+            return wrapper
+
+        def wrap_stream_stream(behavior):
+            def wrapper(request_iterator, context):
+                start_time = time.time()
+                in_count = 0
+                out_count = 0
+                try:
+                    # Count input messages
+                    requests = []
+                    for req in request_iterator:
+                        in_count += 1
+                        requests.append(req)
+
+                    # Process and count output
+                    for response in behavior(iter(requests), context):
+                        out_count += 1
+                        yield response
+
+                    duration = (time.time() - start_time) * 1000  # ms
+                    logger.info(
+                        f"[gRPC] ✅ {method_name} (bidi stream) | "
+                        f"status=OK | "
+                        f"in={in_count} out={out_count} | "
+                        f"time={duration:.2f}ms | "
+                        f"peer={peer}"
+                    )
+                except Exception as e:
+                    duration = (time.time() - start_time) * 1000  # ms
+                    logger.error(
+                        f"[gRPC] ❌ {method_name} (bidi stream) | "
+                        f"status=ERROR | "
+                        f"in={in_count} out={out_count} | "
+                        f"time={duration:.2f}ms | "
+                        f"error={type(e).__name__}: {str(e)} | "
+                        f"peer={peer}",
+                        exc_info=True
+                    )
+                    raise
+            return wrapper
+
+        # Return wrapped handler based on type
+        if handler.unary_unary:
+            return grpc.unary_unary_rpc_method_handler(
+                wrap_unary_unary(handler.unary_unary),
+                request_deserializer=handler.request_deserializer,
+                response_serializer=handler.response_serializer,
+            )
+        elif handler.unary_stream:
+            return grpc.unary_stream_rpc_method_handler(
+                wrap_unary_stream(handler.unary_stream),
+                request_deserializer=handler.request_deserializer,
+                response_serializer=handler.response_serializer,
+            )
+        elif handler.stream_unary:
+            return grpc.stream_unary_rpc_method_handler(
+                wrap_stream_unary(handler.stream_unary),
+                request_deserializer=handler.request_deserializer,
+                response_serializer=handler.response_serializer,
+            )
+        elif handler.stream_stream:
+            return grpc.stream_stream_rpc_method_handler(
+                wrap_stream_stream(handler.stream_stream),
+                request_deserializer=handler.request_deserializer,
+                response_serializer=handler.response_serializer,
+            )
+        else:
+            return handler
+
+    def _extract_peer(self, metadata: tuple) -> str:
+        """
+        Extract peer information from metadata.
+
+        Args:
+            metadata: gRPC invocation metadata
+
+        Returns:
+            Peer identifier string
+        """
+        if not metadata:
+            return "unknown"
+
+        # Convert to dict for easier access
+        metadata_dict = dict(metadata)
+
+        # Try to get user-agent or return unknown
+        return metadata_dict.get("user-agent", "unknown")
+
+
+__all__ = ["LoggingInterceptor"]

django_cfg/apps/grpc/interceptors/metrics.py

@@ -0,0 +1,306 @@
+"""
+Metrics Interceptor for gRPC.
+
+Tracks request counts, response times, and error rates.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from collections import defaultdict
+from typing import Callable
+
+import grpc
+
+logger = logging.getLogger(__name__)
+
+
+class MetricsCollector:
+    """
+    Thread-safe metrics collector for gRPC.
+
+    Tracks:
+    - Request counts per method
+    - Response times per method
+    - Error counts per method
+    - Total requests/errors
+    """
+
+    def __init__(self):
+        """Initialize metrics collector."""
+        self.request_counts = defaultdict(int)
+        self.error_counts = defaultdict(int)
+        self.response_times = defaultdict(list)
+        self.total_requests = 0
+        self.total_errors = 0
+
+    def record_request(self, method: str):
+        """Record a request."""
+        self.request_counts[method] += 1
+        self.total_requests += 1
+
+    def record_error(self, method: str):
+        """Record an error."""
+        self.error_counts[method] += 1
+        self.total_errors += 1
+
+    def record_response_time(self, method: str, duration_ms: float):
+        """Record response time."""
+        self.response_times[method].append(duration_ms)
+
+    def get_stats(self, method: str = None) -> dict:
+        """
+        Get statistics for a method or all methods.
+
+        Args:
+            method: Specific method name, or None for all
+
+        Returns:
+            Dictionary with statistics
+        """
+        if method:
+            times = self.response_times.get(method, [])
+            return {
+                "requests": self.request_counts.get(method, 0),
+                "errors": self.error_counts.get(method, 0),
+                "avg_time_ms": sum(times) / len(times) if times else 0,
+                "min_time_ms": min(times) if times else 0,
+                "max_time_ms": max(times) if times else 0,
+            }
+        else:
+            return {
+                "total_requests": self.total_requests,
+                "total_errors": self.total_errors,
+                "error_rate": (
+                    self.total_errors / self.total_requests
+                    if self.total_requests > 0
+                    else 0
+                ),
+                "methods": {
+                    method: self.get_stats(method)
+                    for method in self.request_counts.keys()
+                },
+            }
+
+    def reset(self):
+        """Reset all metrics."""
+        self.request_counts.clear()
+        self.error_counts.clear()
+        self.response_times.clear()
+        self.total_requests = 0
+        self.total_errors = 0
+
+
+# Global metrics collector instance
+_metrics = MetricsCollector()
+
+
+def get_metrics(method: str = None) -> dict:
+    """
+    Get metrics for a method or all methods.
+
+    Args:
+        method: Specific method name, or None for all
+
+    Returns:
+        Dictionary with metrics
+
+    Example:
+        ```python
+        from django_cfg.apps.grpc.interceptors.metrics import get_metrics
+
+        # Get all metrics
+        all_stats = get_metrics()
+
+        # Get metrics for specific method
+        stats = get_metrics("/myapp.MyService/MyMethod")
+        print(f"Requests: {stats['requests']}")
+        print(f"Avg time: {stats['avg_time_ms']:.2f}ms")
+        ```
+    """
+    return _metrics.get_stats(method)
+
+
+def reset_metrics():
+    """
+    Reset all metrics.
+
+    Example:
+        ```python
+        from django_cfg.apps.grpc.interceptors.metrics import reset_metrics
+        reset_metrics()
+        ```
+    """
+    _metrics.reset()
+
+
+class MetricsInterceptor(grpc.ServerInterceptor):
+    """
+    gRPC interceptor for metrics collection.
+
+    Features:
+    - Tracks request counts
+    - Tracks response times
+    - Tracks error rates
+    - Per-method statistics
+    - Global statistics
+
+    Example:
+        ```python
+        # In Django settings (auto-configured in dev mode)
+        GRPC_FRAMEWORK = {
+            "SERVER_INTERCEPTORS": [
+                "django_cfg.apps.grpc.interceptors.MetricsInterceptor",
+            ]
+        }
+        ```
+
+    Access Metrics:
+        ```python
+        from django_cfg.apps.grpc.interceptors.metrics import get_metrics
+
+        stats = get_metrics()
+        print(f"Total requests: {stats['total_requests']}")
+        print(f"Error rate: {stats['error_rate']:.2%}")
+        ```
+    """
+
+    def __init__(self):
+        """Initialize metrics interceptor."""
+        self.collector = _metrics
+
+    def intercept_service(
+        self,
+        continuation: Callable,
+        handler_call_details: grpc.HandlerCallDetails,
+    ) -> grpc.RpcMethodHandler:
+        """
+        Intercept gRPC service call for metrics collection.
+
+        Args:
+            continuation: Function to invoke the next interceptor or handler
+            handler_call_details: Details about the RPC call
+
+        Returns:
+            RPC method handler with metrics
+        """
+        method_name = handler_call_details.method
+
+        # Record request
+        self.collector.record_request(method_name)
+
+        # Get handler and wrap it
+        handler = continuation(handler_call_details)
+
+        if handler is None:
+            return None
+
+        # Wrap handler methods to track metrics
+        return self._wrap_handler(handler, method_name)
+
+    def _wrap_handler(
+        self,
+        handler: grpc.RpcMethodHandler,
+        method_name: str,
+    ) -> grpc.RpcMethodHandler:
+        """
+        Wrap handler to track metrics.
+
+        Args:
+            handler: Original RPC method handler
+            method_name: gRPC method name
+
+        Returns:
+            Wrapped RPC method handler
+        """
+        def wrap_unary_unary(behavior):
+            def wrapper(request, context):
+                start_time = time.time()
+                try:
+                    response = behavior(request, context)
+                    duration_ms = (time.time() - start_time) * 1000
+                    self.collector.record_response_time(method_name, duration_ms)
+                    return response
+                except Exception as e:
+                    duration_ms = (time.time() - start_time) * 1000
+                    self.collector.record_response_time(method_name, duration_ms)
+                    self.collector.record_error(method_name)
+                    raise
+            return wrapper
+
+        def wrap_unary_stream(behavior):
+            def wrapper(request, context):
+                start_time = time.time()
+                try:
+                    for response in behavior(request, context):
+                        yield response
+                    duration_ms = (time.time() - start_time) * 1000
+                    self.collector.record_response_time(method_name, duration_ms)
+                except Exception as e:
+                    duration_ms = (time.time() - start_time) * 1000
+                    self.collector.record_response_time(method_name, duration_ms)
+                    self.collector.record_error(method_name)
+                    raise
+            return wrapper
+
+        def wrap_stream_unary(behavior):
+            def wrapper(request_iterator, context):
+                start_time = time.time()
+                try:
+                    response = behavior(request_iterator, context)
+                    duration_ms = (time.time() - start_time) * 1000
+                    self.collector.record_response_time(method_name, duration_ms)
+                    return response
+                except Exception as e:
+                    duration_ms = (time.time() - start_time) * 1000
+                    self.collector.record_response_time(method_name, duration_ms)
+                    self.collector.record_error(method_name)
+                    raise
+            return wrapper
+
+        def wrap_stream_stream(behavior):
+            def wrapper(request_iterator, context):
+                start_time = time.time()
+                try:
+                    for response in behavior(request_iterator, context):
+                        yield response
+                    duration_ms = (time.time() - start_time) * 1000
+                    self.collector.record_response_time(method_name, duration_ms)
+                except Exception as e:
+                    duration_ms = (time.time() - start_time) * 1000
+                    self.collector.record_response_time(method_name, duration_ms)
+                    self.collector.record_error(method_name)
+                    raise
+            return wrapper
+
+        # Return wrapped handler based on type
+        if handler.unary_unary:
+            return grpc.unary_unary_rpc_method_handler(
+                wrap_unary_unary(handler.unary_unary),
+                request_deserializer=handler.request_deserializer,
+                response_serializer=handler.response_serializer,
+            )
+        elif handler.unary_stream:
+            return grpc.unary_stream_rpc_method_handler(
+                wrap_unary_stream(handler.unary_stream),
+                request_deserializer=handler.request_deserializer,
+                response_serializer=handler.response_serializer,
+            )
+        elif handler.stream_unary:
+            return grpc.stream_unary_rpc_method_handler(
+                wrap_stream_unary(handler.stream_unary),
+                request_deserializer=handler.request_deserializer,
+                response_serializer=handler.response_serializer,
+            )
+        elif handler.stream_stream:
+            return grpc.stream_stream_rpc_method_handler(
+                wrap_stream_stream(handler.stream_stream),
+                request_deserializer=handler.request_deserializer,
+                response_serializer=handler.response_serializer,
+            )
+        else:
+            return handler
+
+
+__all__ = ["MetricsInterceptor", "MetricsCollector", "get_metrics", "reset_metrics"]