unrealon 2.0.5__tar.gz → 2.0.7__tar.gz

{unrealon-2.0.5/unrealon.egg-info → unrealon-2.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unrealon
-Version: 2.0.5
+Version: 2.0.7
 Summary: Enterprise-grade web scraping platform with AI-powered automation and real-time orchestration capabilities
 Author-email: UnrealOn Team <team@unrealon.com>
 License: MIT

{unrealon-2.0.5 → unrealon-2.0.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "unrealon"
-version = "2.0.5"
+version = "2.0.7"
 description = "Enterprise-grade web scraping platform with AI-powered automation and real-time orchestration capabilities"
 authors = [
     {name = "UnrealOn Team", email = "team@unrealon.com"}

{unrealon-2.0.5 → unrealon-2.0.7}/unrealon-core/src/unrealon_core/__init__.py

@@ -42,7 +42,10 @@ from .models.communication import (
     create_error_message, create_ack_message,
     # Data models for strict typing
     TaskAssignmentData, TaskResultData,
-    DriverRegistrationData, HeartbeatData, LogEntryData, LogContext
+    DriverRegistrationData, HeartbeatData, LogEntryData, LogContext,
+    # Broadcast models
+    DriverBroadcastData, DriverRegisterBroadcast,
+    DriverHeartbeatBroadcast, DriverDisconnectBroadcast
 )
 from .enums.status import DriverStatus, TaskStatus, ProxyStatus, LogLevel
 from .enums.types import MessageType, ProxyType, TaskPriority
@@ -127,6 +130,12 @@ __all__ = [
     "LogEntryData",
     "LogContext",
     
+    # Broadcast models
+    "DriverBroadcastData",
+    "DriverRegisterBroadcast",
+    "DriverHeartbeatBroadcast", 
+    "DriverDisconnectBroadcast",
+    
     # Status enums
     "DriverStatus",
     "TaskStatus",

{unrealon-2.0.5 → unrealon-2.0.7}/unrealon-core/src/unrealon_core/enums/types.py

@@ -53,6 +53,7 @@ class MessageType(str, Enum):
     LOG_BATCH = "log_batch"                       # Batch of log messages
     
     # System messages
+    WELCOME = "welcome"                           # Welcome message from server
     PING = "ping"                                 # Ping message
     PONG = "pong"                                 # Pong response
     ERROR = "error"                               # Error message

{unrealon-2.0.5 → unrealon-2.0.7}/unrealon-core/src/unrealon_core/models/websocket/__init__.py

@@ -38,6 +38,12 @@ from .proxy import (
 )
 
 from .utils import create_error_message, create_ack_message
+from .broadcast import (
+    DriverBroadcastData,
+    DriverRegisterBroadcast,
+    DriverHeartbeatBroadcast,
+    DriverDisconnectBroadcast
+)
 
 __all__ = [
     # Base
@@ -87,5 +93,11 @@ __all__ = [
     
     # Utilities
     'create_error_message',
-    'create_ack_message'
+    'create_ack_message',
+    
+    # Broadcast messages
+    'DriverBroadcastData',
+    'DriverRegisterBroadcast',
+    'DriverHeartbeatBroadcast',
+    'DriverDisconnectBroadcast'
 ]

unrealon-2.0.7/unrealon-core/src/unrealon_core/models/websocket/broadcast.py

@@ -0,0 +1,168 @@
+"""
+Broadcast WebSocket Models.
+
+Strictly typed models for broadcasting driver events to monitoring clients.
+These are Server → Client messages for real-time monitoring.
+
+Phase 2: Core Systems - WebSocket Bridge
+"""
+
+from typing import List, Optional
+from pydantic import Field, ConfigDict
+
+from ..base import UnrealOnBaseModel
+from .base import WebSocketMessage, MessageType
+
+
+class DriverBroadcastData(UnrealOnBaseModel):
+    """Driver broadcast data payload - strictly typed."""
+    
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid"
+    )
+    
+    driver_id: str = Field(
+        description="Unique driver identifier",
+        min_length=1
+    )
+    
+    driver_type: str = Field(
+        description="Type of driver (e.g., 'universal', 'ecommerce')",
+        min_length=1
+    )
+    
+    status: str = Field(
+        default="active",
+        pattern=r"^(active|idle|busy|offline|error)$",
+        description="Current driver status"
+    )
+    
+    capabilities: List[str] = Field(
+        default_factory=list,
+        description="List of supported task types"
+    )
+    
+    active_tasks: int = Field(
+        default=0,
+        ge=0,
+        description="Number of currently active tasks"
+    )
+    
+    completed_tasks: int = Field(
+        default=0,
+        ge=0,
+        description="Total completed tasks since startup"
+    )
+    
+    failed_tasks: int = Field(
+        default=0,
+        ge=0,
+        description="Total failed tasks since startup"
+    )
+    
+    uptime_seconds: float = Field(
+        default=0.0,
+        ge=0.0,
+        description="Driver uptime in seconds"
+    )
+    
+    last_seen: Optional[str] = Field(
+        default=None,
+        description="ISO timestamp of last heartbeat"
+    )
+    
+    connected_at: Optional[str] = Field(
+        default=None,
+        description="ISO timestamp when driver connected"
+    )
+    
+    disconnected_at: Optional[str] = Field(
+        default=None,
+        description="ISO timestamp when driver disconnected"
+    )
+    
+    # Additional fields for complete driver information
+    version: Optional[str] = Field(
+        default=None,
+        description="Driver version"
+    )
+    
+    driver_name: Optional[str] = Field(
+        default=None,
+        description="Human-readable driver name"
+    )
+    
+    environment: Optional[str] = Field(
+        default=None,
+        description="Driver environment (development, production, etc.)"
+    )
+    
+    region: Optional[str] = Field(
+        default=None,
+        description="Driver region"
+    )
+    
+    max_concurrent_tasks: Optional[int] = Field(
+        default=None,
+        ge=1,
+        description="Maximum concurrent tasks"
+    )
+    
+    tags: List[str] = Field(
+        default_factory=list,
+        description="Driver tags"
+    )
+
+
+class DriverRegisterBroadcast(WebSocketMessage):
+    """Driver registration broadcast message (Server → Monitoring Clients)."""
+    
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid"
+    )
+    
+    type: MessageType = Field(
+        default=MessageType.DRIVER_REGISTER
+    )
+    
+    data: DriverBroadcastData = Field(
+        description="Driver registration broadcast data"
+    )
+
+
+class DriverHeartbeatBroadcast(WebSocketMessage):
+    """Driver heartbeat broadcast message (Server → Monitoring Clients)."""
+    
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid"
+    )
+    
+    type: MessageType = Field(
+        default=MessageType.DRIVER_HEARTBEAT,
+        frozen=True
+    )
+    
+    data: DriverBroadcastData = Field(
+        description="Driver heartbeat broadcast data"
+    )
+
+
+class DriverDisconnectBroadcast(WebSocketMessage):
+    """Driver disconnect broadcast message (Server → Monitoring Clients)."""
+    
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid"
+    )
+    
+    type: MessageType = Field(
+        default=MessageType.DRIVER_DISCONNECT,
+        frozen=True
+    )
+    
+    data: DriverBroadcastData = Field(
+        description="Driver disconnect broadcast data"
+    )

{unrealon-2.0.5 → unrealon-2.0.7}/unrealon-driver/src/unrealon_driver/driver/communication/session.py

@@ -12,6 +12,7 @@ from pydantic import BaseModel, Field
 
 from unrealon_core.models.websocket import (
     TaskAssignmentData,
+    TaskAssignmentMessage,
     TaskResultData,
     WebSocketMessage
 )
@@ -69,21 +70,26 @@ class DriverSession:
         
         try:
             # Connect WebSocket
+            logger.info(f"🔌 Connecting WebSocket for driver: {self.driver_id}")
             self.status = SessionStatus.CONNECTING
             if not await self.websocket_client.connect():
+                logger.error(f"❌ WebSocket connection failed for driver: {self.driver_id}")
                 self.status = SessionStatus.ERROR
                 return False
             
+            logger.info(f"✅ WebSocket connected for driver: {self.driver_id}")
             self.status = SessionStatus.CONNECTED
             self.stats.connected_at = utc_now()
             
             # Register driver
+            logger.info(f"📝 Registering driver: {self.driver_id} with capabilities: {capabilities}")
             if await self.register(capabilities or []):
                 self.status = SessionStatus.REGISTERED
                 self.stats.registered_at = utc_now()
-                logger.info(f"Session started for driver: {self.driver_id}")
+                logger.info(f"✅ Session started for driver: {self.driver_id}")
                 return True
             else:
+                logger.error(f"❌ Driver registration failed for: {self.driver_id}")
                 self.status = SessionStatus.ERROR
                 return False
                 
@@ -139,8 +145,11 @@ class DriverSession:
     async def _handle_task_assignment(self, message: WebSocketMessage):
         """Handle task assignment."""
         try:
-            # Validate task data
-            task_data = TaskAssignmentData.model_validate(message.data)
+            # Parse as TaskAssignmentMessage
+            
+            # Convert to proper task assignment message
+            task_message = TaskAssignmentMessage.model_validate(message.model_dump())
+            task_data = task_message.data
             
             # Find handler
             handler = self.task_handlers.get(task_data.task_type)

{unrealon-2.0.5 → unrealon-2.0.7}/unrealon-driver/src/unrealon_driver/driver/communication/websocket_client.py

@@ -40,9 +40,11 @@ class WebSocketClient:
     - Clean error handling
     """
     
-    def __init__(self, websocket_url: str, driver_id: str):
+    def __init__(self, websocket_url: str, driver_id: str, custom_logger=None):
         self.websocket_url = websocket_url
         self.driver_id = driver_id
+        # Use custom logger if provided, otherwise use default
+        self._logger = custom_logger if custom_logger else logger
         self.websocket: Optional[ClientConnection] = None
         self.connected = False
         self.running = False
@@ -94,20 +96,20 @@ class WebSocketClient:
             self.websocket = None
         
         self.connected = False
-        logger.info("WebSocket client stopped")
+        self._logger.info("WebSocket client stopped")
     
     async def _establish_connection(self) -> bool:
         """Establish WebSocket connection."""
         try:
-            logger.info(f"Connecting to WebSocket: {self.websocket_url}")
+            self._logger.info(f"Connecting to WebSocket: {self.websocket_url}")
             self.websocket = await websockets.connect(self.websocket_url)
             self.connected = True
             self.reconnect_attempts = 0
             self.reconnect_delay = 1.0
-            logger.info("WebSocket connected successfully")
+            self._logger.info("WebSocket connected successfully")
             return True
         except Exception as e:
-            logger.error(f"WebSocket connection failed: {e}")
+            self._logger.error(f"WebSocket connection failed: {e}")
             self.connected = False
             return False
     
@@ -115,10 +117,10 @@ class WebSocketClient:
         """Monitor connection and handle reconnection."""
         while self.running:
             if not self.connected and self.running:
-                logger.info(f"Attempting reconnection (attempt {self.reconnect_attempts + 1})")
+                self._logger.info(f"Attempting reconnection (attempt {self.reconnect_attempts + 1})")
                 
                 if await self._establish_connection():
-                    logger.info("Reconnection successful")
+                    self._logger.info("Reconnection successful")
                 else:
                     self.reconnect_attempts += 1
                     # Exponential backoff
@@ -136,13 +138,16 @@ class WebSocketClient:
             if self.connected and self.websocket and self.message_queue:
                 try:
                     message = self.message_queue.popleft()
+                    self._logger.info(f"📤 Sending WebSocket message: {message[:200]}...")  # Log first 200 chars
                     await self.websocket.send(message)
+                    self._logger.info(f"✅ Message sent successfully")
                 except (websockets.exceptions.ConnectionClosed, ConnectionResetError):
                     self.connected = False
                     # Put message back in queue
                     self.message_queue.appendleft(message)
+                    self._logger.warning("🔌 Connection lost, message queued for retry")
                 except Exception as e:
-                    logger.error(f"Error sending message: {e}")
+                    self._logger.error(f"❌ Error sending message: {e}")
             else:
                 await asyncio.sleep(0.1)
     
@@ -163,9 +168,9 @@ class WebSocketClient:
                         
                 except (websockets.exceptions.ConnectionClosed, ConnectionResetError):
                     self.connected = False
-                    logger.warning("WebSocket connection lost")
+                    self._logger.warning("WebSocket connection lost")
                 except Exception as e:
-                    logger.error(f"Error receiving message: {e}")
+                    self._logger.error(f"Error receiving message: {e}")
             else:
                 await asyncio.sleep(0.1)
     
@@ -197,9 +202,9 @@ class WebSocketClient:
             # Queue for sending
             self.send(registration_message)
             
-            logger.info(f"Driver registration queued: {self.driver_id}")
+            self._logger.info(f"Driver registration queued: {self.driver_id}")
             return True
             
         except Exception as e:
-            logger.error(f"Driver registration failed: {e}")
+            self._logger.error(f"Driver registration failed: {e}")
             return False

{unrealon-2.0.5 → unrealon-2.0.7}/unrealon-driver/src/unrealon_driver/driver/lifecycle/daemon.py

@@ -47,6 +47,7 @@ class DaemonManager:
         
         try:
             # Initialize driver with capabilities
+            logger.info(f"🎯 Daemon initializing driver with capabilities: {driver.capabilities}")
             success = await DriverInitializer.initialize_driver(driver, driver.capabilities)
             if not success:
                 raise RuntimeError("Driver initialization failed")

{unrealon-2.0.5 → unrealon-2.0.7}/unrealon-driver/src/unrealon_driver/driver/lifecycle/initialization.py

@@ -10,6 +10,8 @@ from typing import List, TYPE_CHECKING
 from ..core.config import DriverMode
 from ..communication.websocket_client import WebSocketClient
 from ..communication.session import DriverSession
+from unrealon_core.config.environment import get_environment_config
+
 
 if TYPE_CHECKING:
     from ..core.driver import UniversalDriver
@@ -37,6 +39,14 @@ class DriverInitializer:
         
         try:
             logger.info(f"Initializing UniversalDriver: {driver.driver_id}")
+            logger.info(f"🔧 Driver mode: {driver.config.mode}")
+            logger.info(f"📡 WebSocket URL: {driver.config.effective_websocket_url}")
+            logger.info(f"🎯 Capabilities: {capabilities}")
+            
+            # Log environment info if available
+            env_config = get_environment_config()
+            logger.info(f"🌐 Environment: {env_config.environment.value}")
+            print(f"🌐 Environment: {env_config.environment}")
             
             # Initialize manager system
             if not await driver.manager_registry.initialize_all():
@@ -65,9 +75,12 @@ class DriverInitializer:
         
         # Setup WebSocket client if URL available
         if websocket_url:
+            # Pass driver's logger to WebSocket client for unified logging
+            custom_logger = driver.logger_manager.local_logger if driver.logger_manager else None
             driver.websocket_client = WebSocketClient(
                 websocket_url,
-                driver.driver_id
+                driver.driver_id,
+                custom_logger=custom_logger
             )
             
             # Set WebSocket client for logger (always for logging)

{unrealon-2.0.5 → unrealon-2.0.7}/unrealon-driver/src/unrealon_driver/managers/logger.py

@@ -89,6 +89,11 @@ class LoggerManager(BaseManager):
             self.local_logger.addHandler(handler)
             self.local_logger.setLevel(getattr(logging, self.config.log_level))
             
+            # Also configure root unrealon_driver logger to use same handler
+            unrealon_logger = logging.getLogger('unrealon_driver')
+            unrealon_logger.addHandler(handler)
+            unrealon_logger.setLevel(getattr(logging, self.config.log_level))
+            
         except Exception as e:
             logger.error(f"Failed to setup local logging: {e}")
     

{unrealon-2.0.5 → unrealon-2.0.7/unrealon.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unrealon
-Version: 2.0.5
+Version: 2.0.7
 Summary: Enterprise-grade web scraping platform with AI-powered automation and real-time orchestration capabilities
 Author-email: UnrealOn Team <team@unrealon.com>
 License: MIT

{unrealon-2.0.5 → unrealon-2.0.7}/unrealon.egg-info/SOURCES.txt

@@ -67,6 +67,7 @@ unrealon-core/src/unrealon_core/models/typed_responses.py
 unrealon-core/src/unrealon_core/models/websocket_session.py
 unrealon-core/src/unrealon_core/models/websocket/__init__.py
 unrealon-core/src/unrealon_core/models/websocket/base.py
+unrealon-core/src/unrealon_core/models/websocket/broadcast.py
 unrealon-core/src/unrealon_core/models/websocket/config.py
 unrealon-core/src/unrealon_core/models/websocket/driver.py
 unrealon-core/src/unrealon_core/models/websocket/errors.py