diff --git a/DisCatSharp/Clients/BaseDiscordClient.cs b/DisCatSharp/Clients/BaseDiscordClient.cs
index 28ed752e8..9d1721702 100644
--- a/DisCatSharp/Clients/BaseDiscordClient.cs
+++ b/DisCatSharp/Clients/BaseDiscordClient.cs
@@ -1,483 +1,498 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2023 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 #pragma warning disable CS0618
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.IO;
 using System.Linq;
 using System.Net.Http;
 using System.Reflection;
 using System.Threading.Tasks;
 
 using DisCatSharp.Attributes;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net;
 
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Console;
 using Microsoft.Extensions.Options;
 
 using Sentry;
 
 namespace DisCatSharp;
 
 /// <summary>
 /// Represents a common base for various Discord Client implementations.
 /// </summary>
 public abstract class BaseDiscordClient : IDisposable
 {
 	/// <summary>
 	/// Gets the api client.
 	/// </summary>
 	internal protected DiscordApiClient ApiClient { get; }
 
 	/// <summary>
 	/// Gets the sentry client.
 	/// </summary>
 	internal SentryClient Sentry { get; set; }
 
 	/// <summary>
 	/// Gets the sentry dsn.
 	/// </summary>
 	internal static string SentryDsn
 		=> "https://1da216e26a2741b99e8ccfccea1b7ac8@o1113828.ingest.sentry.io/4504901362515968";
 
 	/// <summary>
 	/// Gets the configuration.
 	/// </summary>
 	internal protected DiscordConfiguration Configuration { get; }
 
 	/// <summary>
 	/// Gets the instance of the logger for this client.
 	/// </summary>
 	public ILogger<BaseDiscordClient> Logger { get; internal set; }
 
 	/// <summary>
 	/// Gets the string representing the version of bot lib.
 	/// </summary>
 	public string VersionString { get; }
 
 	/// <summary>
 	/// Gets the bot library name.
 	/// </summary>
 	public string BotLibrary
 		=> "DisCatSharp";
 
 	/// <summary>
 	/// Gets the current user.
 	/// </summary>
 	public DiscordUser CurrentUser { get; internal set; }
 
 	/// <summary>
 	/// Gets the current application.
 	/// </summary>
 	public DiscordApplication CurrentApplication { get; internal set; }
 
 	/// <summary>
 	/// Exposes a <see cref="HttpClient">Http Client</see> for custom operations.
 	/// </summary>
 	public HttpClient RestClient { get; internal set; }
 
 	/// <summary>
 	/// Gets the cached guilds for this client.
 	/// </summary>
 	public abstract IReadOnlyDictionary<ulong, DiscordGuild> Guilds { get; }
 
 	/// <summary>
 	/// Gets the cached users for this client.
 	/// </summary>
 	public ConcurrentDictionary<ulong, DiscordUser> UserCache { get; internal set; }
 
 	/// <summary>
 	/// <para>Gets the service provider.</para>
 	/// <para>This allows passing data around without resorting to static members.</para>
 	/// <para>Defaults to null.</para>
 	/// </summary>
 	internal IServiceProvider ServiceProvider { get; set; }
 
 	/// <summary>
 	/// Gets the list of available voice regions. Note that this property will not contain VIP voice regions.
 	/// </summary>
 	public IReadOnlyDictionary<string, DiscordVoiceRegion> VoiceRegions
 		=> this.VoiceRegionsLazy.Value;
 
 	/// <summary>
 	/// Gets the list of available voice regions. This property is meant as a way to modify <see cref="VoiceRegions"/>.
 	/// </summary>
 	protected internal ConcurrentDictionary<string, DiscordVoiceRegion> InternalVoiceRegions { get; set; }
 	internal Lazy<IReadOnlyDictionary<string, DiscordVoiceRegion>> VoiceRegionsLazy;
 
 	/// <summary>
 	/// Initializes this Discord API client.
 	/// </summary>
 	/// <param name="config">Configuration for this client.</param>
 	protected BaseDiscordClient(DiscordConfiguration config)
 	{
 		this.Configuration = new DiscordConfiguration(config);
 		this.ServiceProvider = config.ServiceProvider;
 
 		if (this.ServiceProvider != null)
 		{
 			this.Configuration.LoggerFactory ??= config.ServiceProvider.GetService<ILoggerFactory>()!;
 			this.Logger = config.ServiceProvider.GetService<ILogger<BaseDiscordClient>>()!;
 		}
 
 		if (this.Configuration.LoggerFactory == null && !this.Configuration.EnableSentry)
 		{
 			this.Configuration.LoggerFactory = new DefaultLoggerFactory();
 			this.Configuration.LoggerFactory.AddProvider(new DefaultLoggerProvider(this));
 		}
 		else if (this.Configuration.LoggerFactory == null && this.Configuration.EnableSentry)
 		{
 			var configureNamedOptions = new ConfigureNamedOptions<ConsoleLoggerOptions>(string.Empty, x =>
 			{
 				x.Format = ConsoleLoggerFormat.Default;
 				x.TimestampFormat = this.Configuration.LogTimestampFormat;
 				x.LogToStandardErrorThreshold = this.Configuration.MinimumLogLevel;
 
 			});
 			var optionsFactory = new OptionsFactory<ConsoleLoggerOptions>(new[] { configureNamedOptions }, Enumerable.Empty<IPostConfigureOptions<ConsoleLoggerOptions>>());
 			var optionsMonitor = new OptionsMonitor<ConsoleLoggerOptions>(optionsFactory, Enumerable.Empty<IOptionsChangeTokenSource<ConsoleLoggerOptions>>(), new OptionsCache<ConsoleLoggerOptions>());
 
 			var l = new ConsoleLoggerProvider(optionsMonitor);
 			this.Configuration.LoggerFactory = new LoggerFactory();
 			this.Configuration.LoggerFactory.AddProvider(l);
 		}
 
 		var ass = typeof(DiscordClient).GetTypeInfo().Assembly;
 		var vrs = "";
 		var ivr = ass.GetCustomAttribute<AssemblyInformationalVersionAttribute>();
 		if (ivr != null)
 			vrs = ivr.InformationalVersion;
 		else
 		{
 			var v = ass.GetName().Version;
 			vrs = v?.ToString(3);
 		}
 
 		if (!this.Configuration.HasShardLogger)
 			if (this.Configuration.LoggerFactory != null && this.Configuration.EnableSentry)
 			{
 				this.Configuration.LoggerFactory.AddSentry(o =>
 				{
 					o.InitializeSdk = true;
 					o.Dsn = SentryDsn;
 					o.DetectStartupTime = StartupTimeDetectionMode.Fast;
 					o.DiagnosticLevel = SentryLevel.Debug;
 					o.Environment = "dev";
-					o.IsGlobalModeEnabled = true;
+					o.IsGlobalModeEnabled = false;
 					o.TracesSampleRate = 1.0;
 					o.ReportAssembliesMode = ReportAssembliesMode.InformationalVersion;
 					o.AddInAppInclude("DisCatSharp");
 					o.AttachStacktrace = true;
 					o.StackTraceMode = StackTraceMode.Enhanced;
 					o.Release = $"{this.BotLibrary}@{vrs}";
 					o.SendClientReports = true;
 					o.IsEnvironmentUser = false;
 					o.UseAsyncFileIO = true;
 					o.EnableScopeSync = true;
+					o.AddExceptionFilter(new DisCatSharpExceptionFilter(this.Configuration));
 					o.BeforeSend = e =>
 					{
-						if (e.Exception?.Message?.ToLower()?.Contains("connection") ?? false)
+						if (e.Exception != null)
+						{
+							if (!this.Configuration.TrackExceptions.Contains(e.Exception.GetType()))
+								return null;
+						}
+						else if (e.Extra.Count == 0 || !e.Extra.ContainsKey("Found Fields"))
 							return null;
+
 						if (!e.HasUser())
 							if (this.Configuration.AttachUserInfo && this.CurrentUser! != null!)
 								e.User = new()
 								{
 									Id = this.CurrentUser.Id.ToString(),
 									Username = this.CurrentUser.UsernameWithDiscriminator,
 									Other = new Dictionary<string, string>()
 								{
 									{ "developer", this.Configuration.DeveloperUserId?.ToString() ?? "not_given" },
 									{ "email", this.Configuration.FeedbackEmail ?? "not_given" }
 								}
 								};
 						return e;
 					};
 				});
 			}
 
 		if (this.Configuration.EnableSentry)
 			this.Sentry = new SentryClient(new SentryOptions()
 			{
 				DetectStartupTime = StartupTimeDetectionMode.Fast,
 				DiagnosticLevel = SentryLevel.Debug,
 				Environment = "dev",
-				IsGlobalModeEnabled = true,
+				IsGlobalModeEnabled = false,
 				TracesSampleRate = 1.0,
 				ReportAssembliesMode = ReportAssembliesMode.InformationalVersion,
 				Dsn = SentryDsn,
 				AttachStacktrace = true,
 				StackTraceMode = StackTraceMode.Enhanced,
 				SendClientReports = true,
 				Release = $"{this.BotLibrary}@{vrs}",
 				IsEnvironmentUser = false,
 				UseAsyncFileIO = true,
 				EnableScopeSync = true,
 				BeforeSend = e =>
 				{
+					if (e.Exception != null)
+					{
+						if (!this.Configuration.TrackExceptions.Contains(e.Exception.GetType()))
+							return null;
+					}
+					else if (e.Extra.Count == 0 || !e.Extra.ContainsKey("Found Fields"))
+						return null;
+
 					if (!e.HasUser())
 						if (this.Configuration.AttachUserInfo && this.CurrentUser! != null!)
 							e.User = new()
 							{
 								Id = this.CurrentUser.Id.ToString(),
 								Username = this.CurrentUser.UsernameWithDiscriminator,
 								Other = new Dictionary<string, string>()
 									{
 										{ "developer", this.Configuration.DeveloperUserId?.ToString() ?? "not_given" },
 										{ "email", this.Configuration.FeedbackEmail ?? "not_given" }
 									}
 							};
 					return e;
 				}
 			});
 
 		this.Logger ??= this.Configuration.LoggerFactory!.CreateLogger<BaseDiscordClient>();
 
 		this.ApiClient = new DiscordApiClient(this);
 		this.UserCache = new ConcurrentDictionary<ulong, DiscordUser>();
 		this.InternalVoiceRegions = new ConcurrentDictionary<string, DiscordVoiceRegion>();
 		this.VoiceRegionsLazy = new Lazy<IReadOnlyDictionary<string, DiscordVoiceRegion>>(() => new ReadOnlyDictionary<string, DiscordVoiceRegion>(this.InternalVoiceRegions));
 
 		this.RestClient = new();
 		this.RestClient.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", Utilities.GetUserAgent());
 		this.RestClient.DefaultRequestHeaders.TryAddWithoutValidation("x-discord-locale", this.Configuration.Locale);
 		this.RestClient.DefaultRequestHeaders.TryAddWithoutValidation("x-discord-timezone", this.Configuration.Timezone);
 		if (this.Configuration.Override != null)
 			this.RestClient.DefaultRequestHeaders.TryAddWithoutValidation("x-super-properties", this.Configuration.Override);
 
 		var a = typeof(DiscordClient).GetTypeInfo().Assembly;
 
 		var iv = a.GetCustomAttribute<AssemblyInformationalVersionAttribute>();
 		if (iv != null)
 		{
 			this.VersionString = iv.InformationalVersion;
 		}
 		else
 		{
 			var v = a.GetName().Version;
 			var vs = v.ToString(3);
 
 			if (v.Revision > 0)
 				this.VersionString = $"{vs}, CI build {v.Revision}";
 		}
 	}
 
 	/// <summary>
 	/// Gets the current API application.
 	/// </summary>
 	public async Task<DiscordApplication> GetCurrentApplicationAsync()
 	{
 		var tapp = await this.ApiClient.GetCurrentApplicationOauth2InfoAsync().ConfigureAwait(false);
 		var app = new DiscordApplication
 		{
 			Discord = this,
 			Id = tapp.Id,
 			Name = tapp.Name,
 			Description = tapp.Description,
 			Summary = tapp.Summary,
 			IconHash = tapp.IconHash,
 			RpcOrigins = tapp.RpcOrigins != null ? new ReadOnlyCollection<string>(tapp.RpcOrigins) : null,
 			Flags = tapp.Flags,
 			IsHook = tapp.IsHook,
 			Type = tapp.Type,
 			PrivacyPolicyUrl = tapp.PrivacyPolicyUrl,
 			TermsOfServiceUrl = tapp.TermsOfServiceUrl,
 			CustomInstallUrl = tapp.CustomInstallUrl,
 			InstallParams = tapp.InstallParams,
 			RoleConnectionsVerificationUrl = tapp.RoleConnectionsVerificationUrl,
 			Tags = (tapp.Tags ?? Enumerable.Empty<string>()).ToArray()
 		};
 
 		if (tapp.Team == null)
 		{
 			app.Owners = new List<DiscordUser>(new[] { new DiscordUser(tapp.Owner) });
 			app.Team = null;
 			app.TeamName = null;
 		}
 		else
 		{
 			app.Team = new DiscordTeam(tapp.Team);
 
 			var members = tapp.Team.Members
 				.Select(x => new DiscordTeamMember(x) { TeamId = app.Team.Id, TeamName = app.Team.Name, User = new DiscordUser(x.User) })
 				.ToArray();
 
 			var owners = members
 				.Where(x => x.MembershipStatus == DiscordTeamMembershipStatus.Accepted)
 				.Select(x => x.User)
 				.ToArray();
 
 			app.Owners = new List<DiscordUser>(owners);
 			app.Team.Owner = owners.FirstOrDefault(x => x.Id == tapp.Team.OwnerId);
 			app.Team.Members = new List<DiscordTeamMember>(members);
 			app.TeamName = app.Team.Name;
 		}
 
 		app.GuildId = tapp.GuildId.ValueOrDefault();
 		app.Slug = tapp.Slug.ValueOrDefault();
 		app.PrimarySkuId = tapp.PrimarySkuId.ValueOrDefault();
 		app.VerifyKey = tapp.VerifyKey.ValueOrDefault();
 		app.CoverImageHash = tapp.CoverImageHash.ValueOrDefault();
 		app.Guild = tapp.Guild.ValueOrDefault();
 		app.ApproximateGuildCount = tapp.ApproximateGuildCount.ValueOrDefault();
 		app.RequiresCodeGrant = tapp.BotRequiresCodeGrant.ValueOrDefault();
 		app.IsPublic = tapp.IsPublicBot.ValueOrDefault();
 		app.RedirectUris = tapp.RedirectUris.ValueOrDefault();
 		app.InteractionsEndpointUrl = tapp.InteractionsEndpointUrl.ValueOrDefault();
 
 		return app;
 	}
 
 	/// <summary>
 	/// Updates the current API application.
 	/// </summary>
 	/// <param name="description">The new description.</param>
 	/// <param name="interactionsEndpointUrl">The new interactions endpoint url.</param>
 	/// <param name="roleConnectionsVerificationUrl">The new role connections verification url.</param>
 	/// <param name="tags">The new tags.</param>
 	/// <param name="icon">The new application icon.</param>
 	/// <returns>The updated application.</returns>
 	public async Task<DiscordApplication> UpdateCurrentApplicationInfoAsync(Optional<string> description, Optional<string> interactionsEndpointUrl, Optional<string> roleConnectionsVerificationUrl, Optional<List<string>?> tags, Optional<Stream> icon)
 	{
 		var iconb64 = ImageTool.Base64FromStream(icon);
 		if (tags != null && tags.HasValue && tags.Value != null)
 			if (tags.Value.Any(x => x.Length > 20))
 				throw new InvalidOperationException("Tags can not exceed 20 chars.");
 		_ = await this.ApiClient.ModifyCurrentApplicationInfoAsync(description, interactionsEndpointUrl, roleConnectionsVerificationUrl, tags, iconb64);
 		// We use GetCurrentApplicationAsync because modify returns internal data not meant for developers.
 		var app = await this.GetCurrentApplicationAsync();
 		this.CurrentApplication = app;
 		return app;
 	}
 
 	/// <summary>
 	/// Gets a list of voice regions.
 	/// </summary>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordVoiceRegion>> ListVoiceRegionsAsync()
 		=> this.ApiClient.ListVoiceRegionsAsync();
 
 	/// <summary>
 	/// Initializes this client. This method fetches information about current user, application, and voice regions.
 	/// </summary>
 	public virtual async Task InitializeAsync()
 	{
 		if (this.CurrentUser == null)
 		{
 			this.CurrentUser = await this.ApiClient.GetCurrentUserAsync().ConfigureAwait(false);
 			this.UserCache.AddOrUpdate(this.CurrentUser.Id, this.CurrentUser, (id, xu) => this.CurrentUser);
 		}
 
 		if (this.Configuration.TokenType == TokenType.Bot && this.CurrentApplication == null)
 			this.CurrentApplication = await this.GetCurrentApplicationAsync().ConfigureAwait(false);
 
 		if (this.Configuration.TokenType != TokenType.Bearer && this.InternalVoiceRegions.IsEmpty)
 		{
 			var vrs = await this.ListVoiceRegionsAsync().ConfigureAwait(false);
 			foreach (var xvr in vrs)
 				this.InternalVoiceRegions.TryAdd(xvr.Id, xvr);
 		}
 
 		if (this.Configuration.EnableSentry && this.Configuration.AttachUserInfo)
 			SentrySdk.ConfigureScope(x => x.User = new User()
 			{
 				Id = this.CurrentUser.Id.ToString(),
 				Username = this.CurrentUser.UsernameWithDiscriminator,
 				Other = new Dictionary<string, string>()
 				{
 					{ "developer", this.Configuration.DeveloperUserId?.ToString() ?? "not_given" },
 					{ "email", this.Configuration.FeedbackEmail ?? "not_given" }
 				}
 			});
 	}
 
 	/// <summary>
 	/// Gets the current gateway info for the provided token.
 	/// <para>If no value is provided, the configuration value will be used instead.</para>
 	/// </summary>
 	/// <returns>A gateway info object.</returns>
 	public async Task<GatewayInfo> GetGatewayInfoAsync(string token = null)
 	{
 		if (this.Configuration.TokenType != TokenType.Bot)
 			throw new InvalidOperationException("Only bot tokens can access this info.");
 
 		if (string.IsNullOrEmpty(this.Configuration.Token))
 		{
 			if (string.IsNullOrEmpty(token))
 				throw new InvalidOperationException("Could not locate a valid token.");
 
 			this.Configuration.Token = token;
 
 			var res = await this.ApiClient.GetGatewayInfoAsync().ConfigureAwait(false);
 			this.Configuration.Token = null;
 			return res;
 		}
 
 		return await this.ApiClient.GetGatewayInfoAsync().ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Gets some information about the development team behind DisCatSharp.
 	/// Can be used for crediting etc.
 	/// <para>Note: This call contacts servers managed by the DCS team, no information is collected.</para>
 	/// <returns>The team, or null with errors being logged on failure.</returns>
 	/// </summary>
 	[Deprecated("Don't use this right now, inactive")]
 	public async Task<DisCatSharpTeam> GetLibraryDevelopmentTeamAsync()
 		=> await DisCatSharpTeam.Get(this.RestClient, this.Logger, this.ApiClient).ConfigureAwait(false);
 
 	/// <summary>
 	/// Gets a cached user.
 	/// </summary>
 	/// <param name="userId">The user id.</param>
 	internal DiscordUser GetCachedOrEmptyUserInternal(ulong userId)
 	{
 		this.TryGetCachedUserInternal(userId, out var user);
 		return user;
 	}
 
 	/// <summary>
 	/// Tries the get a cached user.
 	/// </summary>
 	/// <param name="userId">The user id.</param>
 	/// <param name="user">The user.</param>
 	internal bool TryGetCachedUserInternal(ulong userId, out DiscordUser user)
 	{
 		if (this.UserCache.TryGetValue(userId, out user))
 			return true;
 
 		user = new DiscordUser { Id = userId, Discord = this };
 		return false;
 	}
 
 	/// <summary>
 	/// Disposes this client.
 	/// </summary>
 	public abstract void Dispose();
 }
diff --git a/DisCatSharp/Clients/DiscordShardedClient.cs b/DisCatSharp/Clients/DiscordShardedClient.cs
index b146d98f5..621ca8b6e 100644
--- a/DisCatSharp/Clients/DiscordShardedClient.cs
+++ b/DisCatSharp/Clients/DiscordShardedClient.cs
@@ -1,871 +1,880 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2023 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 #pragma warning disable CS0618
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Diagnostics;
 using System.Globalization;
 using System.Linq;
 using System.Net.Http;
 using System.Reflection;
 using System.Threading.Tasks;
 
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
+using DisCatSharp.Exceptions;
 using DisCatSharp.Net;
 
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Console;
 using Microsoft.Extensions.Options;
 
 using Newtonsoft.Json.Linq;
 
 using Sentry;
 
 namespace DisCatSharp;
 
 /// <summary>
 /// A Discord client that shards automatically.
 /// </summary>
 public sealed partial class DiscordShardedClient
 {
 	#region Public Properties
 
 	/// <summary>
 	/// Gets the logger for this client.
 	/// </summary>
 	public ILogger<BaseDiscordClient> Logger { get; }
 
 	/// <summary>
 	/// Gets all client shards.
 	/// </summary>
 	public IReadOnlyDictionary<int, DiscordClient> ShardClients { get; }
 
 	/// <summary>
 	/// Gets the gateway info for the client's session.
 	/// </summary>
 	public GatewayInfo GatewayInfo { get; private set; }
 
 	/// <summary>
 	/// Gets the current user.
 	/// </summary>
 	public DiscordUser CurrentUser { get; private set; }
 
 	/// <summary>
 	/// Gets the bot library name.
 	/// </summary>
 	public string BotLibrary
 		=> "DisCatSharp";
 
 	/// <summary>
 	/// Gets the current application.
 	/// </summary>
 	public DiscordApplication CurrentApplication { get; private set; }
 
 	/// <summary>
 	/// Gets the list of available voice regions. Note that this property will not contain VIP voice regions.
 	/// </summary>
 	public IReadOnlyDictionary<string, DiscordVoiceRegion> VoiceRegions
 		=> this._voiceRegionsLazy?.Value;
 
 	#endregion
 
 	#region Private Properties/Fields
 
 	/// <summary>
 	/// Gets the configuration.
 	/// </summary>
 	private readonly DiscordConfiguration _configuration;
 
 	/// <summary>
 	/// Gets the list of available voice regions. This property is meant as a way to modify <see cref="VoiceRegions"/>.
 	/// </summary>
 	private ConcurrentDictionary<string, DiscordVoiceRegion> _internalVoiceRegions;
 
 	/// <summary>
 	/// Gets a list of shards.
 	/// </summary>
 	private readonly ConcurrentDictionary<int, DiscordClient> _shards = new();
 
 	/// <summary>
 	/// Gets a lazy list of voice regions.
 	/// </summary>
 	private Lazy<IReadOnlyDictionary<string, DiscordVoiceRegion>> _voiceRegionsLazy;
 
 	/// <summary>
 	/// Whether the shard client is started.
 	/// </summary>
 	private bool _isStarted;
 
 	/// <summary>
 	/// Whether manual sharding is enabled.
 	/// </summary>
 	private readonly bool _manuallySharding;
 
 	#endregion
 
 	#region Constructor
 
 	/// <summary>
 	/// Initializes a new auto-sharding Discord client.
 	/// </summary>
 	/// <param name="config">The configuration to use.</param>
 	public DiscordShardedClient(DiscordConfiguration config)
 	{
 		this.InternalSetup();
 
 		if (config.ShardCount > 1)
 			this._manuallySharding = true;
 
 		this._configuration = config;
 		this.ShardClients = new ReadOnlyConcurrentDictionary<int, DiscordClient>(this._shards);
 
 		if (this._configuration.LoggerFactory == null && !this._configuration.EnableSentry)
 		{
 			this._configuration.LoggerFactory = new DefaultLoggerFactory();
 			this._configuration.LoggerFactory.AddProvider(new DefaultLoggerProvider(this._configuration.MinimumLogLevel, this._configuration.LogTimestampFormat));
 		}
 		else if (this._configuration.LoggerFactory == null && this._configuration.EnableSentry)
 		{
 			var configureNamedOptions = new ConfigureNamedOptions<ConsoleLoggerOptions>(string.Empty, x =>
 			{
 				x.Format = ConsoleLoggerFormat.Default;
 				x.TimestampFormat = this._configuration.LogTimestampFormat;
 				x.LogToStandardErrorThreshold = this._configuration.MinimumLogLevel;
 
 			}); var optionsFactory = new OptionsFactory<ConsoleLoggerOptions>(new[] { configureNamedOptions }, Enumerable.Empty<IPostConfigureOptions<ConsoleLoggerOptions>>());
 			var optionsMonitor = new OptionsMonitor<ConsoleLoggerOptions>(optionsFactory, Enumerable.Empty<IOptionsChangeTokenSource<ConsoleLoggerOptions>>(), new OptionsCache<ConsoleLoggerOptions>());
 
 			var l = new ConsoleLoggerProvider(optionsMonitor);
 			this._configuration.LoggerFactory = new LoggerFactory();
 			this._configuration.LoggerFactory.AddProvider(l);
 		}
 
 		if (this._configuration.LoggerFactory != null && this._configuration.EnableSentry)
 			this._configuration.LoggerFactory.AddSentry(o =>
 			{
 				var a = typeof(DiscordClient).GetTypeInfo().Assembly;
 				var vs = "";
 				var iv = a.GetCustomAttribute<AssemblyInformationalVersionAttribute>();
 				if (iv != null)
 					vs = iv.InformationalVersion;
 				else
 				{
 					var v = a.GetName().Version;
 					vs = v?.ToString(3);
 				}
 				o.InitializeSdk = true;
 				o.Dsn = BaseDiscordClient.SentryDsn;
 				o.DetectStartupTime = StartupTimeDetectionMode.Fast;
 				o.DiagnosticLevel = SentryLevel.Debug;
 				o.Environment = "dev";
-				o.IsGlobalModeEnabled = true;
+				o.IsGlobalModeEnabled = false;
 				o.TracesSampleRate = 1.0;
 				o.ReportAssembliesMode = ReportAssembliesMode.InformationalVersion;
 				o.AddInAppInclude("DisCatSharp");
 				o.AttachStacktrace = true;
 				o.StackTraceMode = StackTraceMode.Enhanced;
 				o.Release = $"{this.BotLibrary}@{vs}";
 				o.SendClientReports = true;
+				o.AddExceptionFilter(new DisCatSharpExceptionFilter(this._configuration));
 				o.IsEnvironmentUser = false;
 				o.UseAsyncFileIO = true;
+				o.Debug = true;
 				o.EnableScopeSync = true;
 				o.BeforeSend = e =>
 				{
-					if (e.Exception?.Message?.ToLower()?.Contains("connection") ?? false)
+					if (e.Exception != null)
+					{
+						if (!this._configuration.TrackExceptions.Contains(e.Exception.GetType()))
+							return null;
+					}
+					else if (e.Extra.Count == 0 || !e.Extra.ContainsKey("Found Fields"))
 						return null;
+
 					if (!e.HasUser())
 						if (this._configuration.AttachUserInfo && this.CurrentUser! != null!)
 							e.User = new()
 							{
 								Id = this.CurrentUser.Id.ToString(),
 								Username = this.CurrentUser.UsernameWithDiscriminator,
 								Other = new Dictionary<string, string>()
 								{
 									{ "developer", this._configuration.DeveloperUserId?.ToString() ?? "not_given" },
 									{ "email", this._configuration.FeedbackEmail ?? "not_given" }
 								}
 							};
 					return e;
 				};
 			});
 
 		this._configuration.HasShardLogger = true;
 
 		this.Logger ??= this._configuration.LoggerFactory!.CreateLogger<BaseDiscordClient>();
 	}
 
 	#endregion
 
 	#region Public Methods
 
 	/// <summary>
 	/// Initializes and connects all shards.
 	/// </summary>
 	/// <exception cref="AggregateException"></exception>
 	/// <exception cref="InvalidOperationException"></exception>
 	public async Task StartAsync()
 	{
 		if (this._isStarted)
 			throw new InvalidOperationException("This client has already been started.");
 
 		this._isStarted = true;
 
 		try
 		{
 			if (this._configuration.TokenType != TokenType.Bot)
 				this.Logger.LogWarning(LoggerEvents.Misc, "You are logging in with a token that is not a bot token. This is not officially supported by Discord, and can result in your account being terminated if you aren't careful.");
 			this.Logger.LogInformation(LoggerEvents.Startup, "Lib {0}, version {1}", this._botLibrary, this._versionString.Value);
 
 			var shardc = await this.InitializeShardsAsync().ConfigureAwait(false);
 			var connectTasks = new List<Task>();
 			this.Logger.LogInformation(LoggerEvents.ShardStartup, "Booting {0} shards.", shardc);
 
 			for (var i = 0; i < shardc; i++)
 			{
 				//This should never happen, but in case it does...
 				if (this.GatewayInfo.SessionBucket.MaxConcurrency < 1)
 					this.GatewayInfo.SessionBucket.MaxConcurrency = 1;
 
 				if (this.GatewayInfo.SessionBucket.MaxConcurrency == 1)
 					await this.ConnectShardAsync(i).ConfigureAwait(false);
 				else
 				{
 					//Concurrent login.
 					connectTasks.Add(this.ConnectShardAsync(i));
 
 					if (connectTasks.Count == this.GatewayInfo.SessionBucket.MaxConcurrency)
 					{
 						await Task.WhenAll(connectTasks).ConfigureAwait(false);
 						connectTasks.Clear();
 					}
 				}
 			}
 		}
 		catch (Exception ex)
 		{
 			await this.InternalStopAsync(false).ConfigureAwait(false);
 
 			var message = $"Shard initialization failed, check inner exceptions for details: ";
 
 			this.Logger.LogCritical(LoggerEvents.ShardClientError, $"{message}\n{ex}");
 			throw new AggregateException(message, ex);
 		}
 	}
 
 	/// <summary>
 	/// Disconnects and disposes all shards.
 	/// </summary>
 	/// <exception cref="InvalidOperationException"></exception>
 	public Task StopAsync()
 		=> this.InternalStopAsync();
 
 	/// <summary>
 	/// Gets a shard from a guild id.
 	/// <para>
 	///     If automatically sharding, this will use the <see cref="Utilities.GetShardId(ulong, int)"/> method.
 	///     Otherwise if manually sharding, it will instead iterate through each shard's guild caches.
 	/// </para>
 	/// </summary>
 	/// <param name="guildId">The guild ID for the shard.</param>
 	/// <returns>The found <see cref="DiscordClient"/> shard. Otherwise null if the shard was not found for the guild id.</returns>
 	public DiscordClient GetShard(ulong guildId)
 	{
 		var index = this._manuallySharding ? this.GetShardIdFromGuilds(guildId) : Utilities.GetShardId(guildId, this.ShardClients.Count);
 
 		return index != -1 ? this._shards[index] : null;
 	}
 
 	/// <summary>
 	/// Gets a shard from a guild.
 	/// <para>
 	///     If automatically sharding, this will use the <see cref="Utilities.GetShardId(ulong, int)"/> method.
 	///     Otherwise if manually sharding, it will instead iterate through each shard's guild caches.
 	/// </para>
 	/// </summary>
 	/// <param name="guild">The guild for the shard.</param>
 	/// <returns>The found <see cref="DiscordClient"/> shard. Otherwise null if the shard was not found for the guild.</returns>
 	public DiscordClient GetShard(DiscordGuild guild)
 		=> this.GetShard(guild.Id);
 
 	/// <summary>
 	/// Updates the status on all shards.
 	/// </summary>
 	/// <param name="activity">The activity to set. Defaults to null.</param>
 	/// <param name="userStatus">The optional status to set. Defaults to null.</param>
 	/// <param name="idleSince">Since when is the client performing the specified activity. Defaults to null.</param>
 	/// <returns>Asynchronous operation.</returns>
 	public async Task UpdateStatusAsync(DiscordActivity activity = null, UserStatus? userStatus = null, DateTimeOffset? idleSince = null)
 	{
 		var tasks = new List<Task>();
 		foreach (var client in this._shards.Values)
 			tasks.Add(client.UpdateStatusAsync(activity, userStatus, idleSince));
 
 		await Task.WhenAll(tasks).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// <see cref="BaseDiscordClient.GetLibraryDevelopmentTeamAsync"/>
 	/// </summary>
 	[Obsolete("Don't use this right now, inactive")]
 	public async Task<DisCatSharpTeam> GetLibraryDevelopmentTeamAsync()
 		=> await this.GetShard(0).GetLibraryDevelopmentTeamAsync().ConfigureAwait(false);
 
 	#endregion
 
 	#region Internal Methods
 
 	/// <summary>
 	/// Initializes the shards.
 	/// </summary>
 	/// <returns>The count of initialized shards.</returns>
 	internal async Task<int> InitializeShardsAsync()
 	{
 		if (!this._shards.IsEmpty)
 			return this._shards.Count;
 
 		this.GatewayInfo = await this.GetGatewayInfoAsync().ConfigureAwait(false);
 		var shardCount = this._configuration.ShardCount == 1 ? this.GatewayInfo.ShardCount : this._configuration.ShardCount;
 		var lf = new ShardedLoggerFactory(this.Logger);
 		for (var i = 0; i < shardCount; i++)
 		{
 			var cfg = new DiscordConfiguration(this._configuration)
 			{
 				ShardId = i,
 				ShardCount = shardCount,
 				LoggerFactory = lf
 			};
 
 			var client = new DiscordClient(cfg);
 			if (!this._shards.TryAdd(i, client))
 				throw new InvalidOperationException("Could not initialize shards.");
 		}
 
 		return shardCount;
 	}
 
 	#endregion
 
 	#region Private Methods & Version Property
 
 	/// <summary>
 	/// Gets the gateway info.
 	/// </summary>
 	private async Task<GatewayInfo> GetGatewayInfoAsync()
 	{
 		var url = $"{Utilities.GetApiBaseUri(this._configuration)}{Endpoints.GATEWAY}{Endpoints.BOT}";
 		var http = new HttpClient();
 
 		http.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", Utilities.GetUserAgent());
 		http.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", Utilities.GetFormattedToken(this._configuration));
 		http.DefaultRequestHeaders.TryAddWithoutValidation("x-discord-locale", this._configuration.Locale);
 		http.DefaultRequestHeaders.TryAddWithoutValidation("x-discord-timezone", this._configuration.Timezone);
 		if (this._configuration.Override != null)
 			http.DefaultRequestHeaders.TryAddWithoutValidation("x-super-properties", this._configuration.Override);
 
 		this.Logger.LogDebug(LoggerEvents.ShardRest, $"Obtaining gateway information from GET {Endpoints.GATEWAY}{Endpoints.BOT}...");
 		var resp = await http.GetAsync(url).ConfigureAwait(false);
 
 		http.Dispose();
 
 		if (!resp.IsSuccessStatusCode)
 		{
 			var ratelimited = await HandleHttpError(url, resp).ConfigureAwait(false);
 
 			if (ratelimited)
 				return await this.GetGatewayInfoAsync().ConfigureAwait(false);
 		}
 
 		var timer = new Stopwatch();
 		timer.Start();
 
 		var jo = JObject.Parse(await resp.Content.ReadAsStringAsync().ConfigureAwait(false));
 		var info = jo.ToObject<GatewayInfo>();
 
 		//There is a delay from parsing here.
 		timer.Stop();
 
 		info.SessionBucket.ResetAfterInternal -= (int)timer.ElapsedMilliseconds;
 		info.SessionBucket.ResetAfter = DateTimeOffset.UtcNow + TimeSpan.FromMilliseconds(info.SessionBucket.ResetAfterInternal);
 
 		return info;
 
 		async Task<bool> HandleHttpError(string reqUrl, HttpResponseMessage msg)
 		{
 			var code = (int)msg.StatusCode;
 
 			if (code == 401 || code == 403)
 			{
 				throw new Exception($"Authentication failed, check your token and try again: {code} {msg.ReasonPhrase}");
 			}
 			else if (code == 429)
 			{
 				this.Logger.LogError(LoggerEvents.ShardClientError, $"Ratelimit hit, requeuing request to {reqUrl}");
 
 				var hs = msg.Headers.ToDictionary(xh => xh.Key, xh => string.Join("\n", xh.Value), StringComparer.OrdinalIgnoreCase);
 				var waitInterval = 0;
 
 				if (hs.TryGetValue("Retry-After", out var retryAfterRaw))
 					waitInterval = int.Parse(retryAfterRaw, CultureInfo.InvariantCulture);
 
 				await Task.Delay(waitInterval).ConfigureAwait(false);
 				return true;
 			}
 			else if (code >= 500)
 			{
 				throw new Exception($"Internal Server Error: {code} {msg.ReasonPhrase}");
 			}
 			else
 			{
 				throw new Exception($"An unsuccessful HTTP status code was encountered: {code} {msg.ReasonPhrase}");
 			}
 		}
 	}
 
 	/// <summary>
 	/// Gets the version string.
 	/// </summary>
 	private readonly Lazy<string> _versionString = new(() =>
 	{
 		var a = typeof(DiscordShardedClient).GetTypeInfo().Assembly;
 
 		var iv = a.GetCustomAttribute<AssemblyInformationalVersionAttribute>();
 		if (iv != null)
 			return iv.InformationalVersion;
 
 		var v = a.GetName().Version;
 		var vs = v.ToString(3);
 
 		if (v.Revision > 0)
 			vs = $"{vs}, CI build {v.Revision}";
 
 		return vs;
 	});
 
 	/// <summary>
 	/// Gets the name of the used bot library.
 	/// </summary>
 	private readonly string _botLibrary = "DisCatSharp";
 
 	#endregion
 
 	#region Private Connection Methods
 
 	/// <summary>
 	/// Connects a shard.
 	/// </summary>
 	/// <param name="i">The shard id.</param>
 	private async Task ConnectShardAsync(int i)
 	{
 		if (!this._shards.TryGetValue(i, out var client))
 			throw new Exception($"Could not initialize shard {i}.");
 
 		client.IsShard = true;
 		if (this.GatewayInfo != null)
 		{
 			client.GatewayInfo = this.GatewayInfo;
 			client.GatewayUri = new Uri(client.GatewayInfo.Url);
 		}
 
 		if (this.CurrentUser != null)
 			client.CurrentUser = this.CurrentUser;
 
 		if (this.CurrentApplication != null)
 			client.CurrentApplication = this.CurrentApplication;
 
 		if (this._internalVoiceRegions != null)
 		{
 			client.InternalVoiceRegions = this._internalVoiceRegions;
 			client.VoiceRegionsLazy = new Lazy<IReadOnlyDictionary<string, DiscordVoiceRegion>>(() => new ReadOnlyDictionary<string, DiscordVoiceRegion>(client.InternalVoiceRegions));
 		}
 
 		this.HookEventHandlers(client);
 
 		await client.ConnectAsync();
 		this.Logger.LogInformation(LoggerEvents.ShardStartup, "Booted shard {0}.", i);
 
 		this.GatewayInfo ??= client.GatewayInfo;
 
 		if (this.CurrentUser == null)
 			this.CurrentUser = client.CurrentUser;
 
 		if (this.CurrentApplication == null)
 			this.CurrentApplication = client.CurrentApplication;
 
 		if (this._internalVoiceRegions == null)
 		{
 			this._internalVoiceRegions = client.InternalVoiceRegions;
 			this._voiceRegionsLazy = new Lazy<IReadOnlyDictionary<string, DiscordVoiceRegion>>(() => new ReadOnlyDictionary<string, DiscordVoiceRegion>(this._internalVoiceRegions));
 		}
 	}
 
 	/// <summary>
 	/// Stops all shards.
 	/// </summary>
 	/// <param name="enableLogger">Whether to enable the logger.</param>
 	private Task InternalStopAsync(bool enableLogger = true)
 	{
 		if (!this._isStarted)
 			throw new InvalidOperationException("This client has not been started.");
 
 		if (enableLogger)
 			this.Logger.LogInformation(LoggerEvents.ShardShutdown, "Disposing {0} shards.", this._shards.Count);
 
 		this._isStarted = false;
 		this._voiceRegionsLazy = null;
 
 		this.GatewayInfo = null;
 		this.CurrentUser = null;
 		this.CurrentApplication = null;
 
 		for (var i = 0; i < this._shards.Count; i++)
 		{
 			if (this._shards.TryGetValue(i, out var client))
 			{
 				this.UnhookEventHandlers(client);
 
 				client.Dispose();
 
 				if (enableLogger)
 					this.Logger.LogInformation(LoggerEvents.ShardShutdown, "Disconnected shard {0}.", i);
 			}
 		}
 
 		this._shards.Clear();
 
 		return Task.CompletedTask;
 	}
 
 	#endregion
 
 	#region Event Handler Initialization/Registering
 
 	/// <summary>
 	/// Sets the shard client up internally..
 	/// </summary>
 	private void InternalSetup()
 	{
 		this._clientErrored = new AsyncEvent<DiscordClient, ClientErrorEventArgs>("CLIENT_ERRORED", DiscordClient.EventExecutionLimit, this.Goof);
 		this._socketErrored = new AsyncEvent<DiscordClient, SocketErrorEventArgs>("SOCKET_ERRORED", DiscordClient.EventExecutionLimit, this.Goof);
 		this._socketOpened = new AsyncEvent<DiscordClient, SocketEventArgs>("SOCKET_OPENED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._socketClosed = new AsyncEvent<DiscordClient, SocketCloseEventArgs>("SOCKET_CLOSED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._ready = new AsyncEvent<DiscordClient, ReadyEventArgs>("READY", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._resumed = new AsyncEvent<DiscordClient, ReadyEventArgs>("RESUMED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._channelCreated = new AsyncEvent<DiscordClient, ChannelCreateEventArgs>("CHANNEL_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._channelUpdated = new AsyncEvent<DiscordClient, ChannelUpdateEventArgs>("CHANNEL_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._channelDeleted = new AsyncEvent<DiscordClient, ChannelDeleteEventArgs>("CHANNEL_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._dmChannelDeleted = new AsyncEvent<DiscordClient, DmChannelDeleteEventArgs>("DM_CHANNEL_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._channelPinsUpdated = new AsyncEvent<DiscordClient, ChannelPinsUpdateEventArgs>("CHANNEL_PINS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildCreated = new AsyncEvent<DiscordClient, GuildCreateEventArgs>("GUILD_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildAvailable = new AsyncEvent<DiscordClient, GuildCreateEventArgs>("GUILD_AVAILABLE", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildUpdated = new AsyncEvent<DiscordClient, GuildUpdateEventArgs>("GUILD_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildDeleted = new AsyncEvent<DiscordClient, GuildDeleteEventArgs>("GUILD_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildUnavailable = new AsyncEvent<DiscordClient, GuildDeleteEventArgs>("GUILD_UNAVAILABLE", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildDownloadCompleted = new AsyncEvent<DiscordClient, GuildDownloadCompletedEventArgs>("GUILD_DOWNLOAD_COMPLETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._inviteCreated = new AsyncEvent<DiscordClient, InviteCreateEventArgs>("INVITE_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._inviteDeleted = new AsyncEvent<DiscordClient, InviteDeleteEventArgs>("INVITE_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._messageCreated = new AsyncEvent<DiscordClient, MessageCreateEventArgs>("MESSAGE_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._presenceUpdated = new AsyncEvent<DiscordClient, PresenceUpdateEventArgs>("PRESENCE_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildBanAdded = new AsyncEvent<DiscordClient, GuildBanAddEventArgs>("GUILD_BAN_ADDED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildBanRemoved = new AsyncEvent<DiscordClient, GuildBanRemoveEventArgs>("GUILD_BAN_REMOVED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildEmojisUpdated = new AsyncEvent<DiscordClient, GuildEmojisUpdateEventArgs>("GUILD_EMOJI_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildStickersUpdated = new AsyncEvent<DiscordClient, GuildStickersUpdateEventArgs>("GUILD_STICKER_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildIntegrationsUpdated = new AsyncEvent<DiscordClient, GuildIntegrationsUpdateEventArgs>("GUILD_INTEGRATIONS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberAdded = new AsyncEvent<DiscordClient, GuildMemberAddEventArgs>("GUILD_MEMBER_ADDED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberRemoved = new AsyncEvent<DiscordClient, GuildMemberRemoveEventArgs>("GUILD_MEMBER_REMOVED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberUpdated = new AsyncEvent<DiscordClient, GuildMemberUpdateEventArgs>("GUILD_MEMBER_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildRoleCreated = new AsyncEvent<DiscordClient, GuildRoleCreateEventArgs>("GUILD_ROLE_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildRoleUpdated = new AsyncEvent<DiscordClient, GuildRoleUpdateEventArgs>("GUILD_ROLE_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildRoleDeleted = new AsyncEvent<DiscordClient, GuildRoleDeleteEventArgs>("GUILD_ROLE_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._messageUpdated = new AsyncEvent<DiscordClient, MessageUpdateEventArgs>("MESSAGE_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._messageDeleted = new AsyncEvent<DiscordClient, MessageDeleteEventArgs>("MESSAGE_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._messageBulkDeleted = new AsyncEvent<DiscordClient, MessageBulkDeleteEventArgs>("MESSAGE_BULK_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._interactionCreated = new AsyncEvent<DiscordClient, InteractionCreateEventArgs>("INTERACTION_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._componentInteractionCreated = new AsyncEvent<DiscordClient, ComponentInteractionCreateEventArgs>("COMPONENT_INTERACTED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._contextMenuInteractionCreated = new AsyncEvent<DiscordClient, ContextMenuInteractionCreateEventArgs>("CONTEXT_MENU_INTERACTED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._typingStarted = new AsyncEvent<DiscordClient, TypingStartEventArgs>("TYPING_STARTED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._userSettingsUpdated = new AsyncEvent<DiscordClient, UserSettingsUpdateEventArgs>("USER_SETTINGS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._userUpdated = new AsyncEvent<DiscordClient, UserUpdateEventArgs>("USER_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._voiceStateUpdated = new AsyncEvent<DiscordClient, VoiceStateUpdateEventArgs>("VOICE_STATE_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._voiceServerUpdated = new AsyncEvent<DiscordClient, VoiceServerUpdateEventArgs>("VOICE_SERVER_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildMembersChunk = new AsyncEvent<DiscordClient, GuildMembersChunkEventArgs>("GUILD_MEMBERS_CHUNKED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._unknownEvent = new AsyncEvent<DiscordClient, UnknownEventArgs>("UNKNOWN_EVENT", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._messageReactionAdded = new AsyncEvent<DiscordClient, MessageReactionAddEventArgs>("MESSAGE_REACTION_ADDED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._messageReactionRemoved = new AsyncEvent<DiscordClient, MessageReactionRemoveEventArgs>("MESSAGE_REACTION_REMOVED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._messageReactionsCleared = new AsyncEvent<DiscordClient, MessageReactionsClearEventArgs>("MESSAGE_REACTIONS_CLEARED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._messageReactionRemovedEmoji = new AsyncEvent<DiscordClient, MessageReactionRemoveEmojiEventArgs>("MESSAGE_REACTION_REMOVED_EMOJI", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._webhooksUpdated = new AsyncEvent<DiscordClient, WebhooksUpdateEventArgs>("WEBHOOKS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._heartbeated = new AsyncEvent<DiscordClient, HeartbeatEventArgs>("HEARTBEATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._applicationCommandCreated = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._applicationCommandUpdated = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._applicationCommandDeleted = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildApplicationCommandCountUpdated = new AsyncEvent<DiscordClient, GuildApplicationCommandCountEventArgs>("GUILD_APPLICATION_COMMAND_COUNTS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._applicationCommandPermissionsUpdated = new AsyncEvent<DiscordClient, ApplicationCommandPermissionsUpdateEventArgs>("APPLICATION_COMMAND_PERMISSIONS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildIntegrationCreated = new AsyncEvent<DiscordClient, GuildIntegrationCreateEventArgs>("INTEGRATION_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildIntegrationUpdated = new AsyncEvent<DiscordClient, GuildIntegrationUpdateEventArgs>("INTEGRATION_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildIntegrationDeleted = new AsyncEvent<DiscordClient, GuildIntegrationDeleteEventArgs>("INTEGRATION_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._stageInstanceCreated = new AsyncEvent<DiscordClient, StageInstanceCreateEventArgs>("STAGE_INSTANCE_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._stageInstanceUpdated = new AsyncEvent<DiscordClient, StageInstanceUpdateEventArgs>("STAGE_INSTANCE_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._stageInstanceDeleted = new AsyncEvent<DiscordClient, StageInstanceDeleteEventArgs>("STAGE_INSTANCE_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._threadCreated = new AsyncEvent<DiscordClient, ThreadCreateEventArgs>("THREAD_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._threadUpdated = new AsyncEvent<DiscordClient, ThreadUpdateEventArgs>("THREAD_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._threadDeleted = new AsyncEvent<DiscordClient, ThreadDeleteEventArgs>("THREAD_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._threadListSynced = new AsyncEvent<DiscordClient, ThreadListSyncEventArgs>("THREAD_LIST_SYNCED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._threadMemberUpdated = new AsyncEvent<DiscordClient, ThreadMemberUpdateEventArgs>("THREAD_MEMBER_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._threadMembersUpdated = new AsyncEvent<DiscordClient, ThreadMembersUpdateEventArgs>("THREAD_MEMBERS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._zombied = new AsyncEvent<DiscordClient, ZombiedEventArgs>("ZOMBIED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._payloadReceived = new AsyncEvent<DiscordClient, PayloadReceivedEventArgs>("PAYLOAD_RECEIVED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventCreated = new AsyncEvent<DiscordClient, GuildScheduledEventCreateEventArgs>("GUILD_SCHEDULED_EVENT_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventUpdated = new AsyncEvent<DiscordClient, GuildScheduledEventUpdateEventArgs>("GUILD_SCHEDULED_EVENT_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventDeleted = new AsyncEvent<DiscordClient, GuildScheduledEventDeleteEventArgs>("GUILD_SCHEDULED_EVENT_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventUserAdded = new AsyncEvent<DiscordClient, GuildScheduledEventUserAddEventArgs>("GUILD_SCHEDULED_EVENT_USER_ADDED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventUserRemoved = new AsyncEvent<DiscordClient, GuildScheduledEventUserRemoveEventArgs>("GUILD_SCHEDULED_EVENT_USER_REMOVED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._embeddedActivityUpdated = new AsyncEvent<DiscordClient, EmbeddedActivityUpdateEventArgs>("EMBEDDED_ACTIVITY_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberTimeoutAdded = new AsyncEvent<DiscordClient, GuildMemberTimeoutAddEventArgs>("GUILD_MEMBER_TIMEOUT_ADDED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberTimeoutChanged = new AsyncEvent<DiscordClient, GuildMemberTimeoutUpdateEventArgs>("GUILD_MEMBER_TIMEOUT_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberTimeoutRemoved = new AsyncEvent<DiscordClient, GuildMemberTimeoutRemoveEventArgs>("GUILD_MEMBER_TIMEOUT_REMOVED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._automodRuleCreated = new AsyncEvent<DiscordClient, AutomodRuleCreateEventArgs>("AUTO_MODERATION_RULE_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._automodRuleUpdated = new AsyncEvent<DiscordClient, AutomodRuleUpdateEventArgs>("AUTO_MODERATION_RULE_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._automodRuleDeleted = new AsyncEvent<DiscordClient, AutomodRuleDeleteEventArgs>("AUTO_MODERATION_RULE_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._automodActionExecuted = new AsyncEvent<DiscordClient, AutomodActionExecutedEventArgs>("AUTO_MODERATION_ACTION_EXECUTED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildAuditLogEntryCreated = new AsyncEvent<DiscordClient, GuildAuditLogEntryCreateEventArgs>("GUILD_AUDIT_LOG_ENTRY_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 
 	}
 
 	/// <summary>
 	/// Hooks the event handlers.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	private void HookEventHandlers(DiscordClient client)
 	{
 		client.ClientErrored += this.Client_ClientError;
 		client.SocketErrored += this.Client_SocketError;
 		client.SocketOpened += this.Client_SocketOpened;
 		client.SocketClosed += this.Client_SocketClosed;
 		client.Ready += this.Client_Ready;
 		client.Resumed += this.Client_Resumed;
 		client.ChannelCreated += this.Client_ChannelCreated;
 		client.ChannelUpdated += this.Client_ChannelUpdated;
 		client.ChannelDeleted += this.Client_ChannelDeleted;
 		client.DmChannelDeleted += this.Client_DMChannelDeleted;
 		client.ChannelPinsUpdated += this.Client_ChannelPinsUpdated;
 		client.GuildCreated += this.Client_GuildCreated;
 		client.GuildAvailable += this.Client_GuildAvailable;
 		client.GuildUpdated += this.Client_GuildUpdated;
 		client.GuildDeleted += this.Client_GuildDeleted;
 		client.GuildUnavailable += this.Client_GuildUnavailable;
 		client.GuildDownloadCompleted += this.Client_GuildDownloadCompleted;
 		client.InviteCreated += this.Client_InviteCreated;
 		client.InviteDeleted += this.Client_InviteDeleted;
 		client.MessageCreated += this.Client_MessageCreated;
 		client.PresenceUpdated += this.Client_PresenceUpdate;
 		client.GuildBanAdded += this.Client_GuildBanAdd;
 		client.GuildBanRemoved += this.Client_GuildBanRemove;
 		client.GuildEmojisUpdated += this.Client_GuildEmojisUpdate;
 		client.GuildStickersUpdated += this.Client_GuildStickersUpdate;
 		client.GuildIntegrationsUpdated += this.Client_GuildIntegrationsUpdate;
 		client.GuildMemberAdded += this.Client_GuildMemberAdd;
 		client.GuildMemberRemoved += this.Client_GuildMemberRemove;
 		client.GuildMemberUpdated += this.Client_GuildMemberUpdate;
 		client.GuildRoleCreated += this.Client_GuildRoleCreate;
 		client.GuildRoleUpdated += this.Client_GuildRoleUpdate;
 		client.GuildRoleDeleted += this.Client_GuildRoleDelete;
 		client.MessageUpdated += this.Client_MessageUpdate;
 		client.MessageDeleted += this.Client_MessageDelete;
 		client.MessagesBulkDeleted += this.Client_MessageBulkDelete;
 		client.InteractionCreated += this.Client_InteractionCreate;
 		client.ComponentInteractionCreated += this.Client_ComponentInteractionCreate;
 		client.ContextMenuInteractionCreated += this.Client_ContextMenuInteractionCreate;
 		client.TypingStarted += this.Client_TypingStart;
 		client.UserSettingsUpdated += this.Client_UserSettingsUpdate;
 		client.UserUpdated += this.Client_UserUpdate;
 		client.VoiceStateUpdated += this.Client_VoiceStateUpdate;
 		client.VoiceServerUpdated += this.Client_VoiceServerUpdate;
 		client.GuildMembersChunked += this.Client_GuildMembersChunk;
 		client.UnknownEvent += this.Client_UnknownEvent;
 		client.MessageReactionAdded += this.Client_MessageReactionAdd;
 		client.MessageReactionRemoved += this.Client_MessageReactionRemove;
 		client.MessageReactionsCleared += this.Client_MessageReactionRemoveAll;
 		client.MessageReactionRemovedEmoji += this.Client_MessageReactionRemovedEmoji;
 		client.WebhooksUpdated += this.Client_WebhooksUpdate;
 		client.Heartbeated += this.Client_HeartBeated;
 		client.ApplicationCommandCreated += this.Client_ApplicationCommandCreated;
 		client.ApplicationCommandUpdated += this.Client_ApplicationCommandUpdated;
 		client.ApplicationCommandDeleted += this.Client_ApplicationCommandDeleted;
 		client.GuildApplicationCommandCountUpdated += this.Client_GuildApplicationCommandCountUpdated;
 		client.ApplicationCommandPermissionsUpdated += this.Client_ApplicationCommandPermissionsUpdated;
 		client.GuildIntegrationCreated += this.Client_GuildIntegrationCreated;
 		client.GuildIntegrationUpdated += this.Client_GuildIntegrationUpdated;
 		client.GuildIntegrationDeleted += this.Client_GuildIntegrationDeleted;
 		client.StageInstanceCreated += this.Client_StageInstanceCreated;
 		client.StageInstanceUpdated += this.Client_StageInstanceUpdated;
 		client.StageInstanceDeleted += this.Client_StageInstanceDeleted;
 		client.ThreadCreated += this.Client_ThreadCreated;
 		client.ThreadUpdated += this.Client_ThreadUpdated;
 		client.ThreadDeleted += this.Client_ThreadDeleted;
 		client.ThreadListSynced += this.Client_ThreadListSynced;
 		client.ThreadMemberUpdated += this.Client_ThreadMemberUpdated;
 		client.ThreadMembersUpdated += this.Client_ThreadMembersUpdated;
 		client.Zombied += this.Client_Zombied;
 		client.PayloadReceived += this.Client_PayloadReceived;
 		client.GuildScheduledEventCreated += this.Client_GuildScheduledEventCreated;
 		client.GuildScheduledEventUpdated += this.Client_GuildScheduledEventUpdated;
 		client.GuildScheduledEventDeleted += this.Client_GuildScheduledEventDeleted;
 		client.GuildScheduledEventUserAdded += this.Client_GuildScheduledEventUserAdded; ;
 		client.GuildScheduledEventUserRemoved += this.Client_GuildScheduledEventUserRemoved;
 		client.EmbeddedActivityUpdated += this.Client_EmbeddedActivityUpdated;
 		client.GuildMemberTimeoutAdded += this.Client_GuildMemberTimeoutAdded;
 		client.GuildMemberTimeoutChanged += this.Client_GuildMemberTimeoutChanged;
 		client.GuildMemberTimeoutRemoved += this.Client_GuildMemberTimeoutRemoved;
 		client.AutomodRuleCreated += this.Client_AutomodRuleCreated;
 		client.AutomodRuleUpdated += this.Client_AutomodRuleUpdated;
 		client.AutomodRuleDeleted += this.Client_AutomodRuleDeleted;
 		client.AutomodActionExecuted += this.Client_AutomodActionExecuted;
 		client.GuildAuditLogEntryCreated += this.Client_GuildAuditLogEntryCreated;
 	}
 
 	/// <summary>
 	/// Unhooks the event handlers.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	private void UnhookEventHandlers(DiscordClient client)
 	{
 		client.ClientErrored -= this.Client_ClientError;
 		client.SocketErrored -= this.Client_SocketError;
 		client.SocketOpened -= this.Client_SocketOpened;
 		client.SocketClosed -= this.Client_SocketClosed;
 		client.Ready -= this.Client_Ready;
 		client.Resumed -= this.Client_Resumed;
 		client.ChannelCreated -= this.Client_ChannelCreated;
 		client.ChannelUpdated -= this.Client_ChannelUpdated;
 		client.ChannelDeleted -= this.Client_ChannelDeleted;
 		client.DmChannelDeleted -= this.Client_DMChannelDeleted;
 		client.ChannelPinsUpdated -= this.Client_ChannelPinsUpdated;
 		client.GuildCreated -= this.Client_GuildCreated;
 		client.GuildAvailable -= this.Client_GuildAvailable;
 		client.GuildUpdated -= this.Client_GuildUpdated;
 		client.GuildDeleted -= this.Client_GuildDeleted;
 		client.GuildUnavailable -= this.Client_GuildUnavailable;
 		client.GuildDownloadCompleted -= this.Client_GuildDownloadCompleted;
 		client.InviteCreated -= this.Client_InviteCreated;
 		client.InviteDeleted -= this.Client_InviteDeleted;
 		client.MessageCreated -= this.Client_MessageCreated;
 		client.PresenceUpdated -= this.Client_PresenceUpdate;
 		client.GuildBanAdded -= this.Client_GuildBanAdd;
 		client.GuildBanRemoved -= this.Client_GuildBanRemove;
 		client.GuildEmojisUpdated -= this.Client_GuildEmojisUpdate;
 		client.GuildStickersUpdated -= this.Client_GuildStickersUpdate;
 		client.GuildIntegrationsUpdated -= this.Client_GuildIntegrationsUpdate;
 		client.GuildMemberAdded -= this.Client_GuildMemberAdd;
 		client.GuildMemberRemoved -= this.Client_GuildMemberRemove;
 		client.GuildMemberUpdated -= this.Client_GuildMemberUpdate;
 		client.GuildRoleCreated -= this.Client_GuildRoleCreate;
 		client.GuildRoleUpdated -= this.Client_GuildRoleUpdate;
 		client.GuildRoleDeleted -= this.Client_GuildRoleDelete;
 		client.MessageUpdated -= this.Client_MessageUpdate;
 		client.MessageDeleted -= this.Client_MessageDelete;
 		client.MessagesBulkDeleted -= this.Client_MessageBulkDelete;
 		client.InteractionCreated -= this.Client_InteractionCreate;
 		client.ComponentInteractionCreated -= this.Client_ComponentInteractionCreate;
 		client.ContextMenuInteractionCreated -= this.Client_ContextMenuInteractionCreate;
 		client.TypingStarted -= this.Client_TypingStart;
 		client.UserSettingsUpdated -= this.Client_UserSettingsUpdate;
 		client.UserUpdated -= this.Client_UserUpdate;
 		client.VoiceStateUpdated -= this.Client_VoiceStateUpdate;
 		client.VoiceServerUpdated -= this.Client_VoiceServerUpdate;
 		client.GuildMembersChunked -= this.Client_GuildMembersChunk;
 		client.UnknownEvent -= this.Client_UnknownEvent;
 		client.MessageReactionAdded -= this.Client_MessageReactionAdd;
 		client.MessageReactionRemoved -= this.Client_MessageReactionRemove;
 		client.MessageReactionsCleared -= this.Client_MessageReactionRemoveAll;
 		client.MessageReactionRemovedEmoji -= this.Client_MessageReactionRemovedEmoji;
 		client.WebhooksUpdated -= this.Client_WebhooksUpdate;
 		client.Heartbeated -= this.Client_HeartBeated;
 		client.ApplicationCommandCreated -= this.Client_ApplicationCommandCreated;
 		client.ApplicationCommandUpdated -= this.Client_ApplicationCommandUpdated;
 		client.ApplicationCommandDeleted -= this.Client_ApplicationCommandDeleted;
 		client.GuildApplicationCommandCountUpdated -= this.Client_GuildApplicationCommandCountUpdated;
 		client.ApplicationCommandPermissionsUpdated -= this.Client_ApplicationCommandPermissionsUpdated;
 		client.GuildIntegrationCreated -= this.Client_GuildIntegrationCreated;
 		client.GuildIntegrationUpdated -= this.Client_GuildIntegrationUpdated;
 		client.GuildIntegrationDeleted -= this.Client_GuildIntegrationDeleted;
 		client.StageInstanceCreated -= this.Client_StageInstanceCreated;
 		client.StageInstanceUpdated -= this.Client_StageInstanceUpdated;
 		client.StageInstanceDeleted -= this.Client_StageInstanceDeleted;
 		client.ThreadCreated -= this.Client_ThreadCreated;
 		client.ThreadUpdated -= this.Client_ThreadUpdated;
 		client.ThreadDeleted -= this.Client_ThreadDeleted;
 		client.ThreadListSynced -= this.Client_ThreadListSynced;
 		client.ThreadMemberUpdated -= this.Client_ThreadMemberUpdated;
 		client.ThreadMembersUpdated -= this.Client_ThreadMembersUpdated;
 		client.Zombied -= this.Client_Zombied;
 		client.PayloadReceived -= this.Client_PayloadReceived;
 		client.GuildScheduledEventCreated -= this.Client_GuildScheduledEventCreated;
 		client.GuildScheduledEventUpdated -= this.Client_GuildScheduledEventUpdated;
 		client.GuildScheduledEventDeleted -= this.Client_GuildScheduledEventDeleted;
 		client.GuildScheduledEventUserAdded -= this.Client_GuildScheduledEventUserAdded; ;
 		client.GuildScheduledEventUserRemoved -= this.Client_GuildScheduledEventUserRemoved;
 		client.EmbeddedActivityUpdated -= this.Client_EmbeddedActivityUpdated;
 		client.GuildMemberTimeoutAdded -= this.Client_GuildMemberTimeoutAdded;
 		client.GuildMemberTimeoutChanged -= this.Client_GuildMemberTimeoutChanged;
 		client.GuildMemberTimeoutRemoved -= this.Client_GuildMemberTimeoutRemoved;
 		client.AutomodRuleCreated -= this.Client_AutomodRuleCreated;
 		client.AutomodRuleUpdated -= this.Client_AutomodRuleUpdated;
 		client.AutomodRuleDeleted -= this.Client_AutomodRuleDeleted;
 		client.AutomodActionExecuted -= this.Client_AutomodActionExecuted;
 		client.GuildAuditLogEntryCreated -= this.Client_GuildAuditLogEntryCreated;
 	}
 
 	/// <summary>
 	/// Gets the shard id from guilds.
 	/// </summary>
 	/// <param name="id">The id.</param>
 	/// <returns>An int.</returns>
 	private int GetShardIdFromGuilds(ulong id)
 	{
 		foreach (var s in this._shards.Values)
 		{
 			if (s.GuildsInternal.TryGetValue(id, out _))
 			{
 				return s.ShardId;
 			}
 		}
 
 		return -1;
 	}
 
 	#endregion
 
 	#region Destructor
 
 	~DiscordShardedClient()
 	{
 		this.InternalStopAsync(false).GetAwaiter().GetResult();
 	}
 
 	#endregion
 }
diff --git a/DisCatSharp/DiscordConfiguration.cs b/DisCatSharp/DiscordConfiguration.cs
index b8a00d92c..a14918680 100644
--- a/DisCatSharp/DiscordConfiguration.cs
+++ b/DisCatSharp/DiscordConfiguration.cs
@@ -1,365 +1,397 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2023 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Net;
 
 using DisCatSharp.Attributes;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
+using DisCatSharp.Exceptions;
 using DisCatSharp.Net.Udp;
 using DisCatSharp.Net.WebSocket;
 
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp;
 
 /// <summary>
 /// Represents configuration for <see cref="DiscordClient"/> and <see cref="DiscordShardedClient"/>.
 /// </summary>
 public sealed class DiscordConfiguration
 {
 	/// <summary>
 	/// Sets the token used to identify the client.
 	/// </summary>
 	public string Token
 	{
 		internal get => this._token;
 		set
 		{
 			if (string.IsNullOrWhiteSpace(value))
 				throw new ArgumentNullException(nameof(value), "Token cannot be null, empty, or all whitespace.");
 
 			this._token = value.Trim();
 		}
 	}
 	private string _token = "";
 
 	/// <summary>
 	/// <para>Sets the type of the token used to identify the client.</para>
 	/// <para>Defaults to <see cref="TokenType.Bot"/>.</para>
 	/// </summary>
 	public TokenType TokenType { internal get; set; } = TokenType.Bot;
 
 	/// <summary>
 	/// <para>Sets the minimum logging level for messages.</para>
 	/// <para>Typically, the default value of <see cref="LogLevel.Information"/> is ok for most uses.</para>
 	/// </summary>
 	public LogLevel MinimumLogLevel { internal get; set; } = LogLevel.Information;
 
 	/// <summary>
 	/// Overwrites the api version.
 	/// Defaults to 10.
 	/// </summary>
 	public string ApiVersion { internal get; set; } = "10";
 
 	/// <summary>
 	/// <para>Sets whether to rely on Discord for NTP (Network Time Protocol) synchronization with the "X-Ratelimit-Reset-After" header.</para>
 	/// <para>If the system clock is unsynced, setting this to true will ensure ratelimits are synced with Discord and reduce the risk of hitting one.</para>
 	/// <para>This should only be set to false if the system clock is synced with NTP.</para>
 	/// <para>Defaults to <see langword="true"/>.</para>
 	/// </summary>
 	public bool UseRelativeRatelimit { internal get; set; } = true;
 
 	/// <summary>
 	/// <para>Allows you to overwrite the time format used by the internal debug logger.</para>
 	/// <para>Only applicable when <see cref="LoggerFactory"/> is set left at default value. Defaults to ISO 8601-like format.</para>
 	/// </summary>
 	public string LogTimestampFormat { internal get; set; } = "yyyy-MM-dd HH:mm:ss zzz";
 
 	/// <summary>
 	/// <para>Sets the member count threshold at which guilds are considered large.</para>
 	/// <para>Defaults to 250.</para>
 	/// </summary>
 	public int LargeThreshold { internal get; set; } = 250;
 
 	/// <summary>
 	/// <para>Sets whether to automatically reconnect in case a connection is lost.</para>
 	/// <para>Defaults to <see langword="true"/>.</para>
 	/// </summary>
 	public bool AutoReconnect { internal get; set; } = true;
 
 	/// <summary>
 	/// <para>Sets the ID of the shard to connect to.</para>
 	/// <para>If not sharding, or sharding automatically, this value should be left with the default value of 0.</para>
 	/// </summary>
 	public int ShardId { internal get; set; } = 0;
 
 	/// <summary>
 	/// <para>Sets the total number of shards the bot is on. If not sharding, this value should be left with a default value of 1.</para>
 	/// <para>If sharding automatically, this value will indicate how many shards to boot. If left default for automatic sharding, the client will determine the shard count automatically.</para>
 	/// </summary>
 	public int ShardCount { internal get; set; } = 1;
 
 	/// <summary>
 	/// <para>Sets the level of compression for WebSocket traffic.</para>
 	/// <para>Disabling this option will increase the amount of traffic sent via WebSocket. Setting <see cref="GatewayCompressionLevel.Payload"/> will enable compression for READY and GUILD_CREATE payloads. Setting <see cref="GatewayCompressionLevel.Stream"/> will enable compression for the entire WebSocket stream, drastically reducing amount of traffic.</para>
 	/// <para>Defaults to <see cref="GatewayCompressionLevel.Stream"/>.</para>
 	/// </summary>
 	public GatewayCompressionLevel GatewayCompressionLevel { internal get; set; } = GatewayCompressionLevel.Stream;
 
 	/// <summary>
 	/// <para>Sets the size of the global message cache.</para>
 	/// <para>Setting this to 0 will disable message caching entirely.</para>
 	/// <para>Defaults to 1024.</para>
 	/// </summary>
 	public int MessageCacheSize { internal get; set; } = 1024;
 
 	/// <summary>
 	/// <para>Sets the proxy to use for HTTP and WebSocket connections to Discord.</para>
 	/// <para>Defaults to <see langword="null"/>.</para>
 	/// </summary>
 	public IWebProxy Proxy { internal get; set; } = null!;
 
 	/// <summary>
 	/// <para>Sets the timeout for HTTP requests.</para>
 	/// <para>Set to <see cref="System.Threading.Timeout.InfiniteTimeSpan"/> to disable timeouts.</para>
 	/// <para>Defaults to 20 seconds.</para>
 	/// </summary>
 	public TimeSpan HttpTimeout { internal get; set; } = TimeSpan.FromSeconds(20);
 
 	/// <summary>
 	/// <para>Defines that the client should attempt to reconnect indefinitely.</para>
 	/// <para>This is typically a very bad idea to set to <c>true</c>, as it will swallow all connection errors.</para>
 	/// <para>Defaults to <see langword="false"/>.</para>
 	/// </summary>
 	public bool ReconnectIndefinitely { internal get; set; } = false;
 
 	/// <summary>
 	/// Sets whether the client should attempt to cache members if exclusively using unprivileged intents.
 	/// <para>
 	///     This will only take effect if there are no <see cref="DiscordIntents.GuildMembers"/> or <see cref="DiscordIntents.GuildPresences"/>
 	///     intents specified. Otherwise, this will always be overwritten to true.
 	/// </para>
 	/// <para>Defaults to <see langword="true"/>.</para>
 	/// </summary>
 	public bool AlwaysCacheMembers { internal get; set; } = true;
 
+	/// <summary>
+	/// Sets whether a shard logger is attached.
+	/// </summary>
+	internal bool HasShardLogger { get; set; } = false;
+
 	/// <summary>
 	/// <para>Sets the gateway intents for this client.</para>
 	/// <para>If set, the client will only receive events that they specify with intents.</para>
 	/// <para>Defaults to <see cref="DiscordIntents.AllUnprivileged"/>.</para>
 	/// </summary>
 	public DiscordIntents Intents { internal get; set; } = DiscordIntents.AllUnprivileged;
 
 	/// <summary>
 	/// <para>Sets the factory method used to create instances of WebSocket clients.</para>
 	/// <para>Use <see cref="WebSocketClient.CreateNew"/> and equivalents on other implementations to switch out client implementations.</para>
 	/// <para>Defaults to <see cref="WebSocketClient.CreateNew"/>.</para>
 	/// </summary>
 	public WebSocketClientFactoryDelegate WebSocketClientFactory
 	{
 		internal get => this._webSocketClientFactory;
 		set
 		{
 			if (value == null)
 				throw new InvalidOperationException("You need to supply a valid WebSocket client factory method.");
 
 			this._webSocketClientFactory = value;
 		}
 	}
 	private WebSocketClientFactoryDelegate _webSocketClientFactory = WebSocketClient.CreateNew;
 
 	/// <summary>
 	/// <para>Sets the factory method used to create instances of UDP clients.</para>
 	/// <para>Use <see cref="DcsUdpClient.CreateNew"/> and equivalents on other implementations to switch out client implementations.</para>
 	/// <para>Defaults to <see cref="DcsUdpClient.CreateNew"/>.</para>
 	/// </summary>
 	public UdpClientFactoryDelegate UdpClientFactory
 	{
 		internal get => this._udpClientFactory;
 		set => this._udpClientFactory = value ?? throw new InvalidOperationException("You need to supply a valid UDP client factory method.");
 	}
 	private UdpClientFactoryDelegate _udpClientFactory = DcsUdpClient.CreateNew;
 
 	/// <summary>
 	/// <para>Sets the logger implementation to use.</para>
 	/// <para>To create your own logger, implement the <see cref="Microsoft.Extensions.Logging.ILoggerFactory"/> instance.</para>
 	/// <para>Defaults to built-in implementation.</para>
 	/// </summary>
 	public ILoggerFactory LoggerFactory { internal get; set; }
 
 	/// <summary>
 	/// <para>Sets if the bot's status should show the mobile icon.</para>
 	/// <para>Defaults to <see langword="false"/>.</para>
 	/// </summary>
 	public bool MobileStatus { internal get; set; } = false;
 
 	/// <summary>
 	/// <para>Whether to use canary. <see cref="UsePtb"/> has to be false.</para>
 	/// <para>Defaults to <see langword="false"/>.</para>
 	/// </summary>
 	[Deprecated("Use ApiChannel instead.")]
 	public bool UseCanary
 	{
 		internal get => this.ApiChannel == ApiChannel.Canary;
 		set
 		{
 			if (value)
 				this.ApiChannel = ApiChannel.Canary;
 		}
 	}
 
 	/// <summary>
 	/// <para>Whether to use ptb. <see cref="UseCanary"/> has to be false.</para>
 	/// <para>Defaults to <see langword="false"/>.</para>
 	/// </summary>
 	[Deprecated("Use ApiChannel instead.")]
 	public bool UsePtb
 	{
 		internal get => this.ApiChannel == ApiChannel.PTB;
 		set
 		{
 			if (value)
 				this.ApiChannel = ApiChannel.PTB;
 		}
 	}
 
 	/// <summary>
 	/// <para>Which api channel to use.</para>
 	/// <para>Defaults to <see cref="ApiChannel.Stable"/>.</para>
 	/// </summary>
 	public ApiChannel ApiChannel { internal get; set; } = ApiChannel.Stable;
 
 	/// <summary>
 	/// <para>Refresh full guild channel cache.</para>
 	/// <para>Defaults to <see langword="false"/>.</para>
 	/// </summary>
 	public bool AutoRefreshChannelCache { internal get; set; } = false;
 
 	/// <summary>
 	/// <para>Do not use, this is meant for DisCatSharp Devs.</para>
 	/// <para>Defaults to <see langword="null"/>.</para>
 	/// </summary>
 	public string Override { internal get; set; } = null!;
 
 	/// <summary>
 	/// Sets your preferred API language. See <see cref="DiscordLocales" /> for valid locales.
 	/// </summary>
 	public string Locale { internal get; set; } = DiscordLocales.AMERICAN_ENGLISH;
 
 	/// <summary>
 	/// Sets your timezone.
 	/// </summary>
 	public string Timezone { internal get; set; } = "Europe/Berlin";
 
 	/// <summary>
 	/// <para>Whether to report missing fields for discord object.</para>
 	/// <para>Useful for library development.</para>
 	/// <para>Defaults to <see langword="false"/>.</para>
 	/// </summary>
 	public bool ReportMissingFields { internal get; set; } = false;
 
 	/// <summary>
 	/// <para>Sets the service provider.</para>
 	/// <para>This allows passing data around without resorting to static members.</para>
 	/// <para>Defaults to an empty service provider.</para>
 	/// </summary>
 	public IServiceProvider ServiceProvider { internal get; set; } = new ServiceCollection().BuildServiceProvider(true);
 
 	/// <summary>
 	/// <para>Whether to report missing fields for discord object.</para>
 	/// <para>This helps us to track missing data and library bugs better.</para>
 	/// <para>Defaults to <see langword="false"/>.</para>
 	/// </summary>
 	public bool EnableSentry { internal get; set; } = false;
 
 	/// <summary>
 	/// <para>Whether to attach the bots username and id to sentry reports.</para>
 	/// <para>This helps us to pinpoint problems.</para>
 	/// <para>Defaults to <see langword="false"/>.</para>
 	/// </summary>
 	public bool AttachUserInfo { internal get; set; } = false;
 
 	/// <summary>
 	/// <para>Your email address we can reach out when your bot encounters library bugs.</para>
 	/// <para>Will only be transmitted if <see cref="AttachUserInfo"/> is <see langword="true"/>.</para>
 	/// <para>Defaults to <see langword="null"/>.</para>
 	/// </summary>
 	public string? FeedbackEmail { internal get; set; } = null;
 
 	/// <summary>
 	/// <para>Your discord user id we can reach out when your bot encounters library bugs.</para>
 	/// <para>Will only be transmitted if <see cref="AttachUserInfo"/> is <see langword="true"/>.</para>
 	/// <para>Defaults to <see langword="null"/>.</para>
 	/// </summary>
 	public ulong? DeveloperUserId { internal get; set; } = null;
-	internal bool HasShardLogger { get; set; } = false;
+
+	/// <summary>
+	/// Sets which exceptions to track with sentry.
+	/// </summary>
+	/// <exception cref="InvalidOperationException">Thrown when the base type of all exceptions is not <see cref="DisCatSharpException"/>.</exception>
+	public List<Type> TrackExceptions
+	{
+		internal get => this._exceptions;
+		set {
+			if (value == null)
+				this._exceptions.Clear();
+			else this._exceptions = value.All(val => val.BaseType == typeof(DisCatSharpException))
+				? value
+				: throw new InvalidOperationException("Can only track exceptions who inherit from " + nameof(DisCatSharpException) + " and must be constructed with typeof(Type)");
+		}
+	}
+
+	/// <summary>
+	/// The exception we track with sentry.
+	/// </summary>
+	private List<Type> _exceptions = new()
+	{
+		typeof(ServerErrorException),
+		typeof(BadRequestException)
+	};
 
 	/// <summary>
 	/// Creates a new configuration with default values.
 	/// </summary>
 	public DiscordConfiguration()
 	{ }
 
 	/// <summary>
 	/// Utilized via Dependency Injection Pipeline
 	/// </summary>
 	/// <param name="provider"></param>
 	[ActivatorUtilitiesConstructor]
 	public DiscordConfiguration(IServiceProvider provider)
 	{
 		this.ServiceProvider = provider;
 	}
 
 	/// <summary>
 	/// Creates a clone of another discord configuration.
 	/// </summary>
 	/// <param name="other">Client configuration to clone.</param>
 	public DiscordConfiguration(DiscordConfiguration other)
 	{
 		this.Token = other.Token;
 		this.TokenType = other.TokenType;
 		this.MinimumLogLevel = other.MinimumLogLevel;
 		this.UseRelativeRatelimit = other.UseRelativeRatelimit;
 		this.LogTimestampFormat = other.LogTimestampFormat;
 		this.LargeThreshold = other.LargeThreshold;
 		this.AutoReconnect = other.AutoReconnect;
 		this.ShardId = other.ShardId;
 		this.ShardCount = other.ShardCount;
 		this.GatewayCompressionLevel = other.GatewayCompressionLevel;
 		this.MessageCacheSize = other.MessageCacheSize;
 		this.WebSocketClientFactory = other.WebSocketClientFactory;
 		this.UdpClientFactory = other.UdpClientFactory;
 		this.Proxy = other.Proxy;
 		this.HttpTimeout = other.HttpTimeout;
 		this.ReconnectIndefinitely = other.ReconnectIndefinitely;
 		this.Intents = other.Intents;
 		this.LoggerFactory = other.LoggerFactory;
 		this.MobileStatus = other.MobileStatus;
 		this.UseCanary = other.UseCanary;
 		this.UsePtb = other.UsePtb;
 		this.AutoRefreshChannelCache = other.AutoRefreshChannelCache;
 		this.ApiVersion = other.ApiVersion;
 		this.ServiceProvider = other.ServiceProvider;
 		this.Override = other.Override;
 		this.Locale = other.Locale;
 		this.Timezone = other.Timezone;
 		this.ReportMissingFields = other.ReportMissingFields;
 		this.EnableSentry = other.EnableSentry;
 		this.AttachUserInfo = other.AttachUserInfo;
 		this.FeedbackEmail = other.FeedbackEmail;
 		this.DeveloperUserId = other.DeveloperUserId;
 		this.HasShardLogger = other.HasShardLogger;
 	}
 }
diff --git a/DisCatSharp/Exceptions/BadRequestException.cs b/DisCatSharp/Exceptions/BadRequestException.cs
index d5463c340..51b197475 100644
--- a/DisCatSharp/Exceptions/BadRequestException.cs
+++ b/DisCatSharp/Exceptions/BadRequestException.cs
@@ -1,86 +1,87 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2023 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 
 using DisCatSharp.Net;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Exceptions;
 
 /// <summary>
 /// Represents an exception thrown when a malformed request is sent.
 /// </summary>
-public class BadRequestException : Exception
+public class BadRequestException : DisCatSharpException
 {
 	/// <summary>
 	/// Gets the request that caused the exception.
 	/// </summary>
 	public BaseRestRequest WebRequest { get; internal set; }
 
 	/// <summary>
 	/// Gets the response to the request.
 	/// </summary>
 	public RestResponse WebResponse { get; internal set; }
 
 	/// <summary>
 	/// Gets the error code for this exception.
 	/// </summary>
 	public int Code { get; internal set; }
 
 	/// <summary>
 	/// Gets the JSON message received.
 	/// </summary>
 	public string JsonMessage { get; internal set; }
 
 	/// <summary>
 	/// Gets the form error responses in JSON format.
 	/// </summary>
 	public string Errors { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="BadRequestException"/> class.
 	/// </summary>
 	/// <param name="request">The request.</param>
 	/// <param name="response">The response.</param>
-	internal BadRequestException(BaseRestRequest request, RestResponse response) : base("Bad request: " + response.ResponseCode)
+	internal BadRequestException(BaseRestRequest request, RestResponse response)
+		: base("Bad request: " + response.ResponseCode)
 	{
 		this.WebRequest = request;
 		this.WebResponse = response;
 
 		try
 		{
 			var j = JObject.Parse(response.Response);
 
 			if (j["code"] != null)
 				this.Code = (int)j["code"];
 
 			if (j["message"] != null)
 				this.JsonMessage = j["message"].ToString();
 
 			if (j["errors"] != null)
 				this.Errors = j["errors"].ToString();
 		}
 		catch { }
 	}
 }
diff --git a/DisCatSharp/Exceptions/RateLimitException.cs b/DisCatSharp/Exceptions/DisCatSharpException.cs
similarity index 52%
copy from DisCatSharp/Exceptions/RateLimitException.cs
copy to DisCatSharp/Exceptions/DisCatSharpException.cs
index 6d9c8b590..ce66caadd 100644
--- a/DisCatSharp/Exceptions/RateLimitException.cs
+++ b/DisCatSharp/Exceptions/DisCatSharpException.cs
@@ -1,70 +1,32 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2023 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 
-using DisCatSharp.Net;
-
-using Newtonsoft.Json.Linq;
-
 namespace DisCatSharp.Exceptions;
 
-/// <summary>
-/// Represents an exception thrown when too many requests are sent.
-/// </summary>
-public class RateLimitException : Exception
+public class DisCatSharpException : Exception
 {
-	/// <summary>
-	/// Gets the request that caused the exception.
-	/// </summary>
-	public BaseRestRequest WebRequest { get; internal set; }
-
-	/// <summary>
-	/// Gets the response to the request.
-	/// </summary>
-	public RestResponse WebResponse { get; internal set; }
-
-	/// <summary>
-	/// Gets the JSON received.
-	/// </summary>
-	public string JsonMessage { get; internal set; }
-
-	/// <summary>
-	/// Initializes a new instance of the <see cref="RateLimitException"/> class.
-	/// </summary>
-	/// <param name="request">The request.</param>
-	/// <param name="response">The response.</param>
-	internal RateLimitException(BaseRestRequest request, RestResponse response) : base("Rate limited: " + response.ResponseCode)
-	{
-		this.WebRequest = request;
-		this.WebResponse = response;
-
-		try
-		{
-			var j = JObject.Parse(response.Response);
-
-			if (j["message"] != null)
-				this.JsonMessage = j["message"].ToString();
-		}
-		catch (Exception) { }
-	}
+	internal DisCatSharpException(string message)
+		: base(message)
+	{ }
 }
diff --git a/DisCatSharp/Exceptions/RateLimitException.cs b/DisCatSharp/Exceptions/ExceptionFilter.cs
similarity index 52%
copy from DisCatSharp/Exceptions/RateLimitException.cs
copy to DisCatSharp/Exceptions/ExceptionFilter.cs
index 6d9c8b590..5ffbb03e1 100644
--- a/DisCatSharp/Exceptions/RateLimitException.cs
+++ b/DisCatSharp/Exceptions/ExceptionFilter.cs
@@ -1,70 +1,40 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2023 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 
-using DisCatSharp.Net;
-
-using Newtonsoft.Json.Linq;
+using Sentry.Extensibility;
 
 namespace DisCatSharp.Exceptions;
 
-/// <summary>
-/// Represents an exception thrown when too many requests are sent.
-/// </summary>
-public class RateLimitException : Exception
+public class DisCatSharpExceptionFilter : IExceptionFilter
 {
-	/// <summary>
-	/// Gets the request that caused the exception.
-	/// </summary>
-	public BaseRestRequest WebRequest { get; internal set; }
-
-	/// <summary>
-	/// Gets the response to the request.
-	/// </summary>
-	public RestResponse WebResponse { get; internal set; }
+	internal DiscordConfiguration config { get; set; }
 
-	/// <summary>
-	/// Gets the JSON received.
-	/// </summary>
-	public string JsonMessage { get; internal set; }
+	public bool Filter(Exception ex)
+		=> !this.config.TrackExceptions.Contains(ex.GetType());
 
-	/// <summary>
-	/// Initializes a new instance of the <see cref="RateLimitException"/> class.
-	/// </summary>
-	/// <param name="request">The request.</param>
-	/// <param name="response">The response.</param>
-	internal RateLimitException(BaseRestRequest request, RestResponse response) : base("Rate limited: " + response.ResponseCode)
+	internal DisCatSharpExceptionFilter(DiscordConfiguration configuration)
 	{
-		this.WebRequest = request;
-		this.WebResponse = response;
-
-		try
-		{
-			var j = JObject.Parse(response.Response);
-
-			if (j["message"] != null)
-				this.JsonMessage = j["message"].ToString();
-		}
-		catch (Exception) { }
+		this.config = configuration;
 	}
 }
diff --git a/DisCatSharp/Exceptions/NotFoundException.cs b/DisCatSharp/Exceptions/NotFoundException.cs
index 1b48f0d30..1b6a97ed3 100644
--- a/DisCatSharp/Exceptions/NotFoundException.cs
+++ b/DisCatSharp/Exceptions/NotFoundException.cs
@@ -1,70 +1,71 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2023 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 
 using DisCatSharp.Net;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Exceptions;
 
 /// <summary>
 /// Represents an exception thrown when a requested resource is not found.
 /// </summary>
-public class NotFoundException : Exception
+public class NotFoundException : DisCatSharpException
 {
 	/// <summary>
 	/// Gets the request that caused the exception.
 	/// </summary>
 	public BaseRestRequest WebRequest { get; internal set; }
 
 	/// <summary>
 	/// Gets the response to the request.
 	/// </summary>
 	public RestResponse WebResponse { get; internal set; }
 
 	/// <summary>
 	/// Gets the JSON received.
 	/// </summary>
 	public string JsonMessage { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="NotFoundException"/> class.
 	/// </summary>
 	/// <param name="request">The request.</param>
 	/// <param name="response">The response.</param>
-	internal NotFoundException(BaseRestRequest request, RestResponse response) : base("Not found: " + response.ResponseCode)
+	internal NotFoundException(BaseRestRequest request, RestResponse response)
+		: base("Not found: " + response.ResponseCode)
 	{
 		this.WebRequest = request;
 		this.WebResponse = response;
 
 		try
 		{
 			var j = JObject.Parse(response.Response);
 
 			if (j["message"] != null)
 				this.JsonMessage = j["message"].ToString();
 		}
 		catch (Exception) { }
 	}
 }
diff --git a/DisCatSharp/Exceptions/RateLimitException.cs b/DisCatSharp/Exceptions/RateLimitException.cs
index 6d9c8b590..10577ac22 100644
--- a/DisCatSharp/Exceptions/RateLimitException.cs
+++ b/DisCatSharp/Exceptions/RateLimitException.cs
@@ -1,70 +1,71 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2023 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 
 using DisCatSharp.Net;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Exceptions;
 
 /// <summary>
 /// Represents an exception thrown when too many requests are sent.
 /// </summary>
-public class RateLimitException : Exception
+public class RateLimitException : DisCatSharpException
 {
 	/// <summary>
 	/// Gets the request that caused the exception.
 	/// </summary>
 	public BaseRestRequest WebRequest { get; internal set; }
 
 	/// <summary>
 	/// Gets the response to the request.
 	/// </summary>
 	public RestResponse WebResponse { get; internal set; }
 
 	/// <summary>
 	/// Gets the JSON received.
 	/// </summary>
 	public string JsonMessage { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="RateLimitException"/> class.
 	/// </summary>
 	/// <param name="request">The request.</param>
 	/// <param name="response">The response.</param>
-	internal RateLimitException(BaseRestRequest request, RestResponse response) : base("Rate limited: " + response.ResponseCode)
+	internal RateLimitException(BaseRestRequest request, RestResponse response)
+		: base("Rate limited: " + response.ResponseCode)
 	{
 		this.WebRequest = request;
 		this.WebResponse = response;
 
 		try
 		{
 			var j = JObject.Parse(response.Response);
 
 			if (j["message"] != null)
 				this.JsonMessage = j["message"].ToString();
 		}
 		catch (Exception) { }
 	}
 }
diff --git a/DisCatSharp/Exceptions/RequestSizeException.cs b/DisCatSharp/Exceptions/RequestSizeException.cs
index 71205e0a9..f9f3c3c42 100644
--- a/DisCatSharp/Exceptions/RequestSizeException.cs
+++ b/DisCatSharp/Exceptions/RequestSizeException.cs
@@ -1,70 +1,71 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2023 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 
 using DisCatSharp.Net;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Exceptions;
 
 /// <summary>
 /// Represents an exception thrown when the request sent to Discord is too large.
 /// </summary>
-public class RequestSizeException : Exception
+public class RequestSizeException : DisCatSharpException
 {
 	/// <summary>
 	/// Gets the request that caused the exception.
 	/// </summary>
 	public BaseRestRequest WebRequest { get; internal set; }
 
 	/// <summary>
 	/// Gets the response to the request.
 	/// </summary>
 	public RestResponse WebResponse { get; internal set; }
 
 	/// <summary>
 	/// Gets the JSON received.
 	/// </summary>
 	public string JsonMessage { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="RequestSizeException"/> class.
 	/// </summary>
 	/// <param name="request">The request.</param>
 	/// <param name="response">The response.</param>
-	internal RequestSizeException(BaseRestRequest request, RestResponse response) : base($"Request entity too large: {response.ResponseCode}. Make sure the data sent is within Discord's upload limit.")
+	internal RequestSizeException(BaseRestRequest request, RestResponse response)
+		: base($"Request entity too large: {response.ResponseCode}. Make sure the data sent is within Discord's upload limit.")
 	{
 		this.WebRequest = request;
 		this.WebResponse = response;
 
 		try
 		{
 			var j = JObject.Parse(response.Response);
 
 			if (j["message"] != null)
 				this.JsonMessage = j["message"].ToString();
 		}
 		catch (Exception) { }
 	}
 }
diff --git a/DisCatSharp/Exceptions/ServerErrorException.cs b/DisCatSharp/Exceptions/ServerErrorException.cs
index 863f1caed..782e539ea 100644
--- a/DisCatSharp/Exceptions/ServerErrorException.cs
+++ b/DisCatSharp/Exceptions/ServerErrorException.cs
@@ -1,70 +1,71 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2023 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 
 using DisCatSharp.Net;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Exceptions;
 
 /// <summary>
 /// Represents an exception thrown when Discord returns an Internal Server Error.
 /// </summary>
-public class ServerErrorException : Exception
+public class ServerErrorException : DisCatSharpException
 {
 	/// <summary>
 	/// Gets the request that caused the exception.
 	/// </summary>
 	public BaseRestRequest WebRequest { get; internal set; }
 
 	/// <summary>
 	/// Gets the response to the request.
 	/// </summary>
 	public RestResponse WebResponse { get; internal set; }
 
 	/// <summary>
 	/// Gets the JSON received.
 	/// </summary>
 	public string JsonMessage { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="ServerErrorException"/> class.
 	/// </summary>
 	/// <param name="request">The request.</param>
 	/// <param name="response">The response.</param>
-	internal ServerErrorException(BaseRestRequest request, RestResponse response) : base("Internal Server Error: " + response.ResponseCode)
+	internal ServerErrorException(BaseRestRequest request, RestResponse response)
+		: base("Internal Server Error: " + response.ResponseCode)
 	{
 		this.WebRequest = request;
 		this.WebResponse = response;
 
 		try
 		{
 			var j = JObject.Parse(response.Response);
 
 			if (j["message"] != null)
 				this.JsonMessage = j["message"].ToString();
 		}
 		catch (Exception) { }
 	}
 }
diff --git a/DisCatSharp/Exceptions/UnauthorizedException.cs b/DisCatSharp/Exceptions/UnauthorizedException.cs
index f25938ea5..741da47af 100644
--- a/DisCatSharp/Exceptions/UnauthorizedException.cs
+++ b/DisCatSharp/Exceptions/UnauthorizedException.cs
@@ -1,70 +1,71 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2023 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 
 using DisCatSharp.Net;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Exceptions;
 
 /// <summary>
 /// Represents an exception thrown when requester doesn't have necessary permissions to complete the request.
 /// </summary>
-public class UnauthorizedException : Exception
+public class UnauthorizedException : DisCatSharpException
 {
 	/// <summary>
 	/// Gets the request that caused the exception.
 	/// </summary>
 	public BaseRestRequest WebRequest { get; internal set; }
 
 	/// <summary>
 	/// Gets the response to the request.
 	/// </summary>
 	public RestResponse WebResponse { get; internal set; }
 
 	/// <summary>
 	/// Gets the JSON received.
 	/// </summary>
 	public string JsonMessage { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="UnauthorizedException"/> class.
 	/// </summary>
 	/// <param name="request">The request.</param>
 	/// <param name="response">The response.</param>
-	internal UnauthorizedException(BaseRestRequest request, RestResponse response) : base("Unauthorized: " + response.ResponseCode)
+	internal UnauthorizedException(BaseRestRequest request, RestResponse response)
+		: base("Unauthorized: " + response.ResponseCode)
 	{
 		this.WebRequest = request;
 		this.WebResponse = response;
 
 		try
 		{
 			var j = JObject.Parse(response.Response);
 
 			if (j["message"] != null)
 				this.JsonMessage = j["message"].ToString();
 		}
 		catch (Exception) { }
 	}
 }