Fix logging

am_bot/bot.py

@@ -45,7 +45,6 @@ async def on_ready(self):
         logger.info("Bot is fully ready!")
 
     async def on_message(self, message):
-        logger.info(f"Message from {message.author}: {message.content}")
         if message.author.id == self.user.id:
             return
         await self.process_commands(message)

am_bot/cogs/greetings.py

@@ -13,15 +13,14 @@ def __init__(self):
 
     @commands.Cog.listener()
     async def on_member_join(self, member):
-        logger.debug(f"Member joined guild: {member}")
+        logger.info(f"New member joined {member.guild.name}: {member}")
         channel = member.guild.system_channel
         if channel is not None:
             await channel.send(f"Welcome {member.mention}!")
 
     @commands.command()
     async def hello(self, ctx, *, member: discord.Member = None):
         """Says Hello"""
-        logger.debug("HELLO")
         member = member or ctx.author
         if self._last_member is None or self._last_member.id != member.id:
             await ctx.send(f"Hello {member.name}.")

am_bot/cogs/invite_response.py

@@ -28,22 +28,19 @@ def _parse_embed_email(self, embed: discord.Embed) -> str | None:
 
     @commands.Cog.listener()
     async def on_message(self, message: discord.Message):
-        logger.debug("Message Received")
+        # Ignore messages from self, wrong channel, or without proper reference
         if message.author.id == self.bot.user.id:
-            logger.debug("Message is from self, ignore.")
             return
         if message.channel.id != INVITE_HELP_TEXT_CHANNEL_ID:
-            logger.debug("Message is not in Invite Help channel, ignore.")
             return
         if (
             message.reference is None
             or message.reference.channel_id != INVITE_HELP_TEXT_CHANNEL_ID
         ):
-            logger.debug("Message reference is invalid. Ignore.")
             return
         if not message.content:
-            logger.debug("No Message Content. Ignoring.")
             return
+
         referenced: discord.Message = (
             message.reference.resolved
             if message.reference.resolved is not None
@@ -60,25 +57,23 @@ async def on_message(self, message: discord.Message):
             embed = referenced.embeds[0]
             email = self._parse_embed_email(embed)
             help_request = embed.description
-            logger.debug(f"Parsed from embed - Email: {email}")
         else:
             # Fallback to legacy plain text format
-            logger.warning(referenced.content)
+            logger.debug(f"Legacy plain text format detected: {referenced.id}")
             email_pattern = re.compile(r"Email: (.*)")
             match = email_pattern.match(referenced.content)
             if match:
                 email = match.group(1)
             help_request = "\n".join(referenced.content.split("\n")[7:])
 
-        if not email:
-            logger.debug("Email not found in referenced message.")
-            return
-
-        if not help_request:
-            logger.debug("Help request not found in referenced message.")
+        if not email or not help_request:
+            logger.debug(
+                f"Could not parse email/help request from message "
+                f"{referenced.id}"
+            )
             return
 
-        logger.debug(f"Email found for referenced message: {email}")
+        logger.info(f"Sending invite help response to {email}")
         body_txt = (
             f"Your Message: {help_request}\n\n"
             f"ARK Modding Discord Staff Response:\n\n"

am_bot/cogs/responses.py

@@ -21,33 +21,26 @@ def __init__(self, bot: discord.ext.commands.Bot):
 
     @commands.Cog.listener()
     async def on_message(self, message: discord.Message):
-        logger.debug("Message Received")
         if message.author.id == self.bot.user.id:
-            logger.debug("Message is from self, ignore.")
             return
         if not message.content:
-            logger.debug("No Message Content. Ignoring.")
             return
-        logger.debug(
-            f"First Char: {message.content[0]}, "
-            f"Remaining Chars: {message.content[1:]}"
-        )
+
         if (
             message.content[0] in COMMANDS
             and message.content[1:] in COMMANDS[message.content[0]]
         ):
-            logger.debug(f"Valid Response Command: {message.content}")
             command = COMMANDS[message.content[0]][message.content[1:]]
-            logger.debug(f"Command: {command}")
             if "duplicate" in command:
                 # Handle duplicate commands,
                 # grab original defined by `duplicate`
                 command = COMMANDS[message.content[0]][command["duplicate"]]
+
+            logger.info(f"Executing response command: {message.content}")
+
             if "embed" in command:
-                logger.debug("Embed Response")
                 await message.channel.send(
                     embed=discord.Embed.from_dict(command["embed"])
                 )
             elif "content" in command:
-                logger.debug("Content Response")
                 await message.channel.send(content=command["content"])

am_bot/cogs/role_assignment.py

@@ -28,99 +28,75 @@ async def on_raw_reaction_add(
     ):
         """Add role"""
         if payload.member.id == self.bot.user.id:
-            logger.debug("Reaction from self. Ignore")
             return
-        logger.debug(f"Reaction ADD Received. Payload: {payload}")
         if payload.emoji.name not in ASSIGNABLE_ROLES:
-            logger.debug("Emoji not in ASSIGNABLE_ROLES. Skipping.")
             return
         emoji = payload.emoji.name
         if (
             "message_id" in ASSIGNABLE_ROLES[emoji]
             and payload.message_id != ASSIGNABLE_ROLES[emoji]["message_id"]
         ):
-            logger.debug("Wrong Channel")
             return
-        # Add Role (no need to check)
-        logger.info(
-            f'Adding {ASSIGNABLE_ROLES[emoji]["name"]} '
-            f"Role to {payload.member}"
-        )
+
+        role_name = ASSIGNABLE_ROLES[emoji]["name"]
+        logger.info(f"Adding {role_name} role to {payload.member}")
         await payload.member.add_roles(
             payload.member.guild.get_role(ASSIGNABLE_ROLES[emoji]["role_id"])
         )
-        if ASSIGNABLE_ROLES[emoji]["name"] in ["Modder", "Mapper"]:
+        if role_name in ["Modder", "Mapper"]:
             server_stats_cog = self.bot.get_cog("ServerStatsCog")
             if server_stats_cog:
                 await server_stats_cog.update_role_counts()
 
     @commands.Cog.listener()
     async def on_raw_reaction_remove(self, payload):
         """Remove role"""
-        logger.debug(f"Reaction REMOVE Received. Payload {payload}")
         if payload.emoji.name not in ASSIGNABLE_ROLES:
-            logger.debug("Emoji not in ASSIGNABLE_ROLES. Skipping.")
             return
         emoji = payload.emoji.name
         if (
             "message_id" in ASSIGNABLE_ROLES[emoji]
             and payload.message_id != ASSIGNABLE_ROLES[emoji]["message_id"]
         ):
-            logger.debug("Wrong Channel")
             return
 
-        # Remove Role
         guild = await self.bot.fetch_guild(payload.guild_id)
         member = await guild.fetch_member(payload.user_id)
-        logger.info(
-            f'Removing {ASSIGNABLE_ROLES[emoji]["name"]} Role from {member}.'
-        )
+        role_name = ASSIGNABLE_ROLES[emoji]["name"]
+        logger.info(f"Removing {role_name} role from {member}")
         await member.remove_roles(
             guild.get_role(ASSIGNABLE_ROLES[emoji]["role_id"])
         )
-        if ASSIGNABLE_ROLES[emoji]["name"] in ["Modder", "Mapper"]:
+        if role_name in ["Modder", "Mapper"]:
             server_stats_cog = self.bot.get_cog("ServerStatsCog")
             if server_stats_cog:
                 await server_stats_cog.update_role_counts()
 
     async def reset_reactions(self):
         await asyncio.sleep(10)
         while True:
-            logger.debug("Resetting reactions for Reaction Roles...")
             cleared_messages = []
+            emoji_count = 0
+
             for emoji, role_details in ASSIGNABLE_ROLES.items():
-                logger.debug(f"Resetting Emoji: {emoji}")
                 channel = self.bot.get_channel(role_details["channel_id"])
                 message = await channel.fetch_message(
                     role_details["message_id"]
                 )
-                # Check if we have already reset reactions
-                # for this message, if not, clear them
                 if role_details["message_id"] not in cleared_messages:
-                    logger.debug(
-                        f'Message ID {role_details["message_id"]} has not '
-                        f"been reset. Resetting..."
-                    )
                     await message.clear_reactions()
                     cleared_messages.append(role_details["message_id"])
-                # Add first reaction with this emoji.
+
                 if "emoji_id" in role_details:
-                    # Custom Emoji
-                    logger.debug(
-                        f"Adding custom Emoji Reaction {emoji} to Message ID "
-                        f'{role_details["message_id"]}'
-                    )
                     await message.add_reaction(
                         self.bot.get_emoji(role_details["emoji_id"])
                     )
                 else:
-                    # Unicode Emoji
-                    logger.debug(
-                        f"Adding Unicode Emoji Reaction {emoji} to Message ID "
-                        f'{role_details["message_id"]}'
-                    )
                     await message.add_reaction(emoji)
-            logger.debug(
-                "Finished Reaction Role Reset. Sleeping 10 minutes..."
+                emoji_count += 1
+
+            logger.info(
+                f"Reaction role reset complete: {emoji_count} reactions on "
+                f"{len(cleared_messages)} messages"
             )
             await asyncio.sleep(600)

am_bot/cogs/server_stats.py

@@ -35,56 +35,42 @@ def cog_load(self) -> None:
         self.bot.loop.create_task(self.update_server_stats())
 
     async def update_member_count(self):
-        logger.debug("Updating Member Count...")
         self.guild = self.guild or self.bot.get_guild(GUILD_ID)
-        logger.debug(f"Guild: {self.guild}")
         channel = await self.bot.fetch_channel(MEMBERS_COUNT_CHANNEL_ID)
-        logger.debug(f"Member Count Channel: {channel}")
         member_count = len(self.guild.members)
-        logger.debug(f"Member Count: {member_count}")
         await channel.edit(name=f"🔹┇{member_count}︲members")
-        logger.debug("Member Count Channel Updated!")
+        logger.info(f"Updated member count: {member_count}")
 
     async def update_boost_count(self):
-        logger.debug("Updating Boost Count...")
         self.guild = self.guild or self.bot.get_guild(GUILD_ID)
-        logger.debug(f"Guild: {self.guild}")
         channel = await self.bot.fetch_channel(BOOSTS_COUNT_CHANNEL_ID)
-        logger.debug(f"Boost Count Channel: {channel}")
-        logger.debug(f"Boost Count: {self.guild.premium_subscription_count}")
-        await channel.edit(
-            name=f"🔸┇{self.guild.premium_subscription_count}︲boosts"
-        )
-        logger.debug("Boost Count Channel Updated!")
+        boost_count = self.guild.premium_subscription_count
+        await channel.edit(name=f"🔸┇{boost_count}︲boosts")
+        logger.debug(f"Updated boost count: {boost_count}")
 
     async def update_role_counts(self):
-        logger.debug("Updating Role Counts...")
         self.guild = self.guild or self.bot.get_guild(GUILD_ID)
-        logger.debug(f"Guild: {self.guild}")
+
         modder_channel = await self.bot.fetch_channel(MODDER_STATS_CHANNEL_ID)
-        logger.debug(f"Modder Count Channel: {modder_channel}")
         modder_role = self.guild.get_role(MODDER_ROLE_ID)
-        logger.debug(f"Modder Role: {modder_role}")
-        modder_member_count = len(modder_role.members)
-        logger.debug(f"Modder Member Count: {modder_member_count}")
-        await modder_channel.edit(name=f"🔸┇{modder_member_count}︲modders")
-        logger.debug("Modder Count Channel Updated!")
+        modder_count = len(modder_role.members)
+        await modder_channel.edit(name=f"🔸┇{modder_count}︲modders")
 
         mapper_channel = await self.bot.fetch_channel(MAPPER_STATS_CHANNEL_ID)
-        logger.debug("Getting Mapper Role...")
         mapper_role = self.guild.get_role(MAPPER_ROLE_ID)
-        logger.debug(f"Mapper Role: {mapper_role}")
-        mapper_member_count = len(mapper_role.members)
-        logger.debug(f"Mapper Member Count: {mapper_member_count}")
-        await mapper_channel.edit(name=f"🔹┇{mapper_member_count}︲mappers")
-        logger.debug("Mapper Count Channel Updated!")
+        mapper_count = len(mapper_role.members)
+        await mapper_channel.edit(name=f"🔹┇{mapper_count}︲mappers")
+
+        logger.info(
+            f"Updated role counts: {modder_count} modders, "
+            f"{mapper_count} mappers"
+        )
 
     async def update_server_stats(self):
         await asyncio.sleep(60)
-        logger.debug("Updating Server Stats...")
         await self.update_member_count()
         await self.update_role_counts()
+        logger.info("Initial server stats update complete")
         while True:
             await self.update_boost_count()
-            logger.debug("Server Stats updated! Sleeping 10 minutes...")
             await asyncio.sleep(600)