Adjust core error handling

Author: Arcensoth

commanderbot/core/commander_bot_base.py

@@ -7,11 +7,11 @@
 from commanderbot.lib.event_data import EventData
 
 EventErrorHandler: TypeAlias = Callable[
-    [Exception, EventData, bool], Coroutine[Any, Any, Any]
+    [Exception, EventData, bool], Coroutine[Any, Any, Optional[bool]]
 ]
 
 CommandErrorHandler: TypeAlias = Callable[
-    [Exception, Context, bool], Coroutine[Any, Any, Any]
+    [Exception, Context, bool], Coroutine[Any, Any, Optional[bool]]
 ]
 
 

commanderbot/core/error_handling.py

@@ -7,6 +7,7 @@
 from discord.ext.commands.errors import (
     BotMissingPermissions,
     CheckFailure,
+    CommandInvokeError,
     CommandNotFound,
     MissingPermissions,
     NoPrivateMessage,
@@ -24,6 +25,12 @@ class ErrorHandling:
     event_error_handlers: List[EventErrorHandler] = field(default_factory=list)
     command_error_handlers: List[CommandErrorHandler] = field(default_factory=list)
 
+    def _get_root_error(self, error: Exception) -> Exception:
+        if isinstance(error, CommandInvokeError):
+            return error.original
+        else:
+            return error
+
     def add_event_error_handler(self, handler: EventErrorHandler):
         self.event_error_handlers.append(handler)
 
@@ -42,48 +49,68 @@ async def reply(
             allowed_mentions=allowed_mentions or AllowedMentions.none(),
         )
 
-    async def on_event_error(self, error: Exception, event_data: EventData):
-        # TODO Can we handle certain types of event errors? #enhance
-        handled = False
+    async def on_event_error(self, ex: Exception, event_data: EventData):
+        # Extract the root error.
+        error = self._get_root_error(ex)
 
-        # Re-raise the error so that it can be printed to the console.
-        try:
-            raise error
-        except:
-            self.log.exception(f"Ignoring exception in event `{event_data.name}`")
+        # Attempt to handle the error ourselves.
+        handled = await self.try_handle_event_error(error, event_data)
 
         # Run the error through our registered event error handlers.
         for handler in self.event_error_handlers:
             try:
-                await handler(error, event_data, handled)
+                if result := await handler(error, event_data, handled):
+                    handled = result
             except:
                 # If something went wrong here, print another exception to the console.
                 self.log.exception("Handler for command errors caused another error:")
 
-    async def on_command_error(self, error: Exception, ctx: Context):
-        # Attempt to handle the error.
-        handled = await self.try_handle_command_error(ctx, error)
-
-        # If it wasn't handled, re-raise so it can be printed to the console, and then
-        # let the user know something went wrong.
+        # If it wasn't handled, re-raise so it can be printed to the console.
         if not handled:
             try:
                 raise error
             except:
                 self.log.exception(
-                    f"Ignoring exception in cog `{ctx.cog}` from command: {ctx.command}"
+                    f"Ignoring unhandled exception in event `{event_data.name}`"
                 )
-            await self.reply(ctx, f"🔥 Something went wrong trying to do that.")
 
-        # Run the error through our registered command error handlers.
+    async def try_handle_event_error(
+        self, error: Exception, event_data: EventData
+    ) -> bool:
+        # TODO Can we handle certain types of event errors? #enhance
+        return False
+
+    async def on_command_error(self, ex: Exception, ctx: Context):
+        # Extract the root error.
+        error = self._get_root_error(ex)
+
+        # Attempt to handle the error ourselves.
+        handled = await self.try_handle_command_error(error, ctx)
+
+        # Pipe the error through our registered command error handlers, regardless of
+        # whether the error was handled. Handlers can decide on their own whether to do
+        # anything with errors that have already been handled.
         for handler in self.command_error_handlers:
             try:
-                await handler(error, ctx, handled)
+                if result := await handler(error, ctx, handled):
+                    handled = result
             except:
                 # If something went wrong here, print another exception to the console.
                 self.log.exception("Handler for command errors caused another error:")
 
-    async def try_handle_command_error(self, ctx: Context, error: Exception) -> bool:
+        # If it wasn't handled, re-raise so it can be printed to the console, and then
+        # let the user know something went wrong.
+        if not handled:
+            try:
+                raise error
+            except:
+                cog_name = ctx.cog.__cog_name__ if ctx.cog else None
+                self.log.exception(
+                    f"Ignoring unhandled exception in cog `{cog_name}` from command: `{ctx.command}`"
+                )
+            await self.reply(ctx, f"🔥 Something went wrong trying to do that.")
+
+    async def try_handle_command_error(self, error: Exception, ctx: Context) -> bool:
         if isinstance(error, CommandNotFound):
             return True
         elif isinstance(error, UserInputError):
@@ -105,4 +132,5 @@ async def try_handle_command_error(self, ctx: Context, error: Exception) -> bool
         elif isinstance(error, ResponsiveException):
             await error.respond(ctx)
             return True
+
         return False