unrealon 1.0.9__py3-none-any.whl → 1.1.1__py3-none-any.whl

unrealon_driver/src/services/logger_service.py

@@ -1,232 +0,0 @@
-"""
-Logger Service for UnrealOn Driver v3.0
-
-Intelligent logging service with file rotation and structured output.
-"""
-
-import logging
-import sys
-from pathlib import Path
-from typing import Any, Optional
-from datetime import datetime
-
-from unrealon_driver.src.dto.services import LoggerConfig
-from logging.handlers import RotatingFileHandler
-
-
-class LoggerService:
-    """
-    📝 Logger Service - Intelligent Logging
-
-    Zero-configuration logging with:
-    - Console and file output
-    - Automatic log rotation
-    - Structured logging for production
-    - Integration with unrealon_sdk development logger
-    """
-
-    def __init__(
-        self,
-        config: LoggerConfig,
-        parser_id: str = "unknown",
-        parser_name: str = "UnrealOn Parser",
-    ):
-        """Initialize logger service."""
-        self.config = config
-        self.parser_id = parser_id
-        self.parser_name = parser_name
-
-        # Setup logger
-        self.logger = logging.getLogger(f"unrealon_driver.{parser_id}")
-        self._setup_logging()
-
-    def _setup_logging(self):
-        """Setup logging configuration."""
-        # Clear any existing handlers
-        self.logger.handlers.clear()
-
-        # Set log level using Pydantic config
-        log_level = getattr(logging, self.config.log_level.value.upper())
-        self.logger.setLevel(log_level)
-
-        # Console handler
-        if self.config.console_output:
-            console_handler = logging.StreamHandler(sys.stdout)
-            console_handler.setLevel(log_level)  # Use same level as main logger
-
-            # Console formatter (using standard format from config)
-            console_formatter = logging.Formatter(
-                fmt=self.config.log_format, datefmt=self.config.date_format
-            )
-
-            console_handler.setFormatter(console_formatter)
-            self.logger.addHandler(console_handler)
-
-        # File handler
-        if self.config.file_output:
-            log_dir = (
-                Path(self.config.log_dir)
-                if self.config.log_dir
-                else Path("system/logs")
-            )
-            log_dir.mkdir(parents=True, exist_ok=True)
-
-            log_file_name = self.config.log_file or f"{self.parser_id}.log"
-            log_file = log_dir / log_file_name
-
-            file_handler = RotatingFileHandler(
-                log_file,
-                maxBytes=self._parse_size(self.config.max_file_size),
-                backupCount=self.config.backup_count,
-            )
-
-            file_level = getattr(logging, self.config.log_level.value.upper())
-            file_handler.setLevel(file_level)
-
-            # File formatter (always use standard format)
-            file_formatter = logging.Formatter(
-                fmt=self.config.log_format, datefmt=self.config.date_format
-            )
-
-            file_handler.setFormatter(file_formatter)
-            self.logger.addHandler(file_handler)
-
-        # Initial log message
-        self.logger.info(
-            f"Logger initialized for {self.parser_name} ({self.parser_id})"
-        )
-
-    def _get_standard_formatter(self) -> logging.Formatter:
-        """Get standard text formatter."""
-        format_str = (
-            self.config.format_string or "[{asctime}] {levelname} | {name} | {message}"
-        )
-        date_format = self.config.date_format or "%Y-%m-%d %H:%M:%S"
-
-        return logging.Formatter(format_str, datefmt=date_format, style="{")
-
-    def _get_colored_formatter(self) -> logging.Formatter:
-        """Get colored formatter for console output."""
-        # Color codes
-        colors = {
-            "DEBUG": "\033[36m",  # Cyan
-            "INFO": "\033[32m",  # Green
-            "WARNING": "\033[33m",  # Yellow
-            "ERROR": "\033[31m",  # Red
-            "CRITICAL": "\033[35m",  # Magenta
-            "RESET": "\033[0m",  # Reset
-        }
-
-        class ColoredFormatter(logging.Formatter):
-            def format(self, record):
-                if record.levelname in colors:
-                    record.levelname = (
-                        f"{colors[record.levelname]}{record.levelname}{colors['RESET']}"
-                    )
-                return super().format(record)
-
-        format_str = "[{asctime}] {levelname} | {name} | {message}"
-        return ColoredFormatter(format_str, datefmt="%H:%M:%S", style="{")
-
-    def _get_json_formatter(self) -> logging.Formatter:
-        """Get JSON formatter for structured logging."""
-        import json
-
-        class JSONFormatter(logging.Formatter):
-            def format(self, record):
-                log_entry = {
-                    "timestamp": datetime.utcnow().isoformat(),
-                    "level": record.levelname,
-                    "logger": record.name,
-                    "message": record.getMessage(),
-                    "parser_id": self.parser_id,
-                    "parser_name": self.parser_name,
-                }
-
-                if record.exc_info:
-                    log_entry["exception"] = self.formatException(record.exc_info)
-
-                return json.dumps(log_entry)
-
-        return JSONFormatter()
-
-    def _parse_size(self, size_str: str) -> int:
-        """Parse size string like '10MB' to bytes."""
-        size_str = size_str.upper().strip()
-
-        if size_str.endswith("KB"):
-            return int(size_str[:-2]) * 1024
-        elif size_str.endswith("MB"):
-            return int(size_str[:-2]) * 1024 * 1024
-        elif size_str.endswith("GB"):
-            return int(size_str[:-2]) * 1024 * 1024 * 1024
-        else:
-            return int(size_str)  # Assume bytes
-
-    # ==========================================
-    # LOGGING METHODS
-    # ==========================================
-
-    def debug(self, message: str, **kwargs):
-        """Log debug message."""
-        self.logger.debug(message, **kwargs)
-
-    def info(self, message: str, **kwargs):
-        """Log info message."""
-        self.logger.info(message, **kwargs)
-
-    def warning(self, message: str, **kwargs):
-        """Log warning message."""
-        self.logger.warning(message, **kwargs)
-
-    def error(self, message: str, **kwargs):
-        """Log error message."""
-        self.logger.error(message, **kwargs)
-
-    def critical(self, message: str, **kwargs):
-        """Log critical message."""
-        self.logger.critical(message, **kwargs)
-
-    def exception(self, message: str, **kwargs):
-        """Log exception with traceback."""
-        self.logger.exception(message, **kwargs)
-
-    # ==========================================
-    # SERVICE MANAGEMENT
-    # ==========================================
-
-    def _parse_size(self, size_str: str) -> int:
-        """Parse size string like '10MB' to bytes."""
-        size_str = size_str.upper().strip()
-
-        if size_str.endswith("KB"):
-            return int(size_str[:-2]) * 1024
-        elif size_str.endswith("MB"):
-            return int(size_str[:-2]) * 1024 * 1024
-        elif size_str.endswith("GB"):
-            return int(size_str[:-2]) * 1024 * 1024 * 1024
-        else:
-            # Assume bytes if no unit
-            return int(size_str)
-
-    def health_check(self) -> dict:
-        """Check logger service health."""
-        return {
-            "status": "healthy",
-            "log_level": self.logger.level,
-            "handlers_count": len(self.logger.handlers),
-            "console_output": self.config.console_output,
-            "file_output": self.config.file_output,
-        }
-
-    async def cleanup(self):
-        """Clean up logger resources."""
-        # Close all handlers
-        for handler in self.logger.handlers[:]:
-            handler.close()
-            self.logger.removeHandler(handler)
-
-        self.logger.info("Logger service cleanup completed")
-
-    def __repr__(self) -> str:
-        return f"<LoggerService(parser_id={self.parser_id}, level={self.logger.level})>"

unrealon_driver/src/services/metrics_service.py

@@ -1,185 +0,0 @@
-"""
-Metrics Service for UnrealOn Driver v3.0
-
-Built-in metrics and monitoring with Prometheus integration.
-Includes full event logging through SDK DevelopmentLogger.
-
-CRITICAL REQUIREMENTS COMPLIANCE:
-- ✅ Absolute imports only 
-- ✅ Pydantic v2 models everywhere
-- ✅ Complete type annotations
-- ✅ Full unrealon_sdk integration
-"""
-
-from typing import Any, Dict, Optional
-
-from unrealon_sdk.src.enterprise.logging.development import get_development_logger
-from unrealon_sdk.src.dto.logging import SDKContext, SDKEventType
-
-from unrealon_driver.src.dto.services import MetricsConfig
-from unrealon_driver.src.dto.events import DriverEventType
-
-
-class MetricsService:
-    """
-    📊 Metrics Service - Built-in Monitoring
-
-    TODO: Full implementation with Prometheus integration
-    """
-
-    def __init__(self, config: MetricsConfig, parser_id: str = "unknown"):
-        """Initialize metrics service with full SDK integration."""
-        self.config = config
-        self.parser_id = parser_id
-        self._metrics_data = {}
-
-        # ✅ DEVELOPMENT LOGGER INTEGRATION (CRITICAL REQUIREMENT)
-        self.dev_logger = get_development_logger()
-
-        # Log initialization with development logger
-        if self.dev_logger:
-            self.dev_logger.log_info(
-                SDKEventType.COMPONENT_CREATED,
-                "Metrics service initialized",
-                context=SDKContext(
-                    parser_id=self.parser_id,
-                    component_name="Metrics",
-                    layer_name="UnrealOn_Driver",
-                    metadata={
-                        "enabled": True,
-                        "config": "auto-configured",
-                    },
-                ),
-            )
-
-    def record_operation(
-        self,
-        service: str,
-        operation: str,
-        duration: float,
-        result_count: int,
-        error: Optional[str] = None,
-    ):
-        """Record operation metrics with structured logging."""
-        # Collect metrics data
-        key = f"{service}_{operation}"
-        if key not in self._metrics_data:
-            self._metrics_data[key] = {
-                "count": 0,
-                "total_duration": 0.0,
-                "errors": 0,
-                "total_results": 0,
-            }
-
-        self._metrics_data[key]["count"] += 1
-        self._metrics_data[key]["total_duration"] += duration or 0.0
-        self._metrics_data[key]["total_results"] += result_count
-
-        if error:
-            self._metrics_data[key]["errors"] += 1
-            
-            # Log error with SDK
-            if self.dev_logger:
-                self.dev_logger.log_error(
-                    SDKEventType.ERROR_DETECTED,
-                    f"Operation failed: {service}.{operation}",
-                    context=SDKContext(
-                        parser_id=self.parser_id,
-                        component_name="Metrics",
-                        layer_name="UnrealOn_Driver",
-                        metadata={
-                            "service": service,
-                            "operation": operation,
-                            "error": error,
-                            "duration_ms": duration * 1000,
-                        },
-                    ),
-                )
-        else:
-            # Log successful metrics collection
-            if self.dev_logger and self._metrics_data[key]["count"] % 10 == 0:  # Log every 10th operation
-                self.dev_logger.log_info(
-                    SDKEventType.PERFORMANCE_METRIC_COLLECTED,
-                    f"Metrics collected for {service}.{operation}",
-                    context=SDKContext(
-                        parser_id=self.parser_id,
-                        component_name="Metrics",
-                        layer_name="UnrealOn_Driver",
-                        metadata={
-                            "service": service,
-                            "operation": operation,
-                            "total_count": self._metrics_data[key]["count"],
-                            "avg_duration_ms": (self._metrics_data[key]["total_duration"] / self._metrics_data[key]["count"]) * 1000,
-                            "total_results": self._metrics_data[key]["total_results"],
-                        },
-                    ),
-                )
-
-    def record_test_execution(
-        self,
-        parser_id: str,
-        duration: float,
-        success: bool,
-        result_size: Optional[int] = None,
-        error: Optional[str] = None,
-    ):
-        """Record test execution metrics."""
-        key = "test_execution"
-        if key not in self._metrics_data:
-            self._metrics_data[key] = {
-                "total": 0,
-                "successful": 0,
-                "failed": 0,
-                "total_duration": 0.0,
-            }
-
-        self._metrics_data[key]["total"] += 1
-        self._metrics_data[key]["total_duration"] += duration
-
-        if success:
-            self._metrics_data[key]["successful"] += 1
-        else:
-            self._metrics_data[key]["failed"] += 1
-
-    def start_timer(self, name: str) -> float:
-        """Start a timer and return start time."""
-        import time
-
-        return time.time()
-
-    def end_timer(self, name: str, start_time: float):
-        """End a timer and record duration."""
-        import time
-
-        duration = time.time() - start_time
-        self.record_operation("timer", name, duration, 1)
-
-    def record_success(self, result_count: int = 1):
-        """Record successful operation."""
-        self.record_operation("general", "success", 0.0, result_count)
-
-    def record_error(self, error_message: str):
-        """Record error."""
-        self.record_operation("general", "error", 0.0, 0, error_message)
-
-    def health_check(self) -> dict:
-        """Check metrics service health."""
-        return {
-            "status": "healthy" if self.config.enable_metrics else "disabled",
-            "collected_metrics": len(self._metrics_data),
-            "prometheus_enabled": getattr(self.config, 'prometheus_enabled', False),
-        }
-
-    def get_metrics_data(self) -> dict:
-        """Get collected metrics data."""
-        return self._metrics_data.copy()
-
-    async def cleanup(self):
-        """Clean up metrics resources."""
-        # TODO: Implement cleanup (e.g., flush metrics to storage)
-        pass
-
-    def __repr__(self) -> str:
-        return (
-            f"<MetricsService(parser_id={self.parser_id}, metrics_count={len(self._metrics_data)})>"
-        )