Hoist stats whole_key collapse counter off the per-dropped-span map lookup

The collapsed:whole_key counter is incremented once per dropped span on the
aggregator thread (Aggregator, findOrInsert == null branch), unlike every other
collapse reason which is batched once per reporting cycle. Under a cardinality
explosion the aggregate table pins at cap and every arriving span is dropped,
turning that path hot on an already-bottlenecked thread -- yet it went through a
ConcurrentHashMap.computeIfAbsent lookup on StatsMetrics per span.

Pre-create the whole_key TaggedCounter at construction (still registered in the
reason map so the telemetry drain picks it up unchanged) and add a dedicated
onWholeKeyCollapse() that increments the cached reference directly. The hot path
no longer touches the map; the batched reasons still route through
onCollapsedSpans as before.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: dougqh

dd-trace-core/src/main/java/datadog/trace/common/metrics/Aggregator.java

@@ -16,10 +16,6 @@ final class Aggregator implements Runnable {
 
   private static final long DEFAULT_SLEEP_MILLIS = 10;
 
-  // Telemetry collapse reason for a whole-key drop (aggregate table at cap, no evictable entry);
-  // mirrors the statsd "collapsed:whole_key" tag on datadog.tracer.stats.collapsed_spans.
-  private static final String COLLAPSED_WHOLE_KEY_TAG = "collapsed:whole_key";
-
   private static final Logger log = LoggerFactory.getLogger(Aggregator.class);
 
   private final MessagePassingQueue<InboxItem> inbox;
@@ -161,7 +157,7 @@ public void accept(InboxItem item) {
         } else {
           // table at cap with no stale entry available to evict
           healthMetrics.onStatsAggregateDropped();
-          StatsMetrics.getInstance().onCollapsedSpans(COLLAPSED_WHOLE_KEY_TAG, 1);
+          StatsMetrics.getInstance().onWholeKeyCollapse();
         }
       }
     }

internal-api/src/main/java/datadog/trace/api/metrics/StatsMetrics.java

@@ -24,13 +24,23 @@
  */
 public final class StatsMetrics {
   static final String COLLAPSED_SPANS = "stats.collapsed_spans";
+  static final String COLLAPSED_WHOLE_KEY = "collapsed:whole_key";
 
   private static final StatsMetrics INSTANCE = new StatsMetrics();
 
   // reason tag (e.g. "collapsed:additional_metric_tags") -> counter. Created on first collapse for
   // that reason; the reason set is bounded, so this never grows unboundedly.
   private final ConcurrentMap<String, TaggedCounter> collapsedByReason = new ConcurrentHashMap<>();
 
+  // The one reason counted per dropped span on the hot aggregator path (aggregate table at cap);
+  // every other reason is batched once per reporting cycle. Pre-created and cached so the per-span
+  // increment is a direct counter hit rather than a map lookup -- this matters precisely when a
+  // cardinality explosion pins the table at cap and every arriving span is dropped, turning a cold
+  // path hot. Still registered in the map above, so the telemetry drain sees it with the rest.
+  private final TaggedCounter wholeKeyCollapses =
+      this.collapsedByReason.computeIfAbsent(
+          COLLAPSED_WHOLE_KEY, tag -> new TaggedCounter(COLLAPSED_SPANS, tag));
+
   public static StatsMetrics getInstance() {
     return INSTANCE;
   }
@@ -51,6 +61,15 @@ public void onCollapsedSpans(String reason, long count) {
         .addAndGet(count);
   }
 
+  /**
+   * Records a single whole-key collapse: a span dropped because the aggregate table was at cap with
+   * no entry to evict. Increments the pre-created {@link #COLLAPSED_WHOLE_KEY} counter directly,
+   * keeping the per-dropped-span aggregator path off the reason map.
+   */
+  public void onWholeKeyCollapse() {
+    this.wholeKeyCollapses.counter.addAndGet(1);
+  }
+
   public Collection<TaggedCounter> getTaggedCounters() {
     return this.collapsedByReason.values();
   }