Merge main and resolve conflicts.

25 files changed, 1235 insertions, 72 deletions

diff --git a/bot/constants.py b/bot/constants.py
index d14355a38..e1c3ade5a 100644
--- a/bot/constants.py
+++ b/bot/constants.py
@@ -175,13 +175,14 @@ class YAMLGetter(type):
             if cls.subsection is not None:
                 return _CONFIG_YAML[cls.section][cls.subsection][name]
             return _CONFIG_YAML[cls.section][name]
-        except KeyError:
+        except KeyError as e:
             dotted_path = '.'.join(
                 (cls.section, cls.subsection, name)
                 if cls.subsection is not None else (cls.section, name)
             )
-            log.critical(f"Tried accessing configuration variable at `{dotted_path}`, but it could not be found.")
-            raise
+            # Only an INFO log since this can be caught through `hasattr` or `getattr`.
+            log.info(f"Tried accessing configuration variable at `{dotted_path}`, but it could not be found.")
+            raise AttributeError(repr(name)) from e
 
     def __getitem__(cls, name):
         return cls.__getattr__(name)
@@ -199,6 +200,7 @@ class Bot(metaclass=YAMLGetter):
     prefix: str
     sentry_dsn: Optional[str]
     token: str
+    trace_loggers: Optional[str]
 
 
 class Redis(metaclass=YAMLGetter):
@@ -279,6 +281,8 @@ class Emojis(metaclass=YAMLGetter):
     badge_partner: str
     badge_staff: str
     badge_verified_bot_developer: str
+    verified_bot: str
+    bot: str
 
     defcon_shutdown: str  # noqa: E704
     defcon_unshutdown: str  # noqa: E704
@@ -486,6 +490,7 @@ class Roles(metaclass=YAMLGetter):
     domain_leads: int
     helpers: int
     moderators: int
+    mod_team: int
     owners: int
     project_leads: int
 
diff --git a/bot/decorators.py b/bot/decorators.py
index e971a5bd3..f65ec4103 100644
--- a/bot/decorators.py
+++ b/bot/decorators.py
@@ -107,11 +107,19 @@ def has_no_roles(*roles: t.Union[str, int]) -> t.Callable:
     return commands.check(predicate)
 
 
-def redirect_output(destination_channel: int, bypass_roles: t.Container[int] = None) -> t.Callable:
+def redirect_output(
+    destination_channel: int,
+    bypass_roles: t.Optional[t.Container[int]] = None,
+    channels: t.Optional[t.Container[int]] = None,
+    categories: t.Optional[t.Container[int]] = None,
+    ping_user: bool = True
+) -> t.Callable:
     """
     Changes the channel in the context of the command to redirect the output to a certain channel.
 
-    Redirect is bypassed if the author has a role to bypass redirection.
+    Redirect is bypassed if the author has a bypass role or if it is in a channel that can bypass redirection.
+
+    If ping_user is False, it will not send a message in the destination channel.
 
     This decorator must go before (below) the `command` decorator.
     """
@@ -119,7 +127,7 @@ def redirect_output(destination_channel: int, bypass_roles: t.Container[int] = N
         @command_wraps(func)
         async def inner(self: Cog, ctx: Context, *args, **kwargs) -> None:
             if ctx.channel.id == destination_channel:
-                log.trace(f"Command {ctx.command.name} was invoked in destination_channel, not redirecting")
+                log.trace(f"Command {ctx.command} was invoked in destination_channel, not redirecting")
                 await func(self, ctx, *args, **kwargs)
                 return
 
@@ -128,12 +136,24 @@ def redirect_output(destination_channel: int, bypass_roles: t.Container[int] = N
                 await func(self, ctx, *args, **kwargs)
                 return
 
+            elif channels and ctx.channel.id not in channels:
+                log.trace(f"{ctx.author} used {ctx.command} in a channel that can bypass output redirection")
+                await func(self, ctx, *args, **kwargs)
+                return
+
+            elif categories and ctx.channel.category.id not in categories:
+                log.trace(f"{ctx.author} used {ctx.command} in a category that can bypass output redirection")
+                await func(self, ctx, *args, **kwargs)
+                return
+
             redirect_channel = ctx.guild.get_channel(destination_channel)
             old_channel = ctx.channel
 
             log.trace(f"Redirecting output of {ctx.author}'s command '{ctx.command.name}' to {redirect_channel.name}")
             ctx.channel = redirect_channel
-            await ctx.channel.send(f"Here's the output of your command, {ctx.author.mention}")
+
+            if ping_user:
+                await ctx.send(f"Here's the output of your command, {ctx.author.mention}")
             asyncio.create_task(func(self, ctx, *args, **kwargs))
 
             message = await old_channel.send(
diff --git a/bot/exts/backend/error_handler.py b/bot/exts/backend/error_handler.py
index da0e94a7e..d8de177f5 100644
--- a/bot/exts/backend/error_handler.py
+++ b/bot/exts/backend/error_handler.py
@@ -1,4 +1,3 @@
-import contextlib
 import difflib
 import logging
 import typing as t
@@ -60,7 +59,7 @@ class ErrorHandler(Cog):
             log.trace(f"Command {command} had its error already handled locally; ignoring.")
             return
 
-        if isinstance(e, errors.CommandNotFound) and not hasattr(ctx, "invoked_from_error_handler"):
+        if isinstance(e, errors.CommandNotFound) and not getattr(ctx, "invoked_from_error_handler", False):
             if await self.try_silence(ctx):
                 return
             # Try to look for a tag with the command's name
@@ -162,9 +161,8 @@ class ErrorHandler(Cog):
                 f"and the fallback tag failed validation in TagNameConverter."
             )
         else:
-            with contextlib.suppress(ResponseCodeError):
-                if await ctx.invoke(tags_get_command, tag_name=tag_name):
-                    return
+            if await ctx.invoke(tags_get_command, tag_name=tag_name):
+                return
 
         if not any(role.id in MODERATION_ROLES for role in ctx.author.roles):
             await self.send_command_suggestion(ctx, ctx.invoked_with)
@@ -214,32 +212,30 @@ class ErrorHandler(Cog):
         * ArgumentParsingError: send an error message
         * Other: send an error message and the help command
         """
-        prepared_help_command = self.get_help_command(ctx)
-
         if isinstance(e, errors.MissingRequiredArgument):
             embed = self._get_error_embed("Missing required argument", e.param.name)
             await ctx.send(embed=embed)
-            await prepared_help_command
+            await self.get_help_command(ctx)
             self.bot.stats.incr("errors.missing_required_argument")
         elif isinstance(e, errors.TooManyArguments):
             embed = self._get_error_embed("Too many arguments", str(e))
             await ctx.send(embed=embed)
-            await prepared_help_command
+            await self.get_help_command(ctx)
             self.bot.stats.incr("errors.too_many_arguments")
         elif isinstance(e, errors.BadArgument):
             embed = self._get_error_embed("Bad argument", str(e))
             await ctx.send(embed=embed)
-            await prepared_help_command
+            await self.get_help_command(ctx)
             self.bot.stats.incr("errors.bad_argument")
         elif isinstance(e, errors.BadUnionArgument):
             embed = self._get_error_embed("Bad argument", f"{e}\n{e.errors[-1]}")
             await ctx.send(embed=embed)
-            await prepared_help_command
+            await self.get_help_command(ctx)
             self.bot.stats.incr("errors.bad_union_argument")
         elif isinstance(e, errors.ArgumentParsingError):
             embed = self._get_error_embed("Argument parsing error", str(e))
             await ctx.send(embed=embed)
-            prepared_help_command.close()
+            self.get_help_command(ctx).close()
             self.bot.stats.incr("errors.argument_parsing_error")
         else:
             embed = self._get_error_embed(
@@ -247,7 +243,7 @@ class ErrorHandler(Cog):
                 "Something about your input seems off. Check the arguments and try again."
             )
             await ctx.send(embed=embed)
-            await prepared_help_command
+            await self.get_help_command(ctx)
             self.bot.stats.incr("errors.other_user_input_error")
 
     @staticmethod
diff --git a/bot/exts/info/code_snippets.py b/bot/exts/info/code_snippets.py
new file mode 100644
index 000000000..06885410b
--- /dev/null
+++ b/bot/exts/info/code_snippets.py
@@ -0,0 +1,265 @@
+import logging
+import re
+import textwrap
+from typing import Any
+from urllib.parse import quote_plus
+
+from aiohttp import ClientResponseError
+from discord import Message
+from discord.ext.commands import Cog
+
+from bot.bot import Bot
+from bot.constants import Channels
+from bot.utils.messages import wait_for_deletion
+
+log = logging.getLogger(__name__)
+
+GITHUB_RE = re.compile(
+    r'https://github\.com/(?P<repo>[a-zA-Z0-9-]+/[\w.-]+)/blob/'
+    r'(?P<path>[^#>]+)(\?[^#>]+)?(#L(?P<start_line>\d+)([-~:]L(?P<end_line>\d+))?)'
+)
+
+GITHUB_GIST_RE = re.compile(
+    r'https://gist\.github\.com/([a-zA-Z0-9-]+)/(?P<gist_id>[a-zA-Z0-9]+)/*'
+    r'(?P<revision>[a-zA-Z0-9]*)/*#file-(?P<file_path>[^#>]+?)(\?[^#>]+)?'
+    r'(-L(?P<start_line>\d+)([-~:]L(?P<end_line>\d+))?)'
+)
+
+GITHUB_HEADERS = {'Accept': 'application/vnd.github.v3.raw'}
+
+GITLAB_RE = re.compile(
+    r'https://gitlab\.com/(?P<repo>[\w.-]+/[\w.-]+)/\-/blob/(?P<path>[^#>]+)'
+    r'(\?[^#>]+)?(#L(?P<start_line>\d+)(-(?P<end_line>\d+))?)'
+)
+
+BITBUCKET_RE = re.compile(
+    r'https://bitbucket\.org/(?P<repo>[a-zA-Z0-9-]+/[\w.-]+)/src/(?P<ref>[0-9a-zA-Z]+)'
+    r'/(?P<file_path>[^#>]+)(\?[^#>]+)?(#lines-(?P<start_line>\d+)(:(?P<end_line>\d+))?)'
+)
+
+
+class CodeSnippets(Cog):
+    """
+    Cog that parses and sends code snippets to Discord.
+
+    Matches each message against a regex and prints the contents of all matched snippets.
+    """
+
+    async def _fetch_response(self, url: str, response_format: str, **kwargs) -> Any:
+        """Makes http requests using aiohttp."""
+        async with self.bot.http_session.get(url, raise_for_status=True, **kwargs) as response:
+            if response_format == 'text':
+                return await response.text()
+            elif response_format == 'json':
+                return await response.json()
+
+    def _find_ref(self, path: str, refs: tuple) -> tuple:
+        """Loops through all branches and tags to find the required ref."""
+        # Base case: there is no slash in the branch name
+        ref, file_path = path.split('/', 1)
+        # In case there are slashes in the branch name, we loop through all branches and tags
+        for possible_ref in refs:
+            if path.startswith(possible_ref['name'] + '/'):
+                ref = possible_ref['name']
+                file_path = path[len(ref) + 1:]
+                break
+        return ref, file_path
+
+    async def _fetch_github_snippet(
+        self,
+        repo: str,
+        path: str,
+        start_line: str,
+        end_line: str
+    ) -> str:
+        """Fetches a snippet from a GitHub repo."""
+        # Search the GitHub API for the specified branch
+        branches = await self._fetch_response(
+            f'https://api.github.com/repos/{repo}/branches',
+            'json',
+            headers=GITHUB_HEADERS
+        )
+        tags = await self._fetch_response(f'https://api.github.com/repos/{repo}/tags', 'json', headers=GITHUB_HEADERS)
+        refs = branches + tags
+        ref, file_path = self._find_ref(path, refs)
+
+        file_contents = await self._fetch_response(
+            f'https://api.github.com/repos/{repo}/contents/{file_path}?ref={ref}',
+            'text',
+            headers=GITHUB_HEADERS,
+        )
+        return self._snippet_to_codeblock(file_contents, file_path, start_line, end_line)
+
+    async def _fetch_github_gist_snippet(
+        self,
+        gist_id: str,
+        revision: str,
+        file_path: str,
+        start_line: str,
+        end_line: str
+    ) -> str:
+        """Fetches a snippet from a GitHub gist."""
+        gist_json = await self._fetch_response(
+            f'https://api.github.com/gists/{gist_id}{f"/{revision}" if len(revision) > 0 else ""}',
+            'json',
+            headers=GITHUB_HEADERS,
+        )
+
+        # Check each file in the gist for the specified file
+        for gist_file in gist_json['files']:
+            if file_path == gist_file.lower().replace('.', '-'):
+                file_contents = await self._fetch_response(
+                    gist_json['files'][gist_file]['raw_url'],
+                    'text',
+                )
+                return self._snippet_to_codeblock(file_contents, gist_file, start_line, end_line)
+        return ''
+
+    async def _fetch_gitlab_snippet(
+        self,
+        repo: str,
+        path: str,
+        start_line: str,
+        end_line: str
+    ) -> str:
+        """Fetches a snippet from a GitLab repo."""
+        enc_repo = quote_plus(repo)
+
+        # Searches the GitLab API for the specified branch
+        branches = await self._fetch_response(
+            f'https://gitlab.com/api/v4/projects/{enc_repo}/repository/branches',
+            'json'
+        )
+        tags = await self._fetch_response(f'https://gitlab.com/api/v4/projects/{enc_repo}/repository/tags', 'json')
+        refs = branches + tags
+        ref, file_path = self._find_ref(path, refs)
+        enc_ref = quote_plus(ref)
+        enc_file_path = quote_plus(file_path)
+
+        file_contents = await self._fetch_response(
+            f'https://gitlab.com/api/v4/projects/{enc_repo}/repository/files/{enc_file_path}/raw?ref={enc_ref}',
+            'text',
+        )
+        return self._snippet_to_codeblock(file_contents, file_path, start_line, end_line)
+
+    async def _fetch_bitbucket_snippet(
+        self,
+        repo: str,
+        ref: str,
+        file_path: str,
+        start_line: str,
+        end_line: str
+    ) -> str:
+        """Fetches a snippet from a BitBucket repo."""
+        file_contents = await self._fetch_response(
+            f'https://bitbucket.org/{quote_plus(repo)}/raw/{quote_plus(ref)}/{quote_plus(file_path)}',
+            'text',
+        )
+        return self._snippet_to_codeblock(file_contents, file_path, start_line, end_line)
+
+    def _snippet_to_codeblock(self, file_contents: str, file_path: str, start_line: str, end_line: str) -> str:
+        """
+        Given the entire file contents and target lines, creates a code block.
+
+        First, we split the file contents into a list of lines and then keep and join only the required
+        ones together.
+
+        We then dedent the lines to look nice, and replace all ` characters with `\u200b to prevent
+        markdown injection.
+
+        Finally, we surround the code with ``` characters.
+        """
+        # Parse start_line and end_line into integers
+        if end_line is None:
+            start_line = end_line = int(start_line)
+        else:
+            start_line = int(start_line)
+            end_line = int(end_line)
+
+        split_file_contents = file_contents.splitlines()
+
+        # Make sure that the specified lines are in range
+        if start_line > end_line:
+            start_line, end_line = end_line, start_line
+        if start_line > len(split_file_contents) or end_line < 1:
+            return ''
+        start_line = max(1, start_line)
+        end_line = min(len(split_file_contents), end_line)
+
+        # Gets the code lines, dedents them, and inserts zero-width spaces to prevent Markdown injection
+        required = '\n'.join(split_file_contents[start_line - 1:end_line])
+        required = textwrap.dedent(required).rstrip().replace('`', '`\u200b')
+
+        # Extracts the code language and checks whether it's a "valid" language
+        language = file_path.split('/')[-1].split('.')[-1]
+        trimmed_language = language.replace('-', '').replace('+', '').replace('_', '')
+        is_valid_language = trimmed_language.isalnum()
+        if not is_valid_language:
+            language = ''
+
+        # Adds a label showing the file path to the snippet
+        if start_line == end_line:
+            ret = f'`{file_path}` line {start_line}\n'
+        else:
+            ret = f'`{file_path}` lines {start_line} to {end_line}\n'
+
+        if len(required) != 0:
+            return f'{ret}```{language}\n{required}```'
+        # Returns an empty codeblock if the snippet is empty
+        return f'{ret}``` ```'
+
+    def __init__(self, bot: Bot):
+        """Initializes the cog's bot."""
+        self.bot = bot
+
+        self.pattern_handlers = [
+            (GITHUB_RE, self._fetch_github_snippet),
+            (GITHUB_GIST_RE, self._fetch_github_gist_snippet),
+            (GITLAB_RE, self._fetch_gitlab_snippet),
+            (BITBUCKET_RE, self._fetch_bitbucket_snippet)
+        ]
+
+    @Cog.listener()
+    async def on_message(self, message: Message) -> None:
+        """Checks if the message has a snippet link, removes the embed, then sends the snippet contents."""
+        if not message.author.bot:
+            all_snippets = []
+
+            for pattern, handler in self.pattern_handlers:
+                for match in pattern.finditer(message.content):
+                    try:
+                        snippet = await handler(**match.groupdict())
+                        all_snippets.append((match.start(), snippet))
+                    except ClientResponseError as error:
+                        error_message = error.message  # noqa: B306
+                        log.log(
+                            logging.DEBUG if error.status == 404 else logging.ERROR,
+                            f'Failed to fetch code snippet from {match[0]!r}: {error.status} '
+                            f'{error_message} for GET {error.request_info.real_url.human_repr()}'
+                        )
+
+            # Sorts the list of snippets by their match index and joins them into a single message
+            message_to_send = '\n'.join(map(lambda x: x[1], sorted(all_snippets)))
+
+            if 0 < len(message_to_send) <= 2000 and message_to_send.count('\n') <= 15:
+                await message.edit(suppress=True)
+                if len(message_to_send) > 1000 and message.channel.id != Channels.bot_commands:
+                    # Redirects to #bot-commands if the snippet contents are too long
+                    await self.bot.wait_until_guild_available()
+                    await message.channel.send(('The snippet you tried to send was too long. Please '
+                                                f'see <#{Channels.bot_commands}> for the full snippet.'))
+                    bot_commands_channel = self.bot.get_channel(Channels.bot_commands)
+                    await wait_for_deletion(
+                        await bot_commands_channel.send(message_to_send),
+                        (message.author.id,)
+                    )
+                else:
+                    await wait_for_deletion(
+                        await message.channel.send(message_to_send),
+                        (message.author.id,)
+                    )
+
+
+def setup(bot: Bot) -> None:
+    """Load the CodeSnippets cog."""
+    bot.add_cog(CodeSnippets(bot))
diff --git a/bot/exts/info/information.py b/bot/exts/info/information.py
index 5e2c4b417..834fee1b4 100644
--- a/bot/exts/info/information.py
+++ b/bot/exts/info/information.py
@@ -230,6 +230,11 @@ class Information(Cog):
         if on_server and user.nick:
             name = f"{user.nick} ({name})"
 
+        if user.public_flags.verified_bot:
+            name += f" {constants.Emojis.verified_bot}"
+        elif user.bot:
+            name += f" {constants.Emojis.bot}"
+
         badges = []
 
         for badge, is_set in user.public_flags:
diff --git a/bot/exts/moderation/infraction/infractions.py b/bot/exts/moderation/infraction/infractions.py
index d89e80acc..f19323c7c 100644
--- a/bot/exts/moderation/infraction/infractions.py
+++ b/bot/exts/moderation/infraction/infractions.py
@@ -54,8 +54,12 @@ class Infractions(InfractionScheduler, commands.Cog):
     # region: Permanent infractions
 
     @command()
-    async def warn(self, ctx: Context, user: Member, *, reason: t.Optional[str] = None) -> None:
+    async def warn(self, ctx: Context, user: FetchedMember, *, reason: t.Optional[str] = None) -> None:
         """Warn a user for the given reason."""
+        if not isinstance(user, Member):
+            await ctx.send(":x: The user doesn't appear to be on the server.")
+            return
+
         infraction = await _utils.post_infraction(ctx, user, "warning", reason, active=False)
         if infraction is None:
             return
@@ -63,36 +67,61 @@ class Infractions(InfractionScheduler, commands.Cog):
         await self.apply_infraction(ctx, infraction, user)
 
     @command()
-    async def kick(self, ctx: Context, user: Member, *, reason: t.Optional[str] = None) -> None:
+    async def kick(self, ctx: Context, user: FetchedMember, *, reason: t.Optional[str] = None) -> None:
         """Kick a user for the given reason."""
+        if not isinstance(user, Member):
+            await ctx.send(":x: The user doesn't appear to be on the server.")
+            return
+
         await self.apply_kick(ctx, user, reason)
 
     @command()
-    async def ban(self, ctx: Context, user: FetchedMember, *, reason: t.Optional[str] = None) -> None:
-        """Permanently ban a user for the given reason and stop watching them with Big Brother."""
-        await self.apply_ban(ctx, user, reason)
+    async def ban(
+        self,
+        ctx: Context,
+        user: FetchedMember,
+        duration: t.Optional[Expiry] = None,
+        *,
+        reason: t.Optional[str] = None
+    ) -> None:
+        """
+        Permanently ban a user for the given reason and stop watching them with Big Brother.
+
+        If duration is specified, it temporarily bans that user for the given duration.
+        """
+        await self.apply_ban(ctx, user, reason, expires_at=duration)
 
     @command(aliases=('pban',))
     async def purgeban(
         self,
         ctx: Context,
         user: FetchedMember,
-        purge_days: t.Optional[int] = 1,
+        duration: t.Optional[Expiry] = None,
         *,
         reason: t.Optional[str] = None
     ) -> None:
         """
-        Same as ban but removes all their messages for the given number of days, default being 1.
+        Same as ban but removes all their messages of the last 24 hours.
 
-        `purge_days` can only be values between 0 and 7.
-        Anything outside these bounds are automatically adjusted to their respective limits.
+        If duration is specified, it temporarily bans that user for the given duration.
         """
-        await self.apply_ban(ctx, user, reason, max(min(purge_days, 7), 0))
+        await self.apply_ban(ctx, user, reason, 1, expires_at=duration)
 
     @command(aliases=('vban',))
-    async def voiceban(self, ctx: Context, user: FetchedMember, *, reason: t.Optional[str]) -> None:
-        """Permanently ban user from using voice channels."""
-        await self.apply_voice_ban(ctx, user, reason)
+    async def voiceban(
+        self,
+        ctx: Context,
+        user: FetchedMember,
+        duration: t.Optional[Expiry] = None,
+        *,
+        reason: t.Optional[str]
+    ) -> None:
+        """
+        Permanently ban user from using voice channels.
+
+        If duration is specified, it temporarily voice bans that user for the given duration.
+        """
+        await self.apply_voice_ban(ctx, user, reason, expires_at=duration)
 
     # endregion
     # region: Temporary infractions
@@ -100,7 +129,7 @@ class Infractions(InfractionScheduler, commands.Cog):
     @command(aliases=["mute"])
     async def tempmute(
         self, ctx: Context,
-        user: Member,
+        user: FetchedMember,
         duration: t.Optional[Expiry] = None,
         *,
         reason: t.Optional[str] = None
@@ -122,6 +151,10 @@ class Infractions(InfractionScheduler, commands.Cog):
 
         If no duration is given, a one hour duration is used by default.
         """
+        if not isinstance(user, Member):
+            await ctx.send(":x: The user doesn't appear to be on the server.")
+            return
+
         if duration is None:
             duration = await Duration().convert(ctx, "1h")
         await self.apply_mute(ctx, user, reason, expires_at=duration)
diff --git a/bot/exts/moderation/modlog.py b/bot/exts/moderation/modlog.py
index 2dae9d268..be65ade6e 100644
--- a/bot/exts/moderation/modlog.py
+++ b/bot/exts/moderation/modlog.py
@@ -12,9 +12,10 @@ from deepdiff import DeepDiff
 from discord import Colour
 from discord.abc import GuildChannel
 from discord.ext.commands import Cog, Context
+from discord.utils import escape_markdown
 
 from bot.bot import Bot
-from bot.constants import Categories, Channels, Colours, Emojis, Event, Guild as GuildConstant, Icons, URLs
+from bot.constants import Categories, Channels, Colours, Emojis, Event, Guild as GuildConstant, Icons, Roles, URLs
 from bot.utils.messages import format_user
 from bot.utils.time import humanize_delta
 
@@ -115,9 +116,9 @@ class ModLog(Cog, name="ModLog"):
 
         if ping_everyone:
             if content:
-                content = f"@everyone\n{content}"
+                content = f"<@&{Roles.moderators}>\n{content}"
             else:
-                content = "@everyone"
+                content = f"<@&{Roles.moderators}>"
 
         # Truncate content to 2000 characters and append an ellipsis.
         if content and len(content) > 2000:
@@ -127,8 +128,7 @@ class ModLog(Cog, name="ModLog"):
         log_message = await channel.send(
             content=content,
             embed=embed,
-            files=files,
-            allowed_mentions=discord.AllowedMentions(everyone=True)
+            files=files
         )
 
         if additional_embeds:
@@ -641,9 +641,10 @@ class ModLog(Cog, name="ModLog"):
         channel = msg_before.channel
         channel_name = f"{channel.category}/#{channel.name}" if channel.category else f"#{channel.name}"
 
+        cleaned_contents = (escape_markdown(msg.clean_content).split() for msg in (msg_before, msg_after))
         # Getting the difference per words and group them by type - add, remove, same
         # Note that this is intended grouping without sorting
-        diff = difflib.ndiff(msg_before.clean_content.split(), msg_after.clean_content.split())
+        diff = difflib.ndiff(*cleaned_contents)
         diff_groups = tuple(
             (diff_type, tuple(s[2:] for s in diff_words))
             for diff_type, diff_words in itertools.groupby(diff, key=lambda s: s[0])
diff --git a/bot/exts/moderation/modpings.py b/bot/exts/moderation/modpings.py
new file mode 100644
index 000000000..1ad5005de
--- /dev/null
+++ b/bot/exts/moderation/modpings.py
@@ -0,0 +1,138 @@
+import datetime
+import logging
+
+from async_rediscache import RedisCache
+from dateutil.parser import isoparse
+from discord import Embed, Member
+from discord.ext.commands import Cog, Context, group, has_any_role
+
+from bot.bot import Bot
+from bot.constants import Colours, Emojis, Guild, Icons, MODERATION_ROLES, Roles
+from bot.converters import Expiry
+from bot.utils.scheduling import Scheduler
+
+log = logging.getLogger(__name__)
+
+
+class ModPings(Cog):
+    """Commands for a moderator to turn moderator pings on and off."""
+
+    # RedisCache[discord.Member.id, 'Naïve ISO 8601 string']
+    # The cache's keys are mods who have pings off.
+    # The cache's values are the times when the role should be re-applied to them, stored in ISO format.
+    pings_off_mods = RedisCache()
+
+    def __init__(self, bot: Bot):
+        self.bot = bot
+        self._role_scheduler = Scheduler(self.__class__.__name__)
+
+        self.guild = None
+        self.moderators_role = None
+
+        self.reschedule_task = self.bot.loop.create_task(self.reschedule_roles(), name="mod-pings-reschedule")
+
+    async def reschedule_roles(self) -> None:
+        """Reschedule moderators role re-apply times."""
+        await self.bot.wait_until_guild_available()
+        self.guild = self.bot.get_guild(Guild.id)
+        self.moderators_role = self.guild.get_role(Roles.moderators)
+
+        mod_team = self.guild.get_role(Roles.mod_team)
+        pings_on = self.moderators_role.members
+        pings_off = await self.pings_off_mods.to_dict()
+
+        log.trace("Applying the moderators role to the mod team where necessary.")
+        for mod in mod_team.members:
+            if mod in pings_on:  # Make sure that on-duty mods aren't in the cache.
+                if mod in pings_off:
+                    await self.pings_off_mods.delete(mod.id)
+                continue
+
+            # Keep the role off only for those in the cache.
+            if mod.id not in pings_off:
+                await self.reapply_role(mod)
+            else:
+                expiry = isoparse(pings_off[mod.id]).replace(tzinfo=None)
+                self._role_scheduler.schedule_at(expiry, mod.id, self.reapply_role(mod))
+
+    async def reapply_role(self, mod: Member) -> None:
+        """Reapply the moderator's role to the given moderator."""
+        log.trace(f"Re-applying role to mod with ID {mod.id}.")
+        await mod.add_roles(self.moderators_role, reason="Pings off period expired.")
+
+    @group(name='modpings', aliases=('modping',), invoke_without_command=True)
+    @has_any_role(*MODERATION_ROLES)
+    async def modpings_group(self, ctx: Context) -> None:
+        """Allow the removal and re-addition of the pingable moderators role."""
+        await ctx.send_help(ctx.command)
+
+    @modpings_group.command(name='off')
+    @has_any_role(*MODERATION_ROLES)
+    async def off_command(self, ctx: Context, duration: Expiry) -> None:
+        """
+        Temporarily removes the pingable moderators role for a set amount of time.
+
+        A unit of time should be appended to the duration.
+        Units (∗case-sensitive):
+        \u2003`y` - years
+        \u2003`m` - months∗
+        \u2003`w` - weeks
+        \u2003`d` - days
+        \u2003`h` - hours
+        \u2003`M` - minutes∗
+        \u2003`s` - seconds
+
+        Alternatively, an ISO 8601 timestamp can be provided for the duration.
+
+        The duration cannot be longer than 30 days.
+        """
+        duration: datetime.datetime
+        delta = duration - datetime.datetime.utcnow()
+        if delta > datetime.timedelta(days=30):
+            await ctx.send(":x: Cannot remove the role for longer than 30 days.")
+            return
+
+        mod = ctx.author
+
+        until_date = duration.replace(microsecond=0).isoformat()  # Looks noisy with microseconds.
+        await mod.remove_roles(self.moderators_role, reason=f"Turned pings off until {until_date}.")
+
+        await self.pings_off_mods.set(mod.id, duration.isoformat())
+
+        # Allow rescheduling the task without cancelling it separately via the `on` command.
+        if mod.id in self._role_scheduler:
+            self._role_scheduler.cancel(mod.id)
+        self._role_scheduler.schedule_at(duration, mod.id, self.reapply_role(mod))
+
+        embed = Embed(timestamp=duration, colour=Colours.bright_green)
+        embed.set_footer(text="Moderators role has been removed until", icon_url=Icons.green_checkmark)
+        await ctx.send(embed=embed)
+
+    @modpings_group.command(name='on')
+    @has_any_role(*MODERATION_ROLES)
+    async def on_command(self, ctx: Context) -> None:
+        """Re-apply the pingable moderators role."""
+        mod = ctx.author
+        if mod in self.moderators_role.members:
+            await ctx.send(":question: You already have the role.")
+            return
+
+        await mod.add_roles(self.moderators_role, reason="Pings off period canceled.")
+
+        await self.pings_off_mods.delete(mod.id)
+
+        # We assume the task exists. Lack of it may indicate a bug.
+        self._role_scheduler.cancel(mod.id)
+
+        await ctx.send(f"{Emojis.check_mark} Moderators role has been re-applied.")
+
+    def cog_unload(self) -> None:
+        """Cancel role tasks when the cog unloads."""
+        log.trace("Cog unload: canceling role tasks.")
+        self.reschedule_task.cancel()
+        self._role_scheduler.cancel_all()
+
+
+def setup(bot: Bot) -> None:
+    """Load the ModPings cog."""
+    bot.add_cog(ModPings(bot))
diff --git a/bot/exts/moderation/stream.py b/bot/exts/moderation/stream.py
index 1dbb2a46b..fd856a7f4 100644
--- a/bot/exts/moderation/stream.py
+++ b/bot/exts/moderation/stream.py
@@ -70,6 +70,28 @@ class Stream(commands.Cog):
                 self._revoke_streaming_permission(member)
             )
 
+    async def _suspend_stream(self, ctx: commands.Context, member: discord.Member) -> None:
+        """Suspend a member's stream."""
+        await self.bot.wait_until_guild_available()
+        voice_state = member.voice
+
+        if not voice_state:
+            return
+
+        # If the user is streaming.
+        if voice_state.self_stream:
+            # End user's stream by moving them to AFK voice channel and back.
+            original_vc = voice_state.channel
+            await member.move_to(ctx.guild.afk_channel)
+            await member.move_to(original_vc)
+
+            # Notify.
+            await ctx.send(f"{member.mention}'s stream has been suspended!")
+            log.debug(f"Successfully suspended stream from {member} ({member.id}).")
+            return
+
+        log.debug(f"No stream found to suspend from {member} ({member.id}).")
+
     @commands.command(aliases=("streaming",))
     @commands.has_any_role(*MODERATION_ROLES)
     async def stream(self, ctx: commands.Context, member: discord.Member, duration: Expiry = None) -> None:
@@ -170,10 +192,12 @@ class Stream(commands.Cog):
 
             await ctx.send(f"{Emojis.check_mark} Revoked the permission to stream from {member.mention}.")
             log.debug(f"Successfully revoked streaming permission from {member} ({member.id}).")
-            return
 
-        await ctx.send(f"{Emojis.cross_mark} This member doesn't have video permissions to remove!")
-        log.debug(f"{member} ({member.id}) didn't have the streaming permission to remove!")
+        else:
+            await ctx.send(f"{Emojis.cross_mark} This member doesn't have video permissions to remove!")
+            log.debug(f"{member} ({member.id}) didn't have the streaming permission to remove!")
+
+        await self._suspend_stream(ctx, member)
 
     @commands.command(aliases=('lstream',))
     @commands.has_any_role(*MODERATION_ROLES)
diff --git a/bot/exts/recruitment/talentpool/_review.py b/bot/exts/recruitment/talentpool/_review.py
index 11aa3b62b..4ae1c5ad6 100644
--- a/bot/exts/recruitment/talentpool/_review.py
+++ b/bot/exts/recruitment/talentpool/_review.py
@@ -57,7 +57,7 @@ class Reviewer:
         """Schedules a single user for review."""
         log.trace(f"Scheduling review of user with ID {user_id}")
 
-        user_data = self._pool.watched_users[user_id]
+        user_data = self._pool.watched_users.get(user_id)
         inserted_at = isoparse(user_data['inserted_at']).replace(tzinfo=None)
         review_at = inserted_at + timedelta(days=MAX_DAYS_IN_POOL)
 
@@ -81,14 +81,18 @@ class Reviewer:
                 await message.add_reaction(reaction)
 
         if update_database:
-            nomination = self._pool.watched_users[user_id]
+            nomination = self._pool.watched_users.get(user_id)
             await self.bot.api_client.patch(f"{self._pool.api_endpoint}/{nomination['id']}", json={"reviewed": True})
 
     async def make_review(self, user_id: int) -> typing.Tuple[str, Optional[Emoji]]:
         """Format a generic review of a user and return it with the seen emoji."""
         log.trace(f"Formatting the review of {user_id}")
 
-        nomination = self._pool.watched_users[user_id]
+        # Since `watched_users` is a defaultdict, we should take care
+        # not to accidentally insert the IDs of users that have no
+        # active nominated by using the `watched_users.get(user_id)`
+        # instead of `watched_users[user_id]`.
+        nomination = self._pool.watched_users.get(user_id)
         if not nomination:
             log.trace(f"There doesn't appear to be an active nomination for {user_id}")
             return "", None
@@ -303,7 +307,7 @@ class Reviewer:
             await ctx.send(f":x: Can't find a currently nominated user with id `{user_id}`")
             return False
 
-        nomination = self._pool.watched_users[user_id]
+        nomination = self._pool.watched_users.get(user_id)
         if nomination["reviewed"]:
             await ctx.send(":x: This nomination was already reviewed, but here's a cookie :cookie:")
             return False
diff --git a/bot/exts/utils/extensions.py b/bot/exts/utils/extensions.py
index 418db0150..8a1ed98f4 100644
--- a/bot/exts/utils/extensions.py
+++ b/bot/exts/utils/extensions.py
@@ -109,7 +109,7 @@ class Extensions(commands.Cog):
         blacklisted = "\n".join(UNLOAD_BLACKLIST & set(extensions))
 
         if blacklisted:
-            msg = f":x: The following extension(s) may not be unloaded:```{blacklisted}```"
+            msg = f":x: The following extension(s) may not be unloaded:```\n{blacklisted}```"
         else:
             if "*" in extensions or "**" in extensions:
                 extensions = set(self.bot.extensions.keys()) - UNLOAD_BLACKLIST
@@ -212,7 +212,7 @@ class Extensions(commands.Cog):
 
         if failures:
             failures = "\n".join(f"{ext}\n    {err}" for ext, err in failures.items())
-            msg += f"\nFailures:```{failures}```"
+            msg += f"\nFailures:```\n{failures}```"
 
         log.debug(f"Batch {verb}ed extensions.")
 
@@ -239,7 +239,7 @@ class Extensions(commands.Cog):
             log.exception(f"Extension '{ext}' failed to {verb}.")
 
             error_msg = f"{e.__class__.__name__}: {e}"
-            msg = f":x: Failed to {verb} extension `{ext}`:\n```{error_msg}```"
+            msg = f":x: Failed to {verb} extension `{ext}`:\n```\n{error_msg}```"
         else:
             msg = f":ok_hand: Extension successfully {verb}ed: `{ext}`."
             log.debug(msg[10:])
diff --git a/bot/exts/utils/reminders.py b/bot/exts/utils/reminders.py
index 3113a1149..6c21920a1 100644
--- a/bot/exts/utils/reminders.py
+++ b/bot/exts/utils/reminders.py
@@ -90,15 +90,18 @@ class Reminders(Cog):
         delivery_dt: t.Optional[datetime],
     ) -> None:
         """Send an embed confirming the reminder change was made successfully."""
-        embed = discord.Embed()
-        embed.colour = discord.Colour.green()
-        embed.title = random.choice(POSITIVE_REPLIES)
-        embed.description = on_success
+        embed = discord.Embed(
+            description=on_success,
+            colour=discord.Colour.green(),
+            title=random.choice(POSITIVE_REPLIES)
+        )
 
         footer_str = f"ID: {reminder_id}"
+
         if delivery_dt:
             # Reminder deletion will have a `None` `delivery_dt`
-            footer_str = f"{footer_str}, Due: {delivery_dt.strftime('%Y-%m-%dT%H:%M:%S')}"
+            footer_str += ', Due'
+            embed.timestamp = delivery_dt
 
         embed.set_footer(text=footer_str)
 
diff --git a/bot/exts/utils/snekbox.py b/bot/exts/utils/snekbox.py
index da95240bb..b1f1ba6a8 100644
--- a/bot/exts/utils/snekbox.py
+++ b/bot/exts/utils/snekbox.py
@@ -13,7 +13,7 @@ from discord.ext.commands import Cog, Context, command, guild_only
 
 from bot.bot import Bot
 from bot.constants import Categories, Channels, Roles, URLs
-from bot.decorators import not_in_blacklist
+from bot.decorators import redirect_output
 from bot.utils import send_to_paste_service
 from bot.utils.messages import wait_for_deletion
 
@@ -280,7 +280,13 @@ class Snekbox(Cog):
 
     @command(name="eval", aliases=("e",))
     @guild_only()
-    @not_in_blacklist(channels=NO_EVAL_CHANNELS, categories=NO_EVAL_CATEGORIES, override_roles=EVAL_ROLES)
+    @redirect_output(
+        destination_channel=Channels.bot_commands,
+        bypass_roles=EVAL_ROLES,
+        categories=NO_EVAL_CATEGORIES,
+        channels=NO_EVAL_CHANNELS,
+        ping_user=False
+    )
     async def eval_command(self, ctx: Context, *, code: str = None) -> None:
         """
         Run Python code and get the results.
diff --git a/bot/exts/utils/utils.py b/bot/exts/utils/utils.py
index 8d9d27c64..4c39a7c2a 100644
--- a/bot/exts/utils/utils.py
+++ b/bot/exts/utils/utils.py
@@ -109,7 +109,7 @@ class Utils(Cog):
         # handle if it's an index int
         if isinstance(search_value, int):
             upper_bound = len(zen_lines) - 1
-            lower_bound = -1 * upper_bound
+            lower_bound = -1 * len(zen_lines)
             if not (lower_bound <= search_value <= upper_bound):
                 raise BadArgument(f"Please provide an index between {lower_bound} and {upper_bound}.")
 
diff --git a/bot/log.py b/bot/log.py
index e92233a33..4e20c005e 100644
--- a/bot/log.py
+++ b/bot/log.py
@@ -20,7 +20,6 @@ def setup() -> None:
     logging.addLevelName(TRACE_LEVEL, "TRACE")
     Logger.trace = _monkeypatch_trace
 
-    log_level = TRACE_LEVEL if constants.DEBUG_MODE else logging.INFO
     format_string = "%(asctime)s | %(name)s | %(levelname)s | %(message)s"
     log_format = logging.Formatter(format_string)
 
@@ -30,7 +29,6 @@ def setup() -> None:
     file_handler.setFormatter(log_format)
 
     root_log = logging.getLogger()
-    root_log.setLevel(log_level)
     root_log.addHandler(file_handler)
 
     if "COLOREDLOGS_LEVEL_STYLES" not in os.environ:
@@ -44,11 +42,9 @@ def setup() -> None:
     if "COLOREDLOGS_LOG_FORMAT" not in os.environ:
         coloredlogs.DEFAULT_LOG_FORMAT = format_string
 
-    if "COLOREDLOGS_LOG_LEVEL" not in os.environ:
-        coloredlogs.DEFAULT_LOG_LEVEL = log_level
-
-    coloredlogs.install(logger=root_log, stream=sys.stdout)
+    coloredlogs.install(level=logging.TRACE, logger=root_log, stream=sys.stdout)
 
+    root_log.setLevel(logging.DEBUG if constants.DEBUG_MODE else logging.INFO)
     logging.getLogger("discord").setLevel(logging.WARNING)
     logging.getLogger("websockets").setLevel(logging.WARNING)
     logging.getLogger("chardet").setLevel(logging.WARNING)
@@ -57,6 +53,8 @@ def setup() -> None:
     # Set back to the default of INFO even if asyncio's debug mode is enabled.
     logging.getLogger("asyncio").setLevel(logging.INFO)
 
+    _set_trace_loggers()
+
 
 def setup_sentry() -> None:
     """Set up the Sentry logging integrations."""
@@ -86,3 +84,30 @@ def _monkeypatch_trace(self: logging.Logger, msg: str, *args, **kwargs) -> None:
     """
     if self.isEnabledFor(TRACE_LEVEL):
         self._log(TRACE_LEVEL, msg, args, **kwargs)
+
+
+def _set_trace_loggers() -> None:
+    """
+    Set loggers to the trace level according to the value from the BOT_TRACE_LOGGERS env var.
+
+    When the env var is a list of logger names delimited by a comma,
+    each of the listed loggers will be set to the trace level.
+
+    If this list is prefixed with a "!", all of the loggers except the listed ones will be set to the trace level.
+
+    Otherwise if the env var begins with a "*",
+    the root logger is set to the trace level and other contents are ignored.
+    """
+    level_filter = constants.Bot.trace_loggers
+    if level_filter:
+        if level_filter.startswith("*"):
+            logging.getLogger().setLevel(logging.TRACE)
+
+        elif level_filter.startswith("!"):
+            logging.getLogger().setLevel(logging.TRACE)
+            for logger_name in level_filter.strip("!,").split(","):
+                logging.getLogger(logger_name).setLevel(logging.DEBUG)
+
+        else:
+            for logger_name in level_filter.strip(",").split(","):
+                logging.getLogger(logger_name).setLevel(logging.TRACE)
diff --git a/bot/resources/stars.json b/bot/resources/stars.json
index 5ecad0213..3eb0a9d0d 100644
--- a/bot/resources/stars.json
+++ b/bot/resources/stars.json
@@ -20,6 +20,7 @@
   "Céline Dion",
   "Cher",
   "Christina Aguilera",
+  "Darude",
   "David Bowie",
   "Donna Summer",
   "Drake",
@@ -31,11 +32,14 @@
   "Flo Rida",
   "Frank Sinatra",
   "Garth Brooks",
+  "George Harrison",
   "George Michael",
   "George Strait",
+  "Guido Van Rossum",
   "James Taylor",
   "Janet Jackson",
   "Jay-Z",
+  "John Lennon",
   "Johnny Cash",
   "Johnny Hallyday",
   "Julio Iglesias",
@@ -61,13 +65,16 @@
   "Pink",
   "Prince",
   "Reba McEntire",
+  "Rick Astley",
   "Rihanna",
+  "Ringo Starr",
   "Robbie Williams",
   "Rod Stewart",
   "Santana",
   "Shania Twain",
   "Stevie Wonder",
   "Taylor Swift",
+  "The Weeknd",
   "Tim McGraw",
   "Tina Turner",
   "Tom Petty",
diff --git a/bot/resources/tags/identity.md b/bot/resources/tags/identity.md
new file mode 100644
index 000000000..fb2010759
--- /dev/null
+++ b/bot/resources/tags/identity.md
@@ -0,0 +1,24 @@
+**Identity vs. Equality**
+
+Should I be using `is` or `==`?
+
+To check if two objects are equal, use the equality operator (`==`).
+```py
+x = 5
+if x == 5:
+    print("x equals 5")
+if x == 3:
+    print("x equals 3")
+# Prints 'x equals 5'
+```
+To check if two objects are actually the same thing in memory, use the identity comparison operator (`is`).
+```py
+list_1 = [1, 2, 3]
+list_2 = [1, 2, 3]
+if list_1 is [1, 2, 3]:
+    print("list_1 is list_2")
+reference_to_list_1 = list_1
+if list_1 is reference_to_list_1:
+    print("list_1 is reference_to_list_1")
+# Prints 'list_1 is reference_to_list_1'
+```
diff --git a/bot/resources/tags/str-join.md b/bot/resources/tags/str-join.md
new file mode 100644
index 000000000..c835f9313
--- /dev/null
+++ b/bot/resources/tags/str-join.md
@@ -0,0 +1,28 @@
+**Joining Iterables**
+
+If you want to display a list (or some other iterable), you can write:
+```py
+colors = ['red', 'green', 'blue', 'yellow']
+output = ""
+separator = ", "
+for color in colors:
+    output += color + separator
+print(output)
+# Prints 'red, green, blue, yellow, '
+```
+However, the separator is still added to the last element, and it is relatively slow.
+
+A better solution is to use `str.join`.
+```py
+colors = ['red', 'green', 'blue', 'yellow']
+separator = ", "
+print(separator.join(colors))
+# Prints 'red, green, blue, yellow'
+```
+An important thing to note is that you can only `str.join` strings. For a list of ints,
+you must convert each element to a string before joining.
+```py
+integers = [1, 3, 6, 10, 15]
+print(", ".join(str(e) for e in integers))
+# Prints '1, 3, 6, 10, 15'
+```
diff --git a/config-default.yml b/config-default.yml
index b437829e0..c5c9b12ce 100644
--- a/config-default.yml
+++ b/config-default.yml
@@ -1,7 +1,8 @@
 bot:
-    prefix:      "!"
-    sentry_dsn:  !ENV "BOT_SENTRY_DSN"
-    token:       !ENV "BOT_TOKEN"
+    prefix:         "!"
+    sentry_dsn:     !ENV "BOT_SENTRY_DSN"
+    token:          !ENV "BOT_TOKEN"
+    trace_loggers:  !ENV "BOT_TRACE_LOGGERS"
 
     clean:
         # Maximum number of messages to traverse for clean commands
@@ -46,6 +47,8 @@ style:
         badge_partner: "<:partner:748666453242413136>"
         badge_staff: "<:discord_staff:743882896498098226>"
         badge_verified_bot_developer: "<:verified_bot_dev:743882897299210310>"
+        bot: "<:bot:812712599464443914>"
+        verified_bot: "<:verified_bot:811645219220750347>"
 
         defcon_shutdown:    "<:defcondisabled:470326273952972810>"
         defcon_unshutdown:  "<:defconenabled:470326274213150730>"
@@ -255,7 +258,8 @@ guild:
         devops:                             409416496733880320
         domain_leads:                       807415650778742785
         helpers:            &HELPERS_ROLE   267630620367257601
-        moderators:         &MODS_ROLE      267629731250176001
+        moderators:         &MODS_ROLE      831776746206265384
+        mod_team:           &MOD_TEAM_ROLE  267629731250176001
         owners:             &OWNERS_ROLE    267627879762755584
         project_leads:                      815701647526330398
 
@@ -268,13 +272,14 @@ guild:
 
     moderation_roles:
         - *ADMINS_ROLE
+        - *MOD_TEAM_ROLE
         - *MODS_ROLE
         - *OWNERS_ROLE
 
     staff_roles:
         - *ADMINS_ROLE
         - *HELPERS_ROLE
-        - *MODS_ROLE
+        - *MOD_TEAM_ROLE
         - *OWNERS_ROLE
 
     webhooks:
diff --git a/docker-compose.yml b/docker-compose.yml
index 8afdd6ef1..bdfedf5c2 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -4,8 +4,20 @@
 
 version: "3.7"
 
+x-logging: &logging
+  logging:
+    driver: "json-file"
+    options:
+      max-file: "5"
+      max-size: "10m"
+
+x-restart-policy: &restart_policy
+  restart: always
+
 services:
   postgres:
+    << : *logging
+    << : *restart_policy
     image: postgres:12-alpine
     environment:
       POSTGRES_DB: pysite
@@ -13,11 +25,15 @@ services:
       POSTGRES_USER: pysite
 
   redis:
+    << : *logging
+    << : *restart_policy
     image: redis:5.0.9
     ports:
       - "127.0.0.1:6379:6379"
 
   snekbox:
+    << : *logging
+    << : *restart_policy
     image: ghcr.io/python-discord/snekbox:latest
     init: true
     ipc: none
@@ -26,6 +42,8 @@ services:
     privileged: true
 
   web:
+    << : *logging
+    << : *restart_policy
     image: ghcr.io/python-discord/site:latest
     command: ["run", "--debug"]
     networks:
@@ -46,6 +64,8 @@ services:
       STATIC_ROOT: /var/www/static
 
   bot:
+    << : *logging
+    << : *restart_policy
     build:
       context: .
       dockerfile: Dockerfile
diff --git a/tests/README.md b/tests/README.md
index 4f62edd68..092324123 100644
--- a/tests/README.md
+++ b/tests/README.md
@@ -114,7 +114,7 @@ class BotCogTests(unittest.TestCase):
 
 ### Mocking coroutines
 
-By default, the `unittest.mock.Mock` and `unittest.mock.MagicMock` classes cannot mock coroutines, since the `__call__` method they provide is synchronous. In anticipation of the `AsyncMock` that will be [introduced in Python 3.8](https://docs.python.org/3.9/whatsnew/3.8.html#unittest), we have added an `AsyncMock` helper to [`helpers.py`](/tests/helpers.py). Do note that this drop-in replacement only implements an asynchronous `__call__` method, not the additional assertions that will come with the new `AsyncMock` type in Python 3.8.
+By default, the `unittest.mock.Mock` and `unittest.mock.MagicMock` classes cannot mock coroutines, since the `__call__` method they provide is synchronous. The [`AsyncMock`](https://docs.python.org/3/library/unittest.mock.html#unittest.mock.AsyncMock) that has been [introduced in Python 3.8](https://docs.python.org/3.9/whatsnew/3.8.html#unittest) is an asynchronous version of `MagicMock` that can be used anywhere a coroutine is expected.
 
 ### Special mocks for some `discord.py` types
 
diff --git a/tests/bot/exts/backend/test_error_handler.py b/tests/bot/exts/backend/test_error_handler.py
new file mode 100644
index 000000000..bd4fb5942
--- /dev/null
+++ b/tests/bot/exts/backend/test_error_handler.py
@@ -0,0 +1,550 @@
+import unittest
+from unittest.mock import AsyncMock, MagicMock, call, patch
+
+from discord.ext.commands import errors
+
+from bot.api import ResponseCodeError
+from bot.errors import InvalidInfractedUser, LockedResourceError
+from bot.exts.backend.error_handler import ErrorHandler, setup
+from bot.exts.info.tags import Tags
+from bot.exts.moderation.silence import Silence
+from bot.utils.checks import InWhitelistCheckFailure
+from tests.helpers import MockBot, MockContext, MockGuild, MockRole
+
+
+class ErrorHandlerTests(unittest.IsolatedAsyncioTestCase):
+    """Tests for error handler functionality."""
+
+    def setUp(self):
+        self.bot = MockBot()
+        self.ctx = MockContext(bot=self.bot)
+
+    async def test_error_handler_already_handled(self):
+        """Should not do anything when error is already handled by local error handler."""
+        self.ctx.reset_mock()
+        cog = ErrorHandler(self.bot)
+        error = errors.CommandError()
+        error.handled = "foo"
+        self.assertIsNone(await cog.on_command_error(self.ctx, error))
+        self.ctx.send.assert_not_awaited()
+
+    async def test_error_handler_command_not_found_error_not_invoked_by_handler(self):
+        """Should try first (un)silence channel, when fail, try to get tag."""
+        error = errors.CommandNotFound()
+        test_cases = (
+            {
+                "try_silence_return": True,
+                "called_try_get_tag": False
+            },
+            {
+                "try_silence_return": False,
+                "called_try_get_tag": False
+            },
+            {
+                "try_silence_return": False,
+                "called_try_get_tag": True
+            }
+        )
+        cog = ErrorHandler(self.bot)
+        cog.try_silence = AsyncMock()
+        cog.try_get_tag = AsyncMock()
+
+        for case in test_cases:
+            with self.subTest(try_silence_return=case["try_silence_return"], try_get_tag=case["called_try_get_tag"]):
+                self.ctx.reset_mock()
+                cog.try_silence.reset_mock(return_value=True)
+                cog.try_get_tag.reset_mock()
+
+                cog.try_silence.return_value = case["try_silence_return"]
+                self.ctx.channel.id = 1234
+
+                self.assertIsNone(await cog.on_command_error(self.ctx, error))
+
+                if case["try_silence_return"]:
+                    cog.try_get_tag.assert_not_awaited()
+                    cog.try_silence.assert_awaited_once()
+                else:
+                    cog.try_silence.assert_awaited_once()
+                    cog.try_get_tag.assert_awaited_once()
+
+                self.ctx.send.assert_not_awaited()
+
+    async def test_error_handler_command_not_found_error_invoked_by_handler(self):
+        """Should do nothing when error is `CommandNotFound` and have attribute `invoked_from_error_handler`."""
+        ctx = MockContext(bot=self.bot, invoked_from_error_handler=True)
+
+        cog = ErrorHandler(self.bot)
+        cog.try_silence = AsyncMock()
+        cog.try_get_tag = AsyncMock()
+
+        error = errors.CommandNotFound()
+
+        self.assertIsNone(await cog.on_command_error(ctx, error))
+
+        cog.try_silence.assert_not_awaited()
+        cog.try_get_tag.assert_not_awaited()
+        self.ctx.send.assert_not_awaited()
+
+    async def test_error_handler_user_input_error(self):
+        """Should await `ErrorHandler.handle_user_input_error` when error is `UserInputError`."""
+        self.ctx.reset_mock()
+        cog = ErrorHandler(self.bot)
+        cog.handle_user_input_error = AsyncMock()
+        error = errors.UserInputError()
+        self.assertIsNone(await cog.on_command_error(self.ctx, error))
+        cog.handle_user_input_error.assert_awaited_once_with(self.ctx, error)
+
+    async def test_error_handler_check_failure(self):
+        """Should await `ErrorHandler.handle_check_failure` when error is `CheckFailure`."""
+        self.ctx.reset_mock()
+        cog = ErrorHandler(self.bot)
+        cog.handle_check_failure = AsyncMock()
+        error = errors.CheckFailure()
+        self.assertIsNone(await cog.on_command_error(self.ctx, error))
+        cog.handle_check_failure.assert_awaited_once_with(self.ctx, error)
+
+    async def test_error_handler_command_on_cooldown(self):
+        """Should send error with `ctx.send` when error is `CommandOnCooldown`."""
+        self.ctx.reset_mock()
+        cog = ErrorHandler(self.bot)
+        error = errors.CommandOnCooldown(10, 9)
+        self.assertIsNone(await cog.on_command_error(self.ctx, error))
+        self.ctx.send.assert_awaited_once_with(error)
+
+    async def test_error_handler_command_invoke_error(self):
+        """Should call `handle_api_error` or `handle_unexpected_error` depending on original error."""
+        cog = ErrorHandler(self.bot)
+        cog.handle_api_error = AsyncMock()
+        cog.handle_unexpected_error = AsyncMock()
+        test_cases = (
+            {
+                "args": (self.ctx, errors.CommandInvokeError(ResponseCodeError(AsyncMock()))),
+                "expect_mock_call": cog.handle_api_error
+            },
+            {
+                "args": (self.ctx, errors.CommandInvokeError(TypeError)),
+                "expect_mock_call": cog.handle_unexpected_error
+            },
+            {
+                "args": (self.ctx, errors.CommandInvokeError(LockedResourceError("abc", "test"))),
+                "expect_mock_call": "send"
+            },
+            {
+                "args": (self.ctx, errors.CommandInvokeError(InvalidInfractedUser(self.ctx.author))),
+                "expect_mock_call": "send"
+            }
+        )
+
+        for case in test_cases:
+            with self.subTest(args=case["args"], expect_mock_call=case["expect_mock_call"]):
+                self.ctx.send.reset_mock()
+                self.assertIsNone(await cog.on_command_error(*case["args"]))
+                if case["expect_mock_call"] == "send":
+                    self.ctx.send.assert_awaited_once()
+                else:
+                    case["expect_mock_call"].assert_awaited_once_with(
+                        self.ctx, case["args"][1].original
+                    )
+
+    async def test_error_handler_conversion_error(self):
+        """Should call `handle_api_error` or `handle_unexpected_error` depending on original error."""
+        cog = ErrorHandler(self.bot)
+        cog.handle_api_error = AsyncMock()
+        cog.handle_unexpected_error = AsyncMock()
+        cases = (
+            {
+                "error": errors.ConversionError(AsyncMock(), ResponseCodeError(AsyncMock())),
+                "mock_function_to_call": cog.handle_api_error
+            },
+            {
+                "error": errors.ConversionError(AsyncMock(), TypeError),
+                "mock_function_to_call": cog.handle_unexpected_error
+            }
+        )
+
+        for case in cases:
+            with self.subTest(**case):
+                self.assertIsNone(await cog.on_command_error(self.ctx, case["error"]))
+                case["mock_function_to_call"].assert_awaited_once_with(self.ctx, case["error"].original)
+
+    async def test_error_handler_two_other_errors(self):
+        """Should call `handle_unexpected_error` if error is `MaxConcurrencyReached` or `ExtensionError`."""
+        cog = ErrorHandler(self.bot)
+        cog.handle_unexpected_error = AsyncMock()
+        errs = (
+            errors.MaxConcurrencyReached(1, MagicMock()),
+            errors.ExtensionError(name="foo")
+        )
+
+        for err in errs:
+            with self.subTest(error=err):
+                cog.handle_unexpected_error.reset_mock()
+                self.assertIsNone(await cog.on_command_error(self.ctx, err))
+                cog.handle_unexpected_error.assert_awaited_once_with(self.ctx, err)
+
+    @patch("bot.exts.backend.error_handler.log")
+    async def test_error_handler_other_errors(self, log_mock):
+        """Should `log.debug` other errors."""
+        cog = ErrorHandler(self.bot)
+        error = errors.DisabledCommand()  # Use this just as a other error
+        self.assertIsNone(await cog.on_command_error(self.ctx, error))
+        log_mock.debug.assert_called_once()
+
+
+class TrySilenceTests(unittest.IsolatedAsyncioTestCase):
+    """Test for helper functions that handle `CommandNotFound` error."""
+
+    def setUp(self):
+        self.bot = MockBot()
+        self.silence = Silence(self.bot)
+        self.bot.get_command.return_value = self.silence.silence
+        self.ctx = MockContext(bot=self.bot)
+        self.cog = ErrorHandler(self.bot)
+
+    async def test_try_silence_context_invoked_from_error_handler(self):
+        """Should set `Context.invoked_from_error_handler` to `True`."""
+        self.ctx.invoked_with = "foo"
+        await self.cog.try_silence(self.ctx)
+        self.assertTrue(hasattr(self.ctx, "invoked_from_error_handler"))
+        self.assertTrue(self.ctx.invoked_from_error_handler)
+
+    async def test_try_silence_get_command(self):
+        """Should call `get_command` with `silence`."""
+        self.ctx.invoked_with = "foo"
+        await self.cog.try_silence(self.ctx)
+        self.bot.get_command.assert_called_once_with("silence")
+
+    async def test_try_silence_no_permissions_to_run(self):
+        """Should return `False` because missing permissions."""
+        self.ctx.invoked_with = "foo"
+        self.bot.get_command.return_value.can_run = AsyncMock(return_value=False)
+        self.assertFalse(await self.cog.try_silence(self.ctx))
+
+    async def test_try_silence_no_permissions_to_run_command_error(self):
+        """Should return `False` because `CommandError` raised (no permissions)."""
+        self.ctx.invoked_with = "foo"
+        self.bot.get_command.return_value.can_run = AsyncMock(side_effect=errors.CommandError())
+        self.assertFalse(await self.cog.try_silence(self.ctx))
+
+    async def test_try_silence_silencing(self):
+        """Should run silence command with correct arguments."""
+        self.bot.get_command.return_value.can_run = AsyncMock(return_value=True)
+        test_cases = ("shh", "shhh", "shhhhhh", "shhhhhhhhhhhhhhhhhhh")
+
+        for case in test_cases:
+            with self.subTest(message=case):
+                self.ctx.reset_mock()
+                self.ctx.invoked_with = case
+                self.assertTrue(await self.cog.try_silence(self.ctx))
+                self.ctx.invoke.assert_awaited_once_with(
+                    self.bot.get_command.return_value,
+                    duration=min(case.count("h")*2, 15)
+                )
+
+    async def test_try_silence_unsilence(self):
+        """Should call unsilence command."""
+        self.silence.silence.can_run = AsyncMock(return_value=True)
+        test_cases = ("unshh", "unshhhhh", "unshhhhhhhhh")
+
+        for case in test_cases:
+            with self.subTest(message=case):
+                self.bot.get_command.side_effect = (self.silence.silence, self.silence.unsilence)
+                self.ctx.reset_mock()
+                self.ctx.invoked_with = case
+                self.assertTrue(await self.cog.try_silence(self.ctx))
+                self.ctx.invoke.assert_awaited_once_with(self.silence.unsilence)
+
+    async def test_try_silence_no_match(self):
+        """Should return `False` when message don't match."""
+        self.ctx.invoked_with = "foo"
+        self.assertFalse(await self.cog.try_silence(self.ctx))
+
+
+class TryGetTagTests(unittest.IsolatedAsyncioTestCase):
+    """Tests for `try_get_tag` function."""
+
+    def setUp(self):
+        self.bot = MockBot()
+        self.ctx = MockContext()
+        self.tag = Tags(self.bot)
+        self.cog = ErrorHandler(self.bot)
+        self.bot.get_command.return_value = self.tag.get_command
+
+    async def test_try_get_tag_get_command(self):
+        """Should call `Bot.get_command` with `tags get` argument."""
+        self.bot.get_command.reset_mock()
+        self.ctx.invoked_with = "foo"
+        await self.cog.try_get_tag(self.ctx)
+        self.bot.get_command.assert_called_once_with("tags get")
+
+    async def test_try_get_tag_invoked_from_error_handler(self):
+        """`self.ctx` should have `invoked_from_error_handler` `True`."""
+        self.ctx.invoked_from_error_handler = False
+        self.ctx.invoked_with = "foo"
+        await self.cog.try_get_tag(self.ctx)
+        self.assertTrue(self.ctx.invoked_from_error_handler)
+
+    async def test_try_get_tag_no_permissions(self):
+        """Test how to handle checks failing."""
+        self.tag.get_command.can_run = AsyncMock(return_value=False)
+        self.ctx.invoked_with = "foo"
+        self.assertIsNone(await self.cog.try_get_tag(self.ctx))
+
+    async def test_try_get_tag_command_error(self):
+        """Should call `on_command_error` when `CommandError` raised."""
+        err = errors.CommandError()
+        self.tag.get_command.can_run = AsyncMock(side_effect=err)
+        self.cog.on_command_error = AsyncMock()
+        self.ctx.invoked_with = "foo"
+        self.assertIsNone(await self.cog.try_get_tag(self.ctx))
+        self.cog.on_command_error.assert_awaited_once_with(self.ctx, err)
+
+    @patch("bot.exts.backend.error_handler.TagNameConverter")
+    async def test_try_get_tag_convert_success(self, tag_converter):
+        """Converting tag should successful."""
+        self.ctx.invoked_with = "foo"
+        tag_converter.convert = AsyncMock(return_value="foo")
+        self.assertIsNone(await self.cog.try_get_tag(self.ctx))
+        tag_converter.convert.assert_awaited_once_with(self.ctx, "foo")
+        self.ctx.invoke.assert_awaited_once()
+
+    @patch("bot.exts.backend.error_handler.TagNameConverter")
+    async def test_try_get_tag_convert_fail(self, tag_converter):
+        """Converting tag should raise `BadArgument`."""
+        self.ctx.reset_mock()
+        self.ctx.invoked_with = "bar"
+        tag_converter.convert = AsyncMock(side_effect=errors.BadArgument())
+        self.assertIsNone(await self.cog.try_get_tag(self.ctx))
+        self.ctx.invoke.assert_not_awaited()
+
+    async def test_try_get_tag_ctx_invoke(self):
+        """Should call `ctx.invoke` with proper args/kwargs."""
+        self.ctx.reset_mock()
+        self.ctx.invoked_with = "foo"
+        self.assertIsNone(await self.cog.try_get_tag(self.ctx))
+        self.ctx.invoke.assert_awaited_once_with(self.tag.get_command, tag_name="foo")
+
+    async def test_dont_call_suggestion_tag_sent(self):
+        """Should never call command suggestion if tag is already sent."""
+        self.ctx.invoked_with = "foo"
+        self.ctx.invoke = AsyncMock(return_value=True)
+        self.cog.send_command_suggestion = AsyncMock()
+
+        await self.cog.try_get_tag(self.ctx)
+        self.cog.send_command_suggestion.assert_not_awaited()
+
+    @patch("bot.exts.backend.error_handler.MODERATION_ROLES", new=[1234])
+    async def test_dont_call_suggestion_if_user_mod(self):
+        """Should not call command suggestion if user is a mod."""
+        self.ctx.invoked_with = "foo"
+        self.ctx.invoke = AsyncMock(return_value=False)
+        self.ctx.author.roles = [MockRole(id=1234)]
+        self.cog.send_command_suggestion = AsyncMock()
+
+        await self.cog.try_get_tag(self.ctx)
+        self.cog.send_command_suggestion.assert_not_awaited()
+
+    async def test_call_suggestion(self):
+        """Should call command suggestion if user is not a mod."""
+        self.ctx.invoked_with = "foo"
+        self.ctx.invoke = AsyncMock(return_value=False)
+        self.cog.send_command_suggestion = AsyncMock()
+
+        await self.cog.try_get_tag(self.ctx)
+        self.cog.send_command_suggestion.assert_awaited_once_with(self.ctx, "foo")
+
+
+class IndividualErrorHandlerTests(unittest.IsolatedAsyncioTestCase):
+    """Individual error categories handler tests."""
+
+    def setUp(self):
+        self.bot = MockBot()
+        self.ctx = MockContext(bot=self.bot)
+        self.cog = ErrorHandler(self.bot)
+
+    async def test_handle_input_error_handler_errors(self):
+        """Should handle each error probably."""
+        test_cases = (
+            {
+                "error": errors.MissingRequiredArgument(MagicMock()),
+                "call_prepared": True
+            },
+            {
+                "error": errors.TooManyArguments(),
+                "call_prepared": True
+            },
+            {
+                "error": errors.BadArgument(),
+                "call_prepared": True
+            },
+            {
+                "error": errors.BadUnionArgument(MagicMock(), MagicMock(), MagicMock()),
+                "call_prepared": True
+            },
+            {
+                "error": errors.ArgumentParsingError(),
+                "call_prepared": False
+            },
+            {
+                "error": errors.UserInputError(),
+                "call_prepared": True
+            }
+        )
+
+        for case in test_cases:
+            with self.subTest(error=case["error"], call_prepared=case["call_prepared"]):
+                self.ctx.reset_mock()
+                self.assertIsNone(await self.cog.handle_user_input_error(self.ctx, case["error"]))
+                self.ctx.send.assert_awaited_once()
+                if case["call_prepared"]:
+                    self.ctx.send_help.assert_awaited_once()
+                else:
+                    self.ctx.send_help.assert_not_awaited()
+
+    async def test_handle_check_failure_errors(self):
+        """Should await `ctx.send` when error is check failure."""
+        test_cases = (
+            {
+                "error": errors.BotMissingPermissions(MagicMock()),
+                "call_ctx_send": True
+            },
+            {
+                "error": errors.BotMissingRole(MagicMock()),
+                "call_ctx_send": True
+            },
+            {
+                "error": errors.BotMissingAnyRole(MagicMock()),
+                "call_ctx_send": True
+            },
+            {
+                "error": errors.NoPrivateMessage(),
+                "call_ctx_send": True
+            },
+            {
+                "error": InWhitelistCheckFailure(1234),
+                "call_ctx_send": True
+            },
+            {
+                "error": ResponseCodeError(MagicMock()),
+                "call_ctx_send": False
+            }
+        )
+
+        for case in test_cases:
+            with self.subTest(error=case["error"], call_ctx_send=case["call_ctx_send"]):
+                self.ctx.reset_mock()
+                await self.cog.handle_check_failure(self.ctx, case["error"])
+                if case["call_ctx_send"]:
+                    self.ctx.send.assert_awaited_once()
+                else:
+                    self.ctx.send.assert_not_awaited()
+
+    @patch("bot.exts.backend.error_handler.log")
+    async def test_handle_api_error(self, log_mock):
+        """Should `ctx.send` on HTTP error codes, `log.debug|warning` depends on code."""
+        test_cases = (
+            {
+                "error": ResponseCodeError(AsyncMock(status=400)),
+                "log_level": "debug"
+            },
+            {
+                "error": ResponseCodeError(AsyncMock(status=404)),
+                "log_level": "debug"
+            },
+            {
+                "error": ResponseCodeError(AsyncMock(status=550)),
+                "log_level": "warning"
+            },
+            {
+                "error": ResponseCodeError(AsyncMock(status=1000)),
+                "log_level": "warning"
+            }
+        )
+
+        for case in test_cases:
+            with self.subTest(error=case["error"], log_level=case["log_level"]):
+                self.ctx.reset_mock()
+                log_mock.reset_mock()
+                await self.cog.handle_api_error(self.ctx, case["error"])
+                self.ctx.send.assert_awaited_once()
+                if case["log_level"] == "warning":
+                    log_mock.warning.assert_called_once()
+                else:
+                    log_mock.debug.assert_called_once()
+
+    @patch("bot.exts.backend.error_handler.push_scope")
+    @patch("bot.exts.backend.error_handler.log")
+    async def test_handle_unexpected_error(self, log_mock, push_scope_mock):
+        """Should `ctx.send` this error, error log this and sent to Sentry."""
+        for case in (None, MockGuild()):
+            with self.subTest(guild=case):
+                self.ctx.reset_mock()
+                log_mock.reset_mock()
+                push_scope_mock.reset_mock()
+
+                self.ctx.guild = case
+                await self.cog.handle_unexpected_error(self.ctx, errors.CommandError())
+
+                self.ctx.send.assert_awaited_once()
+                log_mock.error.assert_called_once()
+                push_scope_mock.assert_called_once()
+
+                set_tag_calls = [
+                    call("command", self.ctx.command.qualified_name),
+                    call("message_id", self.ctx.message.id),
+                    call("channel_id", self.ctx.channel.id),
+                ]
+                set_extra_calls = [
+                    call("full_message", self.ctx.message.content)
+                ]
+                if case:
+                    url = (
+                        f"https://discordapp.com/channels/"
+                        f"{self.ctx.guild.id}/{self.ctx.channel.id}/{self.ctx.message.id}"
+                    )
+                    set_extra_calls.append(call("jump_to", url))
+
+                push_scope_mock.set_tag.has_calls(set_tag_calls)
+                push_scope_mock.set_extra.has_calls(set_extra_calls)
+
+
+class OtherErrorHandlerTests(unittest.IsolatedAsyncioTestCase):
+    """Other `ErrorHandler` tests."""
+
+    def setUp(self):
+        self.bot = MockBot()
+        self.ctx = MockContext()
+
+    async def test_get_help_command_command_specified(self):
+        """Should return coroutine of help command of specified command."""
+        self.ctx.command = "foo"
+        result = ErrorHandler.get_help_command(self.ctx)
+        expected = self.ctx.send_help("foo")
+        self.assertEqual(result.__qualname__, expected.__qualname__)
+        self.assertEqual(result.cr_frame.f_locals, expected.cr_frame.f_locals)
+
+        # Await coroutines to avoid warnings
+        await result
+        await expected
+
+    async def test_get_help_command_no_command_specified(self):
+        """Should return coroutine of help command."""
+        self.ctx.command = None
+        result = ErrorHandler.get_help_command(self.ctx)
+        expected = self.ctx.send_help()
+        self.assertEqual(result.__qualname__, expected.__qualname__)
+        self.assertEqual(result.cr_frame.f_locals, expected.cr_frame.f_locals)
+
+        # Await coroutines to avoid warnings
+        await result
+        await expected
+
+
+class ErrorHandlerSetupTests(unittest.TestCase):
+    """Tests for `ErrorHandler` `setup` function."""
+
+    def test_setup(self):
+        """Should call `bot.add_cog` with `ErrorHandler`."""
+        bot = MockBot()
+        setup(bot)
+        bot.add_cog.assert_called_once()
diff --git a/tests/bot/exts/info/test_information.py b/tests/bot/exts/info/test_information.py
index a996ce477..770660fe3 100644
--- a/tests/bot/exts/info/test_information.py
+++ b/tests/bot/exts/info/test_information.py
@@ -281,6 +281,7 @@ class UserEmbedTests(unittest.IsolatedAsyncioTestCase):
         """The embed should use the string representation of the user if they don't have a nick."""
         ctx = helpers.MockContext(channel=helpers.MockTextChannel(id=1))
         user = helpers.MockMember()
+        user.public_flags = unittest.mock.MagicMock(verified_bot=False)
         user.nick = None
         user.__str__ = unittest.mock.Mock(return_value="Mr. Hemlock")
         user.colour = 0
@@ -297,6 +298,7 @@ class UserEmbedTests(unittest.IsolatedAsyncioTestCase):
         """The embed should use the nick if it's available."""
         ctx = helpers.MockContext(channel=helpers.MockTextChannel(id=1))
         user = helpers.MockMember()
+        user.public_flags = unittest.mock.MagicMock(verified_bot=False)
         user.nick = "Cat lover"
         user.__str__ = unittest.mock.Mock(return_value="Mr. Hemlock")
         user.colour = 0
diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index 08f39cd50..b9d527770 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -74,7 +74,7 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         """Should call voice ban applying function without expiry."""
         self.cog.apply_voice_ban = AsyncMock()
         self.assertIsNone(await self.cog.voiceban(self.cog, self.ctx, self.user, reason="foobar"))
-        self.cog.apply_voice_ban.assert_awaited_once_with(self.ctx, self.user, "foobar")
+        self.cog.apply_voice_ban.assert_awaited_once_with(self.ctx, self.user, "foobar", expires_at=None)
 
     async def test_temporary_voice_ban(self):
         """Should call voice ban applying function with expiry."""
@@ -184,7 +184,7 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
 
         user = MockUser()
         await self.cog.voiceban(self.cog, self.ctx, user, reason=None)
-        post_infraction_mock.assert_called_once_with(self.ctx, user, "voice_ban", None, active=True)
+        post_infraction_mock.assert_called_once_with(self.ctx, user, "voice_ban", None, active=True, expires_at=None)
         apply_infraction_mock.assert_called_once_with(self.cog, self.ctx, infraction, user, ANY)
 
         # Test action
diff --git a/tests/helpers.py b/tests/helpers.py
index 496363ae3..e3dc5fe5b 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -385,6 +385,7 @@ message_instance = discord.Message(state=state, channel=channel, data=message_da
 
 # Create a Context instance to get a realistic MagicMock of `discord.ext.commands.Context`
 context_instance = Context(message=unittest.mock.MagicMock(), prefix=unittest.mock.MagicMock())
+context_instance.invoked_from_error_handler = None
 
 
 class MockContext(CustomMockMixin, unittest.mock.MagicMock):
@@ -402,6 +403,7 @@ class MockContext(CustomMockMixin, unittest.mock.MagicMock):
         self.guild = kwargs.get('guild', MockGuild())
         self.author = kwargs.get('author', MockMember())
         self.channel = kwargs.get('channel', MockTextChannel())
+        self.invoked_from_error_handler = kwargs.get('invoked_from_error_handler', False)
 
 
 attachment_instance = discord.Attachment(data=unittest.mock.MagicMock(id=1), state=unittest.mock.MagicMock())