bench(spans): discard native mutations before processing

## Summary

Change-queue flushing consumed 95.8% of the deferred-finish profile and kept the eight-sample CI variant running when the 30-minute job expired.

## Why

The benchmark is meant to isolate span construction and finish, but it applied and exported every queued native mutation. Discarding those mutations reduced the same 250,000-span process from 23.11 s to 0.60 s. Native event samples still drain because libdatadog applies events directly.

## Test plan

- Run all span variants through three fresh sirun matrices.
- Run changed-line coverage and full lint.

Author: BridgeAR

benchmark/sirun/spans/README.md

@@ -1,5 +1,2 @@
-This test initializes a tracer with the no-op scope manager. It then creates
-many spans, and depending on the variant, either finishes all of them as they
-are created, or later on once they're all created. Prior to creating any spans,
-it modifies the processor instance so that no span processing (or exporting) is
-done, and it simply stops storing the spans.
+This benchmark measures span construction and finish with the no-op scope manager. Ordinary native mutations are
+discarded before processing or export; native events are drained because libdatadog applies them directly.

benchmark/sirun/spans/meta.json

@@ -42,7 +42,7 @@
         "DD_TRACE_SCOPE": "noop",
         "FINISH": "now",
         "SHAPE": "tags-and-otel",
-        "OPERATIONS": "100000"
+        "OPERATIONS": "50000"
       }
     }
   }

benchmark/sirun/spans/spans.js

@@ -9,17 +9,27 @@ const { createNativeSpanDrain } = require('../native-span-drain')
 nock.disableNetConnect()
 nock('http://127.0.0.1:8126').persist().put(/.*/).reply(200, '{}').post(/.*/).reply(200, '{}')
 
+const { FINISH, SHAPE = 'plain' } = process.env
+
 const tracer = require('../../..').init({ hostname: '127.0.0.1', port: 8126 })
-const nativeSpanDrain = createNativeSpanDrain(tracer)
+const nativeSpans = tracer._tracer._nativeSpans
+const nativeSpanDrain = SHAPE === 'tags-and-otel' ? createNativeSpanDrain(tracer) : undefined
+
+let queuedSpans = 0
 
+/** @param {import('../../../packages/dd-trace/src/opentracing/span')} span */
 tracer._tracer._processor.process = function process (span) {
   const trace = span.context()._trace
-  nativeSpanDrain.add(span)
+  if (nativeSpanDrain) {
+    nativeSpanDrain.add(span)
+  } else if (nativeSpans && ++queuedSpans === BATCH) {
+    // This benchmark excludes processing and export; discard queued native mutations before the buffer fills.
+    nativeSpans.resetChangeQueue()
+    queuedSpans = 0
+  }
   this._erase(trace, [])
 }
 
-const { FINISH, SHAPE = 'plain' } = process.env
-
 // Total spans created per process. The count stays env-driven so CI can keep
 // each native-mode variant under the job timeout while still making tracer load
 // a small share of the measured run.
@@ -104,14 +114,18 @@ function startOne () {
 }
 
 async function main () {
-  await nativeSpanDrain.drain()
+  await nativeSpanDrain?.drain()
 
   guard.loopStart()
-  if (FINISH === 'now') {
+  if (FINISH === 'now' && nativeSpanDrain) {
     for (let iteration = 0; iteration < OPERATIONS; iteration++) {
       startOne().finish()
       if (nativeSpanDrain.needsDrain()) await nativeSpanDrain.drain()
     }
+  } else if (FINISH === 'now') {
+    for (let iteration = 0; iteration < OPERATIONS; iteration++) {
+      startOne().finish()
+    }
   } else {
     // Deferred finish in batches: start BATCH spans, finish them after the batch is
     // built (so each finishes off the active path), then drop the references.
@@ -126,10 +140,11 @@ async function main () {
       }
       spans.length = 0
       remaining -= size
-      if (nativeSpanDrain.needsDrain()) await nativeSpanDrain.drain()
+      if (nativeSpanDrain?.needsDrain()) await nativeSpanDrain.drain()
     }
   }
-  await nativeSpanDrain.drain()
+  await nativeSpanDrain?.drain()
+  nativeSpans?.resetChangeQueue()
   // Native-mode CI counts are intentionally lower than the old JS-only counts so
   // the candidate shard finishes before the job timeout. The older baseline source
   // can run those counts in under a second, so allow a higher startup share there