Rename TagSet to StringIndex

The structure is more general than tags: a flat, open-addressed String set
whose indexOf returns a stable dense slot for parallel value arrays. "Tag" was
just one prospective consumer. Renames the class, test, and benchmark
references (Support/Data nested types and the SetBenchmark / map-benchmark
usages); leaves the unrelated propagation TagSetChanges in dd-trace-core alone.

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

Author: dougqh

internal-api/src/jmh/java/datadog/trace/util/SetBenchmark.java

@@ -20,13 +20,14 @@
  * capped the fast structures at a ~1.4B contention ceiling (since superseded by the numbers below).
  *
  * <ul>
- *   <li><b>tagSetSupport (static) is the fastest membership path</b> — 2336M hit / 2170M miss. It
- *       beats the TagSet instance ({@code tagSet_*}) by ~7% (hit) to ~12% (miss): the instance pays
- *       an instance-field load of hashes/names, while {@code Support.indexOf} over {@code static
- *       final} arrays lets the refs fold to constants. Matches KeyOfBenchmark's ~12% static-vs-
- *       instance gap. So when the set is fixed, pull {@code Data} into your own static finals.
+ *   <li><b>stringIndexSupport (static) is the fastest membership path</b> — 2336M hit / 2170M miss.
+ *       It beats the StringIndex instance ({@code stringIndex_*}) by ~7% (hit) to ~12% (miss): the
+ *       instance pays an instance-field load of hashes/names, while {@code Support.indexOf} over
+ *       {@code static final} arrays lets the refs fold to constants. Matches KeyOfBenchmark's ~12%
+ *       static-vs- instance gap. So when the set is fixed, pull {@code Data} into your own static
+ *       finals.
  *   <li><b>vs HashSet</b> — the static path is ~12% faster on hit and ~par on miss. But HashSet was
- *       noisy here (±22% error) while TagSet was tight (±2-7%), so TagSet also wins on
+ *       noisy here (±22% error) while StringIndex was tight (±2-7%), so StringIndex also wins on
  *       predictability — and is allocation-free and positional-capable.
  *   <li>array / sortedArray / treeSet cluster ~0.65-1.0B — they compare/scan per element, so they
  *       slow on miss (hit early-exits; miss does the full scan / binary descent / tree walk).
@@ -44,10 +45,10 @@
  * SetBenchmark.hashSet_miss        thrpt    6  2136501411.026 ± 474132929.024  ops/s
  * SetBenchmark.sortedArray_hit     thrpt    6   837595967.794 ± 113538780.712  ops/s
  * SetBenchmark.sortedArray_miss    thrpt    6   692064118.699 ±  25752553.077  ops/s
- * SetBenchmark.tagSet_hit          thrpt    6  2184722734.028 ±  61054981.099  ops/s
- * SetBenchmark.tagSet_miss         thrpt    6  1933588009.009 ± 159869680.982  ops/s
- * SetBenchmark.tagSetSupport_hit   thrpt    6  2335685599.706 ±  52460762.937  ops/s
- * SetBenchmark.tagSetSupport_miss  thrpt    6  2169715463.018 ± 141321499.862  ops/s
+ * SetBenchmark.stringIndex_hit          thrpt    6  2184722734.028 ±  61054981.099  ops/s
+ * SetBenchmark.stringIndex_miss         thrpt    6  1933588009.009 ± 159869680.982  ops/s
+ * SetBenchmark.stringIndexSupport_hit   thrpt    6  2335685599.706 ±  52460762.937  ops/s
+ * SetBenchmark.stringIndexSupport_miss  thrpt    6  2169715463.018 ± 141321499.862  ops/s
  * SetBenchmark.treeSet_hit         thrpt    6   798251906.675 ±  39041398.413  ops/s
  * SetBenchmark.treeSet_miss        thrpt    6   667078954.487 ±  56517120.187  ops/s
  * </code>
@@ -174,37 +175,38 @@ public boolean treeSet_miss() {
     return TREE_SET.contains(nextMiss());
   }
 
-  static final TagSet TAG_SET = TagSet.of(STRINGS);
+  static final StringIndex STRING_INDEX = StringIndex.of(STRINGS);
 
   @Benchmark
-  public boolean tagSet_hit() {
-    return TAG_SET.contains(nextHit());
+  public boolean stringIndex_hit() {
+    return STRING_INDEX.contains(nextHit());
   }
 
   @Benchmark
-  public boolean tagSet_miss() {
-    return TAG_SET.contains(nextMiss());
+  public boolean stringIndex_miss() {
+    return STRING_INDEX.contains(nextMiss());
   }
 
   // The static Support path: hashes/names built once into static-final arrays (refs fold to
-  // constants) and probed directly via Support.indexOf -- vs tagSet_* above, which loads them
-  // through a TagSet instance. Mirrors KeyOfBenchmark's tagSet (static) vs tagSet_throughClass.
+  // constants) and probed directly via Support.indexOf -- vs stringIndex_* above, which loads them
+  // through a StringIndex instance. Mirrors KeyOfBenchmark's stringIndex (static) vs
+  // stringIndex_throughClass.
   static final int[] SUPPORT_HASHES;
   static final String[] SUPPORT_NAMES;
 
   static {
-    TagSet.Data data = TagSet.Support.create(STRINGS);
+    StringIndex.Data data = StringIndex.Support.create(STRINGS);
     SUPPORT_HASHES = data.hashes;
     SUPPORT_NAMES = data.names;
   }
 
   @Benchmark
-  public boolean tagSetSupport_hit() {
-    return TagSet.Support.indexOf(SUPPORT_HASHES, SUPPORT_NAMES, nextHit()) >= 0;
+  public boolean stringIndexSupport_hit() {
+    return StringIndex.Support.indexOf(SUPPORT_HASHES, SUPPORT_NAMES, nextHit()) >= 0;
   }
 
   @Benchmark
-  public boolean tagSetSupport_miss() {
-    return TagSet.Support.indexOf(SUPPORT_HASHES, SUPPORT_NAMES, nextMiss()) >= 0;
+  public boolean stringIndexSupport_miss() {
+    return StringIndex.Support.indexOf(SUPPORT_HASHES, SUPPORT_NAMES, nextMiss()) >= 0;
   }
 }

internal-api/src/jmh/java/datadog/trace/util/UnsynchronizedMapBenchmark.java

@@ -21,17 +21,17 @@
  * <ul>
  *   Benchmark comparing different Map-s...
  *   <li>(RECOMMENDED) HashMap - fastest lookups among general-purpose (mutable) maps - (not
- *       typically needed for tags; a fixed TagSet map below is faster still when the keys are
+ *       typically needed for tags; a fixed StringIndex map below is faster still when the keys are
  *       known)
  *   <li>(RECOMMENDED) TagMap - for storing tags - especially if copying between maps or using
  *       builders
  *   <li>TreeMap - better for custom Comparators - case-insensitive Maps (see
  *       CaseInsensitiveMapBenchmark)
  *   <li>LinkedHashMap - only when insertion order is needed
- *   <li>TagSet + parallel value array - for a FIXED (build-once, read-only) map whose key set is
- *       known up front: the keys go in a {@link TagSet} and the values in a parallel array indexed
- *       by the slot {@code indexOf} returns. Fastest get, no per-lookup allocation, no node chasing
- *       - but it can't change after construction (see get_tagSetMap).
+ *   <li>StringIndex + parallel value array - for a FIXED (build-once, read-only) map whose key set
+ *       is known up front: the keys go in a {@link StringIndex} and the values in a parallel array
+ *       indexed by the slot {@code indexOf} returns. Fastest get, no per-lookup allocation, no node
+ *       chasing - but it can't change after construction (see get_stringIndexMap).
  * </ul>
  *
  * <p>TagMap is the preferred way to store tags.
@@ -51,10 +51,10 @@
  * <p>HashMap & TagMap also perform exceedingly well in cases where the exact same object is used
  * for put & get operations. e.g. when using String literals or Class literals as keys.
  *
- * <p>A TagSet + parallel int[] used as a fixed (build-once) map is the fastest get here -- ~30%
- * ahead of HashMap on the rotating-key path and ~50% ahead on the same-key path, where it sustains
- * 5.4B ops/s at the tightest error in the table (±1.3%). It pays no boxing (int[] values), chases
- * no node, and allocates nothing per lookup. It only applies when the key set is fixed at
+ * <p>A StringIndex + parallel int[] used as a fixed (build-once) map is the fastest get here --
+ * ~30% ahead of HashMap on the rotating-key path and ~50% ahead on the same-key path, where it
+ * sustains 5.4B ops/s at the tightest error in the table (±1.3%). It pays no boxing (int[] values),
+ * chases no node, and allocates nothing per lookup. It only applies when the key set is fixed at
  * construction. <code>
  * Apple M1 Max (10 core), macOS 26.4.1 -- 8 threads (per-thread state), 2 forks -- Java 17 (Zulu 17.42.19, 17.0.7+7-LTS)
  *
@@ -76,8 +76,8 @@
  * UnsynchronizedMapBenchmark.get_linkedHashMap         thrpt    6  1871397460.306 ±  51848940.996  ops/s
  * UnsynchronizedMapBenchmark.get_tagMap                thrpt    6  1706422514.145 ±  91472057.777  ops/s
  * UnsynchronizedMapBenchmark.get_tagMap_sameKey        thrpt    6  2205821374.441 ± 108659512.329  ops/s
- * UnsynchronizedMapBenchmark.get_tagSetMap             thrpt    6  2448917198.752 ± 105399021.596  ops/s
- * UnsynchronizedMapBenchmark.get_tagSetMap_sameKey     thrpt    6  5358887465.195 ±  70196881.552  ops/s
+ * UnsynchronizedMapBenchmark.get_stringIndexMap             thrpt    6  2448917198.752 ± 105399021.596  ops/s
+ * UnsynchronizedMapBenchmark.get_stringIndexMap_sameKey     thrpt    6  5358887465.195 ±  70196881.552  ops/s
  * UnsynchronizedMapBenchmark.get_treeMap               thrpt    6   704782343.575 ±  52129796.457  ops/s
  *
  * UnsynchronizedMapBenchmark.iterate_hashMap           thrpt    6   132215205.201 ±   9079485.505  ops/s
@@ -303,38 +303,42 @@ public TagMap clone_tagMap() {
     return TAG_MAP.copy();
   }
 
-  // TagSet + a parallel value array used as a FIXED (build-once, read-only) map. The keys are known
-  // up front, so they go in a TagSet and the values in a plain array indexed by the slot that
+  // StringIndex + a parallel value array used as a FIXED (build-once, read-only) map. The keys are
+  // known
+  // up front, so they go in a StringIndex and the values in a plain array indexed by the slot that
   // Support.indexOf returns. There is no node, no Entry, and no per-lookup allocation -- a get is a
   // hash probe (with an interned == fast path) plus one array load. Pull the Data into your own
   // static finals (as below) so the hashes/names refs fold to constants -- same static-vs-instance
   // win SetBenchmark and KeyOfBenchmark measure. The values live in a parallel int[] -- no boxing,
   // the same primitive-value advantage TagMap.getInt has over a HashMap<String, Integer>, whose
   // value type structurally forces the box. The trade-off: it cannot change after construction.
-  static final int[] TAG_SET_HASHES;
-  static final String[] TAG_SET_NAMES;
-  static final int[] TAG_SET_VALUES;
+  static final int[] STRING_INDEX_HASHES;
+  static final String[] STRING_INDEX_NAMES;
+  static final int[] STRING_INDEX_VALUES;
 
   static {
-    TagSet.Data data = TagSet.Support.create(INSERTION_KEYS);
+    StringIndex.Data data = StringIndex.Support.create(INSERTION_KEYS);
     int[] values = new int[data.names.length];
     for (int i = 0; i < INSERTION_KEYS.length; ++i) {
-      values[TagSet.Support.indexOf(data.hashes, data.names, INSERTION_KEYS[i])] = i;
+      values[StringIndex.Support.indexOf(data.hashes, data.names, INSERTION_KEYS[i])] = i;
     }
-    TAG_SET_HASHES = data.hashes;
-    TAG_SET_NAMES = data.names;
-    TAG_SET_VALUES = values;
+    STRING_INDEX_HASHES = data.hashes;
+    STRING_INDEX_NAMES = data.names;
+    STRING_INDEX_VALUES = values;
   }
 
   @Benchmark
-  public int get_tagSetMap() {
-    int slot = TagSet.Support.indexOf(TAG_SET_HASHES, TAG_SET_NAMES, nextLookupKey());
-    return slot < 0 ? -1 : TAG_SET_VALUES[slot];
+  public int get_stringIndexMap() {
+    int slot =
+        StringIndex.Support.indexOf(STRING_INDEX_HASHES, STRING_INDEX_NAMES, nextLookupKey());
+    return slot < 0 ? -1 : STRING_INDEX_VALUES[slot];
   }
 
   @Benchmark
-  public int get_tagSetMap_sameKey() {
-    int slot = TagSet.Support.indexOf(TAG_SET_HASHES, TAG_SET_NAMES, nextLookupKey(INSERTION_KEYS));
-    return slot < 0 ? -1 : TAG_SET_VALUES[slot];
+  public int get_stringIndexMap_sameKey() {
+    int slot =
+        StringIndex.Support.indexOf(
+            STRING_INDEX_HASHES, STRING_INDEX_NAMES, nextLookupKey(INSERTION_KEYS));
+    return slot < 0 ? -1 : STRING_INDEX_VALUES[slot];
   }
 }

…main/java/datadog/trace/util/TagSet.java …java/datadog/trace/util/StringIndex.javainternal-api/src/main/java/datadog/trace/util/TagSet.java renamed to internal-api/src/main/java/datadog/trace/util/StringIndex.java internal-api/src/main/java/datadog/trace/util/TagSet.java renamed to internal-api/src/main/java/datadog/trace/util/StringIndex.java

@@ -11,7 +11,7 @@
  *       path; nothing to dereference.
  *   <li>{@link Data} — a <b>build-time carrier</b> for the placed {@code {hashes, names}} returned
  *       by {@link Support#create}. Pull its fields into your own and discard it.
- *   <li>The {@code TagSet} <b>instance</b> ({@link #of}) — a convenience wrapper holding the
+ *   <li>The {@code StringIndex} <b>instance</b> ({@link #of}) — a convenience wrapper holding the
  *       arrays; {@link #indexOf}/{@link #contains} delegate to {@link Support}. Costs an
  *       instance-field load per call (the indirection the static path removes) — fine off the hot
  *       path.
@@ -23,12 +23,12 @@
  * <p>Slot 0-value is the empty sentinel: {@link Support#hash} never returns 0, so {@code hashes[i]
  * == 0} unambiguously means an empty slot.
  */
-public final class TagSet {
+public final class StringIndex {
   private final int[] hashes;
   private final String[] names;
   public final int slots; // == hashes.length
 
-  private TagSet(int[] hashes, String[] names) {
+  private StringIndex(int[] hashes, String[] names) {
     this.hashes = hashes;
     this.names = names;
     this.slots = hashes.length;
@@ -37,9 +37,9 @@ private TagSet(int[] hashes, String[] names) {
   /**
    * Convenience instance — wraps the placed arrays. For the hot path prefer raw {@link Support}.
    */
-  public static TagSet of(String... names) {
+  public static StringIndex of(String... names) {
     Data data = Support.create(names);
-    return new TagSet(data.hashes, data.names);
+    return new StringIndex(data.hashes, data.names);
   }
 
   /** Slot of {@code name}, or -1. Delegates to {@link Support} on the instance's arrays. */
@@ -67,7 +67,9 @@ public static final class Data {
     }
   }
 
-  /** Static algorithm over raw arrays. Query helpers take raw arrays, never a Data or a TagSet. */
+  /**
+   * Static algorithm over raw arrays. Query helpers take raw arrays, never a Data or a StringIndex.
+   */
   public static final class Support {
     private Support() {}
 

…/java/datadog/trace/util/TagSetTest.java …/datadog/trace/util/StringIndexTest.javainternal-api/src/test/java/datadog/trace/util/TagSetTest.java renamed to internal-api/src/test/java/datadog/trace/util/StringIndexTest.java internal-api/src/test/java/datadog/trace/util/TagSetTest.java renamed to internal-api/src/test/java/datadog/trace/util/StringIndexTest.java

@@ -6,11 +6,11 @@
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import datadog.trace.util.TagSet.Data;
-import datadog.trace.util.TagSet.Support;
+import datadog.trace.util.StringIndex.Data;
+import datadog.trace.util.StringIndex.Support;
 import org.junit.jupiter.api.Test;
 
-class TagSetTest {
+class StringIndexTest {
 
   @Test
   void hash_spread_and_zeroSentinel() {
@@ -32,7 +32,7 @@ void tableSizeFor_isPow2_andOversized() {
 
   @Test
   void instance_contains_internedAndCopy_andMiss() {
-    TagSet set = TagSet.of("foo", "bar", "baz");
+    StringIndex set = StringIndex.of("foo", "bar", "baz");
 
     assertEquals(8, set.slots()); // 3 names -> tableSizeFor(3) == 8
 
@@ -84,7 +84,7 @@ void put_throwsWhenFull() {
     assertThrows(IllegalStateException.class, () -> Support.put(hashes, names, "c", 6));
   }
 
-  /** The documented usage: build a TagSet, attach a parallel payload indexed by slot. */
+  /** The documented usage: build a StringIndex, attach a parallel payload indexed by slot. */
   @Test
   void parallelPayloadBySlot() {
     String[] names = {"a", "b", "c"};