dd-trace 6.9.0 → 6.10.0

package/packages/datadog-plugin-mysql/src/index.js

@@ -21,6 +21,38 @@ class MySQLPlugin extends DatabasePlugin {
     })
 
     this.addBind(`apm:${this.component}:connection:finish`, ctx => ctx.currentStore)
+
+    // Explicit getConnection calls get an acquire span. Pool queries report their internal acquire
+    // on the query span instead, so each acquire is counted once.
+    this.addSub(`apm:${this.component}:pool:acquire:start`, ctx => {
+      const operation = `${this.component}.pool.acquire`
+
+      this.startSpan(operation, {
+        service: this.serviceName({ pluginConfig: this.config, dbConfig: ctx.conf, system: this.system }),
+        resource: operation,
+        startTime: ctx.startTime,
+        type: 'sql',
+        kind: 'client',
+        meta: {
+          'db.type': this.system,
+          'db.user': ctx.conf.user,
+          'db.name': ctx.conf.database,
+          'out.host': ctx.conf.host,
+          [CLIENT_PORT_KEY]: ctx.conf.port,
+        },
+      }, ctx)
+    })
+
+    this.addSub(`apm:${this.component}:pool:acquire:finish`, ctx => {
+      const span = ctx.currentStore?.span
+      if (span === undefined) return
+
+      if (ctx.error) {
+        this.addError(ctx.error, span)
+      }
+      span.setTag(`${this.component}.pool.wait_time`, ctx.poolWaitTime)
+      this.finish(ctx)
+    })
   }
 
   bindStart (ctx) {
@@ -38,6 +70,11 @@ class MySQLPlugin extends DatabasePlugin {
         [CLIENT_PORT_KEY]: ctx.conf.port,
       },
     }, ctx)
+
+    if (ctx.poolWaitTime !== undefined) {
+      span.setTag(`${this.component}.pool.wait_time`, ctx.poolWaitTime)
+    }
+
     ctx.sql = this.injectDbmQuery(span, ctx.sql, service.name)
 
     return ctx.currentStore

package/packages/datadog-plugin-next/src/index.js

@@ -145,7 +145,7 @@ class NextPlugin extends ServerPlugin {
   }
 
   configure (config) {
-    return super.configure(normalizeConfig(config))
+    return super.configure(web.normalizeConfig(config))
   }
 }
 
@@ -178,22 +178,4 @@ function setHttpParentRoute (span, method, page, isStatic) {
   span.setTag(RESOURCE_NAME, `${method} ${page}`.trim())
   nextParentRoutes.set(span, page)
 }
-
-function normalizeConfig (config) {
-  const hooks = getHooks(config)
-  const validateStatus = typeof config.validateStatus === 'function'
-    ? config.validateStatus
-    : code => code < 500
-
-  return { ...config, hooks, validateStatus }
-}
-
-const noop = () => {}
-
-function getHooks (config) {
-  const request = config.hooks?.request ?? noop
-
-  return { request }
-}
-
 module.exports = NextPlugin

package/packages/datadog-plugin-openai-agents/src/integration.js

@@ -15,6 +15,9 @@ const { AGENTS_ERROR_TYPE, applyError, deriveSpanName } = require('./util')
 
 const COMPONENT = 'openai-agents'
 const DEFAULT_MODEL_PROVIDER = 'openai'
+// Bounds the agents-core parent-chain walk so a cyclic chain from a future
+// agents-core version can't spin on the span-start hot path.
+const MAX_ANCESTOR_WALK = 32
 const MODEL_BASE_URL_STORE_KEY = Symbol('openai-agents.model-base-url')
 const legacyStorage = storage('legacy')
 
@@ -37,9 +40,20 @@ const KIND_TO_SPAN_KIND = {
  *   metadata?: Record<string, unknown>,
  *   groupId?: string,
  *   llmobsParentStore?: object,
+ *   activeSpanCount: number,
+ *   completionRequested: boolean,
  * }} LLMObsTraceInfo
  */
 
+/**
+ * @typedef {{
+ *   parentId: string | null,
+ *   traceId?: string,
+ *   activeChildCount: number,
+ *   ended: boolean,
+ * }} UntracedSpanInfo
+ */
+
 /**
  * Owns tracer/tagger refs, maps agents-core span ids → dd-trace spans, and
  * reconstructs workflow-level input/output from the first and last response
@@ -59,6 +73,12 @@ class OpenAIAgentsIntegration {
   #tagger
   /** @type {Map<string, import('../../dd-trace/src/opentracing/span')>} */
   #oaiToDdSpan = new Map()
+  /**
+   * agents-core spans we deliberately don't trace (`task` / `turn`). Ended
+   * nodes stay walkable only while an observed child callback is still active.
+   * @type {Map<string, UntracedSpanInfo>}
+   */
+  #untracedSpans = new Map()
   /** @type {Map<string, LLMObsTraceInfo>} */
   #traceInfo = new Map()
 
@@ -83,11 +103,58 @@ class OpenAIAgentsIntegration {
   }
 
   /**
-   * @param {string} spanId agents-core spanId
+   * Resolve the dd-trace span for an agents-core spanId. When the id belongs to
+   * a span type we don't trace — agents-core >=0.14 runs model calls inside a
+   * `turn` span — the nearest traced ancestor's span is returned so callers
+   * still activate the enclosing agent span.
+   *
+   * @param {string | undefined | null} spanId agents-core spanId
    * @returns {import('../../dd-trace/src/opentracing/span') | undefined}
    */
   getDDSpan (spanId) {
-    return this.#oaiToDdSpan.get(spanId)
+    return this.#oaiToDdSpan.get(this.#nearestTracedAncestorId(spanId))
+  }
+
+  /**
+   * Remember an untraced agents-core span's parent so the chain stays walkable.
+   *
+   * @param {object} oaiSpan
+   */
+  recordUntracedSpan (oaiSpan) {
+    const { spanId } = oaiSpan
+    if (!spanId || this.#untracedSpans.has(spanId)) return
+
+    const parentId = oaiSpan.parentId ?? null
+    this.#untracedSpans.set(spanId, {
+      parentId,
+      traceId: oaiSpan.traceId,
+      activeChildCount: 0,
+      ended: false,
+    })
+    this.#retainUntracedParent(parentId)
+    this.#spanStarted(oaiSpan.traceId)
+  }
+
+  /**
+   * Mark an untraced span callback complete. Its ancestry remains available
+   * until every observed child callback has completed.
+   *
+   * @param {object} oaiSpan
+   */
+  endUntracedSpan (oaiSpan) {
+    const info = this.#untracedSpans.get(oaiSpan.spanId)
+    if (!info || info.ended) return
+
+    // agents-core does not end its trace when the run throws. In 0.14 the
+    // failure can live on the root task before any agent span exists, making
+    // this structural callback the only opportunity to finish the workflow.
+    if (oaiSpan.error && this.#isTopLevelSpan(oaiSpan)) {
+      this.#requestWorkflowCompletion(oaiSpan.traceId, oaiSpan)
+    }
+
+    info.ended = true
+    this.#pruneUntracedSpan(oaiSpan.spanId, info)
+    this.#spanEnded(info.traceId)
   }
 
   /**
@@ -114,6 +181,7 @@ class OpenAIAgentsIntegration {
       ddSpan.finish()
     }
     this.#oaiToDdSpan.clear()
+    this.#untracedSpans.clear()
     this.#traceInfo.clear()
   }
 
@@ -138,6 +206,8 @@ class OpenAIAgentsIntegration {
       groupId: oaiTrace.groupId || undefined,
       metadata: oaiTrace.metadata,
       llmobsParentStore,
+      activeSpanCount: 0,
+      completionRequested: false,
     })
 
     this.#tagger.registerLLMObsSpan(ddSpan, {
@@ -153,38 +223,55 @@ class OpenAIAgentsIntegration {
   }
 
   endTrace (oaiTrace) {
-    this.#completeWorkflowSpan(oaiTrace.traceId)
+    this.#requestWorkflowCompletion(oaiTrace.traceId)
   }
 
   /**
-   * Finish the workflow dd-trace span and clear its bookkeeping. Used by both
-   * agents-core's normal `Trace.end()` path and the orphan-recovery path
-   * (when `withTrace` skips its end callback because the body threw). When
-   * `rootAgentSpan` is provided, its `error` field is reflected onto the
-   * workflow span before finishing.
+   * Request workflow completion after all observed span callbacks finish.
+   * Error tags are applied immediately so the agents-core span does not need
+   * to be retained while completion is pending.
    *
    * @param {string | undefined} traceId
-   * @param {object} [rootAgentSpan] - parentless oai-span that ended in error.
+   * @param {object} [rootSpan] - top-level oai-span that ended in error.
    */
-  #completeWorkflowSpan (traceId, rootAgentSpan) {
+  #requestWorkflowCompletion (traceId, rootSpan) {
     if (!traceId) return
     const ddSpan = this.#oaiToDdSpan.get(traceId)
     if (!ddSpan) return
     const info = this.#traceInfo.get(traceId)
 
-    if (rootAgentSpan?.error) {
+    if (rootSpan?.error) {
       ddSpan.setTag('error', true)
       ddSpan.setTag('error.type', AGENTS_ERROR_TYPE)
-      if (rootAgentSpan.error.message) {
-        ddSpan.setTag('error.message', rootAgentSpan.error.message)
+      if (rootSpan.error.message) {
+        ddSpan.setTag('error.message', rootSpan.error.message)
+      }
+    }
+
+    if (info) {
+      if (!info.completionRequested) {
+        info.completionRequested = true
+        if (LLMObsTagger.tagMap.has(ddSpan)) {
+          llmobsStorage.enterWith(info.llmobsParentStore)
+        }
       }
+      if (info.activeSpanCount > 0) return
     }
 
+    this.#completeWorkflowSpan(traceId)
+  }
+
+  /**
+   * Finish the workflow dd-trace span and clear its bookkeeping.
+   *
+   * @param {string} traceId
+   */
+  #completeWorkflowSpan (traceId) {
+    const ddSpan = this.#oaiToDdSpan.get(traceId)
+    if (!ddSpan) return
+
     if (this.#isLLMObsEnabled()) this.#setTraceAttributes(ddSpan, traceId)
     ddSpan.finish()
-    if (info && LLMObsTagger.tagMap.has(ddSpan)) {
-      llmobsStorage.enterWith(info.llmobsParentStore)
-    }
     this.#oaiToDdSpan.delete(traceId)
     this.#traceInfo.delete(traceId)
   }
@@ -204,6 +291,8 @@ class OpenAIAgentsIntegration {
     })
 
     this.#oaiToDdSpan.set(spanId, ddSpan)
+    this.#retainUntracedParent(oaiSpan.parentId)
+    this.#spanStarted(oaiSpan.traceId)
 
     if (this.#isLLMObsEnabled()) {
       const llmobsOptions = {
@@ -230,49 +319,57 @@ class OpenAIAgentsIntegration {
     const ddSpan = this.#oaiToDdSpan.get(spanId)
     if (!ddSpan) return
 
-    applyError(ddSpan, oaiSpan)
+    try {
+      applyError(ddSpan, oaiSpan)
 
-    if (oaiSpan.spanData?.type === 'handoff') {
-      const spanName = deriveSpanName(oaiSpan)
-      ddSpan.setOperationName(spanName)
-      if (this.#isLLMObsEnabled()) this.#tagger.setName(ddSpan, spanName)
-    }
+      if (oaiSpan.spanData?.type === 'handoff') {
+        const spanName = deriveSpanName(oaiSpan)
+        ddSpan.setOperationName(spanName)
+        if (this.#isLLMObsEnabled()) this.#tagger.setName(ddSpan, spanName)
+      }
 
-    if (this.#isLLMObsEnabled()) {
-      const spanData = oaiSpan.spanData
-      switch (spanData?.type) {
-        case 'response':
-          this.#setResponseAttributes(ddSpan, oaiSpan)
-          this.#updateTraceInfoOutput(oaiSpan)
-          break
-        case 'generation':
-          this.#setGenerationAttributes(ddSpan, oaiSpan)
-          this.#updateTraceInfoOutput(oaiSpan)
-          break
-        case 'function':
-          this.#tagger.tagTextIO(ddSpan, spanData.input ?? '', spanData.output ?? '')
-          break
-        case 'handoff':
-          this.#tagger.tagTextIO(ddSpan, spanData.from_agent ?? '', spanData.to_agent ?? '')
-          break
-        case 'agent':
-          this.#setAgentAttributes(ddSpan, oaiSpan)
-          break
-        case 'custom':
-          if (spanData.data && typeof spanData.data === 'object') {
-            this.#tagger.tagMetadata(ddSpan, spanData.data)
-          }
-          break
+      if (this.#isLLMObsEnabled()) {
+        const spanData = oaiSpan.spanData
+        switch (spanData?.type) {
+          case 'response':
+            this.#setResponseAttributes(ddSpan, oaiSpan)
+            this.#updateTraceInfoOutput(oaiSpan)
+            break
+          case 'generation':
+            this.#setGenerationAttributes(ddSpan, oaiSpan)
+            this.#updateTraceInfoOutput(oaiSpan)
+            break
+          case 'function':
+            this.#tagger.tagTextIO(ddSpan, spanData.input ?? '', spanData.output ?? '')
+            break
+          case 'handoff':
+            this.#tagger.tagTextIO(ddSpan, spanData.from_agent ?? '', spanData.to_agent ?? '')
+            break
+          case 'agent':
+            this.#setAgentAttributes(ddSpan, oaiSpan)
+            break
+          case 'custom':
+            if (spanData.data && typeof spanData.data === 'object') {
+              this.#tagger.tagMetadata(ddSpan, spanData.data)
+            }
+            break
+        }
       }
-    }
 
-    ddSpan.finish()
-    // agents-core's withTrace skips Trace.end() when its callback throws, so an
-    // errored parentless span is our last chance to finalize the workflow.
-    if (oaiSpan.parentId == null && oaiSpan.error) {
-      this.#completeWorkflowSpan(oaiSpan.traceId, oaiSpan)
+      // agents-core's withTrace skips Trace.end() when its callback throws, so
+      // an errored top-level span is our last chance to finalize the workflow.
+      if (oaiSpan.error && this.#isTopLevelSpan(oaiSpan)) {
+        this.#requestWorkflowCompletion(oaiSpan.traceId, oaiSpan)
+      }
+    } finally {
+      try {
+        ddSpan.finish()
+      } finally {
+        this.#oaiToDdSpan.delete(spanId)
+        this.#releaseUntracedParent(oaiSpan.parentId)
+        this.#spanEnded(oaiSpan.traceId)
+      }
     }
-    this.#oaiToDdSpan.delete(spanId)
   }
 
   // ── Per-type attribute setters ──────────────────────────────────────────────
@@ -360,7 +457,7 @@ class OpenAIAgentsIntegration {
   #llmSpanParentAgentName (oaiSpan) {
     const traceInfo = this.#traceInfo.get(oaiSpan.traceId)
     if (!traceInfo?.currentTopLevelAgentSpanId) return
-    if (oaiSpan.parentId !== traceInfo.currentTopLevelAgentSpanId) return
+    if (!this.#hasUntracedPathToAncestor(oaiSpan.parentId, traceInfo.currentTopLevelAgentSpanId)) return
     return traceInfo.currentTopLevelAgentName
   }
 
@@ -412,13 +509,12 @@ class OpenAIAgentsIntegration {
     const info = this.#traceInfo.get(oaiSpan.traceId)
     if (!info) return
 
-    const parentId = oaiSpan.parentId
     const type = oaiSpan.spanData?.type
 
     // Identify the first top-level agent span under the root trace and
     // stash its display name so `${agentName} (LLM)` doesn't have to read
     // the dd-trace span context's private fields later.
-    if (type === 'agent' && parentId == null) {
+    if (type === 'agent' && this.#isTopLevelSpan(oaiSpan)) {
       info.currentTopLevelAgentSpanId = oaiSpan.spanId
       info.currentTopLevelAgentName = spanName
     }
@@ -427,9 +523,9 @@ class OpenAIAgentsIntegration {
     // as the workflow-level input source.
     if (
       (type === 'response' || type === 'generation') &&
-      parentId &&
+      info.currentTopLevelAgentSpanId &&
       !info.inputOaiSpan &&
-      parentId === info.currentTopLevelAgentSpanId
+      this.#hasUntracedPathToAncestor(oaiSpan.parentId, info.currentTopLevelAgentSpanId)
     ) {
       info.inputOaiSpan = oaiSpan
     }
@@ -440,9 +536,8 @@ class OpenAIAgentsIntegration {
     if (!info) return
 
     if (
-      oaiSpan.parentId &&
       info.currentTopLevelAgentSpanId &&
-      oaiSpan.parentId === info.currentTopLevelAgentSpanId
+      this.#hasUntracedPathToAncestor(oaiSpan.parentId, info.currentTopLevelAgentSpanId)
     ) {
       info.outputOaiSpan = oaiSpan
     }
@@ -451,18 +546,132 @@ class OpenAIAgentsIntegration {
   // ── Helpers ─────────────────────────────────────────────────────────────────
 
   #resolveParent (oaiSpan) {
-    const parentId = oaiSpan.parentId
-    const traceId = oaiSpan.traceId
-    if (parentId) {
-      const parent = this.#oaiToDdSpan.get(parentId)
-      if (parent) return parent
+    return this.getDDSpan(oaiSpan.parentId) ?? this.#oaiToDdSpan.get(oaiSpan.traceId)
+  }
+
+  /**
+   * Walk the agents-core parent chain from `spanId`, skipping spans we don't
+   * trace, and return the first id that maps to a dd-trace span. Returns
+   * `undefined` when the walk reaches the trace root (or a span we never saw),
+   * which callers read as "no traced ancestor".
+   *
+   * @param {string | undefined | null} spanId agents-core spanId to start from
+   * @returns {string | undefined}
+   */
+  #nearestTracedAncestorId (spanId) {
+    let currentId = spanId
+    for (let depth = 0; currentId != null && depth < MAX_ANCESTOR_WALK; depth++) {
+      if (this.#oaiToDdSpan.has(currentId)) return currentId
+      currentId = this.#untracedSpans.get(currentId)?.parentId
     }
-    if (traceId) {
-      const root = this.#oaiToDdSpan.get(traceId)
-      if (root) return root
+  }
+
+  /**
+   * True when `spanId` reaches `ancestorId` through only untraced structural
+   * spans. Unlike #nearestTracedAncestorId, this still recognizes an ancestor
+   * whose dd-trace span has already finished and been removed from the live map.
+   *
+   * @param {string | undefined | null} spanId agents-core spanId to start from
+   * @param {string} ancestorId agents-core ancestor spanId
+   * @returns {boolean}
+   */
+  #hasUntracedPathToAncestor (spanId, ancestorId) {
+    let currentId = spanId
+    for (let depth = 0; currentId != null && depth < MAX_ANCESTOR_WALK; depth++) {
+      if (currentId === ancestorId) return true
+      currentId = this.#untracedSpans.get(currentId)?.parentId
+    }
+    return false
+  }
+
+  /**
+   * True when nothing but untraced spans sits between this span and the trace
+   * root. Stricter than `#nearestTracedAncestorId(…) === undefined`, which also
+   * answers "undefined" for a parent we simply never saw — that must not be
+   * mistaken for top-level, or an error would finalize the workflow span early.
+   *
+   * @param {object} oaiSpan
+   * @returns {boolean}
+   */
+  #isTopLevelSpan (oaiSpan) {
+    let currentId = oaiSpan.parentId
+    for (let depth = 0; depth < MAX_ANCESTOR_WALK; depth++) {
+      if (currentId == null) return true
+      const info = this.#untracedSpans.get(currentId)
+      if (!info) return false
+      currentId = info.parentId
+    }
+    return false
+  }
+
+  /**
+   * Keep a structural parent alive until this child callback completes.
+   *
+   * @param {string | undefined | null} parentId
+   */
+  #retainUntracedParent (parentId) {
+    const info = this.#untracedSpans.get(parentId)
+    if (info) info.activeChildCount++
+  }
+
+  /**
+   * Release a structural parent and iteratively prune any ended, childless
+   * ancestors. Each iteration deletes one node, so even a cyclic parent chain
+   * terminates when it reaches the first node it already removed.
+   *
+   * @param {string | undefined | null} parentId
+   */
+  #releaseUntracedParent (parentId) {
+    let currentId = parentId
+    while (currentId != null) {
+      const info = this.#untracedSpans.get(currentId)
+      if (!info || info.activeChildCount === 0) return
+
+      info.activeChildCount--
+      if (!info.ended || info.activeChildCount > 0) return
+
+      this.#untracedSpans.delete(currentId)
+      currentId = info.parentId
     }
   }
 
+  /**
+   * Remove an ended structural span once no observed child still needs it.
+   *
+   * @param {string} spanId
+   * @param {UntracedSpanInfo} info
+   */
+  #pruneUntracedSpan (spanId, info) {
+    if (info.activeChildCount > 0) return
+    this.#untracedSpans.delete(spanId)
+    this.#releaseUntracedParent(info.parentId)
+  }
+
+  /**
+   * Count a span callback whose end may arrive after trace completion.
+   *
+   * @param {string | undefined} traceId
+   */
+  #spanStarted (traceId) {
+    const info = this.#traceInfo.get(traceId)
+    if (info) info.activeSpanCount++
+  }
+
+  /**
+   * Release one observed span callback and complete the trace when it becomes
+   * quiescent. Structural ancestry prunes independently with each subtree.
+   *
+   * @param {string | undefined} traceId
+   */
+  #spanEnded (traceId) {
+    const info = this.#traceInfo.get(traceId)
+    if (!info) return
+    if (info.activeSpanCount > 0) info.activeSpanCount--
+    if (info.activeSpanCount > 0) return
+
+    if (info.completionRequested) this.#completeWorkflowSpan(traceId)
+  }
+
   /**
    * Read the mutable tracer configuration so remote/runtime enablement is
    * reflected without reconstructing the plugin.

package/packages/datadog-plugin-openai-agents/src/processor.js

@@ -66,10 +66,16 @@ class DDOpenAIAgentsProcessor {
     const integration = this._getIntegration()
     if (!integration?.enabled) return RESOLVED
     if (!oaiSpan?.spanData) return RESOLVED // guard NoopSpan
-    const kind = SPAN_KIND_BY_TYPE[oaiSpan.spanData.type]
-    if (!kind) return RESOLVED // span types without an LLMObs kind are not traced
+    const type = oaiSpan.spanData.type
+    const kind = SPAN_KIND_BY_TYPE[type]
     try {
-      integration.startSpan(oaiSpan, kind)
+      if (kind) {
+        integration.startSpan(oaiSpan, kind)
+      } else if (type === 'task' || type === 'turn') {
+        // agents-core >=0.14 nests real work under these structural spans, so
+        // their ancestry still has to be walkable for parent resolution.
+        integration.recordUntracedSpan(oaiSpan)
+      }
     } catch (err) {
       log.warn('[openai-agents] onSpanStart failed: %s', err)
     }
@@ -80,8 +86,14 @@ class DDOpenAIAgentsProcessor {
     const integration = this._getIntegration()
     if (!integration?.enabled) return RESOLVED
     if (!oaiSpan?.spanData) return RESOLVED
+    const type = oaiSpan.spanData.type
+    const kind = SPAN_KIND_BY_TYPE[type]
     try {
-      integration.endSpan(oaiSpan)
+      if (kind) {
+        integration.endSpan(oaiSpan)
+      } else if (type === 'task' || type === 'turn') {
+        integration.endUntracedSpan(oaiSpan)
+      }
     } catch (err) {
       log.warn('[openai-agents] onSpanEnd failed: %s', err)
     }

package/packages/datadog-plugin-pg/src/index.js

@@ -29,6 +29,7 @@ class PGPlugin extends DatabasePlugin {
       this.startSpan(operationName, {
         service,
         resource: operationName,
+        startTime: ctx.startTime,
         type: 'sql',
         kind: 'client',
         meta: {

package/packages/datadog-plugin-vitest/src/index.js

@@ -2,6 +2,7 @@
 
 const CiPlugin = require('../../dd-trace/src/plugins/ci_plugin')
 const { storage } = require('../../datadog-core')
+const { writeDatadogParentId, writeDatadogTraceId } = require('../../dd-trace/src/carrier')
 
 const {
   TEST_STATUS,
@@ -13,7 +14,6 @@ const {
   getTestSuiteCommonTags,
   getTestLevelsMetadataTags,
   getTestSessionName,
-  getIsFaultyEarlyFlakeDetection,
   TEST_SOURCE_FILE,
   TEST_IS_RETRY,
   TEST_CODE_OWNERS,
@@ -107,19 +107,6 @@ class VitestPlugin extends CiPlugin {
       })
     })
 
-    this.addSub('ci:vitest:is-early-flake-detection-faulty', ({
-      knownTests,
-      testFilepaths,
-      onDone,
-    }) => {
-      const isFaulty = getIsFaultyEarlyFlakeDetection(
-        testFilepaths.map(testFilepath => getTestSuitePath(testFilepath, this.repositoryRoot)),
-        knownTests,
-        this.libraryConfig.earlyFlakeDetectionFaultyThreshold
-      )
-      onDone(isFaulty)
-    })
-
     this.addBind('ci:vitest:test:start', (ctx) => {
       const {
         testName,
@@ -424,12 +411,13 @@ class VitestPlugin extends CiPlugin {
       this._setRepositoryRoot(repositoryRoot, codeOwnersEntries)
       this.command = testCommand
       this.frameworkVersion = frameworkVersion
-      const testSessionSpanContext = testSessionId && testModuleId
-        ? this.tracer.extract('text_map', {
-          'x-datadog-trace-id': testSessionId,
-          'x-datadog-parent-id': testModuleId,
-        })
-        : undefined
+      let testSessionSpanContext
+      if (testSessionId && testModuleId) {
+        const carrier = /** @type {Record<string, unknown>} */ ({})
+        writeDatadogTraceId(carrier, testSessionId)
+        writeDatadogParentId(carrier, testModuleId)
+        testSessionSpanContext = this.tracer.extract('text_map', carrier)
+      }
 
       const trimmedCommand = DD_MAJOR < 6 ? this.command : 'vitest run'
       // test suites run in a different process, so they also need to init the metadata dictionary

package/packages/datadog-plugin-ws/src/util.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const { readDatadogTraceId, readTraceparent } = require('../../dd-trace/src/carrier')
 const DatadogSpanContext = require('../../dd-trace/src/opentracing/span_context')
 
 const TRACE_ID_UPPER_TAG = '_dd.p.tid'
@@ -38,7 +39,7 @@ function createWebSocketSpanContext (spanContext) {
  * @returns {boolean}
  */
 function hasTraceHeaders (headers) {
-  return !!(headers && (headers['x-datadog-trace-id'] || headers.traceparent))
+  return !!(headers && (readDatadogTraceId(headers) || readTraceparent(headers)))
 }
 
 /**