components/feedback_logger.py

"""Enhanced logging and feedback system for the AI Ethics Engine."""
import logging
import json
from pathlib import Path
from datetime import datetime
from typing import Dict, Any, Optional

# Ensure logs directory exists
Path("logs").mkdir(exist_ok=True)

class FeedbackLogger:
    """Handles structured logging for the AI Ethics Engine."""
    
    def __init__(self, log_file: str = "logs/ethics_engine.log"):
        """Initialize the feedback logger."""
        self.logger = logging.getLogger("ethics_engine")
        self.logger.setLevel(logging.INFO)
        
        # Create file handler
        file_handler = logging.FileHandler(log_file)
        file_handler.setLevel(logging.INFO)
        
        # Create formatter
        formatter = logging.Formatter(
            '%(asctime)s | %(levelname)s | %(message)s',
            datefmt='%Y-%m-%d %H:%M:%S'
        )
        file_handler.setFormatter(formatter)
        
        # Add handler to logger
        self.logger.addHandler(file_handler)
        
        # Also log to console in development
        console_handler = logging.StreamHandler()
        console_handler.setLevel(logging.INFO)
        console_handler.setFormatter(formatter)
        self.logger.addHandler(console_handler)
    
    def log_event(self, event_type: str, payload: Dict[str, Any]) -> None:
        """Log a structured event.
        
        Args:
            event_type: Type of event (e.g., 'analysis', 'feedback', 'error')
            payload: Dictionary containing event data
        """
        log_entry = {
            "timestamp": datetime.utcnow().isoformat(),
            "event_type": event_type,
            **payload
        }
        self.logger.info(json.dumps(log_entry, default=str))
    
    def record_analysis(self, 
                       dilemma: str, 
                       result: Dict[str, Any], 
                       user_id: Optional[str] = None) -> None:
        """Record an analysis event."""
        self.log_event("analysis", {
            "user_id": user_id or "anonymous",
            "dilemma": dilemma,
            "result_summary": {
                "framework_used": list(result.get("framework_analyses", {}).keys()),
                "success": "error" not in result,
                "execution_time": result.get("execution_time")
            }
        })
    
    def record_feedback(self, 
                       dilemma: str, 
                       feedback: str, 
                       user_id: Optional[str] = None,
                       metadata: Optional[Dict[str, Any]] = None) -> None:
        """Record user feedback on an analysis."""
        self.log_event("feedback", {
            "user_id": user_id or "anonymous",
            "dilemma": dilemma,
            "feedback": feedback,
            "metadata": metadata or {}
        })
    
    def record_error(self, 
                    error: Exception, 
                    context: Optional[Dict[str, Any]] = None) -> None:
        """Record an error event."""
        self.log_event("error", {
            "error_type": error.__class__.__name__,
            "error_message": str(error),
            "context": context or {}
        })

# Global instance for easy import
logger = FeedbackLogger()