@@ -40,6 +40,7 @@
 import datadog.trace.api.EndpointTracker;
 import datadog.trace.api.IdGenerationStrategy;
 import datadog.trace.api.InstrumenterConfig;
+import datadog.trace.api.KnownTagCodec;
 import datadog.trace.api.KnownTags;
 import datadog.trace.api.Pair;
 import datadog.trace.api.SizingHint;
@@ -2200,8 +2201,19 @@ protected static final DDSpanContext buildSpanContext(
       // enriching tags a child doesn't, so pick the lane by whether we have a local parent. A
       // resolved hint sizes the span's TagMap and self-tunes on finish; null (no/unkeyable
       // operation name) falls back to the generic default capacity.
-      final boolean entrySpan = !(resolvedParentSpanContext instanceof DDSpanContext);
-      final SizingHint sizingHint = SizingHintTable.hintFor(operationName, entrySpan);
+      //
+      // Gated on KnownTagCodec.isActive(): sizing only helps when the dense known-tag store is live
+      // (the experimental dd.trace.dense.tags.enabled path). With it off -- the default -- known
+      // tags don't take the dense path, so a hint buys nothing; skipping resolution here keeps the
+      // operationName.toString() and the global-table probe off the default span-creation path
+      // entirely (do no harm).
+      final SizingHint sizingHint;
+      if (KnownTagCodec.isActive()) {
+        final boolean entrySpan = !(resolvedParentSpanContext instanceof DDSpanContext);
+        sizingHint = SizingHintTable.hintFor(operationName, entrySpan);
+      } else {
+        sizingHint = null;
+      }
 
       // some attributes are inherited from the parent
       context =
 
@@ -157,7 +157,6 @@ public boolean isFinished() {
   private void finishAndAddToTrace(final long durationNano) {
     // ensure a min duration of 1
     if (DURATION_NANO_UPDATER.compareAndSet(this, 0, Math.max(1, durationNano))) {
-      context.recordDenseSize();
       setLongRunningVersion(-this.longRunningVersion);
       SpanWrapper wrapper = getWrapper();
       if (wrapper != null) {
 
@@ -422,7 +422,7 @@ public DDSpanContext(
     final int capacity = Math.max((tagsSize <= 0 ? 3 : (tagsSize + 1)) * 4 / 3, 8);
     this.unsafeTags =
         readThroughParent != null
-            ? TagMap.createFromParent(readThroughParent)
+            ? TagMap.createFromParent(readThroughParent, sizingHint)
             : sizingHint != null ? TagMap.create(sizingHint) : TagMap.create(capacity);
     this.sizingHint = sizingHint;
 
@@ -976,15 +976,21 @@ public void setTag(final String tag, final String value) {
   }
 
   /**
-   * Feeds this span's final dense-store size back into the sizingHint it was created from (if any).
-   * Called once at span finish; lets a reused hint self-tune to the operation's observed known-tag
-   * high-water mark, so subsequent spans of the operation are sized correctly.
+   * Feeds this span's final dense-store size back into the sizingHint it was created from (if any),
+   * so a reused hint self-tunes to the operation's observed known-tag high-water mark and later
+   * spans of the operation are sized correctly.
+   *
+   * <p>Called from {@link #processTagsAndBaggage} at serialization — the one terminal point that
+   * (a) runs for every serialized span regardless of finish mode (plain {@code finish()} AND {@code
+   * phasedFinish()}+{@code publish()}, which the async gRPC/Netty/WebFlux paths use and which never
+   * enter {@code finishAndAddToTrace}), and (b) runs AFTER the lazy tag post-processors have
+   * appended their serialization-time tags ({@code _dd.integration}, host, ...), so the recorded
+   * count is the span's true final footprint rather than an underestimate. The caller already holds
+   * {@code synchronized (unsafeTags)}, so the {@code knownCount} read is consistent; the hint write
+   * itself is best-effort racy by design (see {@link TagMap#recordSize}).
    */
   void recordDenseSize() {
     if (sizingHint != null) {
-      // Intentionally unsynchronized: recordSize is benign-racy by design (monotonic-max on a plain
-      // int), and a stale knownCount read only ever costs one extra growth on a later span. The
-      // lock would add nothing but contention on the finish path.
       unsafeTags.recordSize(sizingHint);
     }
   }
@@ -1316,6 +1322,10 @@ void processTagsAndBaggage(
       // Tags
       TagsPostProcessorFactory.lazyProcessor().processTags(unsafeTags, this, restrictedSpan);
 
+      // Self-tune the per-operation sizing hint now that every tag (incl. the just-appended
+      // serialization-time tags) is present -- the terminal point shared by all finish modes.
+      recordDenseSize();
+
       // Links
       if (injectLinksAsTags) {
         String linksTag = DDSpanLink.toTag(restrictedSpan.getLinks());
 
@@ -26,14 +26,17 @@ public final class SizingHint {
   final String label;
   final int labelHash;
 
-  // Payload: the tuned dense-store size. Plain racy int, updated monotonic-max — a stale/lost read
-  // only mis-sizes an array (over/under-provision), never corrupts tag data, so no synchronization.
+  // Payload: the tuned dense-store size. Plain racy int, updated best-effort max (see
+  // TagMap#recordSize -- not strictly monotonic under concurrent finishes) — a stale/lost/lowered
+  // read only mis-sizes an array (over/under-provision), never corrupts tag data, so no
+  // synchronization.
   int size;
 
   // When true, {@code size} is fixed and recordSize won't grow it. For the shared default /
   // overflow
-  // hint (a HETEROGENEOUS catch-all for operation-less / over-budget spans): self-tuning it via
-  // monotonic-max would converge to the max across unlike sharers and over-provision the lean ones.
+  // hint (a HETEROGENEOUS catch-all for operation-less / over-budget spans): self-tuning it toward
+  // the observed max would converge to the max across unlike sharers and over-provision the lean
+  // ones.
   final boolean capped;
 
   SizingHint(String label, int labelHash, int seedSize) {
 
@@ -17,7 +17,7 @@
  * <p><b>Bounded + racy by design.</b> Each lane is a fixed-capacity {@link FlatHashtable} (never
  * resized) so memory is bounded even under unbounded/dynamic operation names; once a lane's
  * cardinality budget is spent, further operations share a capped default hint. Construction,
- * insertion, and the monotonic-max size update are all lock-free and deliberately racy — a lost
+ * insertion, and the best-effort-max size update are all lock-free and deliberately racy — a lost
  * update or a double-mint only mis-sizes an array (over/under-provision) for a span or two, never
  * corrupts tag data (see {@link FlatHashtable} and {@link SizingHint} for the rationale).
  *
@@ -30,7 +30,7 @@
 public final class SizingHintTable {
   private SizingHintTable() {}
 
-  // Seed for a fresh per-operation hint: a floor that self-tunes up via monotonic-max recordSize.
+  // Seed for a fresh per-operation hint: a floor that self-tunes up via best-effort-max recordSize.
   static final int SEED_SIZE = 1;
   // Fixed size for the shared over-budget hint: a small lean default. Capped (never grown by
   // recordSize) because it's a heterogeneous catch-all -- growing it would over-provision lean
@@ -84,15 +84,24 @@ public static SizingHint hintFor(CharSequence operationName, boolean entrySpan)
     if ((entrySpan ? entrySize : childSize) >= CARDINALITY_LIMIT) {
       return overflow;
     }
-    final SizingHint created = FlatHashtable.getOrCreate(slots, key, HELPER);
-    if (created == null) {
+    // Count only a genuine insert. Between the get() miss above and this getOrCreate another thread
+    // may have inserted the same operation's hint; getOrCreate then returns that existing entry to
+    // us -- without `created` we'd still bump the lane count, so a cold-start burst of many spans
+    // of
+    // one operation could spend the budget on a single distinct name. `created[0]` is set only on
+    // the actual store branch. Allocated here on the create path only, which is warmup-rare.
+    final boolean[] created = new boolean[1];
+    final SizingHint hint = FlatHashtable.getOrCreate(slots, key, HELPER, created);
+    if (hint == null) {
       return overflow; // physically full -- shouldn't happen under the cap, but stay safe
     }
-    if (entrySpan) {
-      entrySize++; // racy approximate count
-    } else {
-      childSize++;
+    if (created[0]) {
+      if (entrySpan) {
+        entrySize++; // racy approximate count; only a real insert bumps it
+      } else {
+        childSize++;
+      }
     }
-    return created;
+    return hint;
   }
 }
@@ -98,6 +98,19 @@ public static final TagMap create(SizingHint hint) {
    * local miss/removal for no benefit.
    */
   public static final TagMap createFromParent(TagMap parent) {
+    return createFromParent(parent, null);
+  }
+
+  /**
+   * Read-through variant of {@link #create(SizingHint)}: reads through to {@code parent} on local
+   * misses AND sizes the LOCAL dense store from {@code hint}. The two are orthogonal — the parent
+   * supplies inherited reads, while locally-set known tags live in this map's own dense array,
+   * whose initial capacity the hint tunes. So the common child / shared-parent path (a non-null
+   * read-through parent) still gets per-operation sizing; without this the local store would fall
+   * back to the fixed default. A {@code null} hint behaves exactly like {@link
+   * #createFromParent(TagMap)}.
+   */
+  public static final TagMap createFromParent(TagMap parent, SizingHint hint) {
     if (parent != null) {
       if (!parent.frozen) {
         throw new IllegalStateException("read-through parent must be frozen");
@@ -106,7 +119,11 @@ public static final TagMap createFromParent(TagMap parent) {
         parent = null;
       }
     }
-    return new TagMap(parent);
+    TagMap tagMap = new TagMap(parent);
+    if (hint != null && hint.size > 0) {
+      tagMap.denseCapHint = hint.size;
+    }
+    return tagMap;
   }
 
   /** Creates a new TagMap.Ledger */
@@ -1438,13 +1455,22 @@ private void ensureKnownCapacity() {
 
   /**
    * Feeds this map's final dense-entry count back to {@code hint} (call at a terminal point: freeze
-   * / span-finish). The hint self-tunes so future maps of the same operation size correctly.
+   * / serialization). The hint self-tunes so future maps of the same operation size correctly.
+   *
+   * <p>Best-effort max, not a strict monotonic-max: the read-compare-write is unsynchronized, so
+   * two spans of the same operation finishing concurrently can both read the same old {@code size}
+   * and the later write can lower it (a 10-tag span then a 5-tag span settles at 5). And {@code
+   * size} is a plain field, so a fresh update isn't promptly visible to span-creation threads. Both
+   * are deliberately tolerated: a stale or lowered hint only mis-sizes a later span's dense array
+   * (one extra grow-copy), never corrupts tag data — so it stays lock- and atomic-free, and the
+   * next heavy span of the operation nudges it back up. A CAS/atomic-max would buy exactness at the
+   * cost of contention on this terminal path, which isn't worth it for a sizing hint.
    */
   public void recordSize(SizingHint hint) {
     // Capped hints (the heterogeneous shared default) are fixed -- don't let unlike sharers grow
     // them.
     if (!hint.capped && this.knownCount > hint.size) {
-      hint.size = this.knownCount; // monotonic-max; benign racy plain-int write
+      hint.size = this.knownCount; // best-effort racy max (see javadoc); benign plain-int write
     }
   }
 
 
@@ -130,6 +130,20 @@ public static <K, V> V get(V[] table, K key, Helper<K, V> helper) {
    * double-create is acceptable only when the payload makes it benign (see class doc).
    */
   public static <K, V> V getOrCreate(V[] table, K key, Helper<K, V> helper) {
+    return getOrCreate(table, key, helper, null);
+  }
+
+  /**
+   * Like {@link #getOrCreate(Object[], Object, Helper)}, but reports whether this call actually
+   * minted-and-stored a new entry: when {@code createdOut} is non-null, {@code createdOut[0]} is
+   * set to {@code true} only on the store branch, and left untouched when an existing entry
+   * matched. Callers that keep an approximate live-size counter (for a cardinality budget)
+   * increment it only when {@code createdOut[0]} — so racing callers that get an already-inserted
+   * entry back don't each over-count the same operation. Still racy by design: a benign double-mint
+   * (two threads store into the same slot) reports {@code true} on both, an over-count of at most
+   * the store-race width, not of every caller (see class doc).
+   */
+  public static <K, V> V getOrCreate(V[] table, K key, Helper<K, V> helper, boolean[] createdOut) {
     final int mask = table.length - 1;
     final int start = helper.hash(key) & mask;
     int i = start;
@@ -138,6 +152,9 @@ public static <K, V> V getOrCreate(V[] table, K key, Helper<K, V> helper) {
       if (e == null) {
         final V created = helper.create(key);
         table[i] = created; // single-reference publish; benign clobber (see class doc)
+        if (createdOut != null) {
+          createdOut[0] = true;
+        }
         return created;
       }
       if (helper.matches(key, e)) {