fix(native-spans): normalize core span fields before native export

The v0.4 encoder runs `normalizeSpan` on every span as it encodes
(`encode/0.4.js` selects it as the per-span formatter), so the JS
pipeline never ships a span missing the intake defaults or exceeding the
100-character caps on service, name and type. The native path wrote
`formatted.name` / `.service` / `.type` straight into WASM, making it the
only pipeline that could emit un-normalized core fields — so a
high-cardinality route name went out at full length.

Apply the same pass at the native write, after the stats snapshot, which
matches the legacy ordering where normalization happens at encode time
rather than at finish.

Reported by Codex review as P2. Note the report also mentions the 5,000
character resource cap; that is `truncateSpan`, which the v0.4 agent path
does not apply either (only the electron and agentless encoders do), so
it is deliberately left alone.

Author: bengl

packages/dd-trace/src/span_processor.js

@@ -7,7 +7,7 @@ const SpanSampler = require('./span_sampler')
 const GitMetadataTagger = require('./git_metadata_tagger')
 const native = require('./native')
 const processTags = require('./process-tags')
-const { MAX_META_VALUE_LENGTH } = require('./encode/tags-processors')
+const { MAX_META_VALUE_LENGTH, normalizeSpan } = require('./encode/tags-processors')
 const {
   APM_TRACING_ENABLED_KEY,
   SAMPLING_MECHANISM_MANUAL,
@@ -313,7 +313,15 @@ class SpanProcessor {
 
             if (typeof context.syncFinalTagsToNative === 'function') {
               formattedSpan ??= spanFormat(span, isFirstSpanInChunk, this._processTags)
-              context.syncFinalTagsToNative(formattedSpan)
+              // The v0.4 encoder runs `normalizeSpan` on every span as it encodes
+              // (encode/0.4.js picks it as the per-span formatter), so the JS
+              // pipeline never ships a span without the intake defaults and the
+              // 100-char caps on service/name/type. The native path writes these
+              // fields straight into WASM, so apply the same pass here or it
+              // becomes the only pipeline sending un-normalized core fields.
+              // Applied after the stats snapshot, matching the legacy ordering
+              // where normalization happens at encode time rather than at finish.
+              context.syncFinalTagsToNative(normalizeSpan(formattedSpan))
             }
 
             // Remap Datadog HTTP tags to OpenTelemetry names on the native span

packages/dd-trace/test/span_processor.spec.js

@@ -136,6 +136,31 @@ describe('SpanProcessor', () => {
     assert.deepStrictEqual(syncOrder, ['sync', 'export'])
   })
 
+  it('normalizes core fields before syncing them to native storage', () => {
+    // The v0.4 encoder runs `normalizeSpan` per span as it encodes, so the JS
+    // pipeline never ships an over-long service/name or a missing resource. The
+    // native path writes these straight into WASM, so without the same pass it
+    // would be the only pipeline sending un-normalized core fields.
+    spanFormat.returns({
+      name: 'n'.repeat(150),
+      service: 's'.repeat(150),
+      type: 't'.repeat(150),
+      metrics: {},
+      meta: {},
+    })
+    trace.started = [finishedSpan]
+    trace.finished = [finishedSpan]
+
+    processor.process(finishedSpan)
+
+    const synced = finishedSpan.context().syncFinalTagsToNative.getCall(0).args[0]
+    assert.strictEqual(synced.name.length, 100)
+    assert.strictEqual(synced.service.length, 100)
+    assert.strictEqual(synced.type.length, 100)
+    // A missing resource falls back to the (already truncated) name.
+    assert.strictEqual(synced.resource, synced.name)
+  })
+
   it('should generate sampling priority when sampling manually', () => {
     trace.started = [finishedSpan]
     processor.sample(finishedSpan)