feat(discord): gate no-op embed edits in DiscordChannelMessenger singleton

Skips PATCHes whose render matches the last successful send; adds
RetryMode.AlwaysRetry + 30s timeout so bursts degrade to slow catch-up.
Also registers RenderGate/DiscordChannelMessenger in the three
feature registration tests that build a real DI graph (Alarms, Events,
Players) since they wire cross-layer singletons manually instead of
via AddDiscordBot.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: HandyS11

src/RustPlusBot.Discord/DiscordServiceCollectionExtensions.cs

@@ -3,6 +3,7 @@
 using Discord.WebSocket;
 using Microsoft.Extensions.DependencyInjection;
 using RustPlusBot.Discord.Notifications;
+using RustPlusBot.Discord.Posting;
 
 namespace RustPlusBot.Discord;
 
@@ -31,6 +32,8 @@ public static IServiceCollection AddDiscordBot(this IServiceCollection services)
                 DefaultRunMode = RunMode.Async
             }));
         services.AddSingleton<IUserDmSender, DiscordUserDmSender>();
+        services.AddSingleton<RenderGate>();
+        services.AddSingleton<DiscordChannelMessenger>();
         services.AddHostedService<DiscordBotService>();
 
         return services;

src/RustPlusBot.Discord/Posting/DiscordChannelMessenger.cs

@@ -5,22 +5,30 @@
 
 namespace RustPlusBot.Discord.Posting;
 
-/// <summary>Shared Discord channel post/edit boilerplate: fetch, options, self-heal, broad-catch.</summary>
-public static class DiscordChannelMessenger
+/// <summary>
+///     Shared Discord channel post/edit boilerplate: fetch, options, self-heal, broad-catch — plus a
+///     render gate that skips edits whose content is identical to the last successful send, keeping
+///     boot primes and periodic republishes out of Discord's per-channel PATCH rate-limit bucket.
+/// </summary>
+/// <param name="client">The Discord socket client.</param>
+/// <param name="gate">The per-message no-op edit detector.</param>
+public sealed class DiscordChannelMessenger(DiscordSocketClient client, RenderGate gate)
 {
+    /// <summary>Request timeout generous enough to ride out a queued rate-limit burst (default is 15 s).</summary>
+    private const int RequestTimeoutMs = 30_000;
+
     /// <summary>
     ///     Edits the message by id (self-healing on 404 by reposting) or posts a new one.
+    ///     Identical re-renders are skipped without calling Discord's edit endpoint.
     ///     Returns the message id, or null on failure.
     /// </summary>
-    /// <param name="client">The Discord socket client.</param>
     /// <param name="channelId">The target channel id.</param>
     /// <param name="messageId">The existing message id to edit, or null to post a new one.</param>
     /// <param name="embed">The embed to post or update.</param>
     /// <param name="components">The message components to post or update.</param>
     /// <param name="logger">The caller's logger.</param>
     /// <param name="cancellationToken">The cancellation token.</param>
-    public static async Task<ulong?> EnsureAsync(
-        DiscordSocketClient client,
+    public async Task<ulong?> EnsureAsync(
         ulong channelId,
         ulong? messageId,
         Embed embed,
@@ -30,16 +38,14 @@ public static class DiscordChannelMessenger
     {
         try
         {
-            var options = new RequestOptions
-            {
-                CancelToken = cancellationToken
-            };
+            var options = CreateOptions(cancellationToken);
             if (await client.GetChannelAsync(channelId, options).ConfigureAwait(false)
                 is not ITextChannel channel)
             {
                 return null;
             }
 
+            var canonical = RenderCanonicalizer.Canonicalize(embed, components);
             if (messageId is { } id)
             {
                 // Inner try: some Discord.Net versions THROW (HttpException 404/Unknown Message)
@@ -50,11 +56,18 @@ public static class DiscordChannelMessenger
                     var existing = await channel.GetMessageAsync(id, options: options).ConfigureAwait(false);
                     if (existing is IUserMessage userMessage)
                     {
+                        if (!gate.ShouldSend(id, canonical))
+                        {
+                            // Same content as the last successful send: don't spend the PATCH bucket.
+                            return userMessage.Id;
+                        }
+
                         await userMessage.ModifyAsync(m =>
                         {
                             m.Embed = embed;
                             m.Components = components;
                         }, options).ConfigureAwait(false);
+                        gate.Commit(id, canonical);
                         return userMessage.Id;
                     }
 
@@ -68,11 +81,15 @@ await userMessage.ModifyAsync(m =>
                         channelId);
 #pragma warning restore CA1848, CA1873
                 }
+
+                // The tracked message is gone; the repost below re-keys the gate under the new id.
+                gate.Invalidate(id);
             }
 
             var posted = await channel
                 .SendMessageAsync(embed: embed, options: options, components: components)
                 .ConfigureAwait(false);
+            gate.Commit(posted.Id, canonical);
             return posted.Id;
         }
         catch (OperationCanceledException)
@@ -83,6 +100,12 @@ await userMessage.ModifyAsync(m =>
         catch (Exception ex)
 #pragma warning restore CA1031
         {
+            if (messageId is { } failedId)
+            {
+                // Outcome unknown (e.g. timeout mid-flight): forget the entry so the next render retries.
+                gate.Invalidate(failedId);
+            }
+
 #pragma warning disable CA1848, CA1873 // Use LoggerMessage delegates / avoid expensive log-arg evaluation — plain logger.Log is fine for a shared helper (no source-gen partial context); ulong boxing is negligible vs. the caught exception.
             logger.LogWarning(ex, "Posting/editing an embed in channel {ChannelId} failed.", channelId);
 #pragma warning restore CA1848, CA1873
@@ -91,24 +114,19 @@ await userMessage.ModifyAsync(m =>
     }
 
     /// <summary>Posts an embed fire-and-forget; Discord hiccups are logged and swallowed.</summary>
-    /// <param name="client">The Discord socket client.</param>
     /// <param name="channelId">The target channel id.</param>
     /// <param name="embed">The embed to post.</param>
     /// <param name="logger">The caller's logger.</param>
     /// <param name="cancellationToken">The cancellation token.</param>
-    public static async Task PostAsync(
-        DiscordSocketClient client,
+    public async Task PostAsync(
         ulong channelId,
         Embed embed,
         ILogger logger,
         CancellationToken cancellationToken)
     {
         try
         {
-            var options = new RequestOptions
-            {
-                CancelToken = cancellationToken
-            };
+            var options = CreateOptions(cancellationToken);
             if (await client.GetChannelAsync(channelId, options).ConfigureAwait(false) is not ITextChannel channel)
             {
                 return;
@@ -129,4 +147,9 @@ public static async Task PostAsync(
 #pragma warning restore CA1848, CA1873
         }
     }
+
+    private static RequestOptions CreateOptions(CancellationToken cancellationToken) => new()
+    {
+        CancelToken = cancellationToken, RetryMode = RetryMode.AlwaysRetry, Timeout = RequestTimeoutMs,
+    };
 }

src/RustPlusBot.Features.Alarms/Posting/DiscordAlarmChannelPoster.cs

@@ -6,10 +6,12 @@
 namespace RustPlusBot.Features.Alarms.Posting;
 
 /// <summary>Posts/edits alarm embeds in #alarms by message id. Untested integration shim.</summary>
-/// <param name="client">The Discord socket client.</param>
+/// <param name="client">The Discord socket client (used directly for the raw @everyone ping).</param>
+/// <param name="messenger">The shared gated channel messenger.</param>
 /// <param name="logger">The logger.</param>
 internal sealed partial class DiscordAlarmChannelPoster(
     DiscordSocketClient client,
+    DiscordChannelMessenger messenger,
     ILogger<DiscordAlarmChannelPoster> logger) : IAlarmChannelPoster
 {
     /// <inheritdoc />
@@ -19,8 +21,7 @@ internal sealed partial class DiscordAlarmChannelPoster(
         Embed embed,
         MessageComponent components,
         CancellationToken cancellationToken)
-        => DiscordChannelMessenger.EnsureAsync(client, channelId, messageId, embed, components, logger,
-            cancellationToken);
+        => messenger.EnsureAsync(channelId, messageId, embed, components, logger, cancellationToken);
 
     /// <inheritdoc />
     public async Task SendEveryonePingAsync(ulong channelId, string content, CancellationToken cancellationToken)

src/RustPlusBot.Features.Events/Posting/DiscordEventChannelPoster.cs

@@ -1,19 +1,18 @@
 using Discord;
-using Discord.WebSocket;
 using Microsoft.Extensions.Logging;
 using RustPlusBot.Discord.Posting;
 
 namespace RustPlusBot.Features.Events.Posting;
 
 /// <summary>Posts event embeds to Discord text channels via the gateway client.</summary>
-/// <param name="client">The Discord socket client.</param>
+/// <param name="messenger">The shared gated channel messenger.</param>
 /// <param name="logger">The logger.</param>
 internal sealed class DiscordEventChannelPoster(
-    DiscordSocketClient client,
+    DiscordChannelMessenger messenger,
     ILogger<DiscordEventChannelPoster> logger)
     : IEventChannelPoster
 {
     /// <inheritdoc />
     public Task PostAsync(ulong channelId, Embed embed, CancellationToken cancellationToken)
-        => DiscordChannelMessenger.PostAsync(client, channelId, embed, logger, cancellationToken);
+        => messenger.PostAsync(channelId, embed, logger, cancellationToken);
 }

src/RustPlusBot.Features.Players/Posting/DiscordPlayerChannelPoster.cs

@@ -1,19 +1,18 @@
 using Discord;
-using Discord.WebSocket;
 using Microsoft.Extensions.Logging;
 using RustPlusBot.Discord.Posting;
 
 namespace RustPlusBot.Features.Players.Posting;
 
 /// <summary>Posts player-event embeds to Discord text channels via the gateway client.</summary>
-/// <param name="client">The Discord socket client.</param>
+/// <param name="messenger">The shared gated channel messenger.</param>
 /// <param name="logger">The logger.</param>
 internal sealed class DiscordPlayerChannelPoster(
-    DiscordSocketClient client,
+    DiscordChannelMessenger messenger,
     ILogger<DiscordPlayerChannelPoster> logger)
     : IPlayerChannelPoster
 {
     /// <inheritdoc />
     public Task PostAsync(ulong channelId, Embed embed, CancellationToken cancellationToken)
-        => DiscordChannelMessenger.PostAsync(client, channelId, embed, logger, cancellationToken);
+        => messenger.PostAsync(channelId, embed, logger, cancellationToken);
 }

src/RustPlusBot.Features.StorageMonitors/Posting/DiscordStorageMonitorChannelPoster.cs

@@ -1,15 +1,14 @@
 using Discord;
-using Discord.WebSocket;
 using Microsoft.Extensions.Logging;
 using RustPlusBot.Discord.Posting;
 
 namespace RustPlusBot.Features.StorageMonitors.Posting;
 
 /// <summary>Posts/edits storage monitor embeds in #storagemonitors by message id. Untested integration shim.</summary>
-/// <param name="client">The Discord socket client.</param>
+/// <param name="messenger">The shared gated channel messenger.</param>
 /// <param name="logger">The logger.</param>
 internal sealed class DiscordStorageMonitorChannelPoster(
-    DiscordSocketClient client,
+    DiscordChannelMessenger messenger,
     ILogger<DiscordStorageMonitorChannelPoster> logger) : IStorageMonitorChannelPoster
 {
     /// <inheritdoc />
@@ -19,6 +18,5 @@ internal sealed class DiscordStorageMonitorChannelPoster(
         Embed embed,
         MessageComponent components,
         CancellationToken cancellationToken)
-        => DiscordChannelMessenger.EnsureAsync(client, channelId, messageId, embed, components, logger,
-            cancellationToken);
+        => messenger.EnsureAsync(channelId, messageId, embed, components, logger, cancellationToken);
 }

src/RustPlusBot.Features.Switches/Posting/DiscordSwitchChannelPoster.cs

@@ -1,15 +1,14 @@
 using Discord;
-using Discord.WebSocket;
 using Microsoft.Extensions.Logging;
 using RustPlusBot.Discord.Posting;
 
 namespace RustPlusBot.Features.Switches.Posting;
 
 /// <summary>Posts/edits switch embeds in #switches by message id. Untested integration shim.</summary>
-/// <param name="client">The Discord socket client.</param>
+/// <param name="messenger">The shared gated channel messenger.</param>
 /// <param name="logger">The logger.</param>
 internal sealed class DiscordSwitchChannelPoster(
-    DiscordSocketClient client,
+    DiscordChannelMessenger messenger,
     ILogger<DiscordSwitchChannelPoster> logger) : ISwitchChannelPoster
 {
     /// <inheritdoc />
@@ -19,6 +18,5 @@ internal sealed class DiscordSwitchChannelPoster(
         Embed embed,
         MessageComponent components,
         CancellationToken cancellationToken)
-        => DiscordChannelMessenger.EnsureAsync(client, channelId, messageId, embed, components, logger,
-            cancellationToken);
+        => messenger.EnsureAsync(channelId, messageId, embed, components, logger, cancellationToken);
 }

tests/RustPlusBot.Features.Alarms.Tests/AlarmRegistrationTests.cs

@@ -9,6 +9,7 @@
 using RustPlusBot.Features.Alarms.Posting;
 using RustPlusBot.Features.Alarms.Relaying;
 using RustPlusBot.Features.Alarms.Rendering;
+using RustPlusBot.Discord.Posting;
 using RustPlusBot.Features.Connections.Listening;
 using RustPlusBot.Features.Workspace.Locating;
 using RustPlusBot.Localization;
@@ -55,6 +56,8 @@ public void AddAlarms_resolves_without_captive_dependency_errors()
         // Discord
         var discordConfig = new DiscordSocketConfig();
         services.AddSingleton(new DiscordSocketClient(discordConfig));
+        services.AddSingleton<RenderGate>();
+        services.AddSingleton<DiscordChannelMessenger>();
 
         // Scoped stores from Persistence
         services.AddScoped(_ => Substitute.For<IAlarmStore>());

tests/RustPlusBot.Features.Events.Tests/EventRegistrationTests.cs

@@ -5,6 +5,7 @@
 using NSubstitute;
 using RustPlusBot.Abstractions.Events;
 using RustPlusBot.Abstractions.Time;
+using RustPlusBot.Discord.Posting;
 using RustPlusBot.Features.Connections;
 using RustPlusBot.Features.Connections.Listening;
 using RustPlusBot.Features.Events.Hosting;
@@ -39,6 +40,8 @@ private static ServiceProvider BuildProvider()
         services.AddSingleton<IClock>(Substitute.For<IClock>());
         services.AddSingleton<IEventBus, InMemoryEventBus>();
         services.AddSingleton(new DiscordSocketClient());
+        services.AddSingleton<RenderGate>();
+        services.AddSingleton<DiscordChannelMessenger>();
         services.AddSingleton<IEventChannelLocator>(Substitute.For<IEventChannelLocator>());
         services.AddScoped<IWorkspaceStore>(_ => Substitute.For<IWorkspaceStore>());
         services.AddScoped<IConnectionStore>(_ => Substitute.For<IConnectionStore>());

tests/RustPlusBot.Features.Players.Tests/PlayerEventRegistrationTests.cs

@@ -3,6 +3,7 @@
 using Microsoft.Extensions.Hosting;
 using NSubstitute;
 using RustPlusBot.Abstractions.Events;
+using RustPlusBot.Discord.Posting;
 using RustPlusBot.Features.Connections.Listening;
 using RustPlusBot.Features.Players;
 using RustPlusBot.Features.Players.Hosting;
@@ -28,6 +29,8 @@ private static ServiceProvider BuildProvider()
         services.AddLogging();
         services.AddSingleton<IEventBus, InMemoryEventBus>();
         services.AddSingleton(new DiscordSocketClient());
+        services.AddSingleton<RenderGate>();
+        services.AddSingleton<DiscordChannelMessenger>();
         services.AddSingleton<IEventChannelLocator>(Substitute.For<IEventChannelLocator>());
         services.AddScoped<IWorkspaceStore>(_ => Substitute.For<IWorkspaceStore>());
         services.AddSingleton<IBotTeamChatSender>(Substitute.For<IBotTeamChatSender>());