Implement comprehensive analytics system for UI/UX improvements

app.py

@@ -14,14 +14,14 @@ from core.session import session_manager
 from core.memory import check_redis_health
 from core.errors import translate_error
 from core.personality import personality
+from src.analytics.user_logger import user_logger
+from src.analytics.session_analytics import session_analytics
 import logging
 
 # Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-st.set_page_config(page_title="CosmicCat AI Assistant", page_icon="🐱", layout="wide")
-
 # Initialize session state
 if "messages" not in st.session_state:
     st.session_state.messages = []
@@ -33,6 +33,18 @@ if "cosmic_mode" not in st.session_state:
     st.session_state.cosmic_mode = True
 if "show_welcome" not in st.session_state:
     st.session_state.show_welcome = True
+if "session_id" not in st.session_state:
+    st.session_state.session_id = f"sess_{int(time.time())}_{os.urandom(4).hex()}"
+
+# Start session tracking
+session_analytics.start_session_tracking("default_user", st.session_state.session_id)
+
+st.set_page_config(page_title="CosmicCat AI Assistant", page_icon="🐱", layout="wide")
+
+# Log page view
+session_analytics.track_interaction("default_user", st.session_state.session_id, "page_view", {
+    "page": "main_chat"
+})
 
 # Sidebar
 with st.sidebar:
@@ -48,12 +60,23 @@ with st.sidebar:
     selected_model_name = st.selectbox(
         "Select Model",
         options=list(model_options.keys()),
-        index=0
+        index=0,
+        on_change=lambda: session_analytics.track_interaction("default_user", st.session_state.session_id, "model_selection", {
+            "selected_model": st.session_state.selected_model if 'selected_model' in st.session_state else model_options[list(model_options.keys())[0]]
+        })
     )
     st.session_state.selected_model = model_options[selected_model_name]
     
+    # Log model selection
+    session_analytics.track_interaction("default_user", st.session_state.session_id, "model_selection", {
+        "selected_model": st.session_state.selected_model
+    })
+    
     # Cosmic mode toggle
-    st.session_state.cosmic_mode = st.checkbox("Enable Cosmic Mode", value=st.session_state.cosmic_mode)
+    st.session_state.cosmic_mode = st.checkbox("Enable Cosmic Mode", value=st.session_state.cosmic_mode,
+                                              on_change=lambda: session_analytics.track_interaction("default_user", st.session_state.session_id, "cosmic_mode_toggle", {
+                                                  "enabled": st.session_state.cosmic_mode
+                                              }))
     
     st.divider()
     
@@ -62,30 +85,55 @@ with st.sidebar:
     ngrok_url_input = st.text_input(
         "Ollama Server URL",
         value=st.session_state.ngrok_url_temp,
-        help="Enter your ngrok URL"
+        help="Enter your ngrok URL",
+        on_change=lambda: session_analytics.track_interaction("default_user", st.session_state.session_id, "url_update", {
+            "url_changed": ngrok_url_input != st.session_state.ngrok_url_temp
+        })
     )
     
     if ngrok_url_input != st.session_state.ngrok_url_temp:
         st.session_state.ngrok_url_temp = ngrok_url_input
         st.success("✅ URL updated!")
+        session_analytics.track_interaction("default_user", st.session_state.session_id, "url_updated", {
+            "new_url": ngrok_url_input
+        })
     
     if st.button("📡 Test Connection"):
+        start_time = time.time()
+        session_analytics.track_interaction("default_user", st.session_state.session_id, "test_connection_click")
         try:
             from core.providers.ollama import OllamaProvider
             ollama_provider = OllamaProvider(st.session_state.selected_model)
             is_valid = ollama_provider.validate_model()
+            end_time = time.time()
+            
             if is_valid:
                 st.success("✅ Connection successful!")
+                session_analytics.track_interaction("default_user", st.session_state.session_id, "connection_success", {
+                    "response_time": end_time - start_time
+                })
+                user_logger.log_performance_metric("default_user", "connection_test", end_time - start_time)
             else:
                 st.error("❌ Model validation failed")
+                session_analytics.track_interaction("default_user", st.session_state.session_id, "connection_failed", {
+                    "error": "model_validation_failed"
+                })
         except Exception as e:
+            end_time = time.time()
             st.error(f"❌ Error: {str(e)[:50]}...")
+            session_analytics.track_interaction("default_user", st.session_state.session_id, "connection_error", {
+                "error": str(e)[:100],
+                "response_time": end_time - start_time
+            })
+            user_logger.log_error("default_user", "connection_test", str(e))
     
     if st.button("🗑️ Clear History"):
+        session_analytics.track_interaction("default_user", st.session_state.session_id, "clear_history_click")
         st.session_state.messages = []
         # Also clear backend session
         session_manager.clear_session("default_user")
         st.success("History cleared!")
+        session_analytics.track_interaction("default_user", st.session_state.session_id, "history_cleared")
     
     st.divider()
     
@@ -131,16 +179,32 @@ with st.sidebar:
             # Add wake-up button if scaled to zero or initializing
             if "scaled to zero" in status_message.lower() or "initializing" in status_message.lower():
                 if st.button("⚡ Wake Up HF Endpoint", key="wake_up_hf"):
+                    session_analytics.track_interaction("default_user", st.session_state.session_id, "wake_up_hf_click")
                     with st.spinner("Attempting to wake up HF endpoint... This may take 2-4 minutes during initialization..."):
+                        start_time = time.time()
                         if hf_monitor.attempt_wake_up():
+                            end_time = time.time()
                             st.success("✅ Wake-up request sent! The endpoint should be initializing now. Try your request again in a moment.")
+                            session_analytics.track_interaction("default_user", st.session_state.session_id, "hf_wake_up_success", {
+                                "response_time": end_time - start_time
+                            })
+                            user_logger.log_performance_metric("default_user", "hf_wake_up", end_time - start_time)
                             time.sleep(3)
                             st.experimental_rerun()
                         else:
+                            end_time = time.time()
                             st.error("❌ Failed to send wake-up request. Please try again or wait for initialization to complete.")
+                            session_analytics.track_interaction("default_user", st.session_state.session_id, "hf_wake_up_failed", {
+                                "response_time": end_time - start_time
+                            })
+                            user_logger.log_error("default_user", "hf_wake_up", "Failed to wake up HF endpoint")
                             
         except Exception as e:
             st.info(f"🤗 HF Endpoint: Error checking status - {str(e)}")
+            session_analytics.track_interaction("default_user", st.session_state.session_id, "hf_status_error", {
+                "error": str(e)
+            })
+            user_logger.log_error("default_user", "hf_status_check", str(e))
         
         # Redis Status
         try:
@@ -153,10 +217,25 @@ with st.sidebar:
     
     st.divider()
     
+    # Feedback Section
+    st.subheader("⭐ Feedback")
+    rating = st.radio("How would you rate your experience?", [1, 2, 3, 4, 5], horizontal=True)
+    feedback_comment = st.text_area("Additional comments (optional):")
+    if st.button("Submit Feedback"):
+        user_logger.log_feedback("default_user", rating, feedback_comment)
+        session_analytics.track_interaction("default_user", st.session_state.session_id, "feedback_submitted", {
+            "rating": rating,
+            "has_comment": bool(feedback_comment)
+        })
+        st.success("Thank you for your feedback! 🙏")
+    
+    st.divider()
+    
     # Debug Info
     st.subheader("🐛 Debug Info")
     st.markdown(f"**Environment:** {'HF Space' if config.is_hf_space else 'Local'}")
     st.markdown(f"**Model:** {st.session_state.selected_model}")
+    st.markdown(f"**Session ID:** {st.session_state.session_id}")
 
 # Main interface
 st.title("🐱 CosmicCat AI Assistant")
@@ -181,6 +260,9 @@ for message in st.session_state.messages:
 user_input = st.chat_input("Type your message here...", key="chat_input")
 
 if user_input:
+    session_analytics.track_interaction("default_user", st.session_state.session_id, "chat_message_sent", {
+        "message_length": len(user_input)
+    })
     chat_handler.process_user_message(user_input, selected_model_name)
 
 # About tab
@@ -206,3 +288,14 @@ with tab1:
     - **Secondary model**: HF Endpoint (advanced processing)
     - **Memory system**: Redis-based session management
     """)
+    
+    # Log about page view
+    session_analytics.track_interaction("default_user", st.session_state.session_id, "about_page_view")
+
+# End session tracking when app closes
+def on_session_end():
+    session_analytics.end_session_tracking("default_user", st.session_state.session_id)
+
+# Register cleanup function
+import atexit
+atexit.register(on_session_end)

src/analytics/redis_logger.py

@@ -0,0 +1,130 @@
+import json
+import time
+import logging
+from typing import Dict, List, Any, Optional
+from datetime import datetime, timedelta
+from core.redis_client import redis_client
+
+logger = logging.getLogger(__name__)
+
+class RedisAnalyticsLogger:
+    """Redis-based analytics storage system"""
+    
+    def __init__(self):
+        self.redis_client = redis_client.get_client()
+        
+    def store_event(self, event_type: str, data: Dict[str, Any], user_id: Optional[str] = None):
+        """Store an analytics event in Redis"""
+        try:
+            event_data = {
+                "event_type": event_type,
+                "timestamp": datetime.now().isoformat(),
+                "data": data
+            }
+            
+            # Create unique key with timestamp
+            timestamp = int(time.time() * 1000)  # Millisecond precision
+            key = f"analytics:{event_type}:{timestamp}"
+            if user_id:
+                key = f"analytics:{user_id}:{event_type}:{timestamp}"
+                
+            # Store event data
+            self.redis_client.setex(key, 2592000, json.dumps(event_data))  # 30 days expiry
+            
+            # Add to sorted set for time-based queries
+            index_key = f"analytics:index:{event_type}"
+            self.redis_client.zadd(index_key, {key: timestamp})
+            
+            logger.debug(f"Stored analytics event: {key}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to store analytics event: {e}")
+            return False
+            
+    def get_events(self, event_type: str, user_id: Optional[str] = None, 
+                   start_time: Optional[datetime] = None, 
+                   end_time: Optional[datetime] = None,
+                   limit: int = 100) -> List[Dict[str, Any]]:
+        """Retrieve analytics events"""
+        try:
+            # Determine index key
+            index_key = f"analytics:index:{event_type}"
+            if user_id:
+                index_key = f"analytics:{user_id}:index:{event_type}"
+                
+            # Calculate time range
+            if start_time is None:
+                start_time = datetime.now() - timedelta(days=30)
+            if end_time is None:
+                end_time = datetime.now()
+                
+            start_timestamp = int(start_time.timestamp() * 1000)
+            end_timestamp = int(end_time.timestamp() * 1000)
+            
+            # Get event keys in time range
+            event_keys = self.redis_client.zrevrangebyscore(
+                index_key, 
+                end_timestamp, 
+                start_timestamp,
+                start=0,
+                num=limit
+            )
+            
+            # Retrieve event data
+            events = []
+            for key in event_keys:
+                try:
+                    data = self.redis_client.get(key)
+                    if data:
+                        events.append(json.loads(data))
+                except Exception as e:
+                    logger.warning(f"Failed to retrieve event {key}: {e}")
+                    
+            return events
+        except Exception as e:
+            logger.error(f"Failed to retrieve analytics events: {e}")
+            return []
+            
+    def get_event_count(self, event_type: str, user_id: Optional[str] = None,
+                       start_time: Optional[datetime] = None,
+                       end_time: Optional[datetime] = None) -> int:
+        """Get count of events in time range"""
+        try:
+            index_key = f"analytics:index:{event_type}"
+            if user_id:
+                index_key = f"analytics:{user_id}:index:{event_type}"
+                
+            if start_time is None:
+                start_time = datetime.now() - timedelta(days=30)
+            if end_time is None:
+                end_time = datetime.now()
+                
+            start_timestamp = int(start_time.timestamp() * 1000)
+            end_timestamp = int(end_time.timestamp() * 1000)
+            
+            return self.redis_client.zcount(index_key, start_timestamp, end_timestamp)
+        except Exception as e:
+            logger.error(f"Failed to count analytics events: {e}")
+            return 0
+            
+    def aggregate_events(self, event_type: str, aggregation_field: str,
+                        start_time: Optional[datetime] = None,
+                        end_time: Optional[datetime] = None) -> Dict[str, int]:
+        """Aggregate events by a specific field"""
+        try:
+            events = self.get_events(event_type, start_time=start_time, end_time=end_time)
+            aggregation = {}
+            
+            for event in events:
+                data = event.get("data", {})
+                field_value = data.get(aggregation_field)
+                if field_value:
+                    aggregation[field_value] = aggregation.get(field_value, 0) + 1
+                    
+            return aggregation
+        except Exception as e:
+            logger.error(f"Failed to aggregate events: {e}")
+            return {}
+
+# Global instance
+redis_logger = RedisAnalyticsLogger()

src/analytics/session_analytics.py

@@ -0,0 +1,138 @@
+import time
+import json
+import logging
+from typing import Dict, List, Any, Optional
+from datetime import datetime
+from core.redis_client import redis_client
+from src.analytics.user_logger import user_logger
+
+logger = logging.getLogger(__name__)
+
+class SessionAnalytics:
+    """Session-level tracking and analytics"""
+    
+    def __init__(self):
+        self.redis_client = redis_client.get_client()
+        
+    def start_session_tracking(self, user_id: str, session_id: str):
+        """Start tracking a user session"""
+        try:
+            session_data = {
+                "user_id": user_id,
+                "session_id": session_id,
+                "start_time": datetime.now().isoformat(),
+                "interactions": [],
+                "duration": 0,
+                "page_views": 0,
+                "actions": {}
+            }
+            
+            key = f"analytics:sessions:{session_id}"
+            self.redis_client.setex(key, 86400, json.dumps(session_data))  # 24 hours expiry
+            
+            # Log session start
+            user_logger.log_user_action(user_id, "session_start", {
+                "session_id": session_id
+            })
+            
+            logger.info(f"Started session tracking: {session_id}")
+        except Exception as e:
+            logger.error(f"Failed to start session tracking: {e}")
+            
+    def track_interaction(self, user_id: str, session_id: str, interaction_type: str, 
+                         details: Dict[str, Any] = None):
+        """Track a user interaction within a session"""
+        try:
+            key = f"analytics:sessions:{session_id}"
+            session_data_str = self.redis_client.get(key)
+            
+            if session_data_str:
+                session_data = json.loads(session_data_str)
+                
+                # Add interaction
+                interaction = {
+                    "type": interaction_type,
+                    "timestamp": datetime.now().isoformat(),
+                    "details": details or {}
+                }
+                session_data["interactions"].append(interaction)
+                
+                # Update action counts
+                session_data["actions"][interaction_type] = session_data["actions"].get(interaction_type, 0) + 1
+                
+                # Update page views for navigation events
+                if interaction_type == "page_view":
+                    session_data["page_views"] += 1
+                    
+                # Update duration
+                start_time = datetime.fromisoformat(session_data["start_time"])
+                session_data["duration"] = (datetime.now() - start_time).total_seconds()
+                
+                # Save updated session data
+                self.redis_client.setex(key, 86400, json.dumps(session_data))
+                
+                # Log the interaction
+                user_logger.log_user_action(user_id, f"session_interaction_{interaction_type}", {
+                    "session_id": session_id,
+                    "details": details or {}
+                })
+                
+        except Exception as e:
+            logger.error(f"Failed to track interaction: {e}")
+            
+    def end_session_tracking(self, user_id: str, session_id: str):
+        """End session tracking and generate summary"""
+        try:
+            key = f"analytics:sessions:{session_id}"
+            session_data_str = self.redis_client.get(key)
+            
+            if session_data_str:
+                session_data = json.loads(session_data_str)
+                
+                # Update final duration
+                start_time = datetime.fromisoformat(session_data["start_time"])
+                session_data["end_time"] = datetime.now().isoformat()
+                session_data["duration"] = (datetime.now() - start_time).total_seconds()
+                
+                # Save final session data
+                self.redis_client.setex(key, 2592000, json.dumps(session_data))  # 30 days expiry for completed sessions
+                
+                # Log session end with summary
+                user_logger.log_user_action(user_id, "session_end", {
+                    "session_id": session_id,
+                    "duration": session_data["duration"],
+                    "interactions": len(session_data["interactions"]),
+                    "page_views": session_data["page_views"],
+                    "actions": session_data["actions"]
+                })
+                
+                logger.info(f"Ended session tracking: {session_id}")
+                
+        except Exception as e:
+            logger.error(f"Failed to end session tracking: {e}")
+            
+    def get_session_summary(self, session_id: str) -> Optional[Dict[str, Any]]:
+        """Get session summary data"""
+        try:
+            key = f"analytics:sessions:{session_id}"
+            session_data_str = self.redis_client.get(key)
+            
+            if session_data_str:
+                return json.loads(session_data_str)
+            return None
+        except Exception as e:
+            logger.error(f"Failed to get session summary: {e}")
+            return None
+            
+    def get_user_sessions(self, user_id: str, limit: int = 10) -> List[Dict[str, Any]]:
+        """Get recent sessions for a user"""
+        try:
+            # This would require a more complex indexing system
+            # For now, we'll return an empty list as this requires additional implementation
+            return []
+        except Exception as e:
+            logger.error(f"Failed to get user sessions: {e}")
+            return []
+
+# Global instance
+session_analytics = SessionAnalytics()

src/analytics/user_logger.py

@@ -0,0 +1,84 @@
+import json
+import time
+import logging
+from typing import Dict, Any, Optional
+from datetime import datetime
+from core.redis_client import redis_client
+
+logger = logging.getLogger(__name__)
+
+class UserLogger:
+    """Comprehensive user interaction logging system"""
+    
+    def __init__(self):
+        self.redis_client = redis_client.get_client()
+        
+    def log_user_action(self, user_id: str, action: str, details: Dict[str, Any] = None):
+        """Log a user action"""
+        try:
+            event_data = {
+                "user_id": user_id,
+                "action": action,
+                "timestamp": datetime.now().isoformat(),
+                "details": details or {}
+            }
+            
+            # Store in Redis with expiration (30 days)
+            key = f"analytics:user_events:{user_id}:{int(time.time())}"
+            self.redis_client.setex(
+                key, 
+                2592000,  # 30 days in seconds
+                json.dumps(event_data)
+            )
+            
+            # Also store in global events
+            global_key = f"analytics:global_events:{int(time.time())}"
+            self.redis_client.setex(
+                global_key,
+                2592000,  # 30 days in seconds
+                json.dumps(event_data)
+            )
+            
+            logger.info(f"Logged user action: {user_id} - {action}")
+        except Exception as e:
+            logger.error(f"Failed to log user action: {e}")
+    
+    def log_ui_state(self, user_id: str, state: str, details: Dict[str, Any] = None):
+        """Log UI state changes"""
+        self.log_user_action(user_id, f"ui_state_{state}", details)
+        
+    def log_performance_metric(self, user_id: str, metric_name: str, value: float, details: Dict[str, Any] = None):
+        """Log performance metrics"""
+        metric_details = {
+            "value": value,
+            "metric": metric_name
+        }
+        if details:
+            metric_details.update(details)
+            
+        self.log_user_action(user_id, f"performance_{metric_name}", metric_details)
+        
+    def log_error(self, user_id: str, error_type: str, error_message: str, details: Dict[str, Any] = None):
+        """Log errors"""
+        error_details = {
+            "error_type": error_type,
+            "error_message": error_message
+        }
+        if details:
+            error_details.update(details)
+            
+        self.log_user_action(user_id, f"error_{error_type}", error_details)
+        
+    def log_feedback(self, user_id: str, rating: int, comment: str = "", details: Dict[str, Any] = None):
+        """Log user feedback"""
+        feedback_details = {
+            "rating": rating,
+            "comment": comment
+        }
+        if details:
+            feedback_details.update(details)
+            
+        self.log_user_action(user_id, "user_feedback", feedback_details)
+
+# Global instance
+user_logger = UserLogger()