eval-protocol 0.2.43__tar.gz → 0.2.44__tar.gz

{eval_protocol-0.2.43/eval_protocol.egg-info → eval_protocol-0.2.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eval-protocol
-Version: 0.2.43
+Version: 0.2.44
 Summary: The official Python SDK for Eval Protocol (EP.) EP is an open protocol that standardizes how developers author evals for large language model (LLM) applications.
 Author-email: Fireworks AI <info@fireworks.ai>
 License-Expression: MIT

{eval_protocol-0.2.43 → eval_protocol-0.2.44}/eval_protocol/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-10-08T08:52:41-0700",
+ "date": "2025-10-08T11:55:20-0700",
  "dirty": false,
  "error": null,
- "full-revisionid": "535169e7193e6500d8d323e7dbc31c14dca98b96",
- "version": "0.2.43"
+ "full-revisionid": "e5883aeb569de1af057de3eae81aaf7790f468f1",
+ "version": "0.2.44"
 }
 '''  # END VERSION_JSON
 

{eval_protocol-0.2.43 → eval_protocol-0.2.44}/eval_protocol/cli.py

@@ -300,6 +300,7 @@ def parse_args(args=None):
     # Logs command
     logs_parser = subparsers.add_parser("logs", help="Serve logs with file watching and real-time updates")
     logs_parser.add_argument("--port", type=int, default=8000, help="Port to bind to (default: 8000)")
+    logs_parser.add_argument("--debug", action="store_true", help="Enable debug mode")
 
     # Upload command
     upload_parser = subparsers.add_parser(

{eval_protocol-0.2.43 → eval_protocol-0.2.44}/eval_protocol/cli_commands/logs.py

@@ -16,6 +16,7 @@ def logs_command(args):
     print(f"🌐 URL: http://localhost:{port}")
     print(f"🔌 WebSocket: ws://localhost:{port}/ws")
     print(f"👀 Watching paths: {['current directory']}")
+    print(f"🔍 Debug mode: {args.debug}")
     print("Press Ctrl+C to stop the server")
     print("-" * 50)
 
@@ -25,7 +26,7 @@ def logs_command(args):
     elasticsearch_config = ElasticsearchSetup().setup_elasticsearch()
 
     try:
-        serve_logs(port=args.port, elasticsearch_config=elasticsearch_config)
+        serve_logs(port=args.port, elasticsearch_config=elasticsearch_config, debug=args.debug)
         return 0
     except KeyboardInterrupt:
         print("\n🛑 Server stopped by user")

{eval_protocol-0.2.43 → eval_protocol-0.2.44}/eval_protocol/dataset_logger/sqlite_dataset_logger_adapter.py

@@ -23,12 +23,19 @@ class SqliteDatasetLoggerAdapter(DatasetLogger):
 
     def log(self, row: "EvaluationRow") -> None:
         data = row.model_dump(exclude_none=True, mode="json")
+        rollout_id = data.get("execution_metadata", {}).get("rollout_id", "unknown")
+        logger.debug(f"[EVENT_BUS_EMIT] Starting to log row with rollout_id: {rollout_id}")
+
         self._store.upsert_row(data=data)
+        logger.debug(f"[EVENT_BUS_EMIT] Successfully stored row in database for rollout_id: {rollout_id}")
+
         try:
+            logger.debug(f"[EVENT_BUS_EMIT] Emitting event '{LOG_EVENT_TYPE}' for rollout_id: {rollout_id}")
             event_bus.emit(LOG_EVENT_TYPE, EvaluationRow(**data))
+            logger.debug(f"[EVENT_BUS_EMIT] Successfully emitted event for rollout_id: {rollout_id}")
         except Exception as e:
             # Avoid breaking storage due to event emission issues
-            logger.error(f"Failed to emit row_upserted event: {e}")
+            logger.error(f"[EVENT_BUS_EMIT] Failed to emit row_upserted event for rollout_id {rollout_id}: {e}")
             pass
 
     def read(self, rollout_id: Optional[str] = None) -> List["EvaluationRow"]:

eval_protocol-0.2.44/eval_protocol/event_bus/sqlite_event_bus.py

@@ -0,0 +1,126 @@
+import asyncio
+import os
+import threading
+import time
+from typing import Any, Optional
+from uuid import uuid4
+
+from eval_protocol.event_bus.event_bus import EventBus
+from eval_protocol.event_bus.logger import logger
+from eval_protocol.event_bus.sqlite_event_bus_database import SqliteEventBusDatabase
+
+
+class SqliteEventBus(EventBus):
+    """SQLite-based event bus implementation that supports cross-process communication."""
+
+    def __init__(self, db_path: Optional[str] = None):
+        super().__init__()
+
+        # Use the same database as the evaluation row store
+        if db_path is None:
+            from eval_protocol.directory_utils import find_eval_protocol_dir
+
+            eval_protocol_dir = find_eval_protocol_dir()
+            db_path = os.path.join(eval_protocol_dir, "logs.db")
+
+        self._db: SqliteEventBusDatabase = SqliteEventBusDatabase(db_path)
+        self._running = False
+        self._process_id = str(os.getpid())
+
+    def emit(self, event_type: str, data: Any) -> None:
+        """Emit an event to all subscribers.
+
+        Args:
+            event_type: Type of event (e.g., "log")
+            data: Event data
+        """
+        logger.debug(f"[CROSS_PROCESS_EMIT] Emitting event type: {event_type}")
+
+        # Call local listeners immediately
+        logger.debug(f"[CROSS_PROCESS_EMIT] Calling {len(self._listeners)} local listeners")
+        super().emit(event_type, data)
+        logger.debug("[CROSS_PROCESS_EMIT] Completed local listener calls")
+
+        # Publish to cross-process subscribers
+        logger.debug("[CROSS_PROCESS_EMIT] Publishing to cross-process subscribers")
+        self._publish_cross_process(event_type, data)
+        logger.debug("[CROSS_PROCESS_EMIT] Completed cross-process publish")
+
+    def _publish_cross_process(self, event_type: str, data: Any) -> None:
+        """Publish event to cross-process subscribers via database."""
+        logger.debug(f"[CROSS_PROCESS_PUBLISH] Publishing event {event_type} to database")
+        try:
+            self._db.publish_event(event_type, data, self._process_id)
+            logger.debug(f"[CROSS_PROCESS_PUBLISH] Successfully published event {event_type} to database")
+        except Exception as e:
+            logger.error(f"[CROSS_PROCESS_PUBLISH] Failed to publish event {event_type} to database: {e}")
+
+    def start_listening(self) -> None:
+        """Start listening for cross-process events."""
+        if self._running:
+            logger.debug("[CROSS_PROCESS_LISTEN] Already listening, skipping start")
+            return
+
+        logger.debug("[CROSS_PROCESS_LISTEN] Starting cross-process event listening")
+        self._running = True
+        loop = asyncio.get_running_loop()
+        loop.create_task(self._database_listener_task())
+        logger.debug("[CROSS_PROCESS_LISTEN] Started async database listener task")
+
+    def stop_listening(self) -> None:
+        """Stop listening for cross-process events."""
+        logger.debug("[CROSS_PROCESS_LISTEN] Stopping cross-process event listening")
+        self._running = False
+
+    async def _database_listener_task(self) -> None:
+        """Single database listener task that processes events and recreates itself."""
+        if not self._running:
+            # this should end the task loop
+            logger.debug("[CROSS_PROCESS_LISTENER] Stopping database listener task")
+            return
+
+        # Get unprocessed events from other processes
+        events = self._db.get_unprocessed_events(str(self._process_id))
+        if events:
+            logger.debug(f"[CROSS_PROCESS_LISTENER] Found {len(events)} unprocessed events")
+        else:
+            logger.debug(f"[CROSS_PROCESS_LISTENER] No unprocessed events found for process {self._process_id}")
+
+        for event in events:
+            logger.debug(
+                f"[CROSS_PROCESS_LISTENER] Processing event {event['event_id']} of type {event['event_type']}"
+            )
+            # Handle the event
+            self._handle_cross_process_event(event["event_type"], event["data"])
+            logger.debug(f"[CROSS_PROCESS_LISTENER] Successfully processed event {event['event_id']}")
+
+            # Mark as processed
+            self._db.mark_event_processed(event["event_id"])
+            logger.debug(f"[CROSS_PROCESS_LISTENER] Marked event {event['event_id']} as processed")
+
+        # Clean up old events every hour
+        current_time = time.time()
+        if not hasattr(self, "_last_cleanup"):
+            self._last_cleanup = current_time
+        elif current_time - self._last_cleanup >= 3600:
+            logger.debug("[CROSS_PROCESS_LISTENER] Cleaning up old events")
+            self._db.cleanup_old_events()
+            self._last_cleanup = current_time
+
+        # Schedule the next task if still running
+        await asyncio.sleep(1.0)
+        loop = asyncio.get_running_loop()
+        loop.create_task(self._database_listener_task())
+
+    def _handle_cross_process_event(self, event_type: str, data: Any) -> None:
+        """Handle events received from other processes."""
+        logger.debug(f"[CROSS_PROCESS_HANDLE] Handling cross-process event type: {event_type}")
+        logger.debug(f"[CROSS_PROCESS_HANDLE] Calling {len(self._listeners)} listeners")
+
+        for i, listener in enumerate(self._listeners):
+            try:
+                logger.debug(f"[CROSS_PROCESS_HANDLE] Calling listener {i}")
+                listener(event_type, data)
+                logger.debug(f"[CROSS_PROCESS_HANDLE] Successfully called listener {i}")
+            except Exception as e:
+                logger.debug(f"[CROSS_PROCESS_HANDLE] Cross-process event listener {i} failed for {event_type}: {e}")

{eval_protocol-0.2.43 → eval_protocol-0.2.44}/eval_protocol/event_bus/sqlite_event_bus_database.py

@@ -2,7 +2,7 @@ import time
 from typing import Any, List
 from uuid import uuid4
 
-from peewee import CharField, DateTimeField, Model, SqliteDatabase
+from peewee import BooleanField, CharField, DateTimeField, Model, SqliteDatabase
 from playhouse.sqlite_ext import JSONField
 
 from eval_protocol.event_bus.logger import logger
@@ -25,7 +25,7 @@ class SqliteEventBusDatabase:
             data = JSONField()
             timestamp = DateTimeField()
             process_id = CharField()
-            processed = CharField(default="false")  # Track if event has been processed
+            processed = BooleanField(default=False)  # Track if event has been processed
 
         self._Event = Event
         self._db.connect()
@@ -46,7 +46,7 @@ class SqliteEventBusDatabase:
                 data=serialized_data,
                 timestamp=time.time(),
                 process_id=process_id,
-                processed="false",
+                processed=False,
             )
         except Exception as e:
             logger.warning(f"Failed to publish event to database: {e}")
@@ -56,7 +56,7 @@ class SqliteEventBusDatabase:
         try:
             query = (
                 self._Event.select()
-                .where((self._Event.process_id != process_id) & (self._Event.processed == "false"))
+                .where((self._Event.process_id != process_id) & (~self._Event.processed))
                 .order_by(self._Event.timestamp)
             )
 
@@ -80,7 +80,7 @@ class SqliteEventBusDatabase:
     def mark_event_processed(self, event_id: str) -> None:
         """Mark an event as processed."""
         try:
-            self._Event.update(processed="true").where(self._Event.event_id == event_id).execute()
+            self._Event.update(processed=True).where(self._Event.event_id == event_id).execute()
         except Exception as e:
             logger.debug(f"Failed to mark event as processed: {e}")
 
@@ -88,8 +88,6 @@ class SqliteEventBusDatabase:
         """Clean up old processed events."""
         try:
             cutoff_time = time.time() - (max_age_hours * 3600)
-            self._Event.delete().where(
-                (self._Event.processed == "true") & (self._Event.timestamp < cutoff_time)
-            ).execute()
+            self._Event.delete().where((self._Event.processed) & (self._Event.timestamp < cutoff_time)).execute()
         except Exception as e:
             logger.debug(f"Failed to cleanup old events: {e}")

{eval_protocol-0.2.43 → eval_protocol-0.2.44}/eval_protocol/log_utils/elasticsearch_client.py

@@ -100,6 +100,25 @@ class ElasticsearchClient:
         except Exception:
             return False
 
+    def clear_index(self) -> bool:
+        """Clear all documents from the index.
+
+        Returns:
+            bool: True if successful, False otherwise
+        """
+        try:
+            # Delete all documents by query
+            response = self._make_request(
+                "POST", f"{self.index_url}/_delete_by_query", json_data={"query": {"match_all": {}}}
+            )
+            if response.status_code == 200:
+                # Refresh the index to ensure changes are visible
+                refresh_response = self._make_request("POST", f"{self.index_url}/_refresh")
+                return refresh_response.status_code == 200
+            return False
+        except Exception:
+            return False
+
     def get_mapping(self) -> Optional[Dict[str, Any]]:
         """Get the index mapping.
 

{eval_protocol-0.2.43 → eval_protocol-0.2.44}/eval_protocol/log_utils/elasticsearch_direct_http_handler.py

@@ -2,7 +2,7 @@ import logging
 import os
 from concurrent.futures import ThreadPoolExecutor
 from typing import Optional, Any, Dict
-from datetime import datetime
+from datetime import datetime, timezone
 
 from eval_protocol.types.remote_rollout_processor import ElasticsearchConfig
 from .elasticsearch_client import ElasticsearchClient
@@ -36,8 +36,8 @@ class ElasticsearchDirectHttpHandler(logging.Handler):
     def emit(self, record: logging.LogRecord) -> None:
         """Emit a log record by scheduling it for async transmission."""
         try:
-            # Create proper ISO 8601 timestamp
-            timestamp = datetime.fromtimestamp(record.created).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
+            # Create proper ISO 8601 timestamp in UTC
+            timestamp = datetime.fromtimestamp(record.created, tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
 
             rollout_id = self._get_rollout_id(record)
             logger.debug(f"Emitting log record: {record.getMessage()} with rollout_id: {rollout_id}")

{eval_protocol-0.2.43 → eval_protocol-0.2.44}/eval_protocol/utils/logs_server.py

@@ -30,6 +30,19 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+def enable_debug_mode():
+    """Enable debug mode for all relevant loggers in the logs server system."""
+    # Set debug level for all relevant loggers
+    logger.setLevel(logging.DEBUG)
+
+    # Set debug level for event bus logger
+    from eval_protocol.event_bus.logger import logger as event_bus_logger
+
+    event_bus_logger.setLevel(logging.DEBUG)
+
+    print("Debug mode enabled for all relevant loggers")
+
+
 class WebSocketManager:
     """Manages WebSocket connections and broadcasts messages."""
 
@@ -40,100 +53,152 @@ class WebSocketManager:
         self._lock = threading.Lock()
 
     async def connect(self, websocket: WebSocket):
+        logger.debug("[WEBSOCKET_CONNECT] New websocket connection attempt")
         await websocket.accept()
         with self._lock:
             self.active_connections.append(websocket)
             connection_count = len(self.active_connections)
-        logger.info(f"WebSocket connected. Total connections: {connection_count}")
+        logger.info(f"[WEBSOCKET_CONNECT] WebSocket connected. Total connections: {connection_count}")
+
+        logger.debug("[WEBSOCKET_CONNECT] Reading logs for initialization")
         logs = default_logger.read()
+        logger.debug(f"[WEBSOCKET_CONNECT] Found {len(logs)} logs to send")
+
         data = {
             "type": "initialize_logs",
             "logs": [log.model_dump(exclude_none=True, mode="json") for log in logs],
         }
+        logger.debug("[WEBSOCKET_CONNECT] Sending initialization data")
         await websocket.send_text(json.dumps(data))
+        logger.debug("[WEBSOCKET_CONNECT] Successfully sent initialization data")
 
     def disconnect(self, websocket: WebSocket):
+        logger.debug("[WEBSOCKET_DISCONNECT] WebSocket disconnection")
         with self._lock:
             if websocket in self.active_connections:
                 self.active_connections.remove(websocket)
+                logger.debug("[WEBSOCKET_DISCONNECT] Removed websocket from active connections")
+            else:
+                logger.debug("[WEBSOCKET_DISCONNECT] Websocket was not in active connections")
             connection_count = len(self.active_connections)
-        logger.info(f"WebSocket disconnected. Total connections: {connection_count}")
+        logger.info(f"[WEBSOCKET_DISCONNECT] WebSocket disconnected. Total connections: {connection_count}")
 
     def broadcast_row_upserted(self, row: "EvaluationRow"):
         """Broadcast a row-upsert event to all connected clients.
 
         Safe no-op if server loop is not running or there are no connections.
         """
+        rollout_id = row.execution_metadata.rollout_id if row.execution_metadata else "unknown"
+        logger.debug(f"[WEBSOCKET_BROADCAST] Starting broadcast for rollout_id: {rollout_id}")
+
+        with self._lock:
+            active_connections_count = len(self.active_connections)
+        logger.debug(f"[WEBSOCKET_BROADCAST] Active connections: {active_connections_count}")
+
         try:
             # Serialize pydantic model
+            logger.debug(f"[WEBSOCKET_BROADCAST] Serializing row for rollout_id: {rollout_id}")
             json_message = json.dumps({"type": "log", "row": row.model_dump(exclude_none=True, mode="json")})
+            logger.debug(
+                f"[WEBSOCKET_BROADCAST] Successfully serialized message (length: {len(json_message)}) for rollout_id: {rollout_id}"
+            )
+
             # Queue the message for broadcasting in the main event loop
+            logger.debug(f"[WEBSOCKET_BROADCAST] Queuing message for broadcast for rollout_id: {rollout_id}")
             self._broadcast_queue.put(json_message)
+            logger.debug(f"[WEBSOCKET_BROADCAST] Successfully queued message for rollout_id: {rollout_id}")
         except Exception as e:
-            logger.error(f"Failed to serialize row for broadcast: {e}")
+            logger.error(
+                f"[WEBSOCKET_BROADCAST] Failed to serialize row for broadcast for rollout_id {rollout_id}: {e}"
+            )
 
     async def _start_broadcast_loop(self):
         """Start the broadcast loop that processes queued messages."""
+        logger.debug("[WEBSOCKET_BROADCAST_LOOP] Starting broadcast loop")
         while True:
             try:
                 # Wait for a message to be queued
+                logger.debug("[WEBSOCKET_BROADCAST_LOOP] Waiting for message from queue")
                 message_data = await asyncio.get_event_loop().run_in_executor(None, self._broadcast_queue.get)
+                logger.debug(
+                    f"[WEBSOCKET_BROADCAST_LOOP] Retrieved message from queue (length: {len(str(message_data))})"
+                )
 
                 # Regular string message for all connections
+                logger.debug("[WEBSOCKET_BROADCAST_LOOP] Sending message to all connections")
                 await self._send_text_to_all_connections(str(message_data))
+                logger.debug("[WEBSOCKET_BROADCAST_LOOP] Successfully sent message to all connections")
 
             except Exception as e:
-                logger.error(f"Error in broadcast loop: {e}")
+                logger.error(f"[WEBSOCKET_BROADCAST_LOOP] Error in broadcast loop: {e}")
                 await asyncio.sleep(0.1)
             except asyncio.CancelledError:
-                logger.info("Broadcast loop cancelled")
+                logger.info("[WEBSOCKET_BROADCAST_LOOP] Broadcast loop cancelled")
                 break
 
     async def _send_text_to_all_connections(self, text: str):
         with self._lock:
             connections = list(self.active_connections)
 
+        logger.debug(f"[WEBSOCKET_SEND] Attempting to send to {len(connections)} connections")
+
         if not connections:
+            logger.debug("[WEBSOCKET_SEND] No connections available, skipping send")
             return
 
         tasks = []
         failed_connections = []
 
-        for connection in connections:
+        for i, connection in enumerate(connections):
             try:
+                logger.debug(f"[WEBSOCKET_SEND] Preparing to send to connection {i}")
                 tasks.append(connection.send_text(text))
             except Exception as e:
-                logger.error(f"Failed to send text to WebSocket: {e}")
+                logger.error(f"[WEBSOCKET_SEND] Failed to prepare send to WebSocket {i}: {e}")
                 failed_connections.append(connection)
 
         # Execute all sends in parallel
         if tasks:
+            logger.debug(f"[WEBSOCKET_SEND] Executing {len(tasks)} parallel sends")
             results = await asyncio.gather(*tasks, return_exceptions=True)
+            logger.debug("[WEBSOCKET_SEND] Completed parallel sends")
 
             # Check for any exceptions that occurred during execution
             for i, result in enumerate(results):
                 if isinstance(result, Exception):
-                    logger.error(f"Failed to send text to WebSocket: {result}")
+                    logger.error(f"[WEBSOCKET_SEND] Failed to send text to WebSocket {i}: {result}")
                     failed_connections.append(connections[i])
+                else:
+                    logger.debug(f"[WEBSOCKET_SEND] Successfully sent to connection {i}")
 
         # Remove all failed connections
-        with self._lock:
-            for connection in failed_connections:
-                try:
-                    self.active_connections.remove(connection)
-                except ValueError:
-                    pass
+        if failed_connections:
+            logger.debug(f"[WEBSOCKET_SEND] Removing {len(failed_connections)} failed connections")
+            with self._lock:
+                for connection in failed_connections:
+                    try:
+                        self.active_connections.remove(connection)
+                    except ValueError:
+                        pass
 
     def start_broadcast_loop(self):
         """Start the broadcast loop in the current event loop."""
         if self._broadcast_task is None or self._broadcast_task.done():
+            logger.debug("[WEBSOCKET_BROADCAST_LOOP] Creating new broadcast task")
             self._broadcast_task = asyncio.create_task(self._start_broadcast_loop())
+            logger.debug("[WEBSOCKET_BROADCAST_LOOP] Broadcast task created")
+        else:
+            logger.debug("[WEBSOCKET_BROADCAST_LOOP] Broadcast task already running")
 
     def stop_broadcast_loop(self):
         """Stop the broadcast loop."""
         if self._broadcast_task and not self._broadcast_task.done():
+            logger.debug("[WEBSOCKET_BROADCAST_LOOP] Cancelling broadcast task")
             self._broadcast_task.cancel()
             self._broadcast_task = None
+            logger.debug("[WEBSOCKET_BROADCAST_LOOP] Broadcast task cancelled")
+        else:
+            logger.debug("[WEBSOCKET_BROADCAST_LOOP] No active broadcast task to stop")
 
 
 class EvaluationWatcher:
@@ -260,7 +325,12 @@ class LogsServer(ViteServer):
         port: Optional[int] = 8000,
         index_file: str = "index.html",
         elasticsearch_config: Optional[ElasticsearchConfig] = None,
+        debug: bool = False,
     ):
+        # Enable debug mode if requested
+        if debug:
+            enable_debug_mode()
+
         # Initialize WebSocket manager
         self.websocket_manager = WebSocketManager()
 
@@ -304,9 +374,11 @@ class LogsServer(ViteServer):
             logger.info(f"  {methods} {path}")
 
         # Subscribe to events and start listening for cross-process events
+        logger.debug("[LOGS_SERVER_INIT] Subscribing to event bus")
         event_bus.subscribe(self._handle_event)
+        logger.debug("[LOGS_SERVER_INIT] Successfully subscribed to event bus")
 
-        logger.info(f"LogsServer initialized on {host}:{port}")
+        logger.info(f"[LOGS_SERVER_INIT] LogsServer initialized on {host}:{port}")
 
     def _setup_websocket_routes(self):
         """Set up WebSocket routes for real-time communication."""
@@ -418,17 +490,34 @@ class LogsServer(ViteServer):
 
     def _handle_event(self, event_type: str, data: Any) -> None:
         """Handle events from the event bus."""
+        logger.debug(f"[EVENT_BUS_RECEIVE] Received event type: {event_type}")
+
         if event_type in [LOG_EVENT_TYPE]:
             from eval_protocol.models import EvaluationRow
 
-            data = EvaluationRow(**data)
-            self.websocket_manager.broadcast_row_upserted(data)
+            try:
+                logger.debug("[EVENT_BUS_RECEIVE] Processing LOG_EVENT_TYPE event")
+                data = EvaluationRow(**data)
+                rollout_id = data.execution_metadata.rollout_id if data.execution_metadata else "unknown"
+                logger.debug(f"[EVENT_BUS_RECEIVE] Successfully parsed EvaluationRow for rollout_id: {rollout_id}")
+
+                logger.debug("[EVENT_BUS_RECEIVE] Broadcasting row_upserted to websocket manager")
+                self.websocket_manager.broadcast_row_upserted(data)
+                logger.debug(f"[EVENT_BUS_RECEIVE] Successfully queued broadcast for rollout_id: {rollout_id}")
+            except Exception as e:
+                logger.error(f"[EVENT_BUS_RECEIVE] Failed to process LOG_EVENT_TYPE event: {e}")
+        else:
+            logger.debug(f"[EVENT_BUS_RECEIVE] Ignoring event type: {event_type} (not LOG_EVENT_TYPE)")
 
     def start_loops(self):
         """Start the broadcast loop and evaluation watcher."""
+        logger.debug("[LOGS_SERVER_LOOPS] Starting all loops")
         self.websocket_manager.start_broadcast_loop()
+        logger.debug("[LOGS_SERVER_LOOPS] Started websocket broadcast loop")
         self.evaluation_watcher.start()
+        logger.debug("[LOGS_SERVER_LOOPS] Started evaluation watcher")
         event_bus.start_listening()
+        logger.debug("[LOGS_SERVER_LOOPS] Started event bus listening")
 
     async def run_async(self):
         """
@@ -477,6 +566,7 @@ def create_app(
     port: int = 8000,
     build_dir: Optional[str] = None,
     elasticsearch_config: Optional[ElasticsearchConfig] = None,
+    debug: bool = False,
 ) -> FastAPI:
     """
     Factory function to create a FastAPI app instance and start the server with async loops.
@@ -498,17 +588,21 @@ def create_app(
             os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "vite-app", "dist")
         )
 
-    server = LogsServer(host=host, port=port, build_dir=build_dir, elasticsearch_config=elasticsearch_config)
+    server = LogsServer(
+        host=host, port=port, build_dir=build_dir, elasticsearch_config=elasticsearch_config, debug=debug
+    )
     server.start_loops()
     return server.app
 
 
 # For backward compatibility and direct usage
-def serve_logs(port: Optional[int] = None, elasticsearch_config: Optional[ElasticsearchConfig] = None):
+def serve_logs(
+    port: Optional[int] = None, elasticsearch_config: Optional[ElasticsearchConfig] = None, debug: bool = False
+):
     """
     Convenience function to create and run a LogsServer.
     """
-    server = LogsServer(port=port, elasticsearch_config=elasticsearch_config)
+    server = LogsServer(port=port, elasticsearch_config=elasticsearch_config, debug=debug)
     server.run()
 
 
@@ -519,17 +613,27 @@ if __name__ == "__main__":
     parser.add_argument("--host", default="localhost", help="Host to bind to (default: localhost)")
     parser.add_argument("--port", type=int, default=8000, help="Port to bind to (default: 8000)")
     parser.add_argument("--build-dir", help="Path to Vite build directory")
+    parser.add_argument("--debug", help="Set logger level to DEBUG")
 
     args = parser.parse_args()
 
+    if args.debug:
+        enable_debug_mode()
+
     elasticsearch_config = ElasticsearchSetup().setup_elasticsearch()
 
     # Create server with command line arguments
     if args.build_dir:
         server = LogsServer(
-            host=args.host, port=args.port, build_dir=args.build_dir, elasticsearch_config=elasticsearch_config
+            host=args.host,
+            port=args.port,
+            build_dir=args.build_dir,
+            elasticsearch_config=elasticsearch_config,
+            debug=bool(args.debug),
         )
     else:
-        server = LogsServer(host=args.host, port=args.port, elasticsearch_config=elasticsearch_config)
+        server = LogsServer(
+            host=args.host, port=args.port, elasticsearch_config=elasticsearch_config, debug=bool(args.debug)
+        )
 
     server.run()

{eval_protocol-0.2.43 → eval_protocol-0.2.44/eval_protocol.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eval-protocol
-Version: 0.2.43
+Version: 0.2.44
 Summary: The official Python SDK for Eval Protocol (EP.) EP is an open protocol that standardizes how developers author evals for large language model (LLM) applications.
 Author-email: Fireworks AI <info@fireworks.ai>
 License-Expression: MIT

{eval_protocol-0.2.43 → eval_protocol-0.2.44}/eval_protocol.egg-info/SOURCES.txt

@@ -265,6 +265,7 @@ tests/test_evaluation_integration.py
 tests/test_evaluation_postprocess.py
 tests/test_evaluation_preview_integration.py
 tests/test_event_bus.py
+tests/test_event_bus_helper.py
 tests/test_examples_end_to_end.py
 tests/test_fireworks_api.py
 tests/test_format.py