@aj-archipelago/cortex 1.4.2 → 1.4.3

package/helper-apps/cortex-autogen2/tests/collectors/log_collector.py

@@ -0,0 +1,252 @@
+"""
+Docker log collector for test orchestration.
+
+Streams Docker container logs and parses them into structured format.
+"""
+
+import asyncio
+import re
+import logging
+from datetime import datetime
+from typing import List, Dict, Optional
+from collections import Counter
+
+logger = logging.getLogger(__name__)
+
+
+class LogCollector:
+    """Streams and parses Docker container logs."""
+
+    def __init__(self, container_name: str = "cortex-autogen-function"):
+        """
+        Initialize the log collector.
+
+        Args:
+            container_name: Name of the Docker container to collect logs from
+        """
+        self.container_name = container_name
+        self.logs: List[Dict] = []
+        self.is_collecting = False
+        self.process: Optional[asyncio.subprocess.Process] = None
+
+    async def start_collecting(
+        self,
+        request_id: Optional[str] = None,
+        timeout: int = 300,
+        filter_levels: Optional[List[str]] = None
+    ) -> List[Dict]:
+        """
+        Start collecting Docker logs.
+
+        Args:
+            request_id: Optional request ID to filter logs for
+            timeout: Maximum time to collect in seconds
+            filter_levels: Optional list of log levels to collect (e.g., ['ERROR', 'WARNING'])
+
+        Returns:
+            List of parsed log entries
+        """
+        self.logs = []
+        self.is_collecting = True
+
+        try:
+            # Start docker logs process
+            self.process = await asyncio.create_subprocess_exec(
+                'docker', 'logs', '-f', '--tail=0', self.container_name,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE
+            )
+
+            logger.info(f"📝 Log collector started for container: {self.container_name}")
+            if request_id:
+                logger.info(f"   Filtering for request ID: {request_id}")
+            if filter_levels:
+                logger.info(f"   Filtering levels: {', '.join(filter_levels)}")
+
+            # Read logs from both stdout and stderr
+            async def read_stream(stream, stream_name):
+                while self.is_collecting:
+                    line = await stream.readline()
+                    if not line:
+                        break
+
+                    try:
+                        line_str = line.decode('utf-8').strip()
+                        if not line_str:
+                            continue
+
+                        # Parse the log line
+                        log_entry = self._parse_log_line(line_str)
+
+                        if log_entry:
+                            # Apply filters
+                            if request_id and request_id not in line_str:
+                                continue
+
+                            if filter_levels and log_entry.get('level') not in filter_levels:
+                                continue
+
+                            self.logs.append(log_entry)
+
+                    except Exception as e:
+                        logger.debug(f"Error parsing log line: {e}")
+                        continue
+
+            # Collect logs with timeout
+            try:
+                await asyncio.wait_for(
+                    asyncio.gather(
+                        read_stream(self.process.stdout, 'stdout'),
+                        read_stream(self.process.stderr, 'stderr')
+                    ),
+                    timeout=timeout
+                )
+            except asyncio.TimeoutError:
+                logger.info(f"⏱️  Log collection timeout after {timeout}s")
+
+        except Exception as e:
+            logger.error(f"❌ Log collection error: {e}", exc_info=True)
+        finally:
+            await self.stop_collecting()
+
+        logger.info(f"📊 Log collection completed: {len(self.logs)} log entries collected")
+        return self.logs
+
+    async def stop_collecting(self):
+        """Stop collecting logs and cleanup."""
+        self.is_collecting = False
+
+        if self.process:
+            try:
+                self.process.kill()
+                await self.process.wait()
+            except Exception as e:
+                logger.debug(f"Error stopping log collection process: {e}")
+            finally:
+                self.process = None
+
+        logger.info("🛑 Log collection stopped")
+
+    def _parse_log_line(self, line: str) -> Optional[Dict]:
+        """
+        Parse a log line into structured format.
+
+        Supports multiple log formats:
+        - Standard format: "2024-10-25 12:34:56 - INFO - [agent_name] Message"
+        - Python format: "2024-10-25 12:34:56,123 - module - INFO - Message"
+        - Simple format: "INFO: Message"
+
+        Args:
+            line: Log line string
+
+        Returns:
+            Parsed log entry dict or None if parsing fails
+        """
+        # Try standard format first: "YYYY-MM-DD HH:MM:SS - LEVEL - [agent] Message"
+        pattern1 = r'(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})[,\s-]+([A-Z]+)\s*-?\s*\[?([^\]]*)\]?\s*[-:]?\s*(.*)'
+        match = re.search(pattern1, line)
+
+        if match:
+            timestamp_str = match.group(1)
+            level = match.group(2).strip()
+            agent = match.group(3).strip() if match.group(3) else None
+            message = match.group(4).strip()
+
+            try:
+                timestamp = datetime.strptime(timestamp_str, '%Y-%m-%d %H:%M:%S')
+            except:
+                timestamp = datetime.now()
+
+            return {
+                'timestamp': timestamp.isoformat(),
+                'level': level,
+                'agent': agent if agent else None,
+                'message': message,
+                'raw': line
+            }
+
+        # Try simple level format: "LEVEL: Message" or "LEVEL - Message"
+        pattern2 = r'^([A-Z]+)[\s:-]+(.+)$'
+        match = re.search(pattern2, line)
+
+        if match:
+            return {
+                'timestamp': datetime.now().isoformat(),
+                'level': match.group(1).strip(),
+                'agent': None,
+                'message': match.group(2).strip(),
+                'raw': line
+            }
+
+        # If no pattern matches, store as unparsed
+        return {
+            'timestamp': datetime.now().isoformat(),
+            'level': 'UNKNOWN',
+            'agent': None,
+            'message': line,
+            'raw': line
+        }
+
+    def get_logs(
+        self,
+        level: Optional[str] = None,
+        agent: Optional[str] = None
+    ) -> List[Dict]:
+        """
+        Get collected logs with optional filtering.
+
+        Args:
+            level: Filter by log level
+            agent: Filter by agent name
+
+        Returns:
+            Filtered list of log entries
+        """
+        filtered = self.logs
+
+        if level:
+            filtered = [log for log in filtered if log.get('level') == level]
+
+        if agent:
+            filtered = [log for log in filtered if log.get('agent') == agent]
+
+        return filtered
+
+    def get_summary(self) -> Dict:
+        """
+        Get a summary of collected logs.
+
+        Returns:
+            Dictionary with log statistics
+        """
+        if not self.logs:
+            return {
+                'total_logs': 0,
+                'by_level': {},
+                'by_agent': {},
+                'errors': 0,
+                'warnings': 0
+            }
+
+        level_counts = Counter(log.get('level', 'UNKNOWN') for log in self.logs)
+        agent_counts = Counter(log.get('agent', 'unknown') for log in self.logs if log.get('agent'))
+
+        return {
+            'total_logs': len(self.logs),
+            'by_level': dict(level_counts),
+            'by_agent': dict(agent_counts),
+            'errors': level_counts.get('ERROR', 0),
+            'warnings': level_counts.get('WARNING', 0) + level_counts.get('WARN', 0),
+            'first_log': self.logs[0]['timestamp'] if self.logs else None,
+            'last_log': self.logs[-1]['timestamp'] if self.logs else None
+        }
+
+    def get_errors(self) -> List[Dict]:
+        """Get all ERROR level logs."""
+        return self.get_logs(level='ERROR')
+
+    def get_warnings(self) -> List[Dict]:
+        """Get all WARNING level logs."""
+        warnings = self.get_logs(level='WARNING')
+        warnings.extend(self.get_logs(level='WARN'))
+        return warnings

package/helper-apps/cortex-autogen2/tests/collectors/progress_collector.py

@@ -0,0 +1,182 @@
+"""
+Progress update collector for test orchestration.
+
+Subscribes to Redis pub/sub channel and collects progress updates
+during test execution.
+"""
+
+import redis
+import json
+import asyncio
+import logging
+from datetime import datetime
+from typing import List, Dict, Optional
+from collections import defaultdict
+
+logger = logging.getLogger(__name__)
+
+
+class ProgressCollector:
+    """Collects progress updates from Redis pub/sub channel."""
+
+    def __init__(self, redis_url: str, channel: str):
+        """
+        Initialize the progress collector.
+
+        Args:
+            redis_url: Redis connection string (e.g., "redis://localhost:6379")
+            channel: Redis channel name to subscribe to
+        """
+        self.redis_url = redis_url
+        self.channel = channel
+        self.updates: List[Dict] = []
+        self.is_collecting = False
+        self.final_result = None
+
+    async def start_collecting(
+        self,
+        request_id: str,
+        timeout: int = 300,
+        stop_on_final: bool = True
+    ) -> List[Dict]:
+        """
+        Start collecting progress updates for a specific request.
+
+        Args:
+            request_id: The request ID to filter updates for
+            timeout: Maximum time to collect in seconds
+            stop_on_final: Stop collecting when final update (progress=1.0 or data field) is received
+
+        Returns:
+            List of progress updates collected
+        """
+        self.updates = []
+        self.is_collecting = True
+        self.final_result = None
+
+        try:
+            # Create Redis client in executor to avoid blocking
+            redis_client = redis.from_url(self.redis_url)
+            pubsub = redis_client.pubsub()
+            pubsub.subscribe(self.channel)
+
+            logger.info(f"📡 Progress collector started for request {request_id}")
+            logger.info(f"   Subscribed to channel: {self.channel}")
+            logger.info(f"   Timeout: {timeout}s")
+
+            start_time = datetime.now()
+            message_count = 0
+
+            # Listen for messages with timeout
+            for message in pubsub.listen():
+                if not self.is_collecting:
+                    break
+
+                if message['type'] == 'message':
+                    try:
+                        data = json.loads(message['data'])
+
+                        # Only collect updates for our request
+                        if data.get('requestId') == request_id:
+                            message_count += 1
+
+                            update = {
+                                'timestamp': datetime.now().isoformat(),
+                                'progress': data.get('progress', 0.0),
+                                'info': data.get('info', ''),
+                                'data': data.get('data')
+                            }
+
+                            self.updates.append(update)
+
+                            # Log progress update
+                            progress_pct = int(update['progress'] * 100)
+                            logger.info(f"   Progress: {progress_pct}% - {update['info']}")
+
+                            # Check if this is the final update
+                            if stop_on_final:
+                                if update['data'] is not None:
+                                    self.final_result = update['data']
+                                    logger.info(f"✅ Final result received (with data field)")
+                                    break
+                                elif update['progress'] >= 1.0:
+                                    logger.info(f"✅ Final progress reached (100%)")
+                                    # Wait a bit more to catch any late final result
+                                    await asyncio.sleep(2)
+                                    break
+
+                    except json.JSONDecodeError as e:
+                        logger.warning(f"Failed to parse message: {e}")
+                        continue
+                    except Exception as e:
+                        logger.error(f"Error processing message: {e}")
+                        continue
+
+                # Check timeout
+                elapsed = (datetime.now() - start_time).total_seconds()
+                if elapsed > timeout:
+                    logger.warning(f"⏱️  Progress collection timeout after {timeout}s")
+                    break
+
+            # Cleanup
+            pubsub.unsubscribe()
+            pubsub.close()
+            redis_client.close()
+
+            logger.info(f"📊 Progress collection completed: {message_count} updates collected")
+
+        except redis.ConnectionError as e:
+            logger.error(f"❌ Redis connection error: {e}")
+        except Exception as e:
+            logger.error(f"❌ Progress collection error: {e}", exc_info=True)
+        finally:
+            self.is_collecting = False
+
+        return self.updates
+
+    def stop_collecting(self):
+        """Stop collecting progress updates."""
+        self.is_collecting = False
+        logger.info("🛑 Progress collection stopped manually")
+
+    def get_updates(self) -> List[Dict]:
+        """Get all collected updates."""
+        return self.updates
+
+    def get_final_result(self) -> Optional[Dict]:
+        """Get the final result data if received."""
+        return self.final_result
+
+    def get_summary(self) -> Dict:
+        """
+        Get a summary of collected progress updates.
+
+        Returns:
+            Dictionary with statistics about the updates
+        """
+        if not self.updates:
+            return {
+                'total_updates': 0,
+                'duration_seconds': 0,
+                'avg_interval_seconds': 0,
+                'final_progress': 0
+            }
+
+        timestamps = [datetime.fromisoformat(u['timestamp']) for u in self.updates]
+        intervals = []
+
+        for i in range(1, len(timestamps)):
+            interval = (timestamps[i] - timestamps[i-1]).total_seconds()
+            intervals.append(interval)
+
+        duration = (timestamps[-1] - timestamps[0]).total_seconds() if len(timestamps) > 1 else 0
+
+        return {
+            'total_updates': len(self.updates),
+            'duration_seconds': duration,
+            'avg_interval_seconds': sum(intervals) / len(intervals) if intervals else 0,
+            'min_interval_seconds': min(intervals) if intervals else 0,
+            'max_interval_seconds': max(intervals) if intervals else 0,
+            'final_progress': self.updates[-1]['progress'] if self.updates else 0,
+            'has_final_result': self.final_result is not None
+        }

package/helper-apps/cortex-autogen2/tests/conftest.py

@@ -0,0 +1,15 @@
+"""
+Pytest configuration file.
+
+This file can be used for pytest-based testing in the future.
+For now, use the CLI runner: python tests/cli/run_tests.py
+"""
+
+import pytest
+import logging
+
+# Configure logging for tests
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)

package/helper-apps/cortex-autogen2/tests/database/__init__.py

@@ -0,0 +1 @@
+"""Database layer for test results storage."""