Skip the team-info socket call when every clan member's name is cached

ClanStateService.RecordTeamNamesAsync now checks IClanStore.GetNamesAsync
against the full roster first and only calls IRustServerQuery.GetTeamInfoAsync
when a roster member's name is still unknown. OnClanChanged fires on every
clan edit, including score changes, and score moves on every kill, so the
previous unconditional call issued a companion-API RPC per kill per server.
In steady state this now costs zero extra RPCs; the socket is only touched
when a genuinely unknown member appears. Best-effort semantics are
unchanged: a null snapshot, a failing query, or an unknown name still never
blocks persistence or the feed post.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: HandyS11

src/RustPlusBot.Features.Clans/State/ClanStateService.cs

@@ -154,6 +154,17 @@ private async Task RecordTeamNamesAsync(
     {
         try
         {
+            var roster = snapshot.Members.Select(m => m.SteamId).ToHashSet();
+            var known = await store.GetNamesAsync(evt.GuildId, evt.ServerId, roster, cancellationToken)
+                .ConfigureAwait(false);
+            if (roster.All(known.ContainsKey))
+            {
+                // Every roster member already has a cached name: skip the companion-API round trip
+                // entirely. OnClanChanged fires on any clan edit, including score changes, and score
+                // moves on every kill — without this check that would be one RPC per kill per server.
+                return;
+            }
+
             var query = services.GetRequiredService<IRustServerQuery>();
             var team = await query.GetTeamInfoAsync(evt.GuildId, evt.ServerId, cancellationToken)
                 .ConfigureAwait(false);
@@ -163,18 +174,8 @@ private async Task RecordTeamNamesAsync(
                 return;
             }
 
-            var roster = snapshot.Members.Select(m => m.SteamId).ToHashSet();
             var candidates = team.Members
-                .Where(m => roster.Contains(m.SteamId) && !string.IsNullOrWhiteSpace(m.Name))
-                .ToList();
-            if (candidates.Count == 0)
-            {
-                return;
-            }
-
-            var known = await store
-                .GetNamesAsync(evt.GuildId, evt.ServerId, candidates.ConvertAll(m => m.SteamId), cancellationToken)
-                .ConfigureAwait(false);
+                .Where(m => roster.Contains(m.SteamId) && !string.IsNullOrWhiteSpace(m.Name));
 
             foreach (var member in candidates.Where(m => !known.ContainsKey(m.SteamId)))
             {

tests/RustPlusBot.Features.Clans.Tests/State/ClanStateServiceTests.cs

@@ -267,6 +267,8 @@ await service.ApplyAsync(
                 Snapshot(members: [Member(111UL), Member(222UL)])),
             CancellationToken.None);
 
+        // 111 is missing from the cache, so the socket call must happen and its answer recorded.
+        await _query.Received(1).GetTeamInfoAsync(Guild, Server, Arg.Any<CancellationToken>());
         await _store.Received(1).RecordNameAsync(Guild, Server, 111UL, "Alice", Arg.Any<CancellationToken>());
 
         // 222 is already cached, and 333 is on the team but not in the clan.
@@ -276,18 +278,46 @@ await _store.DidNotReceive()
             .RecordNameAsync(Guild, Server, 333UL, Arg.Any<string>(), Arg.Any<CancellationToken>());
     }
 
+    [Fact]
+    public async Task Skips_the_team_query_when_every_roster_member_already_has_a_cached_name()
+    {
+        // OnClanChanged fires on any clan edit, including score changes, and score moves on every
+        // kill: once the whole roster's names are cached this must cost zero companion-API RPCs.
+        _store.GetAsync(Guild, Server, Arg.Any<CancellationToken>()).Returns((ClanSnapshot?)null);
+        _store.GetNamesAsync(Guild, Server, Arg.Any<IReadOnlyCollection<ulong>>(), Arg.Any<CancellationToken>())
+            .Returns(new Dictionary<ulong, string>
+            {
+                [111UL] = "Alice", [222UL] = "Bob"
+            });
+        var service = Build();
+
+        await service.ApplyAsync(
+            new ClanStateChangedEvent(Guild, Server, ClanProbeStatus.HasClan,
+                Snapshot(members: [Member(111UL), Member(222UL)])),
+            CancellationToken.None);
+
+        await _query.DidNotReceive()
+            .GetTeamInfoAsync(Arg.Any<ulong>(), Arg.Any<Guid>(), Arg.Any<CancellationToken>());
+        await _store.DidNotReceive().RecordNameAsync(Arg.Any<ulong>(), Arg.Any<Guid>(), Arg.Any<ulong>(),
+            Arg.Any<string>(), Arg.Any<CancellationToken>());
+    }
+
     [Fact]
     public async Task A_null_team_snapshot_records_nothing_and_changes_nothing_else()
     {
         _query.GetTeamInfoAsync(Guild, Server, Arg.Any<CancellationToken>())
             .Returns((TeamInfoSnapshot?)null);
-        _store.GetAsync(Guild, Server, Arg.Any<CancellationToken>()).Returns(Snapshot());
-        var renamed = Snapshot("Bears");
+        // A non-empty, uncached roster so the harvest actually reaches the socket call whose
+        // null answer this test is meant to prove is harmless.
+        _store.GetAsync(Guild, Server, Arg.Any<CancellationToken>())
+            .Returns(Snapshot(members: [Member(111UL)]));
+        var renamed = Snapshot("Bears", members: [Member(111UL)]);
         var service = Build();
 
         await service.ApplyAsync(new ClanStateChangedEvent(Guild, Server, ClanProbeStatus.HasClan, renamed),
             CancellationToken.None);
 
+        await _query.Received(1).GetTeamInfoAsync(Guild, Server, Arg.Any<CancellationToken>());
         await _store.DidNotReceive().RecordNameAsync(Arg.Any<ulong>(), Arg.Any<Guid>(), Arg.Any<ulong>(),
             Arg.Any<string>(), Arg.Any<CancellationToken>());
         await _store.Received(1).SaveAsync(Guild, Server, renamed, Arg.Any<CancellationToken>());
@@ -299,13 +329,16 @@ public async Task A_failing_team_query_still_persists_the_clan_and_posts_the_fee
     {
         _query.GetTeamInfoAsync(Guild, Server, Arg.Any<CancellationToken>())
             .Returns<TeamInfoSnapshot?>(_ => throw new InvalidOperationException("socket gone"));
-        _store.GetAsync(Guild, Server, Arg.Any<CancellationToken>()).Returns(Snapshot());
-        var renamed = Snapshot("Bears");
+        // A non-empty, uncached roster so the harvest actually reaches the socket call that throws.
+        _store.GetAsync(Guild, Server, Arg.Any<CancellationToken>())
+            .Returns(Snapshot(members: [Member(111UL)]));
+        var renamed = Snapshot("Bears", members: [Member(111UL)]);
         var service = Build();
 
         await service.ApplyAsync(new ClanStateChangedEvent(Guild, Server, ClanProbeStatus.HasClan, renamed),
             CancellationToken.None);
 
+        await _query.Received(1).GetTeamInfoAsync(Guild, Server, Arg.Any<CancellationToken>());
         await _store.Received(1).SaveAsync(Guild, Server, renamed, Arg.Any<CancellationToken>());
         await _poster.Received(1).PostAsync(Channel, "clan.event.renamed", Arg.Any<CancellationToken>());
     }