feat(stats): Add performance metrics tracking and update functionality

Author: siqnole

cogs/Stats.py

@@ -3,6 +3,8 @@
 import logging
 import time
 import json
+import psutil
+import os
 from datetime import datetime
 from discord.ext import commands, tasks
 from typing import Dict, List, Optional
@@ -28,6 +30,7 @@ def __init__(self, bot):
 
         # Start background tasks
         self.send_stats_task.start()
+        self.send_performance_update_task.start()
         self.reset_daily_stats_task.start()
         self.load_stats_task.start()
 
@@ -36,6 +39,7 @@ def __init__(self, bot):
     def cog_unload(self):
         """Clean up when cog is unloaded"""
         self.send_stats_task.cancel()
+        self.send_performance_update_task.cancel()
         self.reset_daily_stats_task.cancel()
         self.load_stats_task.cancel()
         # Save stats before unloading
@@ -72,7 +76,12 @@ async def load_stats_from_mongodb(self):
                 self.daily_commands = stats_doc.get("daily_commands", 0)
                 self.command_types = stats_doc.get("command_types", {})
                 self.last_stats_update = stats_doc.get("last_update", 0)
-                logging.info(f"Loaded stats from MongoDB: {self.command_count} commands")
+                
+                # Load uptime start if available, otherwise use current time
+                if "uptime_start" in stats_doc:
+                    self.start_time = datetime.fromtimestamp(stats_doc["uptime_start"])
+                
+                logging.info(f"Loaded stats from MongoDB: {self.command_count} commands, {len(self.command_types)} unique commands")
             else:
                 logging.info("No stats found in MongoDB, using default values")
         except Exception as e:
@@ -85,13 +94,47 @@ async def save_stats_to_mongodb(self):
             return False
 
         try:
-            # Prepare stats document
+            # Get system performance metrics
+            try:
+                process = psutil.Process(os.getpid())
+                memory_usage = process.memory_info().rss / 1024 / 1024  # MB
+                cpu_usage = process.cpu_percent()
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                memory_usage = 0
+                cpu_usage = 0
+            
+            # Calculate total user count
+            total_users = sum(guild.member_count or 0 for guild in self.bot.guilds)
+            
+            # Prepare comprehensive stats document
             stats_doc = {
                 "command_count": self.command_count,
                 "daily_commands": self.daily_commands,
                 "command_types": self.command_types,
                 "last_update": time.time(),
-                "updated_at": datetime.now()
+                "updated_at": datetime.now(),
+                
+                # Performance metrics
+                "user_count": total_users,
+                "latency": round(self.bot.latency * 1000, 2),
+                "shard_count": self.bot.shard_count or 1,
+                "memory_usage": round(memory_usage, 2),
+                "cpu_usage": round(cpu_usage, 2),
+                "cached_users": len(self.bot.users),
+                
+                # Guild information
+                "guild_count": len(self.bot.guilds),
+                "guild_list": [str(guild.id) for guild in self.bot.guilds],
+                
+                # Uptime information
+                "uptime_start": self.start_time.timestamp(),
+                "uptime_seconds": (datetime.now() - self.start_time).total_seconds(),
+                
+                # System information
+                "python_version": f"{os.sys.version_info.major}.{os.sys.version_info.minor}.{os.sys.version_info.micro}",
+                "discord_py_version": discord.__version__,
+                "platform": os.name,
+                "process_id": os.getpid()
             }
 
             # Update or insert the global stats document
@@ -127,6 +170,54 @@ async def before_send_stats_task(self):
         """Wait until the bot is ready before starting the stats update loop"""
         await self.bot.wait_until_ready()
 
+    @tasks.loop(minutes=1)
+    async def send_performance_update_task(self):
+        """Send performance metrics update every minute for real-time monitoring"""
+        try:
+            await self.send_performance_update()
+        except Exception as e:
+            logging.debug(f"Error in performance update task: {e}")
+
+    @send_performance_update_task.before_loop
+    async def before_send_performance_update_task(self):
+        """Wait until the bot is ready before starting the performance update loop"""
+        await self.bot.wait_until_ready()
+
+    async def send_performance_update(self):
+        """Send lightweight performance update to dashboard"""
+        try:
+            process = psutil.Process(os.getpid())
+            memory_usage = process.memory_info().rss / 1024 / 1024  # MB
+            cpu_usage = process.cpu_percent()
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            memory_usage = 0
+            cpu_usage = 0
+        
+        performance_data = {
+            "type": "performance_update",
+            "latency": round(self.bot.latency * 1000, 2),
+            "memory_usage": round(memory_usage, 2),
+            "cpu_usage": round(cpu_usage, 2),
+            "guild_count": len(self.bot.guilds),
+            "user_count": sum(guild.member_count or 0 for guild in self.bot.guilds),
+            "cached_users": len(self.bot.users),
+            "timestamp": time.time()
+        }
+        
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    f"{self.dashboard_url}/api/stats/performance",
+                    json=performance_data,
+                    timeout=5
+                ) as response:
+                    if response.status == 200:
+                        logging.debug("✅ Performance update sent successfully")
+                    else:
+                        logging.debug(f"❌ Failed to send performance update: {response.status}")
+        except Exception as e:
+            logging.debug(f"❌ Error sending performance update: {e}")
+
     @tasks.loop(hours=24)
     async def reset_daily_stats_task(self):
         """Reset daily command count at midnight"""
@@ -146,6 +237,40 @@ async def send_comprehensive_stats(self):
         """Send comprehensive stats to dashboard"""
         uptime = datetime.now() - self.start_time
 
+        # Get system performance metrics
+        try:
+            process = psutil.Process(os.getpid())
+            memory_usage = process.memory_info().rss / 1024 / 1024  # MB
+            cpu_usage = process.cpu_percent()
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            memory_usage = 0
+            cpu_usage = 0
+        
+        # Calculate total user count across all guilds
+        total_users = sum(guild.member_count or 0 for guild in self.bot.guilds)
+        
+        # Get detailed guild information
+        guild_details = []
+        for guild in self.bot.guilds:
+            try:
+                guild_details.append({
+                    "id": str(guild.id),
+                    "name": guild.name,
+                    "member_count": guild.member_count or 0,
+                    "owner_id": str(guild.owner_id) if guild.owner_id else None,
+                    "created_at": guild.created_at.isoformat() if guild.created_at else None,
+                    "features": list(guild.features) if guild.features else [],
+                    "verification_level": str(guild.verification_level) if guild.verification_level else "none",
+                    "premium_tier": guild.premium_tier if hasattr(guild, 'premium_tier') else 0
+                })
+            except Exception as e:
+                logging.warning(f"Error getting details for guild {guild.id}: {e}")
+                guild_details.append({
+                    "id": str(guild.id),
+                    "name": getattr(guild, 'name', 'Unknown'),
+                    "member_count": getattr(guild, 'member_count', 0) or 0
+                })
+        
         stats = {
             "uptime": {
                 "days": uptime.days,
@@ -157,23 +282,27 @@ async def send_comprehensive_stats(self):
             "guilds": {
                 "count": len(self.bot.guilds),
                 "list": [str(guild.id) for guild in self.bot.guilds],
-                "detailed": [
-                    {
-                        "id": str(guild.id),
-                        "name": guild.name,
-                        "member_count": guild.member_count or 0
-                    } for guild in self.bot.guilds
-                ]
+                "detailed": guild_details
             },
             "performance": {
-                "user_count": sum(guild.member_count or 0 for guild in self.bot.guilds),
-                "latency": round(self.bot.latency * 1000, 2),
-                "shard_count": self.bot.shard_count or 1
+                "user_count": total_users,
+                "latency": round(self.bot.latency * 1000, 2),  # Convert to milliseconds
+                "shard_count": self.bot.shard_count or 1,
+                "memory_usage": round(memory_usage, 2),
+                "cpu_usage": round(cpu_usage, 2),
+                "cached_users": len(self.bot.users),
+                "cached_messages": getattr(self.bot, '_connection', {}).get('_messages', {}) and len(getattr(self.bot._connection, '_messages', {})) or 0
             },
             "commands": {
                 "total_executed": self.command_count,
                 "daily_count": self.daily_commands,
                 "command_types": self.command_types.copy()
+            },
+            "system": {
+                "python_version": f"{os.sys.version_info.major}.{os.sys.version_info.minor}.{os.sys.version_info.micro}",
+                "discord_py_version": discord.__version__,
+                "platform": os.name,
+                "process_id": os.getpid()
             }
         }
 
@@ -187,8 +316,12 @@ async def send_comprehensive_stats(self):
                     if response.status == 200:
                         logging.debug("✅ Comprehensive stats sent to dashboard successfully")
                         self.last_stats_update = time.time()
+                        
+                        # Also save to MongoDB after successful dashboard update
+                        await self.save_stats_to_mongodb()
                     else:
-                        logging.warning(f"❌ Failed to send comprehensive stats: {response.status}")
+                        response_text = await response.text()
+                        logging.warning(f"❌ Failed to send comprehensive stats: {response.status} - {response_text}")
         except Exception as e:
             logging.error(f"❌ Error sending comprehensive stats: {e}")
 
@@ -274,6 +407,17 @@ async def stats_status(self, ctx):
         uptime = datetime.now() - self.start_time
         last_update_ago = time.time() - self.last_stats_update if self.last_stats_update else None
 
+        # Get system metrics
+        try:
+            process = psutil.Process(os.getpid())
+            memory_usage = process.memory_info().rss / 1024 / 1024  # MB
+            cpu_usage = process.cpu_percent()
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            memory_usage = 0
+            cpu_usage = 0
+        
+        total_users = sum(guild.member_count or 0 for guild in self.bot.guilds)
+        
         embed = discord.Embed(
             title="📊 Stats Cog Status",
             color=discord.Color.blue()
@@ -287,6 +431,22 @@ async def stats_status(self, ctx):
             inline=True
         )
 
+        embed.add_field(
+            name="🌐 Bot Performance",
+            value=f"**Guilds:** {len(self.bot.guilds):,}\n"
+                  f"**Users:** {total_users:,}\n"
+                  f"**Latency:** {round(self.bot.latency * 1000, 2)}ms",
+            inline=True
+        )
+        
+        embed.add_field(
+            name="💻 System Performance",
+            value=f"**Memory Usage:** {memory_usage:.1f} MB\n"
+                  f"**CPU Usage:** {cpu_usage:.1f}%\n"
+                  f"**Shards:** {self.bot.shard_count or 1}",
+            inline=True
+        )
+        
         embed.add_field(
             name="⏱️ Timing",
             value=f"**Uptime:** {uptime.days}d {uptime.seconds//3600}h {(uptime.seconds%3600)//60}m\n"
@@ -300,7 +460,15 @@ async def stats_status(self, ctx):
                   f"**Update Interval:** 5 minutes\n"
                   f"**MongoDB Storage:** Enabled\n"
                   f"**Tasks Running:** {self.send_stats_task.is_running()}",
-            inline=False
+            inline=True
+        )
+        
+        embed.add_field(
+            name="📋 System Info",
+            value=f"**Python:** {os.sys.version_info.major}.{os.sys.version_info.minor}.{os.sys.version_info.micro}\n"
+                  f"**Discord.py:** {discord.__version__}\n"
+                  f"**Platform:** {os.name}",
+            inline=True
         )
 
         # Top 5 commands
@@ -323,8 +491,10 @@ async def force_stats_update(self, ctx):
         await ctx.send("🔄 Sending stats update...")
 
         try:
-            # Update dashboard
+            # Update dashboard with comprehensive stats
             await self.send_comprehensive_stats()
+            # Send performance update as well
+            await self.send_performance_update()
             # Save to MongoDB
             mongo_success = await self.save_stats_to_mongodb()
 
@@ -335,6 +505,18 @@ async def force_stats_update(self, ctx):
         except Exception as e:
             await ctx.send(f"❌ Failed to send stats update: {e}")
 
+    @commands.command(name='testperformance', aliases=['perftest'])
+    @commands.is_owner()
+    async def test_performance_update(self, ctx):
+        """Test performance metrics update"""
+        await ctx.send("🔄 Testing performance update...")
+        
+        try:
+            await self.send_performance_update()
+            await ctx.send("✅ Performance update sent successfully!")
+        except Exception as e:
+            await ctx.send(f"❌ Failed to send performance update: {e}")
+
     @commands.command(name='resetstats')
     @commands.is_owner()
     async def reset_stats(self, ctx):

requirements.txt

@@ -31,4 +31,5 @@ aioredis==2.0.1
 # Utils
 python-dotenv==1.0.0
 requests==2.32.2
-asgiref==3.7.2
+asgiref==3.7.2
+psutil==5.9.8