Improve exception handling to avoid broad exception catching

empty_voices/api.py

@@ -71,10 +71,14 @@ async def try_delete_channel(self, guild: discord.Guild, channel: discord.VoiceC
                 if channel.id in temp_channels:
                     temp_channels.remove(channel.id)
                     await guild_group.emptyvoices.temp_channels.set(temp_channels)
+            except (KeyError, ValueError) as e:
+                log.error(f"Configuration error cleaning up deleted channel: {e}", exc_info=True)
             except Exception as e:
-                log.error(f"Error cleaning up deleted channel from config: {e}")
+                log.exception(f"Unexpected error cleaning up deleted channel from config: {e}")
+        except discord.HTTPException as e:
+            log.error(f"HTTP error deleting channel {channel.name}: {e}", exc_info=True)
         except Exception as e:
-            log.error(f"Unexpected error deleting channel {channel.name}: {e}")
+            log.exception(f"Unexpected error deleting channel {channel.name}: {e}")
 
     async def validate_category(self, guild: discord.Guild, category: discord.CategoryChannel):
         """
@@ -124,8 +128,11 @@ async def validate_category(self, guild: discord.Guild, category: discord.Catego
         except discord.Forbidden:
             log.error(f"Missing permissions to fetch category {category.name}")
             return
+        except discord.HTTPException as e:
+            log.error(f"HTTP error refreshing category {category.name}: {e}", exc_info=True)
+            return
         except Exception as e:
-            log.error(f"Error refreshing category {category.name}: {e}")
+            log.exception(f"Unexpected error refreshing category {category.name}: {e}")
             return
 
         # Check how many temp channels we currently have in this category
@@ -198,8 +205,18 @@ async def validate_category(self, guild: discord.Guild, category: discord.Catego
                 except discord.Forbidden:
                     log.error(f"Missing permissions to create voice channel in category {category.name}")
                     break
+                except discord.HTTPException as e:
+                    log.error(
+                        f"HTTP error creating voice channel '{channel_name}' "
+                        f"in category {category.name}: {e}",
+                        exc_info=True
+                    )
+                    break
                 except Exception as e:
-                    log.error(f"Error creating voice channel '{channel_name}' in category {category.name}: {e}")
+                    log.exception(
+                        f"Unexpected error creating voice channel '{channel_name}' "
+                        f"in category {category.name}: {e}"
+                    )
                     break
 
             if created_count > 0:
@@ -236,9 +253,9 @@ async def try_rename_channel(self, guild, channel: discord.VoiceChannel, member)
         except discord.Forbidden:
             log.error(f"Missing permissions to rename channel {channel.name} in guild {guild.name}")
         except discord.HTTPException as e:
-            log.error(f"HTTP error renaming channel {channel.name}: {e}")
+            log.error(f"HTTP error renaming channel {channel.name}: {e}", exc_info=True)
         except Exception as e:
-            log.error(f"Unexpected error renaming channel {channel.name}: {e}")
+            log.exception(f"Unexpected error renaming channel {channel.name}: {e}")
 
     @commands.Cog.listener()
     async def on_voice_state_update(self, member, before, after):

hat/hat.py

@@ -110,22 +110,27 @@ async def _cleanup_previous_preview(self, ctx):
                 if old_msg:
                     await old_msg.delete()
             except (discord.NotFound, discord.Forbidden):
-                pass
-            except Exception:
-                pass
-            del self._preview_messages[key]
+                pass  # Expected: message was already deleted or we lack permissions
+            except discord.HTTPException as e:
+                log.error(f"HTTP error deleting previous preview message: {e}", exc_info=True)
+            except Exception as e:
+                log.exception(f"Unexpected error deleting previous preview message: {e}")
+            finally:
+                del self._preview_messages[key]
 
     async def _schedule_message_cleanup(self, message: discord.Message, delay: int = CLEANUP_DELAY):
         """Schedule a message to be deleted after a delay."""
         try:
             await asyncio.sleep(delay)
             await message.delete()
         except asyncio.CancelledError:
-            pass  # Task was cancelled during cog unload
+            pass  # Task was cancelled during cog unload - expected
         except (discord.NotFound, discord.Forbidden):
-            pass
-        except Exception:
-            pass
+            pass  # Expected: message was already deleted or we lack permissions
+        except discord.HTTPException as e:
+            log.error(f"HTTP error during scheduled message cleanup: {e}", exc_info=True)
+        except Exception as e:
+            log.exception(f"Unexpected error during scheduled message cleanup: {e}")
 
     def _create_cleanup_task(self, message: discord.Message, delay: int = CLEANUP_DELAY):
         """Create a tracked cleanup task for a message."""
@@ -209,7 +214,11 @@ async def _get_avatar_bytes(self, user: discord.User) -> Optional[bytes]:
         avatar = user.display_avatar
         try:
             return await avatar.read()
-        except Exception:
+        except discord.HTTPException as e:
+            log.error(f"HTTP error fetching avatar for {user}: {e}", exc_info=True)
+            return None
+        except Exception as e:
+            log.exception(f"Unexpected error fetching avatar for {user}: {e}")
             return None
 
     async def _send_live_preview(self, ctx, error_msg: Optional[str] = None):

nw_server_status/server_status.py

@@ -43,8 +43,12 @@ async def refresh_queue_data(self):
         try:
             self.queue_data = await self.get_queue_data(worldId=None)
             await self.update_monitor_channels()
-        except Exception:
-            logger.exception("Error in task")
+        except httpx.HTTPError as e:
+            logger.error(f"HTTP error in background task: {e}", exc_info=True)
+        except httpx.TimeoutException as e:
+            logger.error(f"Timeout in background task: {e}", exc_info=True)
+        except Exception as e:
+            logger.exception(f"Unexpected error in background task: {e}")
         logger.info("Finished queue task")
 
     async def get_queue_data(self, worldId=ishtakar_world_id):
@@ -62,8 +66,14 @@ async def get_queue_data(self, worldId=ishtakar_world_id):
                 self.parse_server(server).get("worldName"): self.parse_server(server)
                 for server in servers
             }
-        except Exception:
-            logger.exception("Exception while downloading new data")
+        except httpx.HTTPError as e:
+            logger.error(f"HTTP error downloading server data: {e}", exc_info=True)
+        except httpx.TimeoutException as e:
+            logger.error(f"Timeout downloading server data: {e}", exc_info=True)
+        except (KeyError, ValueError) as e:
+            logger.error(f"Data parsing error: {e}", exc_info=True)
+        except Exception as e:
+            logger.exception(f"Unexpected error downloading server data: {e}")
 
     def parse_server(self, server):
         (
@@ -254,7 +264,11 @@ async def http_get(url):
             else:
                 attempt += 1
             await asyncio.sleep(5)
-        except (httpx._exceptions.ConnectTimeout, httpx._exceptions.HTTPError):
+        except httpx.TimeoutException as e:
+            logger.warning(f"Timeout on attempt {attempt + 1}/{max_attempts}: {e}")
+            attempt += 1
+            await asyncio.sleep(5)
+        except httpx.HTTPError as e:
+            logger.warning(f"HTTP error on attempt {attempt + 1}/{max_attempts}: {e}")
             attempt += 1
             await asyncio.sleep(5)
-            pass