Add comprehensive logging system and analytics with log rotation

.gitignore

@@ -32,7 +32,9 @@ ENV/
 *.swo
 
 # Logs
+logs/
 *.log
+*.log.*
 
 # Local configuration
 .env

README.md

@@ -9,4 +9,108 @@ app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Mental Wellness Platform
+
+A comprehensive mental wellness support system powered by AI, deployed on Hugging Face Spaces.
+
+## Features
+- 🤖 Multi-agent AI support system
+- 💬 Natural therapeutic conversations
+- 📊 Mental health assessments
+- 🧘‍♀️ Guided meditation and mindfulness
+- 🚨 Crisis intervention support
+- 📱 Multi-modal interaction (text, voice, image)
+- 📈 Comprehensive logging and analytics
+- 🔄 Automatic log rotation and management
+
+## System Components
+- Therapeutic Conversation Agent
+- Assessment Agent
+- Mindfulness Agent
+- Crisis Intervention Agent
+- Analytics and Logging System
+
+## Logging System
+The platform includes a comprehensive logging system with:
+- Agent-specific logs
+- System health monitoring
+- Analytics tracking
+- Performance metrics
+- Security event logging
+- Automatic log rotation
+- Log cleanup for older files
+
+### Log Categories
+1. Agent Logs (`logs/agents/`)
+   - Individual agent activities
+   - Performance metrics
+   - Error tracking
+
+2. System Logs (`logs/system/`)
+   - System health
+   - Resource usage
+   - General operations
+
+3. Analytics Logs (`logs/analytics/`)
+   - User interactions
+   - Session metrics
+   - Model performance
+   - Usage statistics
+
+## Usage
+1. Open the chat interface
+2. Type your message or use voice/image input
+3. Choose from available tools:
+   - Mental Health Check
+   - Start Meditation
+   - View Resources
+
+## Important Note
+This is an AI-powered support tool and not a substitute for professional mental health care. In case of emergency:
+- Call emergency services: 911 (US)
+- National Crisis Hotline: 988
+- Crisis Text Line: Text HOME to 741741
+
+## Technical Details
+Built with:
+- Gradio for interface
+- Hugging Face Transformers for AI models
+- CrewAI for multi-agent orchestration
+- Advanced voice and image processing
+- Comprehensive logging system
+
+## Development
+To run locally:
+1. Clone the repository
+2. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+3. Run the application:
+   ```bash
+   python app.py
+   ```
+
+## Monitoring
+The system includes:
+- Real-time performance monitoring
+- Error tracking and alerts
+- Usage analytics
+- System health metrics
+
+## Security
+- All conversations are encrypted
+- Comprehensive security logging
+- Access control and monitoring
+- Data retention policies
+
+## License
+MIT License
+
+## Authors
+Created by Invincible Jha
+
+## Acknowledgments
+- CrewAI for the multi-agent framework
+- Hugging Face for AI models and hosting
+- Gradio for the interface framework

requirements.txt

@@ -15,4 +15,6 @@ pillow>=10.1.0
 redis>=5.0.1
 pytest>=7.4.3
 crewai>=0.11.0
-huggingface_hub>=0.26.5 
+huggingface_hub>=0.26.5
+psutil>=5.9.0
+python-json-logger>=2.0.7 

utils/analytics_logger.py

@@ -0,0 +1,170 @@
+from typing import Dict, Any, Optional
+import json
+import time
+from datetime import datetime
+from utils.log_manager import LogManager
+
+class AnalyticsLogger:
+    """Handles logging of analytics events and metrics"""
+    
+    def __init__(self):
+        self.log_manager = LogManager()
+        self.logger = self.log_manager.get_analytics_logger("events")
+        self.metrics_logger = self.log_manager.get_analytics_logger("metrics")
+        
+    def log_user_interaction(self, 
+                           user_id: str,
+                           interaction_type: str,
+                           agent_type: str,
+                           duration: float,
+                           success: bool,
+                           details: Optional[Dict] = None):
+        """Log user interaction events"""
+        event = {
+            "event_type": "user_interaction",
+            "user_id": user_id,
+            "interaction_type": interaction_type,
+            "agent_type": agent_type,
+            "duration": duration,
+            "success": success,
+            "timestamp": datetime.now().isoformat(),
+            "details": details or {}
+        }
+        
+        self.logger.info(f"User Interaction: {json.dumps(event, indent=2)}")
+        
+    def log_agent_performance(self,
+                            agent_type: str,
+                            operation: str,
+                            response_time: float,
+                            success: bool,
+                            error: Optional[str] = None):
+        """Log agent performance metrics"""
+        metric = {
+            "metric_type": "agent_performance",
+            "agent_type": agent_type,
+            "operation": operation,
+            "response_time": response_time,
+            "success": success,
+            "error": error,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        self.metrics_logger.info(f"Agent Performance: {json.dumps(metric, indent=2)}")
+        
+    def log_system_health(self,
+                         cpu_usage: float,
+                         memory_usage: float,
+                         active_users: int,
+                         active_sessions: int):
+        """Log system health metrics"""
+        metric = {
+            "metric_type": "system_health",
+            "cpu_usage": cpu_usage,
+            "memory_usage": memory_usage,
+            "active_users": active_users,
+            "active_sessions": active_sessions,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        self.metrics_logger.info(f"System Health: {json.dumps(metric, indent=2)}")
+        
+    def log_error(self,
+                  error_type: str,
+                  error_message: str,
+                  severity: str,
+                  context: Optional[Dict] = None):
+        """Log error events"""
+        event = {
+            "event_type": "error",
+            "error_type": error_type,
+            "error_message": error_message,
+            "severity": severity,
+            "context": context or {},
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        self.logger.error(f"Error Event: {json.dumps(event, indent=2)}")
+        
+    def log_security_event(self,
+                          event_type: str,
+                          user_id: str,
+                          success: bool,
+                          details: Optional[Dict] = None):
+        """Log security-related events"""
+        event = {
+            "event_type": "security",
+            "security_event_type": event_type,
+            "user_id": user_id,
+            "success": success,
+            "details": details or {},
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        self.logger.info(f"Security Event: {json.dumps(event, indent=2)}")
+        
+    def log_model_performance(self,
+                            model_name: str,
+                            operation: str,
+                            input_tokens: int,
+                            output_tokens: int,
+                            response_time: float,
+                            success: bool):
+        """Log AI model performance metrics"""
+        metric = {
+            "metric_type": "model_performance",
+            "model_name": model_name,
+            "operation": operation,
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens,
+            "response_time": response_time,
+            "success": success,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        self.metrics_logger.info(f"Model Performance: {json.dumps(metric, indent=2)}")
+        
+    def log_user_feedback(self,
+                         user_id: str,
+                         interaction_id: str,
+                         rating: int,
+                         feedback_text: Optional[str] = None):
+        """Log user feedback"""
+        event = {
+            "event_type": "user_feedback",
+            "user_id": user_id,
+            "interaction_id": interaction_id,
+            "rating": rating,
+            "feedback_text": feedback_text,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        self.logger.info(f"User Feedback: {json.dumps(event, indent=2)}")
+        
+    def log_session_metrics(self,
+                          session_id: str,
+                          user_id: str,
+                          session_type: str,
+                          start_time: str,
+                          end_time: str,
+                          metrics: Dict[str, Any]):
+        """Log session-specific metrics"""
+        session_data = {
+            "metric_type": "session_metrics",
+            "session_id": session_id,
+            "user_id": user_id,
+            "session_type": session_type,
+            "start_time": start_time,
+            "end_time": end_time,
+            "duration": self._calculate_duration(start_time, end_time),
+            "metrics": metrics,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        self.metrics_logger.info(f"Session Metrics: {json.dumps(session_data, indent=2)}")
+        
+    def _calculate_duration(self, start_time: str, end_time: str) -> float:
+        """Calculate duration between two ISO format timestamps"""
+        start = datetime.fromisoformat(start_time)
+        end = datetime.fromisoformat(end_time)
+        return (end - start).total_seconds() 

utils/log_manager.py

@@ -0,0 +1,169 @@
+import logging
+from logging.handlers import RotatingFileHandler
+import os
+from pathlib import Path
+from typing import Optional
+
+class LogManager:
+    """Manages logging configuration and rotation for all agents"""
+    
+    def __init__(self, log_dir: str = "logs", max_bytes: int = 5_000_000, backup_count: int = 5):
+        """Initialize log manager
+        
+        Args:
+            log_dir: Directory to store log files
+            max_bytes: Maximum size of each log file before rotation
+            backup_count: Number of backup files to keep
+        """
+        self.log_dir = Path(log_dir)
+        self.max_bytes = max_bytes
+        self.backup_count = backup_count
+        
+        # Create log directories
+        self._create_log_dirs()
+        
+        # Configure root logger
+        self._configure_root_logger()
+        
+    def _create_log_dirs(self):
+        """Create necessary log directories"""
+        dirs = [
+            self.log_dir,
+            self.log_dir / "agents",
+            self.log_dir / "system",
+            self.log_dir / "analytics"
+        ]
+        
+        for dir_path in dirs:
+            dir_path.mkdir(parents=True, exist_ok=True)
+            
+    def _configure_root_logger(self):
+        """Configure the root logger"""
+        root_logger = logging.getLogger()
+        root_logger.setLevel(logging.INFO)
+        
+        # System log handler
+        system_handler = RotatingFileHandler(
+            self.log_dir / "system" / "system.log",
+            maxBytes=self.max_bytes,
+            backupCount=self.backup_count
+        )
+        system_handler.setLevel(logging.INFO)
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        system_handler.setFormatter(formatter)
+        root_logger.addHandler(system_handler)
+        
+    def get_agent_logger(self, agent_name: str, log_level: int = logging.INFO) -> logging.Logger:
+        """Get a configured logger for an agent
+        
+        Args:
+            agent_name: Name of the agent (used in log file name)
+            log_level: Logging level for this logger
+            
+        Returns:
+            Configured logger instance
+        """
+        logger = logging.getLogger(f"agent.{agent_name}")
+        logger.setLevel(log_level)
+        
+        # Remove any existing handlers
+        logger.handlers = []
+        
+        # Add rotating file handler
+        handler = RotatingFileHandler(
+            self.log_dir / "agents" / f"{agent_name}.log",
+            maxBytes=self.max_bytes,
+            backupCount=self.backup_count
+        )
+        handler.setLevel(log_level)
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+        
+        return logger
+        
+    def get_analytics_logger(self, name: str, log_level: int = logging.INFO) -> logging.Logger:
+        """Get a configured logger for analytics
+        
+        Args:
+            name: Analytics category name
+            log_level: Logging level for this logger
+            
+        Returns:
+            Configured logger instance
+        """
+        logger = logging.getLogger(f"analytics.{name}")
+        logger.setLevel(log_level)
+        
+        # Remove any existing handlers
+        logger.handlers = []
+        
+        # Add rotating file handler
+        handler = RotatingFileHandler(
+            self.log_dir / "analytics" / f"{name}.log",
+            maxBytes=self.max_bytes,
+            backupCount=self.backup_count
+        )
+        handler.setLevel(log_level)
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+        
+        return logger
+        
+    def cleanup_old_logs(self, max_age_days: int = 30):
+        """Clean up log files older than specified days
+        
+        Args:
+            max_age_days: Maximum age of log files in days
+        """
+        import time
+        current_time = time.time()
+        max_age_seconds = max_age_days * 24 * 60 * 60
+        
+        for root, _, files in os.walk(self.log_dir):
+            for file in files:
+                file_path = os.path.join(root, file)
+                if os.path.getmtime(file_path) < (current_time - max_age_seconds):
+                    try:
+                        os.remove(file_path)
+                        logging.info(f"Removed old log file: {file_path}")
+                    except Exception as e:
+                        logging.error(f"Error removing old log file {file_path}: {str(e)}")
+                        
+    def get_log_stats(self) -> dict:
+        """Get statistics about log files
+        
+        Returns:
+            Dictionary containing log statistics
+        """
+        stats = {
+            "total_size": 0,
+            "file_count": 0,
+            "categories": {}
+        }
+        
+        for root, _, files in os.walk(self.log_dir):
+            category = os.path.basename(root)
+            if category not in stats["categories"]:
+                stats["categories"][category] = {
+                    "size": 0,
+                    "file_count": 0
+                }
+                
+            for file in files:
+                file_path = os.path.join(root, file)
+                size = os.path.getsize(file_path)
+                
+                stats["total_size"] += size
+                stats["file_count"] += 1
+                stats["categories"][category]["size"] += size
+                stats["categories"][category]["file_count"] += 1
+                
+        return stats