feat: enhance service cogs with improved functionality

- Add new reminders service
- Update levels service integration
- Improve influxdb logging capabilities
- Enhance gif limiter and status roles

Author: kzndotsh

tux/cogs/services/gif_limiter.py

@@ -4,6 +4,7 @@
 
 import discord
 from discord.ext import commands, tasks
+from loguru import logger
 
 from tux.bot import Tux
 from tux.utils.config import CONFIG
@@ -120,7 +121,7 @@ async def on_message(self, message: discord.Message) -> None:
         if await self._should_process_message(message):
             await self._handle_gif_message(message)
 
-    @tasks.loop(seconds=20)
+    @tasks.loop(seconds=20, name="old_gif_remover")
     async def old_gif_remover(self) -> None:
         """
         Regularly cleans old GIF timestamps
@@ -143,6 +144,23 @@ async def old_gif_remover(self) -> None:
                 else:
                     del self.recent_gifs_by_user[user_id]
 
+    @old_gif_remover.before_loop
+    async def before_old_gif_remover(self) -> None:
+        """Wait until the bot is ready."""
+        await self.bot.wait_until_ready()
+
+    @old_gif_remover.error
+    async def on_old_gif_remover_error(self, error: BaseException) -> None:
+        """Handles errors in the old_gif_remover loop."""
+        logger.error(f"Error in old_gif_remover loop: {error}")
+
+        if isinstance(error, Exception):
+            self.bot.sentry_manager.capture_exception(error)
+        else:
+            # For BaseExceptions that are not Exceptions (like KeyboardInterrupt),
+            # it's often better to let them propagate.
+            raise error
+
     async def cog_unload(self) -> None:
         """Cancel the background task when the cog is unloaded."""
         self.old_gif_remover.cancel()

tux/cogs/services/influxdblogger.py

@@ -1,5 +1,6 @@
 from typing import Any
 
+import discord
 from discord.ext import commands, tasks
 from influxdb_client.client.influxdb_client import InfluxDBClient
 from influxdb_client.client.write.point import Point
@@ -12,13 +13,14 @@
 
 
 class InfluxLogger(commands.Cog):
-    def __init__(self, bot: Tux):
+    def __init__(self, bot: Tux) -> None:
         self.bot = bot
         self.db = DatabaseController()
         self.influx_write_api: Any | None = None
         self.influx_org: str = ""
 
         if self.init_influx():
+            self._log_guild_stats.start()
             self.logger.start()
         else:
             logger.warning("InfluxDB logger failed to init. Check .env configuration if you want to use it.")
@@ -42,7 +44,46 @@ def init_influx(self) -> bool:
             return True
         return False
 
-    @tasks.loop(seconds=60)
+    @tasks.loop(seconds=60, name="influx_guild_stats")
+    async def _log_guild_stats(self) -> None:
+        """Logs guild statistics to InfluxDB."""
+        if not self.bot.is_ready() or not self.influx_write_api:
+            logger.debug("Bot not ready or InfluxDB writer not initialized, skipping InfluxDB logging.")
+            return
+
+        for guild in self.bot.guilds:
+            online_members = sum(m.status != discord.Status.offline for m in guild.members)
+
+            tags = {"guild": guild.name}
+            fields = {
+                "members": guild.member_count,
+                "online": online_members,
+            }
+
+            point = {"measurement": "guild_stats", "tags": tags, "fields": fields}
+
+            self.influx_write_api.write(bucket="tux_stats", org=self.influx_org, record=point)
+
+    @_log_guild_stats.before_loop
+    async def before_log_guild_stats(self) -> None:
+        """Wait until the bot is ready."""
+        await self.bot.wait_until_ready()
+
+    @_log_guild_stats.error
+    async def on_log_guild_stats_error(self, error: BaseException) -> None:
+        """Handles errors in the guild stats logging loop."""
+        logger.error(f"Error in InfluxDB guild stats logger loop: {error}")
+        if isinstance(error, Exception):
+            self.bot.sentry_manager.capture_exception(error)
+        else:
+            raise error
+
+    async def cog_unload(self) -> None:
+        if self.influx_write_api:
+            self._log_guild_stats.cancel()
+            self.logger.cancel()
+
+    @tasks.loop(seconds=60, name="influx_db_logger")
     async def logger(self) -> None:
         """Log statistics to InfluxDB at regular intervals.
 
@@ -55,40 +96,54 @@ async def logger(self) -> None:
         influx_bucket = "tux stats"
 
         # Collect the guild list from the database
-        try:
-            guild_list = await self.db.guild.find_many(where={})
+        guild_list = await self.db.guild.find_many(where={})
+
+        # Iterate through each guild and collect metrics
+        for guild in guild_list:
+            if not guild.guild_id:
+                continue
 
-            # Iterate through each guild and collect metrics
-            for guild in guild_list:
-                if not guild.guild_id:
-                    continue
+            guild_id = int(guild.guild_id)
 
-                guild_id = int(guild.guild_id)
+            # Collect data by querying controllers
+            starboard_stats = await self.db.starboard_message.find_many(where={"message_guild_id": guild_id})
 
-                # Collect data by querying controllers
-                starboard_stats = await self.db.starboard_message.find_many(where={"message_guild_id": guild_id})
+            snippet_stats = await self.db.snippet.find_many(where={"guild_id": guild_id})
 
-                snippet_stats = await self.db.snippet.find_many(where={"guild_id": guild_id})
+            afk_stats = await self.db.afk.find_many(where={"guild_id": guild_id})
 
-                afk_stats = await self.db.afk.find_many(where={"guild_id": guild_id})
+            case_stats = await self.db.case.find_many(where={"guild_id": guild_id})
 
-                case_stats = await self.db.case.find_many(where={"guild_id": guild_id})
+            # Create data points with type ignores for InfluxDB methods
+            # The InfluxDB client's type hints are incomplete
+            points: list[Point] = [
+                Point("guild stats").tag("guild", guild_id).field("starboard count", len(starboard_stats)),  # type: ignore
+                Point("guild stats").tag("guild", guild_id).field("snippet count", len(snippet_stats)),  # type: ignore
+                Point("guild stats").tag("guild", guild_id).field("afk count", len(afk_stats)),  # type: ignore
+                Point("guild stats").tag("guild", guild_id).field("case count", len(case_stats)),  # type: ignore
+            ]
 
-                # Create data points with type ignores for InfluxDB methods
-                # The InfluxDB client's type hints are incomplete
-                points: list[Point] = [
-                    Point("guild stats").tag("guild", guild_id).field("starboard count", len(starboard_stats)),  # type: ignore
-                    Point("guild stats").tag("guild", guild_id).field("snippet count", len(snippet_stats)),  # type: ignore
-                    Point("guild stats").tag("guild", guild_id).field("afk count", len(afk_stats)),  # type: ignore
-                    Point("guild stats").tag("guild", guild_id).field("case count", len(case_stats)),  # type: ignore
-                ]
+            # Write to InfluxDB
+            self.influx_write_api.write(bucket=influx_bucket, org=self.influx_org, record=points)
 
-                # Write to InfluxDB
-                self.influx_write_api.write(bucket=influx_bucket, org=self.influx_org, record=points)
+    @logger.before_loop
+    async def before_logger(self) -> None:
+        """Wait until the bot is ready."""
+        await self.bot.wait_until_ready()
 
-        except Exception as e:
-            logger.error(f"Error collecting metrics for InfluxDB: {e}")
+    @logger.error
+    async def on_logger_error(self, error: BaseException) -> None:
+        """Handles errors in the logger loop."""
+        logger.error(f"Error in InfluxDB logger loop: {error}")
+        if isinstance(error, Exception):
+            self.bot.sentry_manager.capture_exception(error)
+        else:
+            raise error
 
 
 async def setup(bot: Tux) -> None:
-    await bot.add_cog(InfluxLogger(bot))
+    # Only load the cog if InfluxDB configuration is available
+    if all([CONFIG.INFLUXDB_TOKEN, CONFIG.INFLUXDB_URL, CONFIG.INFLUXDB_ORG]):
+        await bot.add_cog(InfluxLogger(bot))
+    else:
+        logger.warning("InfluxDB configuration incomplete, skipping InfluxLogger cog")

tux/cogs/services/levels.py

@@ -5,7 +5,7 @@
 from discord.ext import commands
 from loguru import logger
 
-from tux.app import get_prefix
+from prisma.models import Levels
 from tux.bot import Tux
 from tux.database.controllers import DatabaseController
 from tux.ui.embeds import EmbedCreator
@@ -33,20 +33,40 @@ async def xp_listener(self, message: discord.Message) -> None:
         message : discord.Message
             The message object.
         """
-        if message.author.bot or message.guild is None or message.channel.id in CONFIG.XP_BLACKLIST_CHANNELS:
+        if message.author.bot or not message.guild or message.channel.id in CONFIG.XP_BLACKLIST_CHANNELS:
             return
 
-        prefixes = await get_prefix(self.bot, message)
-        if any(message.content.startswith(prefix) for prefix in prefixes):
+        # Ignore messages that are commands
+        ctx = await self.bot.get_context(message)
+        if ctx.valid:
             return
 
+        # Fetch member object
         member = message.guild.get_member(message.author.id)
-        if member is None:
+        if not member:
             return
 
-        await self.process_xp_gain(member, message.guild)
+        # Fetch all user level data in one query to minimize DB calls
+        user_level_data = await self.db.levels.get_user_level_data(member.id, message.guild.id)
 
-    async def process_xp_gain(self, member: discord.Member, guild: discord.Guild) -> None:
+        # Check if the user is blacklisted
+        if user_level_data and user_level_data.blacklisted:
+            return
+
+        # Check if the user is on cooldown
+        last_message_time = user_level_data.last_message if user_level_data else None
+        if last_message_time and self.is_on_cooldown(last_message_time):
+            return
+
+        # Process XP gain with the already fetched data
+        await self.process_xp_gain(member, message.guild, user_level_data)
+
+    async def process_xp_gain(
+        self,
+        member: discord.Member,
+        guild: discord.Guild,
+        user_level_data: Levels | None,
+    ) -> None:
         """
         Processes XP gain for a member.
 
@@ -56,17 +76,11 @@ async def process_xp_gain(self, member: discord.Member, guild: discord.Guild) ->
             The member gaining XP.
         guild : discord.Guild
             The guild where the member is gaining XP.
+        user_level_data : Levels | None
+            The existing level data for the user.
         """
-        # Get blacklist status
-        is_blacklisted = await self.db.levels.is_blacklisted(member.id, guild.id)
-        if is_blacklisted:
-            return
-
-        last_message_time = await self.db.levels.get_last_message_time(member.id, guild.id)
-        if last_message_time and self.is_on_cooldown(last_message_time):
-            return
-
-        current_xp, current_level = await self.db.levels.get_xp_and_level(member.id, guild.id)
+        current_xp = user_level_data.xp if user_level_data else 0.0
+        current_level = user_level_data.level if user_level_data else 0
 
         xp_increment = self.calculate_xp_increment(member)
         new_xp = current_xp + xp_increment