django-cfg 1.4.61__tar.gz → 1.4.62__tar.gz

{django_cfg-1.4.61 → django_cfg-1.4.62}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-cfg
-Version: 1.4.61
+Version: 1.4.62
 Summary: Django AI framework with built-in agents, type-safe Pydantic v2 configuration, and 8 enterprise apps. Replace settings.py, validate at startup, 90% less code. Production-ready AI workflows for Django.
 Project-URL: Homepage, https://djangocfg.com
 Project-URL: Documentation, https://djangocfg.com

{django_cfg-1.4.61 → django_cfg-1.4.62}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "django-cfg"
-version = "1.4.61"
+version = "1.4.62"
 description = "Django AI framework with built-in agents, type-safe Pydantic v2 configuration, and 8 enterprise apps. Replace settings.py, validate at startup, 90% less code. Production-ready AI workflows for Django."
 readme = "README.md"
 keywords = [ "django", "configuration", "pydantic", "settings", "type-safety", "pydantic-settings", "django-environ", "startup-validation", "ide-autocomplete", "ai-agents", "enterprise-django", "django-settings", "type-safe-config",]

{django_cfg-1.4.61 → django_cfg-1.4.62}/src/django_cfg/__init__.py

@@ -32,7 +32,7 @@ Example:
 default_app_config = "django_cfg.apps.DjangoCfgConfig"
 
 # Version information
-__version__ = "1.4.61"
+__version__ = "1.4.62"
 __license__ = "MIT"
 
 # Import registry for organized lazy loading

{django_cfg-1.4.61 → django_cfg-1.4.62}/src/django_cfg/apps/ipc/admin.py

@@ -30,6 +30,7 @@ rpclog_config = AdminConfig(
     # List display
     list_display=[
         "method",
+        "type_badge",  # NEW: Show RPC vs Event
         "status",
         "user",
         "duration_ms",
@@ -73,9 +74,12 @@ rpclog_config = AdminConfig(
     ],
 
     # Filters
-    list_filter=["status", "method", "created_at"],
+    list_filter=["status", "is_event", "method", "created_at"],
     search_fields=["method", "correlation_id", "user__username", "user__email", "error_message"],
 
+    # Autocomplete for user field
+    autocomplete_fields=["user"],
+
     # Readonly fields (custom methods below)
     readonly_fields=[
         "id",
@@ -108,6 +112,22 @@ class RPCLogAdmin(PydanticAdmin):
     """
     config = rpclog_config
 
+    @computed_field("Type", ordering="is_event")
+    def type_badge(self, obj):
+        """Display badge showing if this is an RPC call or server event."""
+        if obj.is_event:
+            return self.html.badge(
+                "EVENT",
+                variant="info",
+                icon=Icons.NOTIFICATION  # or Icons.BROADCAST
+            )
+        else:
+            return self.html.badge(
+                "RPC",
+                variant="primary",
+                icon=Icons.API
+            )
+
     @computed_field("Duration", ordering="duration_ms")
     def duration_display(self, obj):
         """Display duration with color coding based on speed."""

django_cfg-1.4.62/src/django_cfg/apps/ipc/apps.py

@@ -0,0 +1,98 @@
+"""
+Django app configuration for IPC/RPC module.
+
+Provides RPC client and monitoring dashboard.
+"""
+
+import asyncio
+from django.apps import AppConfig
+from django.conf import settings
+
+
+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
+    - RPC log consumer (Redis Stream -> ORM)
+    """
+
+    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
+
+        # Start RPC Log Consumer in background (if enabled)
+        self._start_rpc_log_consumer()
+
+    def _start_rpc_log_consumer(self):
+        """Start RPC Log Consumer to capture logs from WebSocket server."""
+        # Check if RPC logging consumer is enabled
+        enable_consumer = getattr(settings, 'DJANGO_CFG_RPC_LOG_CONSUMER_ENABLED', True)
+
+        if not enable_consumer:
+            return
+
+        # Check if we have RPC configuration
+        if not hasattr(settings, 'DJANGO_CFG_RPC'):
+            return
+
+        # Check if RPC is enabled (case-insensitive)
+        rpc_enabled = settings.DJANGO_CFG_RPC.get('ENABLED') or settings.DJANGO_CFG_RPC.get('enabled')
+        if not rpc_enabled:
+            return
+
+        try:
+            import threading
+            from .services.rpc_log_consumer import RPCLogConsumer
+
+            # Get Redis URL (case-insensitive)
+            redis_url = settings.DJANGO_CFG_RPC.get('REDIS_URL') or settings.DJANGO_CFG_RPC.get('redis_url', 'redis://localhost:6379/2')
+
+            consumer = RPCLogConsumer(
+                redis_url=redis_url,
+                stream_name="stream:rpc-logs",
+                consumer_group="django-rpc-loggers",
+                consumer_name="django-1",
+            )
+
+            # Run consumer in background thread with its own event loop
+            def run_consumer():
+                """Run consumer in background thread."""
+                try:
+                    # Create new event loop for this thread
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+
+                    # Initialize and start consumer
+                    loop.run_until_complete(consumer.initialize())
+                    loop.run_until_complete(consumer.start())
+
+                    # Keep running
+                    loop.run_forever()
+
+                except Exception as e:
+                    from django_cfg.modules.django_logging import get_logger
+                    logger = get_logger("ipc.consumer")
+                    logger.error(f"RPC Log Consumer error: {e}", exc_info=True)
+
+            # Start in daemon thread (won't block Django shutdown)
+            thread = threading.Thread(target=run_consumer, daemon=True, name="rpc-log-consumer")
+            thread.start()
+
+            from django_cfg.modules.django_logging import get_logger
+            logger = get_logger("ipc.apps")
+            logger.info("✅ RPC Log Consumer started in background thread")
+
+        except Exception as e:
+            from django_cfg.modules.django_logging import get_logger
+            logger = get_logger("ipc.apps")
+            logger.warning(f"Failed to start RPC Log Consumer: {e}")

django_cfg-1.4.62/src/django_cfg/apps/ipc/migrations/0002_rpclog_is_event.py

@@ -0,0 +1,23 @@
+# Generated by Django 5.2.7 on 2025-10-24 07:41
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("django_cfg_ipc", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="rpclog",
+            name="is_event",
+            field=models.BooleanField(
+                db_index=True,
+                default=False,
+                help_text="True if this is a server-to-client event (not a request-response RPC call)",
+                verbose_name="Is Event",
+            ),
+        ),
+    ]

{django_cfg-1.4.61 → django_cfg-1.4.62}/src/django_cfg/apps/ipc/models.py

@@ -110,6 +110,14 @@ class RPCLog(models.Model):
         help_text="Result from RPC call"
     )
 
+    # Type: RPC call or server event
+    is_event = models.BooleanField(
+        default=False,
+        db_index=True,
+        verbose_name="Is Event",
+        help_text="True if this is a server-to-client event (not a request-response RPC call)"
+    )
+
     # Status
     status = models.CharField(
         max_length=20,

django_cfg-1.4.62/src/django_cfg/apps/ipc/services/rpc_log_consumer.py

@@ -0,0 +1,330 @@
+"""
+RPC Log Consumer - Redis Stream to Django ORM.
+
+Consumes RPC events from Redis Stream (published by WebSocket server)
+and saves them to Django database for monitoring and analytics.
+
+Architecture:
+- WebSocket Server -> Redis Stream (stream:rpc-logs)
+- This Consumer <- Redis Stream -> Django ORM (RPCLog model)
+
+This maintains service independence while enabling centralized logging.
+"""
+
+import asyncio
+import json
+import time
+from typing import Dict, Optional, Any
+from django.contrib.auth import get_user_model
+from django_cfg.modules.django_logging import get_logger
+import redis.asyncio as redis
+
+logger = get_logger("ipc.consumer")
+User = get_user_model()
+
+
+class RPCLogConsumer:
+    """
+    Consumes RPC events from Redis Stream and saves to Django ORM.
+
+    Features:
+    - Async consumer for high throughput
+    - Automatic reconnection on Redis errors
+    - Batched processing for performance
+    - Graceful shutdown
+    - Error tolerance (continues on DB errors)
+
+    Example:
+        >>> consumer = RPCLogConsumer(
+        ...     redis_url="redis://localhost:6379/2",
+        ...     stream_name="stream:rpc-logs",
+        ... )
+        >>> await consumer.start()  # Runs in background
+    """
+
+    def __init__(
+        self,
+        redis_url: str = "redis://localhost:6379/2",
+        stream_name: str = "stream:rpc-logs",
+        consumer_group: str = "django-rpc-loggers",
+        consumer_name: str = "django-1",
+        batch_size: int = 10,
+        block_ms: int = 1000,
+    ):
+        """
+        Initialize RPC Log Consumer.
+
+        Args:
+            redis_url: Redis connection URL
+            stream_name: Redis Stream name to consume
+            consumer_group: Consumer group name
+            consumer_name: Unique consumer name
+            batch_size: Number of messages to process per batch
+            block_ms: Block time for XREADGROUP (milliseconds)
+        """
+        self.redis_url = redis_url
+        self.stream_name = stream_name
+        self.consumer_group = consumer_group
+        self.consumer_name = consumer_name
+        self.batch_size = batch_size
+        self.block_ms = block_ms
+
+        self._redis: Optional[redis.Redis] = None
+        self._running = False
+        self._task: Optional[asyncio.Task] = None
+
+        # Pending requests (correlation_id -> log_entry)
+        self._pending_requests: Dict[str, Any] = {}
+
+    async def initialize(self) -> None:
+        """Initialize Redis connection and consumer group."""
+        try:
+            self._redis = await redis.from_url(
+                self.redis_url,
+                decode_responses=True,  # Decode Redis responses to strings
+                socket_keepalive=True,
+            )
+
+            # Test connection
+            await self._redis.ping()
+
+            # Create consumer group if not exists
+            try:
+                await self._redis.xgroup_create(
+                    name=self.stream_name,
+                    groupname=self.consumer_group,
+                    id="0",  # Start from beginning
+                    mkstream=True,  # Create stream if not exists
+                )
+                logger.info(f"✅ Created consumer group: {self.consumer_group}")
+            except redis.ResponseError as e:
+                if "BUSYGROUP" in str(e):
+                    logger.debug(f"Consumer group already exists: {self.consumer_group}")
+                else:
+                    raise
+
+            logger.info(f"✅ RPC Log Consumer initialized: {self.stream_name}")
+
+        except Exception as e:
+            logger.error(f"❌ Failed to initialize RPC Log Consumer: {e}")
+            raise
+
+    async def start(self) -> None:
+        """Start consuming RPC events from Redis Stream."""
+        if self._running:
+            logger.warning("RPC Log Consumer already running")
+            return
+
+        self._running = True
+        self._task = asyncio.create_task(self._consume_loop())
+        logger.info(f"🚀 RPC Log Consumer started: {self.consumer_name}")
+
+    async def stop(self) -> None:
+        """Stop consuming and cleanup."""
+        if not self._running:
+            return
+
+        logger.info("⏹️  Stopping RPC Log Consumer...")
+        self._running = False
+
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+
+        if self._redis:
+            await self._redis.close()
+
+        logger.info("✅ RPC Log Consumer stopped")
+
+    async def _consume_loop(self) -> None:
+        """Main consume loop - reads from Redis Stream and processes events."""
+        last_id = ">"  # Read only new messages
+
+        while self._running:
+            try:
+                # Read from stream
+                messages = await self._redis.xreadgroup(
+                    groupname=self.consumer_group,
+                    consumername=self.consumer_name,
+                    streams={self.stream_name: last_id},
+                    count=self.batch_size,
+                    block=self.block_ms,
+                )
+
+                if not messages:
+                    continue  # No new messages, continue
+
+                # Process messages
+                for stream_name, stream_messages in messages:
+                    for message_id, message_data in stream_messages:
+                        try:
+                            await self._process_event(message_id, message_data)
+
+                            # Acknowledge message
+                            await self._redis.xack(
+                                self.stream_name,
+                                self.consumer_group,
+                                message_id,
+                            )
+
+                        except Exception as e:
+                            logger.error(
+                                f"Error processing RPC event {message_id}: {e}",
+                                exc_info=True
+                            )
+                            # Continue processing other messages
+
+            except asyncio.CancelledError:
+                logger.info("RPC Log Consumer loop cancelled")
+                break
+            except Exception as e:
+                logger.error(f"Error in RPC Log Consumer loop: {e}", exc_info=True)
+                # Wait before retrying
+                await asyncio.sleep(5)
+
+    async def _process_event(self, message_id: str, event_data: Dict[str, str]) -> None:
+        """
+        Process single RPC event from Redis Stream.
+
+        Args:
+            message_id: Redis message ID
+            event_data: Event data from stream
+        """
+        event_type = event_data.get("event_type")
+        correlation_id = event_data.get("correlation_id")
+
+        if not correlation_id:
+            logger.warning(f"Event missing correlation_id: {message_id}")
+            return
+
+        if event_type == "request":
+            await self._handle_request(correlation_id, event_data)
+        elif event_type == "response":
+            await self._handle_response(correlation_id, event_data)
+        else:
+            logger.warning(f"Unknown event type: {event_type}")
+
+    async def _handle_request(self, correlation_id: str, event_data: Dict[str, str]) -> None:
+        """
+        Handle RPC request event - create RPCLog entry.
+
+        Args:
+            correlation_id: Correlation ID
+            event_data: Event data from stream
+        """
+        try:
+            from ..models import RPCLog
+
+            method = event_data.get("method")
+            params_json = event_data.get("params", "{}")
+            user_id = event_data.get("user_id")
+
+            # Parse params
+            try:
+                params = json.loads(params_json)
+            except json.JSONDecodeError:
+                params = {}
+
+            # Get user if user_id provided
+            user = None
+            if user_id:
+                try:
+                    user = await asyncio.to_thread(User.objects.get, pk=user_id)
+                except User.DoesNotExist:
+                    pass
+
+            # Create log entry in database (sync operation in thread)
+            log_entry = await asyncio.to_thread(
+                RPCLog.objects.create,
+                correlation_id=correlation_id,
+                method=method,
+                params=params,
+                user=user,
+                status=RPCLog.StatusChoices.PENDING,
+            )
+
+            # Store in pending for later update
+            self._pending_requests[correlation_id] = log_entry
+
+            logger.debug(f"Created RPC log entry: {method} ({correlation_id})")
+
+        except Exception as e:
+            logger.error(f"Failed to handle RPC request: {e}", exc_info=True)
+
+    async def _handle_response(self, correlation_id: str, event_data: Dict[str, str]) -> None:
+        """
+        Handle RPC response event - update RPCLog entry.
+
+        Args:
+            correlation_id: Correlation ID
+            event_data: Event data from stream
+        """
+        try:
+            from ..models import RPCLog
+
+            # Get log entry from pending or database
+            log_entry = self._pending_requests.pop(correlation_id, None)
+
+            if not log_entry:
+                # Try to find in database with retry (race condition with request handler)
+                max_retries = 3
+                retry_delay = 0.1  # 100ms
+
+                for attempt in range(max_retries):
+                    try:
+                        log_entry = await asyncio.to_thread(
+                            RPCLog.objects.get,
+                            correlation_id=correlation_id
+                        )
+                        break  # Found it!
+                    except RPCLog.DoesNotExist:
+                        if attempt < max_retries - 1:
+                            # Wait a bit and retry
+                            await asyncio.sleep(retry_delay)
+                        else:
+                            # Give up after retries
+                            logger.warning(f"RPCLog not found for correlation_id: {correlation_id} after {max_retries} retries")
+                            return
+
+            # Parse response data
+            success = event_data.get("success") == "1"
+            duration_ms = int(event_data.get("duration_ms", 0))
+
+            if success:
+                result_json = event_data.get("result", "{}")
+                try:
+                    result = json.loads(result_json)
+                except json.JSONDecodeError:
+                    result = {}
+
+                # Mark as success (sync operation in thread)
+                await asyncio.to_thread(
+                    log_entry.mark_success,
+                    result,
+                    duration_ms
+                )
+
+                logger.debug(f"Marked RPC log as success: {correlation_id}")
+
+            else:
+                error_code = event_data.get("error_code", "unknown")
+                error_message = event_data.get("error_message", "")
+
+                # Mark as failed (sync operation in thread)
+                await asyncio.to_thread(
+                    log_entry.mark_failed,
+                    error_code,
+                    error_message,
+                    duration_ms
+                )
+
+                logger.debug(f"Marked RPC log as failed: {correlation_id}")
+
+        except Exception as e:
+            logger.error(f"Failed to handle RPC response: {e}", exc_info=True)
+
+
+__all__ = ["RPCLogConsumer"]

django_cfg-1.4.61/src/django_cfg/apps/ipc/apps.py

@@ -1,28 +0,0 @@
-"""
-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