🔧 Fix user view template and enhance user analytics

Bug Fix:
- Fixed Jinja template error in user view page (dict vs attribute access)
- User statistics now properly display without crashing

Enhanced User Analytics:
- Added detailed user analytics with cost tracking
- Comprehensive model usage statistics per user
- Success rate, response time, and error tracking
- Per-model cost and token breakdown
- Daily and hourly usage distribution

Features:
- Enhanced user view with 8 key metrics
- Detailed model usage table with costs
- Better error handling for missing data
- Backward compatibility with existing stats

Technical Implementation:
- New get_user_analytics() method in structured logger
- Combined data from both event loggers
- Proper dictionary access in templates
- Enhanced dummy logger for Firebase-less deployments

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

pages/admin/view_user.html

@@ -105,15 +105,85 @@
             {% if user_data.usage_stats %}
                 <div class="usage-stats">
                     <div class="stat-item">
-                        <strong>Total Requests:</strong> {{ user_data.usage_stats.total_requests }}
+                        <strong>Total Requests:</strong> {{ user_data.usage_stats.get('total_requests', 0) }}
                     </div>
                     <div class="stat-item">
-                        <strong>Total Tokens:</strong> {{ user_data.usage_stats.total_tokens }}
+                        <strong>Total Tokens:</strong> {{ user_data.usage_stats.get('total_tokens', 0) }}
                     </div>
                     <div class="stat-item">
-                        <strong>Total Cost:</strong> ${{ "%.4f"|format(user_data.usage_stats.total_cost) }}
+                        <strong>Input Tokens:</strong> {{ user_data.usage_stats.get('input_tokens', 0) }}
                     </div>
+                    <div class="stat-item">
+                        <strong>Output Tokens:</strong> {{ user_data.usage_stats.get('output_tokens', 0) }}
+                    </div>
+                    <div class="stat-item">
+                        <strong>Chat Completions:</strong> {{ user_data.usage_stats.get('chat_completions', 0) }}
+                    </div>
+                    <div class="stat-item">
+                        <strong>API Errors:</strong> {{ user_data.usage_stats.get('api_errors', 0) }}
+                    </div>
+                    <div class="stat-item">
+                        <strong>Total Cost:</strong> ${{ "%.4f"|format(user_data.usage_stats.get('total_cost', 0)) }}
+                    </div>
+                    <div class="stat-item">
+                        <strong>Success Rate:</strong> {{ "%.1f"|format(user_data.usage_stats.get('success_rate', 0)) }}%
+                    </div>
+                    <div class="stat-item">
+                        <strong>Avg Response Time:</strong> {{ "%.0f"|format(user_data.usage_stats.get('avg_response_time', 0)) }}ms
+                    </div>
+                </div>
+                
+                {% if user_data.usage_stats.get('model_usage') %}
+                <div class="model-usage-stats">
+                    <h3>Model Usage Details</h3>
+                    <table class="usage-table">
+                        <thead>
+                            <tr>
+                                <th>Model</th>
+                                <th>Requests</th>
+                                <th>Tokens</th>
+                                <th>Cost</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            {% for model, stats in user_data.usage_stats.get('model_usage', {}).items() %}
+                            <tr>
+                                <td>{{ model }}</td>
+                                <td>{{ stats.get('requests', 0) }}</td>
+                                <td>{{ stats.get('tokens', 0) }}</td>
+                                <td>${{ "%.4f"|format(stats.get('cost', 0)) }}</td>
+                            </tr>
+                            {% endfor %}
+                        </tbody>
+                    </table>
+                </div>
+                {% elif user_data.usage_stats.get('model_families') %}
+                <div class="model-families-stats">
+                    <h3>Model Family Usage</h3>
+                    <table class="usage-table">
+                        <thead>
+                            <tr>
+                                <th>Model Family</th>
+                                <th>Requests</th>
+                                <th>Input Tokens</th>
+                                <th>Output Tokens</th>
+                                <th>Total Tokens</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            {% for family, stats in user_data.usage_stats.get('model_families', {}).items() %}
+                            <tr>
+                                <td>{{ family }}</td>
+                                <td>{{ stats.get('requests', 0) }}</td>
+                                <td>{{ stats.get('input_tokens', 0) }}</td>
+                                <td>{{ stats.get('output_tokens', 0) }}</td>
+                                <td>{{ stats.get('total_tokens', 0) }}</td>
+                            </tr>
+                            {% endfor %}
+                        </tbody>
+                    </table>
                 </div>
+                {% endif %}
             {% else %}
                 <p><em>No usage statistics available</em></p>
             {% endif %}

src/routes/admin_web.py

@@ -251,9 +251,23 @@ def view_user(token: str):
         flash('User not found', 'error')
         return redirect(url_for('admin.list_users'))
     
-    # Add detailed statistics
+    # Add detailed statistics from both loggers
     usage_stats = event_logger.get_user_stats(token)
     
+    # Get enhanced stats from structured logger
+    enhanced_stats = structured_logger.get_user_analytics(token)
+    
+    # Combine stats for better reporting
+    if enhanced_stats:
+        usage_stats.update({
+            'total_cost': enhanced_stats.get('total_cost', 0),
+            'avg_response_time': enhanced_stats.get('avg_response_time', 0),
+            'success_rate': enhanced_stats.get('success_rate', 100),
+            'models_used': enhanced_stats.get('models_used', []),
+            'hourly_distribution': enhanced_stats.get('hourly_distribution', {}),
+            'daily_usage': enhanced_stats.get('daily_usage', {})
+        })
+    
     # Add recent events (Firebase logger doesn't have this method yet)
     recent_events = []  # TODO: Implement get_events method in FirebaseEventLogger
     

src/services/firebase_logger.py

@@ -351,6 +351,113 @@ class FirebaseStructuredLogger:
         except Exception as e:
             print(f"Failed to get analytics: {e}")
             return {}
+    
+    def get_user_analytics(self, user_token: str, days: int = 30) -> Dict[str, Any]:
+        """Get detailed analytics for a specific user"""
+        if not self.firebase_available:
+            return {}
+            
+        try:
+            # Get events from last N days
+            cutoff_time = datetime.now() - timedelta(days=days)
+            cutoff_timestamp = int(cutoff_time.timestamp() * 1000)
+            
+            events = self.db_ref.order_by_key().start_at(str(cutoff_timestamp)).get()
+            
+            if not events:
+                return {}
+            
+            # Filter events for this user
+            user_events = {}
+            for event_key, event_data in events.items():
+                if event_data.get("user_token") == user_token:
+                    user_events[event_key] = event_data
+            
+            if not user_events:
+                return {}
+            
+            analytics = {
+                "total_requests": len(user_events),
+                "total_tokens": 0,
+                "total_cost": 0.0,
+                "avg_response_time": 0.0,
+                "success_rate": 0.0,
+                "models_used": [],
+                "model_usage": {},
+                "hourly_distribution": {},
+                "daily_usage": {},
+                "input_tokens": 0,
+                "output_tokens": 0,
+                "chat_completions": 0,
+                "api_errors": 0
+            }
+            
+            successful_requests = 0
+            total_response_time = 0
+            models_set = set()
+            
+            for event_key, event_data in user_events.items():
+                if event_data.get("event_type") == "chat_completion":
+                    analytics["chat_completions"] += 1
+                    analytics["total_tokens"] += event_data.get("total_tokens", 0)
+                    analytics["input_tokens"] += event_data.get("input_tokens", 0)
+                    analytics["output_tokens"] += event_data.get("output_tokens", 0)
+                    analytics["total_cost"] += event_data.get("cost_usd", 0)
+                    
+                    if event_data.get("success", False):
+                        successful_requests += 1
+                        total_response_time += event_data.get("response_time_ms", 0)
+                    else:
+                        analytics["api_errors"] += 1
+                    
+                    # Model usage
+                    model = event_data.get("model_name", "unknown")
+                    models_set.add(model)
+                    if model not in analytics["model_usage"]:
+                        analytics["model_usage"][model] = {
+                            "requests": 0,
+                            "tokens": 0,
+                            "cost": 0.0
+                        }
+                    analytics["model_usage"][model]["requests"] += 1
+                    analytics["model_usage"][model]["tokens"] += event_data.get("total_tokens", 0)
+                    analytics["model_usage"][model]["cost"] += event_data.get("cost_usd", 0)
+                    
+                    # Hourly distribution
+                    timestamp = event_data.get("timestamp", "")
+                    if timestamp:
+                        try:
+                            dt = datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
+                            hour = dt.hour
+                            date_str = dt.strftime("%Y-%m-%d")
+                            
+                            if hour not in analytics["hourly_distribution"]:
+                                analytics["hourly_distribution"][hour] = 0
+                            analytics["hourly_distribution"][hour] += 1
+                            
+                            if date_str not in analytics["daily_usage"]:
+                                analytics["daily_usage"][date_str] = {
+                                    "requests": 0,
+                                    "tokens": 0,
+                                    "cost": 0.0
+                                }
+                            analytics["daily_usage"][date_str]["requests"] += 1
+                            analytics["daily_usage"][date_str]["tokens"] += event_data.get("total_tokens", 0)
+                            analytics["daily_usage"][date_str]["cost"] += event_data.get("cost_usd", 0)
+                        except:
+                            pass
+            
+            # Calculate averages and final stats
+            analytics["models_used"] = list(models_set)
+            if successful_requests > 0:
+                analytics["avg_response_time"] = total_response_time / successful_requests
+                analytics["success_rate"] = (successful_requests / len(user_events)) * 100
+            
+            return analytics
+            
+        except Exception as e:
+            print(f"Failed to get user analytics: {e}")
+            return {}
 
 # Global logger instances
 firebase_event_logger = FirebaseEventLogger()
@@ -367,7 +474,9 @@ else:
         def log_event(self, *args, **kwargs): return False
         def log_chat_completion(self, *args, **kwargs): return False
         def log_api_request(self, *args, **kwargs): return False
+        def log_user_action(self, *args, **kwargs): return False
         def get_user_stats(self, *args, **kwargs): return {}
+        def get_user_analytics(self, *args, **kwargs): return {}
         def cleanup_old_events(self, *args, **kwargs): return False
         def get_analytics(self, *args, **kwargs): return {}