fix: handle uncached role updates and report library faults

Handle GUILD_ROLE_UPDATE when the role is missing from cache by
refreshing the cache entry from the payload instead of dereferencing null.

Also allow library-origin exceptions through telemetry filtering so bugs like
dispatch-time NullReferenceExceptions still reach Sentry even when they are
not part of the explicit tracked-exception allowlist.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Lulalaby

DisCatSharp.Tests/DisCatSharp.CopilotTests/Store/StoreGatewayDispatchFollowupRegressionTests.cs

@@ -354,6 +354,49 @@ public async Task HandleDispatchSafelyAsync_DispatchFailure_CapturesDiagnosticsS
 		Assert.Equal(42, captured.Context["sequence"]);
 	}
 
+	[Fact]
+	public async Task GuildRoleUpdate_MissingRoleCache_DoesNotThrowAndRefreshesGuildRoleCache()
+	{
+		var client = CreateClient();
+		const ulong guildId = 804032421678153819;
+		const ulong roleId = 9001;
+
+		var guild = new DiscordGuild
+		{
+			Id = guildId,
+			Discord = client
+		};
+		client.GuildsInternal[guildId] = guild;
+
+		GuildRoleUpdateEventArgs? captured = null;
+		client.GuildRoleUpdated += (_, args) =>
+		{
+			captured = args;
+			return Task.CompletedTask;
+		};
+
+		var role = new DiscordRole
+		{
+			Id = roleId,
+			Name = "mods",
+			Discord = client,
+			Permissions = Permissions.Administrator,
+			Position = 7,
+			IsMentionable = true
+		};
+
+		var exception = await Record.ExceptionAsync(() => client.OnGuildRoleUpdateEventAsync(role, guild));
+
+		Assert.Null(exception);
+		Assert.NotNull(captured);
+		Assert.Equal(guildId, captured!.Guild.Id);
+		Assert.Equal(roleId, captured.RoleAfter.Id);
+		Assert.Equal("mods", captured.RoleAfter.Name);
+		Assert.Equal(roleId, captured.RoleBefore.Id);
+		Assert.Equal("mods", captured.RoleBefore.Name);
+		Assert.Same(captured.RoleAfter, guild.GetRole(roleId));
+	}
+
 	[Fact]
 	public async Task HandleSocketMessageAsync_HeartbeatWithNullData_UsesLastKnownSequence()
 	{

DisCatSharp.Tests/DisCatSharp.CopilotTests/Telemetry/SentryDiagnosticsSinkTests.cs

@@ -48,6 +48,35 @@ public void ExceptionFilter_AllowsWrappedTrackedException()
 		Assert.False(filter.Filter(exception));
 	}
 
+	[Fact]
+	public void ExceptionFilter_AllowsLibraryOriginExceptionOutsideTrackedList()
+	{
+		var config = new DiscordConfiguration
+		{
+			EnableLibraryDeveloperMode = true
+		};
+		config.TrackExceptions = [typeof(DiscordJsonException)];
+		var filter = new DisCatSharpExceptionFilter(config);
+		var exception = new NullReferenceException("library bug");
+		exception.Data[DiagnosticTags.ErrorOrigin] = DiagnosticTags.OriginLibrary;
+
+		Assert.False(filter.Filter(exception));
+	}
+
+	[Fact]
+	public void ShouldSendEvent_AllowsLibraryOriginExceptionOutsideTrackedList()
+	{
+		var config = new DiscordConfiguration
+		{
+			EnableLibraryDeveloperMode = true
+		};
+		config.TrackExceptions = [typeof(DiscordJsonException)];
+		var evt = new SentryEvent(new NullReferenceException("library bug"));
+		evt.SetTag(DiagnosticTags.ErrorOrigin, DiagnosticTags.OriginLibrary);
+
+		Assert.True(TelemetryBootstrap.ShouldSendEvent(evt, config));
+	}
+
 	[Fact]
 	public void ApplyContext_AttachesStructuredContextToEvent()
 	{

DisCatSharp/Clients/DiscordClient.Dispatch.cs

@@ -2769,34 +2769,37 @@ internal async Task OnGuildRoleCreateEventAsync(DiscordRole role, DiscordGuild g
 	internal async Task OnGuildRoleUpdateEventAsync(DiscordRole role, DiscordGuild guild)
 	{
 		var newRole = guild.GetRole(role.Id);
-		var oldRole = new DiscordRole
-		{
-			GuildId = guild.Id,
-			ColorInternal = newRole.ColorInternal,
-			Discord = this,
-			IsHoisted = newRole.IsHoisted,
-			Id = newRole.Id,
-			IsManaged = newRole.IsManaged,
-			IsMentionable = newRole.IsMentionable,
-			Name = newRole.Name,
-			Permissions = newRole.Permissions,
-			Position = newRole.Position,
-			IconHash = newRole.IconHash,
-			Tags = newRole.Tags ?? null,
-			UnicodeEmojiString = newRole.UnicodeEmojiString
-		};
+		var oldRole = CreateRoleSnapshot(newRole ?? role, guild);
 
-		newRole.GuildId = guild.Id;
-		newRole.ColorInternal = role.ColorInternal;
-		newRole.IsHoisted = role.IsHoisted;
-		newRole.IsManaged = role.IsManaged;
-		newRole.IsMentionable = role.IsMentionable;
-		newRole.Name = role.Name;
-		newRole.Permissions = role.Permissions;
-		newRole.Position = role.Position;
-		newRole.IconHash = role.IconHash;
-		newRole.Tags = role.Tags ?? null;
-		newRole.UnicodeEmojiString = role.UnicodeEmojiString;
+		if (newRole is null)
+		{
+			this.Logger.LogWarning(LoggerEvents.WebSocketReceive, "Received guild_role_update for uncached role {RoleId} in guild {GuildId}; refreshing cache from payload.", role.Id, guild.Id);
+			role.Discord = this;
+			role.GuildId = guild.Id;
+			role.GuildInternal = guild;
+			guild.RolesInternal[role.Id] = role;
+			newRole = role;
+		}
+		else
+		{
+			newRole.GuildId = guild.Id;
+			newRole.ColorInternal = role.ColorInternal;
+			newRole.Discord = this;
+			newRole.GuildInternal = guild;
+			newRole.IsHoisted = role.IsHoisted;
+			newRole.IsManaged = role.IsManaged;
+			newRole.IsMentionable = role.IsMentionable;
+			newRole.Name = role.Name;
+			newRole.Version = role.Version;
+			newRole.Description = role.Description;
+			newRole.Permissions = role.Permissions;
+			newRole.Position = role.Position;
+			newRole.IconHash = role.IconHash;
+			newRole.Tags = role.Tags;
+			newRole.UnicodeEmojiString = role.UnicodeEmojiString;
+			newRole.Flags = role.Flags;
+			newRole.Colors = role.Colors;
+		}
 
 		var ea = new GuildRoleUpdateEventArgs(this.ServiceProvider)
 		{
@@ -2807,6 +2810,29 @@ internal async Task OnGuildRoleUpdateEventAsync(DiscordRole role, DiscordGuild g
 		await this.RaiseEventAsync(this._guildRoleUpdated, ea).ConfigureAwait(false);
 	}
 
+	private DiscordRole CreateRoleSnapshot(DiscordRole source, DiscordGuild guild)
+		=> new()
+		{
+			Id = source.Id,
+			Discord = this,
+			GuildId = guild.Id,
+			GuildInternal = guild,
+			Name = source.Name,
+			Version = source.Version,
+			Description = source.Description,
+			ColorInternal = source.ColorInternal,
+			IsHoisted = source.IsHoisted,
+			Position = source.Position,
+			Permissions = source.Permissions,
+			IsManaged = source.IsManaged,
+			IsMentionable = source.IsMentionable,
+			Tags = source.Tags,
+			IconHash = source.IconHash,
+			UnicodeEmojiString = source.UnicodeEmojiString,
+			Flags = source.Flags,
+			Colors = source.Colors
+		};
+
 	/// <summary>
 	///     Handles the guild role delete event.
 	/// </summary>

DisCatSharp/Exceptions/ExceptionFilter.cs

@@ -31,6 +31,9 @@ internal DisCatSharpExceptionFilter(DiscordConfiguration configuration)
 	/// <param name="ex">The exception to check.</param>
 	public bool Filter(Exception ex)
 	{
+		if (ex.Data[DiagnosticTags.ErrorOrigin] as string == DiagnosticTags.OriginLibrary)
+			return false;
+
 		var trackedException = ex is SentryCapturableException { InnerException: not null } wrapper
 			? wrapper.InnerException
 			: ex;

DisCatSharp/Telemetry/SentryDiagnosticsSink.cs

@@ -40,6 +40,10 @@ public SentryDiagnosticsSink(SentryOptions options, DiscordConfiguration config)
 	/// <inheritdoc />
 	public void CaptureException(string source, Exception exception, IDictionary<string, object>? context = null, IDictionary<string, string>? tags = null)
 	{
+		exception.Data[DiagnosticTags.Source] = source;
+		if (tags?.TryGetValue(DiagnosticTags.ErrorOrigin, out var errorOrigin) is true)
+			exception.Data[DiagnosticTags.ErrorOrigin] = errorOrigin;
+
 		if (context is not null && exception is SentryCapturableException sce)
 			sce.AddSentryContext("Request", context);
 

DisCatSharp/Telemetry/TelemetryBootstrap.cs

@@ -123,26 +123,8 @@ private static void ConfigureBeforeSend(SentryOptions options, DiscordConfigurat
 	{
 		options.SetBeforeSend((e, _) =>
 		{
-			if (!config.Telemetry.DisableExceptionFilter)
-			{
-				if (e.Exception is not null)
-				{
-					var trackedException = e.Exception is SentryCapturableException { InnerException: not null } wrapper
-						? wrapper.InnerException
-						: e.Exception;
-
-					if (!config.Telemetry.TrackExceptions.Contains(trackedException.GetType()))
-						return null;
-				}
-				else if (e.Extra.ContainsKey("Found Fields"))
-				{
-					// Missing-field reports are allowed through the non-exception path.
-				}
-				else if (!e.Tags.ContainsKey(DiagnosticTags.Source))
-				{
-					return null;
-				}
-			}
+			if (!ShouldSendEvent(e, config))
+				return null;
 
 			if (!e.Extra.ContainsKey("Found Fields") && (e.Fingerprint is null || e.Fingerprint.Count is 0))
 				e.SetFingerprint(SentryDiagnosticsSink.GenerateFingerprint(e));
@@ -153,6 +135,32 @@ private static void ConfigureBeforeSend(SentryOptions options, DiscordConfigurat
 		});
 	}
 
+	internal static bool ShouldSendEvent(SentryEvent e, DiscordConfiguration config)
+	{
+		if (config.Telemetry.DisableExceptionFilter)
+			return true;
+
+		var isLibraryOrigin = e.Tags.TryGetValue(DiagnosticTags.ErrorOrigin, out var errorOrigin)
+			&& errorOrigin == DiagnosticTags.OriginLibrary;
+
+		if (e.Exception is not null)
+		{
+			if (isLibraryOrigin)
+				return true;
+
+			var trackedException = e.Exception is SentryCapturableException { InnerException: not null } wrapper
+				? wrapper.InnerException
+				: e.Exception;
+
+			return config.Telemetry.TrackExceptions.Contains(trackedException.GetType());
+		}
+
+		if (e.Extra.ContainsKey("Found Fields"))
+			return true;
+
+		return e.Tags.ContainsKey(DiagnosticTags.Source);
+	}
+
 	/// <summary>
 	///     Rewrites stack frame paths to stable package-root-relative paths so Sentry code mappings can resolve them.
 	/// </summary>