Add user statistics tracking and admin stats command

Co-authored-by: petr.b.lavrov <petr.b.lavrov@gmail.com>

Author: cursoragent

src/app.py

@@ -1135,3 +1135,94 @@ async def chat_about_transcript(
             )
 
             return response
+
+    async def get_user_statistics(self) -> Dict[str, Any]:
+        """
+        Get comprehensive usage statistics for all users.
+
+        Returns:
+            Dictionary with user statistics including request counts, total minutes, and costs
+        """
+        # Get all cost entries from the database
+        costs = await self.db.costs.find({}).to_list(length=10000)
+        events = await self.db.events.find({"event_type": "file_submission"}).to_list(length=10000)
+        
+        # Initialize user stats dictionary
+        user_stats = {}
+        
+        # Process cost data
+        for cost_entry in costs:
+            user_id = cost_entry.get("user_id")
+            if not user_id:
+                continue
+                
+            if user_id not in user_stats:
+                user_stats[user_id] = {
+                    "total_cost": 0.0,
+                    "total_requests": 0,
+                    "total_minutes": 0.0,
+                    "operations": {},
+                    "models": {},
+                    "first_activity": None,
+                    "last_activity": None,
+                }
+            
+            # Add cost
+            cost = float(cost_entry.get("cost", 0.0)) if cost_entry.get("cost") is not None else 0.0
+            user_stats[user_id]["total_cost"] += cost
+            
+            # Track operation types
+            operation = cost_entry.get("operation", "unknown")
+            if operation not in user_stats[user_id]["operations"]:
+                user_stats[user_id]["operations"][operation] = {"cost": 0.0, "count": 0}
+            user_stats[user_id]["operations"][operation]["cost"] += cost
+            user_stats[user_id]["operations"][operation]["count"] += 1
+            
+            # Track models used
+            model = cost_entry.get("model", "unknown")
+            if model not in user_stats[user_id]["models"]:
+                user_stats[user_id]["models"][model] = {"cost": 0.0, "count": 0}
+            user_stats[user_id]["models"][model]["cost"] += cost
+            user_stats[user_id]["models"][model]["count"] += 1
+            
+            # Track timestamps
+            timestamp = cost_entry.get("timestamp")
+            if timestamp:
+                if user_stats[user_id]["first_activity"] is None or timestamp < user_stats[user_id]["first_activity"]:
+                    user_stats[user_id]["first_activity"] = timestamp
+                if user_stats[user_id]["last_activity"] is None or timestamp > user_stats[user_id]["last_activity"]:
+                    user_stats[user_id]["last_activity"] = timestamp
+            
+            # Extract minutes from usage data
+            usage = cost_entry.get("usage", {})
+            if isinstance(usage, dict):
+                # For transcription operations, get minutes from estimated_minutes or audio_duration_seconds
+                if operation == "transcription":
+                    estimated_minutes = usage.get("estimated_minutes", 0)
+                    if estimated_minutes:
+                        user_stats[user_id]["total_minutes"] += float(estimated_minutes)
+                    elif usage.get("audio_duration_seconds"):
+                        minutes = float(usage.get("audio_duration_seconds", 0)) / 60
+                        user_stats[user_id]["total_minutes"] += minutes
+        
+        # Process event data to get request counts
+        for event in events:
+            user_id = event.get("user_id")
+            if user_id and user_id in user_stats:
+                user_stats[user_id]["total_requests"] += 1
+        
+        # Calculate summary statistics
+        total_users = len(user_stats)
+        total_cost_all_users = sum(stats["total_cost"] for stats in user_stats.values())
+        total_requests_all_users = sum(stats["total_requests"] for stats in user_stats.values())
+        total_minutes_all_users = sum(stats["total_minutes"] for stats in user_stats.values())
+        
+        return {
+            "user_stats": user_stats,
+            "summary": {
+                "total_users": total_users,
+                "total_cost": total_cost_all_users,
+                "total_requests": total_requests_all_users,
+                "total_minutes": total_minutes_all_users,
+            }
+        }

src/router.py

@@ -63,6 +63,71 @@ async def help_handler(message: Message, app: App):
     await send_safe(message.chat.id, help_message)
 
 
+@commands_menu.botspot_command("stats", "Show usage statistics (admin only)")
+@router.message(Command("stats"))
+async def stats_handler(message: Message, app: App):
+    """Stats command handler - shows usage statistics for all users"""
+    assert message.from_user is not None
+    
+    # TODO: Implement proper admin checking
+    # For now, you can add admin user IDs to check against
+    # admin_user_ids = [123456789, 987654321]  # Replace with actual admin user IDs
+    # if message.from_user.id not in admin_user_ids:
+    #     await send_safe(message.chat.id, "❌ This command is only available to administrators.")
+    #     return
+    
+    # Get user statistics
+    try:
+        stats = await app.get_user_statistics()
+        
+        # Format the statistics nicely
+        response = "<b>📊 Bot Usage Statistics</b>\n\n"
+        
+        # Summary section
+        summary = stats["summary"]
+        response += f"<b>📈 Summary:</b>\n"
+        response += f"• Total Users: {summary['total_users']}\n"
+        response += f"• Total Requests: {summary['total_requests']}\n"
+        response += f"• Total Audio Minutes: {summary['total_minutes']:.1f}\n"
+        response += f"• Total Cost: ${summary['total_cost']:.4f}\n\n"
+        
+        # Per-user statistics
+        response += "<b>👥 Per-User Statistics:</b>\n"
+        
+        user_stats = stats["user_stats"]
+        # Sort users by total cost (descending)
+        sorted_users = sorted(user_stats.items(), key=lambda x: x[1]["total_cost"], reverse=True)
+        
+        for username, user_data in sorted_users[:20]:  # Show top 20 users
+            response += f"\n<b>@{username}</b>\n"
+            response += f"  • Requests: {user_data['total_requests']}\n"
+            response += f"  • Audio Minutes: {user_data['total_minutes']:.1f}\n"
+            response += f"  • Total Cost: ${user_data['total_cost']:.4f}\n"
+            
+            # Show breakdown of operations if available
+            if user_data["operations"]:
+                response += f"  • Operations: "
+                op_details = []
+                for op, op_data in user_data["operations"].items():
+                    op_details.append(f"{op}({op_data['count']})")
+                response += ", ".join(op_details) + "\n"
+            
+            # Show activity timeframe
+            if user_data["first_activity"] and user_data["last_activity"]:
+                first = user_data["first_activity"]
+                last = user_data["last_activity"]
+                response += f"  • Active: {first.strftime('%Y-%m-%d')} to {last.strftime('%Y-%m-%d')}\n"
+        
+        if len(user_stats) > 20:
+            response += f"\n<i>... and {len(user_stats) - 20} more users</i>"
+            
+    except Exception as e:
+        logger.error(f"Error getting statistics: {e}")
+        response = f"❌ Error retrieving statistics: {str(e)}"
+    
+    await send_safe(message.chat.id, response)
+
+
 class Language(BaseModel):
     language_code: str