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

django_cfg/apps/integrations/grpc/utils/streaming_logger.py

@@ -0,0 +1,425 @@
+"""
+Streaming Logger Utilities for gRPC Services.
+
+Provides reusable logger configuration for gRPC streaming services.
+Follows django-cfg logging patterns for consistency.
+"""
+
+import logging
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+from django.utils import timezone
+
+# Rich for beautiful console output
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+
+# ========================================================================
+# Module-level debug mode caching (performance optimization)
+# ========================================================================
+
+_debug_mode: Optional[bool] = None  # Cached debug mode to avoid repeated config loads
+
+
+def _get_debug_mode() -> bool:
+    """
+    Get debug mode from config (cached at module level).
+
+    Loads config only once and caches the result to avoid repeated config loads.
+    This is a performance optimization - config loading can be expensive.
+
+    Returns:
+        True if debug mode is enabled, False otherwise
+    """
+    global _debug_mode
+
+    if _debug_mode is not None:
+        return _debug_mode
+
+    # Load config once and cache
+    try:
+        from django_cfg.core.state import get_current_config
+        config = get_current_config()
+        _debug_mode = config.debug if config and hasattr(config, 'debug') else False
+    except Exception:
+        _debug_mode = os.getenv('DEBUG', 'false').lower() in ('true', '1', 'yes')
+
+    return _debug_mode
+
+
+class AutoTracebackHandler(logging.Handler):
+    """
+    Custom handler that automatically adds exception info to ERROR and CRITICAL logs.
+
+    This ensures full tracebacks are always logged for errors, even if exc_info=True
+    is not explicitly specified.
+    """
+
+    def __init__(self, base_handler: logging.Handler):
+        super().__init__()
+        self.base_handler = base_handler
+        self.setLevel(base_handler.level)
+        self.setFormatter(base_handler.formatter)
+
+    def emit(self, record: logging.LogRecord):
+        """Emit log record, automatically adding exc_info for errors."""
+        # If ERROR or CRITICAL and no exc_info yet, add current exception if any
+        if record.levelno >= logging.ERROR and not record.exc_info:
+            # Check if we're in exception context
+            exc_info = sys.exc_info()
+            if exc_info[0] is not None:
+                record.exc_info = exc_info
+
+        # Delegate to base handler
+        self.base_handler.emit(record)
+
+
+def setup_streaming_logger(
+    name: str = "grpc_streaming",
+    logs_dir: Optional[Path] = None,
+    level: Optional[int] = None,
+    console_level: Optional[int] = None
+) -> logging.Logger:
+    """
+    Setup dedicated logger for gRPC streaming with file and console handlers.
+
+    Follows django-cfg logging pattern:
+    - Uses os.getcwd() / 'logs' / 'grpc_streaming' for log directory
+    - Time-based log file names (streaming_YYYYMMDD_HHMMSS.log)
+    - Auto-detects debug mode for appropriate logging levels
+    - In dev/debug: files=DEBUG+, console=DEBUG+
+    - In production: files=INFO+, console=WARNING+
+
+    Args:
+        name: Logger name (default: "grpc_streaming")
+        logs_dir: Directory for log files (default: <cwd>/logs/grpc_streaming)
+        level: File logging level (default: auto-detect from debug mode)
+        console_level: Console logging level (default: auto-detect from debug mode)
+
+    Returns:
+        Configured logger instance
+
+    Example:
+        ```python
+        from django_cfg.apps.integrations.grpc.utils import setup_streaming_logger
+
+        # Basic usage (auto-detects debug mode)
+        logger = setup_streaming_logger()
+
+        # Custom configuration
+        logger = setup_streaming_logger(
+            name="my_streaming_service",
+            logs_dir=Path("/var/log/grpc"),
+            level=logging.INFO  # Override auto-detection
+        )
+
+        logger.info("Service started")
+        logger.debug("Detailed debug info")
+        ```
+
+    Features:
+        - Automatic log directory creation
+        - Time-based log file names
+        - No duplicate logs (propagate=False)
+        - UTF-8 encoding
+        - Debug mode auto-detection (cached for performance)
+        - Reusable across all django-cfg gRPC projects
+    """
+    # Auto-detect debug mode (cached - loaded once)
+    debug = _get_debug_mode()
+
+    # Auto-determine logging levels based on debug mode if not explicitly provided
+    if level is None:
+        # File handlers: DEBUG in dev, INFO in production
+        level = logging.DEBUG if debug else logging.INFO
+
+    if console_level is None:
+        # Console: DEBUG in dev (full visibility), WARNING in production (reduce noise)
+        console_level = logging.DEBUG if debug else logging.WARNING
+
+    # Create logger
+    streaming_logger = logging.getLogger(name)
+    streaming_logger.setLevel(level)
+
+    # Avoid duplicate handlers if logger already configured
+    if streaming_logger.handlers:
+        return streaming_logger
+
+    # Determine logs directory using django-cfg pattern
+    if logs_dir is None:
+        # Pattern from django_cfg.modules.django_logging:
+        # current_dir = Path(os.getcwd())
+        # logs_dir = current_dir / 'logs' / 'grpc_streaming'
+        current_dir = Path(os.getcwd())
+        logs_dir = current_dir / 'logs' / 'grpc_streaming'
+
+    # Create logs directory
+    logs_dir.mkdir(parents=True, exist_ok=True)
+
+    # Create log filename with timestamp
+    log_filename = f'streaming_{timezone.now().strftime("%Y%m%d_%H%M%S")}.log'
+    log_file_path = logs_dir / log_filename
+
+    # File handler - detailed logs with auto-traceback
+    base_file_handler = logging.FileHandler(
+        log_file_path,
+        encoding='utf-8'
+    )
+    base_file_handler.setLevel(level)
+    file_formatter = logging.Formatter(
+        '%(asctime)s | %(levelname)-8s | %(message)s',
+        datefmt='%H:%M:%S'
+    )
+    base_file_handler.setFormatter(file_formatter)
+
+    # Wrap with auto-traceback handler for automatic exc_info on errors
+    file_handler = AutoTracebackHandler(base_file_handler)
+    streaming_logger.addHandler(file_handler)
+
+    # Console handler - important messages only (also with auto-traceback)
+    base_console_handler = logging.StreamHandler()
+    base_console_handler.setLevel(console_level)
+    console_formatter = logging.Formatter('%(levelname)s: %(message)s')
+    base_console_handler.setFormatter(console_formatter)
+
+    # Wrap console handler with auto-traceback too
+    console_handler = AutoTracebackHandler(base_console_handler)
+    streaming_logger.addHandler(console_handler)
+
+    # Prevent propagation to avoid duplicate logs
+    streaming_logger.propagate = False
+
+    # Log initialization
+    streaming_logger.info("=" * 80)
+    streaming_logger.info(f"🌊 {name.title()} Logger Initialized")
+    streaming_logger.info(f"📁 Log file: {log_file_path}")
+    streaming_logger.info("=" * 80)
+
+    return streaming_logger
+
+
+def get_streaming_logger(name: str = "grpc_streaming") -> logging.Logger:
+    """
+    Get existing streaming logger or create new one.
+
+    Args:
+        name: Logger name (default: "grpc_streaming")
+
+    Returns:
+        Logger instance
+
+    Example:
+        ```python
+        from django_cfg.apps.integrations.grpc.utils import get_streaming_logger
+
+        logger = get_streaming_logger()
+        logger.info("Using existing logger")
+        ```
+    """
+    logger = logging.getLogger(name)
+
+    # If not configured yet, set it up
+    if not logger.handlers:
+        return setup_streaming_logger(name)
+
+    return logger
+
+
+def log_server_start(
+    logger: logging.Logger,
+    server_type: str = "Server",
+    mode: str = "Development",
+    hotreload_enabled: bool = False,
+    use_rich: bool = True,
+    **extra_info
+):
+    """
+    Log server startup with timestamp and configuration using Rich panels.
+
+    Args:
+        logger: Logger instance to use
+        server_type: Type of server (e.g., "gRPC Server", "WebSocket Server")
+        mode: Running mode (Development/Production)
+        hotreload_enabled: Whether hot-reload is enabled
+        use_rich: Use Rich for beautiful output (default: True)
+        **extra_info: Additional key-value pairs to log
+
+    Example:
+        ```python
+        from django_cfg.apps.integrations.grpc.utils import log_server_start
+        from datetime import datetime
+
+        start_time = log_server_start(
+            logger,
+            server_type="gRPC Server",
+            mode="Development",
+            hotreload_enabled=True,
+            host="0.0.0.0",
+            port=50051
+        )
+        ```
+
+    Returns:
+        datetime object of start time for later use in log_server_shutdown
+    """
+    from datetime import datetime
+
+    start_time = datetime.now()
+
+    if use_rich:
+        # Create Rich table for server info
+        console = Console()
+
+        table = Table(show_header=False, box=None, padding=(0, 1))
+        table.add_column("Key", style="cyan")
+        table.add_column("Value", style="white")
+
+        table.add_row("⏰ Started at", start_time.strftime('%Y-%m-%d %H:%M:%S'))
+        table.add_row("Mode", f"[{'red' if mode == 'Production' else 'green'}]{mode}[/]")
+        table.add_row("Hotreload", f"[{'yellow' if hotreload_enabled else 'dim'}]{'Enabled ⚡' if hotreload_enabled else 'Disabled'}[/]")
+
+        # Add extra info
+        for key, value in extra_info.items():
+            key_display = key.replace('_', ' ').title()
+            table.add_row(key_display, str(value))
+
+        # Create panel
+        panel = Panel(
+            table,
+            title=f"[bold green]🚀 {server_type} Starting[/bold green]",
+            border_style="green",
+            padding=(1, 2)
+        )
+
+        console.print(panel)
+
+        if hotreload_enabled:
+            console.print(
+                "[yellow]⚠️  Hotreload active - connections may be dropped on code changes[/yellow]",
+                style="bold"
+            )
+    else:
+        # Fallback to simple logging
+        logger.info("=" * 80)
+        logger.info(f"🚀 {server_type} Starting")
+        logger.info(f"   ⏰ Started at: {start_time.strftime('%Y-%m-%d %H:%M:%S')}")
+        logger.info(f"   Mode: {mode}")
+        logger.info(f"   Hotreload: {'Enabled' if hotreload_enabled else 'Disabled'}")
+
+        for key, value in extra_info.items():
+            key_display = key.replace('_', ' ').title()
+            logger.info(f"   {key_display}: {value}")
+
+        if hotreload_enabled:
+            logger.warning(
+                "⚠️  Hotreload active - connections may be dropped on code changes"
+            )
+
+        logger.info("=" * 80)
+
+    return start_time
+
+
+def log_server_shutdown(
+    logger: logging.Logger,
+    start_time,
+    server_type: str = "Server",
+    reason: str = None,
+    use_rich: bool = True,
+    **extra_info
+):
+    """
+    Log server shutdown with uptime calculation using Rich panels.
+
+    Args:
+        logger: Logger instance to use
+        start_time: datetime object from log_server_start()
+        server_type: Type of server (e.g., "gRPC Server", "WebSocket Server")
+        reason: Shutdown reason (e.g., "Keyboard interrupt", "Hotreload")
+        use_rich: Use Rich for beautiful output (default: True)
+        **extra_info: Additional key-value pairs to log
+
+    Example:
+        ```python
+        from django_cfg.apps.integrations.grpc.utils import log_server_shutdown
+
+        log_server_shutdown(
+            logger,
+            start_time,
+            server_type="gRPC Server",
+            reason="Hotreload triggered",
+            active_connections=5
+        )
+        ```
+    """
+    from datetime import datetime
+
+    end_time = datetime.now()
+    uptime = end_time - start_time
+    uptime_seconds = int(uptime.total_seconds())
+
+    # Format uptime
+    hours = uptime_seconds // 3600
+    minutes = (uptime_seconds % 3600) // 60
+    seconds = uptime_seconds % 60
+    uptime_str = f"{hours}h {minutes}m {seconds}s"
+
+    if use_rich:
+        # Create Rich table for shutdown info
+        console = Console()
+
+        table = Table(show_header=False, box=None, padding=(0, 1))
+        table.add_column("Key", style="cyan")
+        table.add_column("Value", style="white")
+
+        if reason:
+            table.add_row("📋 Reason", reason)
+
+        table.add_row("⏱️  Uptime", f"[bold]{uptime_str}[/bold]")
+        table.add_row("🕐 Stopped at", end_time.strftime('%Y-%m-%d %H:%M:%S'))
+
+        # Add extra info
+        for key, value in extra_info.items():
+            key_display = key.replace('_', ' ').title()
+            table.add_row(key_display, str(value))
+
+        # Create panel
+        panel = Panel(
+            table,
+            title=f"[bold red]🧹 Shutting down {server_type}[/bold red]",
+            border_style="red",
+            padding=(1, 2)
+        )
+
+        console.print(panel)
+        console.print("[green]✅ Server shutdown complete[/green]", style="bold")
+    else:
+        # Fallback to simple logging
+        logger.info("=" * 80)
+        logger.info(f"🧹 Shutting down {server_type}...")
+
+        if reason:
+            logger.info(f"   📋 Reason: {reason}")
+
+        logger.info(f"   ⏱️  Uptime: {uptime_str}")
+        logger.info(f"   🕐 Stopped at: {end_time.strftime('%Y-%m-%d %H:%M:%S')}")
+
+        for key, value in extra_info.items():
+            key_display = key.replace('_', ' ').title()
+            logger.info(f"   {key_display}: {value}")
+
+        logger.info("✅ Server shutdown complete")
+        logger.info("=" * 80)
+
+
+__all__ = [
+    "setup_streaming_logger",
+    "get_streaming_logger",
+    "log_server_start",
+    "log_server_shutdown",
+]

django_cfg/apps/integrations/grpc/views/__init__.py

@@ -0,0 +1,15 @@
+"""
+Views for gRPC monitoring API.
+"""
+
+from .api_keys import GRPCApiKeyViewSet
+from .config import GRPCConfigViewSet
+from .monitoring import GRPCMonitorViewSet
+from .services import GRPCServiceViewSet
+
+__all__ = [
+    "GRPCMonitorViewSet",
+    "GRPCConfigViewSet",
+    "GRPCServiceViewSet",
+    "GRPCApiKeyViewSet",
+]

django_cfg/apps/integrations/grpc/views/api_keys.py

@@ -0,0 +1,235 @@
+"""
+gRPC API Keys ViewSet.
+
+Provides REST API endpoints for viewing API keys.
+Create/Update/Delete operations handled through Django Admin.
+"""
+
+from django.db.models import Q, Sum
+from django.utils import timezone
+from django_cfg.middleware.pagination import DefaultPagination
+from django_cfg.mixins import AdminAPIMixin
+from django_cfg.utils import get_logger
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import OpenApiParameter, extend_schema
+from rest_framework import status, viewsets
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from ..models import GrpcApiKey
+from ..serializers.api_keys import (
+    ApiKeyListSerializer,
+    ApiKeySerializer,
+    ApiKeyStatsSerializer,
+)
+
+logger = get_logger("grpc.api_keys")
+
+
+class GRPCApiKeyViewSet(AdminAPIMixin, viewsets.GenericViewSet):
+    """
+    ViewSet for gRPC API Keys (Read-Only).
+
+    Provides listing and statistics for API keys.
+    Create/Update/Delete operations are handled through Django Admin.
+
+    Requires admin authentication (JWT, Session, or Basic Auth).
+    """
+
+    # Pagination for list endpoint
+    pagination_class = DefaultPagination
+
+    queryset = GrpcApiKey.objects.none()
+    serializer_class = ApiKeySerializer
+
+    @extend_schema(
+        tags=["gRPC API Keys"],
+        summary="List API keys",
+        description="Returns a list of all API keys with their details. Uses standard DRF pagination.",
+        parameters=[
+            OpenApiParameter(
+                name="is_active",
+                type=OpenApiTypes.BOOL,
+                location=OpenApiParameter.QUERY,
+                description="Filter by active status",
+                required=False,
+            ),
+            OpenApiParameter(
+                name="user_id",
+                type=OpenApiTypes.INT,
+                location=OpenApiParameter.QUERY,
+                description="Filter by user ID",
+                required=False,
+            ),
+        ],
+        responses={
+            200: ApiKeySerializer(many=True),
+            400: {"description": "Invalid parameters"},
+        },
+    )
+    def list(self, request):
+        """List all API keys."""
+        try:
+            # Build queryset with filters
+            queryset = GrpcApiKey.objects.select_related("user").all()
+
+            # Apply filters
+            is_active = request.GET.get("is_active")
+            if is_active is not None:
+                is_active_bool = is_active.lower() in ("true", "1", "yes")
+                queryset = queryset.filter(is_active=is_active_bool)
+
+            user_id = request.GET.get("user_id")
+            if user_id:
+                queryset = queryset.filter(user_id=user_id)
+
+            # Order by most recently created
+            queryset = queryset.order_by("-created_at")
+
+            # Paginate
+            page = self.paginate_queryset(queryset)
+            if page is not None:
+                # Serialize paginated data
+                results = []
+                for key in page:
+                    results.append({
+                        "id": key.id,
+                        "name": key.name,
+                        "masked_key": key.masked_key,
+                        "is_active": key.is_active,
+                        "is_valid": key.is_valid,
+                        "user_id": key.user.id,
+                        "username": key.user.username,
+                        "user_email": key.user.email,
+                        "request_count": key.request_count,
+                        "last_used_at": key.last_used_at,
+                        "expires_at": key.expires_at,
+                        "created_at": key.created_at,
+                    })
+                return self.get_paginated_response(results)
+
+            # No pagination fallback
+            results = []
+            for key in queryset[:100]:
+                results.append({
+                    "id": key.id,
+                    "name": key.name,
+                    "masked_key": key.masked_key,
+                    "is_active": key.is_active,
+                    "is_valid": key.is_valid,
+                    "user_id": key.user.id,
+                    "username": key.user.username,
+                    "user_email": key.user.email,
+                    "request_count": key.request_count,
+                    "last_used_at": key.last_used_at,
+                    "expires_at": key.expires_at,
+                    "created_at": key.created_at,
+                })
+
+            return Response({"results": results, "count": len(results)})
+
+        except ValueError as e:
+            logger.warning(f"API keys list validation error: {e}")
+            return Response(
+                {"error": str(e)}, status=status.HTTP_400_BAD_REQUEST
+            )
+        except Exception as e:
+            logger.error(f"API keys list error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC API Keys"],
+        summary="Get API key details",
+        description="Returns detailed information about a specific API key.",
+        responses={
+            200: ApiKeySerializer,
+            404: {"description": "API key not found"},
+        },
+    )
+    def retrieve(self, request, pk=None):
+        """Get details of a specific API key."""
+        try:
+            key = GrpcApiKey.objects.select_related("user").get(pk=pk)
+
+            data = {
+                "id": key.id,
+                "name": key.name,
+                "masked_key": key.masked_key,
+                "is_active": key.is_active,
+                "is_valid": key.is_valid,
+                "user_id": key.user.id,
+                "username": key.user.username,
+                "user_email": key.user.email,
+                "request_count": key.request_count,
+                "last_used_at": key.last_used_at,
+                "expires_at": key.expires_at,
+                "created_at": key.created_at,
+            }
+
+            serializer = ApiKeySerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+
+        except GrpcApiKey.DoesNotExist:
+            return Response(
+                {"error": "API key not found"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+        except Exception as e:
+            logger.error(f"API key retrieve error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC API Keys"],
+        summary="Get API keys statistics",
+        description="Returns overall statistics about API keys usage.",
+        responses={
+            200: ApiKeyStatsSerializer,
+        },
+    )
+    @action(detail=False, methods=["get"], url_path="stats")
+    def stats(self, request):
+        """Get API keys statistics."""
+        try:
+            # Total keys
+            total_keys = GrpcApiKey.objects.count()
+
+            # Active keys
+            active_keys = GrpcApiKey.objects.filter(is_active=True).count()
+
+            # Expired keys
+            expired_keys = GrpcApiKey.objects.filter(
+                Q(is_active=True) & Q(expires_at__lt=timezone.now())
+            ).count()
+
+            # Total requests across all keys
+            total_requests = GrpcApiKey.objects.aggregate(
+                total=Sum("request_count")
+            )["total"] or 0
+
+            stats_data = {
+                "total_keys": total_keys,
+                "active_keys": active_keys,
+                "expired_keys": expired_keys,
+                "total_requests": total_requests,
+            }
+
+            serializer = ApiKeyStatsSerializer(data=stats_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+
+        except Exception as e:
+            logger.error(f"API keys stats error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+__all__ = ["GRPCApiKeyViewSet"]