dd-trace 6.1.0 → 6.3.0

package/packages/dd-trace/src/config/parsers.js

@@ -297,8 +297,87 @@ const parsers = {
   },
 }
 
+const programmaticTypeCoercions = {
+  /**
+   * @param {unknown} value
+   */
+  BOOLEAN (value) {
+    if (typeof value === 'boolean') {
+      return value
+    }
+    if (typeof value === 'string') {
+      return parsers.BOOLEAN(value)
+    }
+  },
+  /**
+   * @param {unknown} value
+   */
+  INT (value) {
+    if (typeof value === 'number' || typeof value === 'string' && value.trim() !== '') {
+      return parsers.INT(value)
+    }
+  },
+  /**
+   * @param {unknown} value
+   */
+  DECIMAL (value) {
+    if (typeof value === 'number' || typeof value === 'string' && value.trim() !== '') {
+      return parsers.DECIMAL(value)
+    }
+  },
+  /**
+   * @param {unknown} value
+   */
+  STRING (value) {
+    if (typeof value === 'string') {
+      return value
+    }
+    if (typeof value === 'boolean' || typeof value === 'number' && Number.isFinite(value)) {
+      return String(value)
+    }
+  },
+  /**
+   * @param {unknown} value
+   */
+  FUNCTION (value) {
+    if (typeof value === 'function') {
+      return value
+    }
+  },
+  /**
+   * @param {unknown} value
+   */
+  ARRAY (value) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (typeof item !== 'string' && typeof item !== 'number' && typeof item !== 'boolean') {
+          return
+        }
+      }
+      return value
+    }
+  },
+  /**
+   * @param {unknown} value
+   */
+  MAP (value) {
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      return value
+    }
+  },
+  /**
+   * @param {unknown} value
+   */
+  JSON (value) {
+    if (typeof value === 'object' && value !== null) {
+      return value
+    }
+  },
+}
+
 module.exports = {
   parsers,
+  programmaticTypeCoercions,
   transformers,
   telemetryTransformers,
   setWarnInvalidValue,

package/packages/dd-trace/src/datastreams/writer.js

@@ -4,7 +4,7 @@ const zlib = require('zlib')
 const pkg = require('../../../../package.json')
 const log = require('../log')
 const request = require('../exporters/common/request')
-const { encode: encodeMsgpack } = require('../msgpack')
+const { encode: encodeMsgpack, MAX_SIZE: MAX_CHUNK_SIZE } = require('../msgpack')
 
 function makeRequest (data, url, cb) {
   const options = {
@@ -36,7 +36,19 @@ class DataStreamsWriter {
       log.debug('Maximum number of active requests reached. Payload discarded: %j', payload)
       return
     }
-    const encodedPayload = encodeMsgpack(payload)
+
+    let encodedPayload
+    try {
+      encodedPayload = encodeMsgpack(payload)
+    } catch (error) {
+      if (error.code !== 'ERR_MSGPACK_CHUNK_OVERFLOW') throw error
+      // The msgpack-encoded pipeline-stats payload exceeded the agent
+      // intake cap. Dropping it locally is safer than letting the
+      // RangeError crash the host process; the agent would reject the
+      // oversized payload at the network boundary anyway.
+      log.error('DataStreamsWriter dropped a payload that exceeded the %d byte chunk cap', MAX_CHUNK_SIZE)
+      return
+    }
 
     zlib.gzip(encodedPayload, { level: 1 }, (err, compressedData) => {
       if (err) {

package/packages/dd-trace/src/encode/0.4.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const getConfig = require('../config')
-const { MsgpackChunk } = require('../msgpack')
+const { MsgpackChunk, MAX_SIZE: MAX_CHUNK_SIZE } = require('../msgpack')
 const log = require('../log')
 const { normalizeSpan, eventTimeNano } = require('./tags-processors')
 
@@ -265,7 +265,28 @@ class AgentEncoder {
 
     this._traceCount++
 
-    this._encode(bytes, trace)
+    try {
+      this._encode(bytes, trace)
+    } catch (error) {
+      if (error.code !== 'ERR_MSGPACK_CHUNK_OVERFLOW') throw error
+      // The trace, or the queued payload it joined, hit the chunk cap.
+      // Rolling back just the in-flight trace is unsafe: the string cache
+      // may already hold subarrays / indices pointing at bytes we'd
+      // discard, and the next encode would emit stale bytes against a
+      // smaller string table. Drop the whole queued payload so the next
+      // encode starts from a clean state. Emitting a partial buffer would
+      // corrupt the msgpack wire. The virtual `reset()` is called (not
+      // `_reset()`) so subclasses can clear their own per-payload state
+      // (e.g. `AgentlessCiVisibilityEncoder._eventCount`).
+      const dropped = this._traceCount
+      this.reset()
+      log.error(
+        'Trace encoder reset after exceeding the %d byte chunk cap; dropped %d trace(s)',
+        MAX_CHUNK_SIZE,
+        dropped
+      )
+      return
+    }
 
     if (this.#debugEncoding) {
       const end = bytes.length

package/packages/dd-trace/src/encode/0.5.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const { MAX_SIZE, OverflowError } = require('../msgpack')
 const { normalizeSpan } = require('./tags-processors')
 const { AgentEncoder: BaseEncoder, stringifySpanEvents } = require('./0.4')
 
@@ -30,7 +31,17 @@ class AgentEncoder extends BaseEncoder {
     const prefixSize = 1
     const stringSize = this._stringBytes.length + 5
     const traceSize = this._traceBytes.length + 5
-    const buffer = Buffer.allocUnsafe(prefixSize + stringSize + traceSize)
+    const payloadSize = prefixSize + stringSize + traceSize
+
+    // The string table and the trace bytes are capped independently, so both
+    // can sit just under the cap while their concatenation crosses it. `encode`
+    // never sees this overflow — it only exists once the two are summed here —
+    // so the writer's flush-time catch drops the payload.
+    if (payloadSize > MAX_SIZE) {
+      throw new OverflowError(payloadSize)
+    }
+
+    const buffer = Buffer.allocUnsafe(payloadSize)
 
     buffer[0] = ARRAY_OF_TWO
 

package/packages/dd-trace/src/encode/agentless-ci-visibility.js

@@ -7,7 +7,7 @@ const {
   TELEMETRY_ENDPOINT_PAYLOAD_SERIALIZATION_MS,
   TELEMETRY_ENDPOINT_PAYLOAD_EVENTS_COUNT,
 } = require('../ci-visibility/telemetry')
-const { MsgpackChunk } = require('../msgpack')
+const { MsgpackChunk, MAX_SIZE, OverflowError } = require('../msgpack')
 const { AgentEncoder } = require('./0.4')
 const {
   truncateSpanTestOpt,
@@ -371,6 +371,16 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
 
     const eventsBytes = this._traceBytes
     const totalSize = prefixBytes.length + eventsBytes.length
+
+    // The metadata prefix (built here, not during `encode`) and the events are
+    // capped independently, so both can stay under the cap while the assembled
+    // payload crosses it. An oversized metadata tag also overflows the prefix
+    // chunk itself inside `_encodePayloadStart` above; either way the tagged
+    // error propagates to the writer's flush-time catch to drop the payload.
+    if (totalSize > MAX_SIZE) {
+      throw new OverflowError(totalSize)
+    }
+
     const buffer = Buffer.allocUnsafe(totalSize)
     prefixBytes.buffer.copy(buffer, 0, 0, prefixBytes.length)
     eventsBytes.buffer.copy(buffer, prefixBytes.length, 0, eventsBytes.length)

package/packages/dd-trace/src/encode/coverage-ci-visibility.js

@@ -1,11 +1,12 @@
 'use strict'
-const { MsgpackChunk } = require('../msgpack')
+const { MsgpackChunk, MAX_SIZE: MAX_CHUNK_SIZE } = require('../msgpack')
 
 const {
   distributionMetric,
   TELEMETRY_ENDPOINT_PAYLOAD_SERIALIZATION_MS,
   TELEMETRY_ENDPOINT_PAYLOAD_EVENTS_COUNT,
 } = require('../ci-visibility/telemetry')
+const log = require('../log')
 const FormData = require('../exporters/common/form-data')
 const { AgentEncoder } = require('./0.4')
 
@@ -40,7 +41,24 @@ class CoverageCIVisibilityEncoder extends AgentEncoder {
     const startTime = Date.now()
 
     this._coveragesCount++
-    this.encodeCodeCoverage(this._coverageBytes, coverage)
+    try {
+      this.encodeCodeCoverage(this._coverageBytes, coverage)
+    } catch (error) {
+      if (error.code !== 'ERR_MSGPACK_CHUNK_OVERFLOW') throw error
+      // The coverage payload hit the chunk cap. `_coverageBytes` may
+      // hold a partial entry and a stale `coverages` array prefix. Drop
+      // the whole queued payload so the next encode starts from a clean
+      // state; the parent `AgentEncoder` does the equivalent for its own
+      // bytes / string cache via the inherited `_reset()`.
+      const dropped = this._coveragesCount
+      this.reset()
+      log.error(
+        'Coverage encoder reset after exceeding the %d byte chunk cap; dropped %d coverage(s)',
+        MAX_CHUNK_SIZE,
+        dropped
+      )
+      return
+    }
 
     distributionMetric(
       TELEMETRY_ENDPOINT_PAYLOAD_SERIALIZATION_MS,

package/packages/dd-trace/src/exporters/common/writer.js

@@ -3,6 +3,7 @@
 const { channel } = require('dc-polyfill')
 
 const log = require('../../log')
+const { MAX_SIZE: MAX_CHUNK_SIZE } = require('../../msgpack')
 const request = require('./request')
 const { safeJSONStringify } = require('./util')
 
@@ -27,7 +28,22 @@ class Writer {
         this.#isFirstFlush = false
         this._beforeFirstFlush()
       }
-      const payload = this._encoder.makePayload()
+      let payload
+      try {
+        payload = this._encoder.makePayload()
+      } catch (error) {
+        if (error.code !== 'ERR_MSGPACK_CHUNK_OVERFLOW') throw error
+        // Multi-chunk encoders (v0.5, CI Visibility) only learn the assembled
+        // payload exceeds the cap when `makePayload` stitches the chunks
+        // together, after `encode` already returned — so the encode-time catch
+        // never sees it. Drop the queued payload here instead of letting the
+        // RangeError escape into the host application; the agent would reject
+        // the oversized payload at the network boundary anyway.
+        this._encoder.reset()
+        log.error('Writer dropped %d trace(s) that exceeded the %d byte chunk cap', count, MAX_CHUNK_SIZE)
+        done()
+        return
+      }
       this._sendPayload(payload, count, done)
     } else {
       done()

package/packages/dd-trace/src/guardrails/index.js

@@ -48,6 +48,8 @@ function guard (fn) {
   if (!clobberBailout && (NODE_MAJOR < minMajor || NODE_MAJOR >= nextMajor)) {
     initBailout = true
     var runtimeInfo = 'Incompatible runtime Node.js ' + version + ', supported runtimes: Node.js ' + supportedRange
+    // When not forced, the process bails out here and may call process.exit() right away;
+    // forward synchronously so the telemetry child can't outlive us and wedge the exit.
     telemetry([
       { name: 'abort', tags: ['reason:incompatible_runtime'] },
       { name: 'abort.runtime', tags: [] }
@@ -55,7 +57,7 @@ function guard (fn) {
       result: 'abort',
       result_class: 'incompatible_runtime',
       result_reason: runtimeInfo
-    })
+    }, !forced)
     log.info('Aborting application instrumentation due to incompatible_runtime.')
     log.info('Found incompatible runtime Node.js %s, Supported runtimes: Node.js %s.', version, supportedRange)
     if (forced) {

package/packages/dd-trace/src/guardrails/telemetry.js

@@ -1,7 +1,13 @@
 'use strict'
 
 var fs = require('fs')
-var spawn = require('child_process').spawn
+// Capture the child_process functions at load time, before the tracer wraps the module.
+// Reaching through require('child_process') at send time would route the forwarder through
+// the tracer's own child_process instrumentation once the tracer is initialized.
+var childProcess = require('child_process')
+var spawn = childProcess.spawn
+// eslint-disable-next-line n/no-unsupported-features/node-builtins
+var spawnSync = childProcess.spawnSync
 var tracerVersion = require('../../../../package.json').version
 var log = require('./log')
 
@@ -47,7 +53,7 @@ function shouldSend (point) {
   return true
 }
 
-function sendTelemetry (name, tags, resultMetadata) {
+function sendTelemetry (name, tags, resultMetadata, synchronous) {
   var points = name
   if (typeof name === 'string') {
     points = [{ name: name, tags: tags || [] }]
@@ -74,6 +80,37 @@ function sendTelemetry (name, tags, resultMetadata) {
     }
   }
 
+  var payload = JSON.stringify({ metadata: currentMetadata, points: points })
+
+  // A forwarder spawned asynchronously can still be tearing down its stdio pipes when the
+  // injected app calls process.exit(); on Node 24.0.0/24.1.x that deadlocks the exit
+  // (fixed upstream in 24.2), hanging short-lived single-step-install processes. On the
+  // bailout path the caller passes synchronous=true, so the child is fully reaped before we
+  // return and nothing survives to race the exit. spawnSync is only reached on that path,
+  // before any instrumentation is active, so it never traces the forwarder. It exists since
+  // Node 0.11.12; the guardrails still target >=0.8, which predates the exit bug anyway.
+  if (synchronous && spawnSync) {
+    // Bound the blocking send: this telemetry is best-effort and the whole point of the
+    // synchronous path is to avoid a hung exit, so a forwarder that wedges must not become a
+    // new hard hang. On timeout spawnSync kills the child and returns error.code ETIMEDOUT.
+    var result = spawnSync(telemetryForwarderPath, ['library_entrypoint'], {
+      input: payload,
+      stdio: ['pipe', 'ignore', 'ignore'],
+      timeout: 1000,
+      killSignal: 'SIGKILL'
+    })
+    if (result.error) {
+      if (result.error.code === 'ETIMEDOUT') {
+        log.error('Telemetry forwarder timed out')
+      } else {
+        log.error('Failed to spawn telemetry forwarder')
+      }
+    } else if (result.status) {
+      log.error('Telemetry forwarder exited with code', result.status)
+    }
+    return
+  }
+
   var proc = spawn(telemetryForwarderPath, ['library_entrypoint'], {
     stdio: 'pipe'
   })
@@ -88,5 +125,5 @@ function sendTelemetry (name, tags, resultMetadata) {
   proc.stdin.on('error', function () {
     log.error('Failed to write telemetry data to telemetry forwarder')
   })
-  proc.stdin.end(JSON.stringify({ metadata: currentMetadata, points: points }))
+  proc.stdin.end(payload)
 }

package/packages/dd-trace/src/llmobs/constants/tags.js

@@ -13,6 +13,7 @@ module.exports = {
   ML_APP: '_ml_obs.meta.ml_app',
   PROPAGATED_PARENT_ID_KEY: '_dd.p.llmobs_parent_id',
   PROPAGATED_ML_APP_KEY: '_dd.p.llmobs_ml_app',
+  PROPAGATED_SESSION_ID_KEY: '_dd.p.llmobs_sid',
   PARENT_ID_KEY: '_ml_obs.llmobs_parent_id',
   PROPAGATED_SAMPLE_RATE_KEY: '_dd.p.llmobs_sr',
   PROPAGATED_SAMPLING_DECISION_KEY: '_dd.p.llmobs_sd',

package/packages/dd-trace/src/llmobs/tagger.js

@@ -35,6 +35,7 @@ const {
   INTEGRATION,
   DECORATOR,
   PROPAGATED_ML_APP_KEY,
+  PROPAGATED_SESSION_ID_KEY,
   DEFAULT_PROMPT_NAME,
   INTERNAL_CONTEXT_VARIABLE_KEYS,
   INTERNAL_QUERY_VARIABLE_KEYS,
@@ -139,7 +140,8 @@ class LLMObsTagger {
     if (modelName) this.tagModelName(span, modelName)
     if (modelProvider) this._setTag(span, MODEL_PROVIDER, modelProvider)
 
-    sessionId = sessionId || registry.get(parent)?.[SESSION_ID]
+    const traceTags = span.context()._trace.tags
+    sessionId = sessionId || registry.get(parent)?.[SESSION_ID] || traceTags[PROPAGATED_SESSION_ID_KEY]
     if (sessionId) this._setTag(span, SESSION_ID, sessionId)
     if (integration) this._setTag(span, INTEGRATION, integration)
     if (_decorator) this._setTag(span, DECORATOR, _decorator)
@@ -752,6 +754,18 @@ class LLMObsTagger {
 
     const tagsCarrier = registry.get(span)
     tagsCarrier[key] = value
+
+    // The first session set in a trace becomes the trace-level default, stored on the trace-shared
+    // propagating tags so later spans (incl. those under a session-less parent) inherit it and it
+    // rides `x-datadog-tags` across service boundaries. Established here, the single choke point for
+    // session writes, so sessions post-populated by integrations after span start also seed it.
+    // First-writer wins, so an explicit session still overrides locally.
+    if (key === SESSION_ID && value) {
+      const traceTags = span.context()._trace.tags
+      if (traceTags[PROPAGATED_SESSION_ID_KEY] === undefined) {
+        traceTags[PROPAGATED_SESSION_ID_KEY] = value
+      }
+    }
   }
 }
 

package/packages/dd-trace/src/msgpack/chunk.js

@@ -10,6 +10,33 @@ const SHRINK_AFTER_FLUSHES = 32
 // shape: after a halving step the post-shrink fill is the prior peak doubled,
 // still under 50 %.
 const SHRINK_USAGE_RATIO = 4
+// Hard cap on chunk growth. The agent's trace intake rejects payloads over
+// 50 MiB, so anything past that is dead on arrival anyway. A pathological
+// single trace (unsanitized meta tag the size of a media file, multi-MB
+// stack trace) used to grow the buffer without limit until either the
+// allocation failed or the process tripped its memory ceiling. `reserve`
+// now refuses the growth with a tagged `RangeError`; `AgentEncoder` catches
+// it, resets the in-flight payload, and logs.
+const MAX_SIZE = 50 * 1024 * 1024 // 50 MiB
+
+/**
+ * Thrown when a chunk — or an assembled payload stitched from several chunks —
+ * would cross `MAX_SIZE`. Shared so the `reserve` cap and the per-encoder
+ * assembled-size guards (`0.5`, agentless CI Visibility) raise the same `code`,
+ * which every writer's `flush` recognises to drop the payload instead of
+ * crashing the host.
+ */
+class OverflowError extends RangeError {
+  code = 'ERR_MSGPACK_CHUNK_OVERFLOW'
+
+  /**
+   * @param {number} needed Requested total byte size.
+   */
+  constructor (needed) {
+    super(`MsgpackChunk capped at ${MAX_SIZE} bytes; requested ${needed}`)
+    this.name = 'OverflowError'
+  }
+}
 
 /**
  * Resizable msgpack write buffer. Owns the byte-layout primitives the encoder
@@ -100,11 +127,14 @@ class MsgpackChunk {
     const needed = this.length + size
 
     if (needed > this.buffer.length) {
+      if (needed > MAX_SIZE) {
+        throw new OverflowError(needed)
+      }
       let newSize = this.buffer.length
       // `*= 2` instead of `<<= 1`: `1073741824 << 1` is negative as int32,
       // and msgpack values can legitimately reach the multi-GiB range.
       while (newSize < needed) newSize *= 2
-      this.#resize(newSize)
+      this.#resize(Math.min(newSize, MAX_SIZE))
     }
 
     this.length += size
@@ -454,3 +484,5 @@ class MsgpackChunk {
 }
 
 module.exports = MsgpackChunk
+module.exports.MAX_SIZE = MAX_SIZE
+module.exports.OverflowError = OverflowError

package/packages/dd-trace/src/msgpack/index.js

@@ -97,4 +97,9 @@ function writeMap (bytes, value) {
   }
 }
 
-module.exports = { MsgpackChunk, encode }
+module.exports = {
+  MsgpackChunk,
+  encode,
+  MAX_SIZE: MsgpackChunk.MAX_SIZE,
+  OverflowError: MsgpackChunk.OverflowError,
+}

package/packages/dd-trace/src/opentelemetry/span_processor.js

@@ -14,32 +14,34 @@ class NoopSpanProcessor {
 }
 
 class MultiSpanProcessor extends NoopSpanProcessor {
+  #processors
+
   constructor (spanProcessors) {
     super()
-    this._processors = spanProcessors
+    this.#processors = spanProcessors
   }
 
   forceFlush () {
     return Promise.all(
-      this._processors.map(p => p.forceFlush())
+      this.#processors.map(p => p.forceFlush())
     )
   }
 
   onStart (span, context) {
-    for (const processor of this._processors) {
+    for (const processor of this.#processors) {
       processor.onStart(span, context)
     }
   }
 
   onEnd (span) {
-    for (const processor of this._processors) {
+    for (const processor of this.#processors) {
       processor.onEnd(span)
     }
   }
 
   shutdown () {
     return Promise.all(
-      this._processors.map(p => p.shutdown())
+      this.#processors.map(p => p.shutdown())
     )
   }
 }

package/packages/dd-trace/src/opentelemetry/tracer_provider.js

@@ -10,46 +10,62 @@ const { MultiSpanProcessor, NoopSpanProcessor } = require('./span_processor')
 const Tracer = require('./tracer')
 
 class TracerProvider {
+  #activeProcessor = new NoopSpanProcessor()
+  #contextManager = new ContextManager()
+  #processors = []
+  #tracers = new Map()
+
   constructor (config = {}) {
     this.config = config
     this.resource = config.resource
 
-    this._processors = []
-    this._tracers = new Map()
-    this._activeProcessor = new NoopSpanProcessor()
-    this._contextManager = new ContextManager()
+    // @opentelemetry/sdk-trace 2.x (used by @opentelemetry/sdk-node 0.220+)
+    // dropped `addSpanProcessor` and hands the processors to the provider
+    // constructor instead. Wire them the same way the 1.x `addSpanProcessor`
+    // path does, so a NodeSDK configured with a trace exporter or custom
+    // processors still delivers onStart/onEnd to them.
+    if (Array.isArray(config.spanProcessors)) {
+      for (const spanProcessor of config.spanProcessors) {
+        this.addSpanProcessor(spanProcessor)
+      }
+    }
   }
 
   getTracer (name = 'opentelemetry', version = '0.0.0', options) {
     const key = `${name}@${version}`
-    if (!this._tracers.has(key)) {
-      this._tracers.set(key, new Tracer(
+    if (!this.#tracers.has(key)) {
+      this.#tracers.set(key, new Tracer(
         { ...options, name, version },
         this.config,
         this
       ))
     }
-    return this._tracers.get(key)
+    return this.#tracers.get(key)
   }
 
+  /**
+   * @param {NoopSpanProcessor} spanProcessor
+   */
   addSpanProcessor (spanProcessor) {
-    if (!this._processors.length) {
-      this._activeProcessor.shutdown()
+    if (this.#processors.includes(spanProcessor)) return
+
+    if (!this.#processors.length) {
+      this.#activeProcessor.shutdown()
     }
-    this._processors.push(spanProcessor)
-    this._activeProcessor = new MultiSpanProcessor(
-      this._processors
+    this.#processors.push(spanProcessor)
+    this.#activeProcessor = new MultiSpanProcessor(
+      this.#processors
     )
   }
 
   getActiveSpanProcessor () {
-    return this._activeProcessor
+    return this.#activeProcessor
   }
 
   // Not actually required by the SDK spec, but the official Node.js SDK does
   // this and the docs reflect that so we should do this too for familiarity.
   register (config = {}) {
-    context.setGlobalContextManager(this._contextManager)
+    context.setGlobalContextManager(this.#contextManager)
     if (!trace.setGlobalTracerProvider(this)) {
       trace.getTracerProvider().setDelegate(this)
     }
@@ -69,11 +85,11 @@ class TracerProvider {
     }
 
     exporter._writer?.flush()
-    return this._activeProcessor.forceFlush()
+    return this.#activeProcessor.forceFlush()
   }
 
   shutdown () {
-    return this._activeProcessor.shutdown()
+    return this.#activeProcessor.shutdown()
   }
 }
 

package/packages/dd-trace/src/plugins/index.js

@@ -84,6 +84,9 @@ const plugins = {
   get langchain () { return require('../../../datadog-plugin-langchain/src') },
   get mariadb () { return require('../../../datadog-plugin-mariadb/src') },
   get memcached () { return require('../../../datadog-plugin-memcached/src') },
+  // mercurius is traced under the graphql plugin: its instrumentation opens the
+  // top-level graphql.request span handled by the graphql CompositePlugin.
+  get mercurius () { return require('../../../datadog-plugin-graphql/src') },
   get 'microgateway-core' () { return require('../../../datadog-plugin-microgateway-core/src') },
   get mocha () { return require('../../../datadog-plugin-mocha/src') },
   get 'mocha-each' () { return require('../../../datadog-plugin-mocha/src') },