dd-trace 5.99.1 → 5.101.0

package/packages/dd-trace/src/opentracing/propagation/tracestate.js

@@ -1,19 +1,48 @@
 'use strict'
 
-const traceStateRegex = /[ \t]*([^=]+)=([ \t]*[^, \t]+)[ \t]*(,|$)/gim
-const traceStateDataRegex = /([^:]+):([^;]+)(;|$)/gim
+// W3C Trace Context §3.3.1.2: max 32 list-members.
+// https://www.w3.org/TR/trace-context/#tracestate-header-field-values
+const MAX_LIST_MEMBERS = 32
+const WHITESPACE = /[ \t]/
 
-function fromString (Type, regex, value) {
-  if (typeof value !== 'string' || !value.length) {
-    return new Type()
+/**
+ * Parse a separator-delimited string into key/value entries.
+ *
+ * @param {string} value
+ * @param {string} fieldSeparator Between entries.
+ * @param {string} pairSeparator Between key and value within an entry.
+ * @param {boolean} rejectValueTabs Drop entries whose value contains an internal tab.
+ * @returns {[string, string][]} Entries in reverse of wire order.
+ */
+function parseEntries (value, fieldSeparator, pairSeparator, rejectValueTabs) {
+  const segments = value.split(fieldSeparator, MAX_LIST_MEMBERS)
+
+  // TODO: We should extract dd no matter at what position and move it to the front of the list.
+  // Extract up 31 additional entries.
+  const entries = []
+  for (let index = 0; index < segments.length; index++) {
+    const segment = segments[index]
+    const splitIndex = segment.indexOf(pairSeparator)
+    if (splitIndex === -1) continue
+    const key = segment.slice(0, splitIndex).trim()
+    if (!key || WHITESPACE.test(key)) continue
+    // W3C §3.3.1.3.2: value = 0*255(chr) nblk-chr; chr = %x20 / nblk-chr (no tab).
+    // Leading 0x20 is part of value; trailing whitespace is OWS.
+    const entryValue = segment.slice(splitIndex + 1).trimEnd()
+    if (!entryValue || rejectValueTabs && entryValue.includes('\t')) continue
+    entries.push([key, entryValue])
   }
+  // Reverse so the Map's insertion order is reverse of wire order. `toString`
+  // prepends as it iterates, which yields the original wire order back.
+  entries.reverse()
+  return entries
+}
 
-  const values = []
-  for (const row of value.matchAll(regex)) {
-    values.unshift(row.slice(1, 3))
+function fromString (Type, value, fieldSeparator, pairSeparator, rejectValueTabs) {
+  if (typeof value !== 'string' || !value.length) {
+    return new Type()
   }
-
-  return new Type(values)
+  return new Type(parseEntries(value, fieldSeparator, pairSeparator, rejectValueTabs))
 }
 
 function toString (map, pairSeparator, fieldSeparator) {
@@ -27,32 +56,49 @@ function toString (map, pairSeparator, fieldSeparator) {
   return result
 }
 
-class TraceStateData extends Map {
-  constructor (...args) {
-    super(...args)
-    this.changed = false
+class TraceStateData {
+  #map
+  changed = false
+
+  constructor (entries) {
+    this.#map = entries ? new Map(entries) : new Map()
   }
 
-  set (...args) {
-    if (this.has(args[0]) && this.get(args[0]) === args[1]) {
-      return
-    }
+  set (key, value) {
+    if (this.#map.get(key) === value && (value !== undefined || this.#map.has(key))) return this
     this.changed = true
-    return super.set(...args)
+    this.#map.set(key, value)
+    return this
   }
 
-  delete (...args) {
+  get (key) {
+    return this.#map.get(key)
+  }
+
+  delete (key) {
     this.changed = true
-    return super.delete(...args)
+    return this.#map.delete(key)
   }
 
-  clear (...args) {
+  clear () {
     this.changed = true
-    return super.clear(...args)
+    this.#map.clear()
+  }
+
+  entries () {
+    return this.#map.entries()
+  }
+
+  [Symbol.iterator] () {
+    return this.#map[Symbol.iterator]()
+  }
+
+  get size () {
+    return this.#map.size
   }
 
   static fromString (value) {
-    return fromString(TraceStateData, traceStateDataRegex, value)
+    return fromString(TraceStateData, value, ';', ':', false)
   }
 
   toString () {
@@ -64,25 +110,45 @@ class TraceStateData extends Map {
  * Pairs are stored in reverse of the serialized format to rely on set ordering
  * new entries at the end to express update movement.
  */
-class TraceState extends Map {
+class TraceState {
+  #map
+
+  constructor (entries) {
+    this.#map = entries ? new Map(entries) : new Map()
+  }
+
   // Delete entries on update to ensure they're moved to the end of the list
   set (key, value) {
-    if (this.has(key)) {
-      this.delete(key)
-    }
+    if (this.#map.has(key)) this.#map.delete(key)
+    this.#map.set(key, value)
+    return this
+  }
+
+  get (key) {
+    return this.#map.get(key)
+  }
+
+  delete (key) {
+    return this.#map.delete(key)
+  }
+
+  [Symbol.iterator] () {
+    return this.#map[Symbol.iterator]()
+  }
 
-    return super.set(key, value)
+  get size () {
+    return this.#map.size
   }
 
   forVendor (vendor, handle) {
-    const data = super.get(vendor)
+    const data = this.#map.get(vendor)
     const state = TraceStateData.fromString(data)
     const result = handle(state)
 
     if (state.changed) {
       const value = state.toString()
       if (value) {
-        this.set(vendor, state.toString())
+        this.set(vendor, value)
       } else {
         this.delete(vendor)
       }
@@ -92,7 +158,7 @@ class TraceState extends Map {
   }
 
   static fromString (value) {
-    return fromString(TraceState, traceStateRegex, value)
+    return fromString(TraceState, value, ',', '=', true)
   }
 
   toString () {

package/packages/dd-trace/src/opentracing/span.js

@@ -11,21 +11,16 @@ const runtimeMetrics = require('../runtime_metrics')
 const log = require('../log')
 const { storage } = require('../../../datadog-core')
 const telemetryMetrics = require('../telemetry/metrics')
-const { getValueFromEnvSources } = require('../config/helper')
-const { isTrue } = require('../util')
 const SpanContext = require('./span_context')
 
 const dateNow = Date.now
 
 const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
 
-const DD_TRACE_EXPERIMENTAL_STATE_TRACKING = isTrue(getValueFromEnvSources('DD_TRACE_EXPERIMENTAL_STATE_TRACKING'))
-const DD_TRACE_EXPERIMENTAL_SPAN_COUNTS = isTrue(getValueFromEnvSources('DD_TRACE_EXPERIMENTAL_SPAN_COUNTS'))
-
 const unfinishedRegistry = createRegistry('unfinished')
 const finishedRegistry = createRegistry('finished')
 
-const OTEL_ENABLED = !!getValueFromEnvSources('DD_TRACE_OTEL_ENABLED')
+let OTEL_ENABLED = false
 const ALLOWED = new Set(['string', 'number', 'boolean'])
 
 const integrationCounters = {
@@ -37,6 +32,25 @@ const startCh = channel('dd-trace:span:start')
 const finishCh = channel('dd-trace:span:finish')
 const tagsUpdateCh = channel('dd-trace:span:tags:update')
 
+// Module-scope so we don't allocate a fresh recursive closure on every
+// `addLink` / `addEvent`.
+/**
+ * @param {Record<string, string>} out
+ * @param {string} key
+ * @param {unknown} value
+ */
+function addArrayOrScalarAttribute (out, key, value) {
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      addArrayOrScalarAttribute(out, `${key}.${i}`, value[i])
+    }
+  } else if (ALLOWED.has(typeof value)) {
+    out[key] = typeof value === 'string' ? value : String(value)
+  } else {
+    log.warn('Dropping span link attribute. It is not of an allowed type')
+  }
+}
+
 function getIntegrationCounter (event, integration) {
   const counters = integrationCounters[event]
 
@@ -55,15 +69,22 @@ function getIntegrationCounter (event, integration) {
 }
 
 class DatadogSpan {
+  #parentTracer
+
   constructor (tracer, processor, prioritySampler, fields, debug) {
+    OTEL_ENABLED = tracer._config.DD_TRACE_OTEL_ENABLED
+
     const operationName = fields.operationName
     const parent = fields.parent || null
-    // TODO(BridgeAR): Investigate why this is causing a performance regression
+    // Stay on `Object.assign({}, src)` for backportability: V8 12+ (Node 22 /
+    // 24) inlines `{ ...src }` and beats `Object.assign` here, but on V8 10.2
+    // / 11.3 (Node 18 / 20) the spread takes a generic runtime path and slows
+    // `spans-finish-*` by ~140%. Revisit once those LTS lines drop.
     // eslint-disable-next-line prefer-object-spread
     const tags = Object.assign({}, fields.tags)
     const hostname = fields.hostname
 
-    this._parentTracer = tracer
+    this.#parentTracer = tracer
     this._debug = debug
     this._processor = processor
     this._prioritySampler = prioritySampler
@@ -94,7 +115,7 @@ class DatadogSpan {
       attributes: this._sanitizeAttributes(link.attributes),
     })) ?? []
 
-    if (DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
+    if (this.#parentTracer._config.DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
       runtimeMetrics.increment('runtime.node.spans.unfinished')
       runtimeMetrics.increment('runtime.node.spans.unfinished.by.name', `span_name:${operationName}`)
 
@@ -104,16 +125,8 @@ class DatadogSpan {
       unfinishedRegistry.register(this, operationName, this)
     }
 
-    // Nullish operator is used here because both `tracer` and `tracer._config`
-    // can be null and there are tests passing invalid values to the `Span`
-    // constructor which still succeed today. Part of the problem is that `Span`
-    // stores only the tracer and not the config, so anything that needs the
-    // config has to read it from the tracer stored on the span, including
-    // even `Span` itself in this case.
-    //
-    // TODO: Refactor Tracer/Span + tests to avoid having to do nullish checks.
-    if (tracer?._config?.DD_TRACE_SPAN_LEAK_DEBUG > 0) {
-      require('../spanleak').addSpan(this, operationName)
+    if (tracer._config.DD_TRACE_SPAN_LEAK_DEBUG > 0) {
+      require('../spanleak').addSpan(this)
     }
 
     if (startCh.hasSubscribers) {
@@ -124,7 +137,7 @@ class DatadogSpan {
   [util.inspect.custom] () {
     return {
       ...this,
-      _parentTracer: `[${this._parentTracer.constructor.name}]`,
+      parentTracer: `[${this.#parentTracer.constructor.name}]`,
       _prioritySampler: `[${this._prioritySampler.constructor.name}]`,
       _processor: `[${this._processor.constructor.name}]`,
     }
@@ -156,7 +169,7 @@ class DatadogSpan {
   }
 
   tracer () {
-    return this._parentTracer
+    return this.#parentTracer
   }
 
   setOperationName (name) {
@@ -254,14 +267,14 @@ class DatadogSpan {
       return
     }
 
-    if (DD_TRACE_EXPERIMENTAL_STATE_TRACKING && !this._spanContext._tags['service.name']) {
+    if (this.#parentTracer._config.DD_TRACE_EXPERIMENTAL_STATE_TRACKING && !this._spanContext._tags['service.name']) {
       log.error('Finishing invalid span: %s', this)
     }
 
     getIntegrationCounter('spans_finished', this._integrationName).inc()
     this._spanContext._tags['_dd.integration'] = this._integrationName
 
-    if (DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
+    if (this.#parentTracer._config.DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
       runtimeMetrics.decrement('runtime.node.spans.unfinished')
       runtimeMetrics.decrement('runtime.node.spans.unfinished.by.name', `span_name:${this._name}`)
       runtimeMetrics.increment('runtime.node.spans.finished')
@@ -274,7 +287,11 @@ class DatadogSpan {
       finishedRegistry.register(this, this._name)
     }
 
-    finishTime = Number.parseFloat(finishTime) || this._getTime()
+    // Dominant call site is `span.finish()` with no argument; skip the
+    // `Number.parseFloat` round-trip for the undefined case.
+    finishTime = finishTime === undefined
+      ? this._getTime()
+      : (Number.parseFloat(finishTime) || this._getTime())
 
     this._duration = finishTime - this._startTime
     this._spanContext._trace.finished.push(this)
@@ -283,38 +300,29 @@ class DatadogSpan {
     this._processor.process(this)
   }
 
+  /**
+   * @param {Record<string, unknown>} [attributes]
+   */
   _sanitizeAttributes (attributes = {}) {
-    const sanitizedAttributes = {}
-
-    const addArrayOrScalarAttributes = (key, maybeArray) => {
-      if (Array.isArray(maybeArray)) {
-        for (const subkey in maybeArray) {
-          addArrayOrScalarAttributes(`${key}.${subkey}`, maybeArray[subkey])
-        }
-      } else {
-        const maybeScalar = maybeArray
-        if (ALLOWED.has(typeof maybeScalar)) {
-          // Wrap the value as a string if it's not already a string
-          sanitizedAttributes[key] = typeof maybeScalar === 'string' ? maybeScalar : String(maybeScalar)
-        } else {
-          log.warn('Dropping span link attribute. It is not of an allowed type')
-        }
-      }
+    /** @type {Record<string, string>} */
+    const out = {}
+    for (const key of Object.keys(attributes)) {
+      addArrayOrScalarAttribute(out, key, attributes[key])
     }
-
-    for (const [key, value] of Object.entries(attributes)) {
-      addArrayOrScalarAttributes(key, value)
-    }
-    return sanitizedAttributes
+    return out
   }
 
+  /**
+   * @param {Record<string, unknown>} [attributes]
+   */
   _sanitizeEventAttributes (attributes = {}) {
     const sanitizedAttributes = {}
 
-    for (const [key, value] of Object.entries(attributes)) {
+    for (const key of Object.keys(attributes)) {
+      const value = attributes[key]
       if (Array.isArray(value)) {
         const newArray = []
-        for (const subvalue of Object.values(value)) {
+        for (const subvalue of value) {
           if (ALLOWED.has(typeof subvalue)) {
             newArray.push(subvalue)
           } else {
@@ -336,7 +344,8 @@ class DatadogSpan {
     let startTime
 
     let baggage = {}
-    if (parent && parent._isRemote && this._parentTracer?._config?.tracePropagationBehaviorExtract !== 'continue') {
+    const propagationBehavior = this.#parentTracer._config.DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT
+    if (parent && parent._isRemote && propagationBehavior !== 'continue') {
       baggage = parent._baggageItems
       parent = null
     }
@@ -375,7 +384,7 @@ class DatadogSpan {
           .padEnd(16, '0')
       }
 
-      if (this._parentTracer?._config?.tracePropagationBehaviorExtract === 'restart') {
+      if (propagationBehavior === 'restart') {
         spanContext._baggageItems = baggage
       }
     }

package/packages/dd-trace/src/opentracing/span_context.js

@@ -30,6 +30,7 @@ class DatadogSpanContext {
       tags: {},
     }
     this._otelSpanContext = undefined
+    this._otelActiveSpan = undefined
   }
 
   [util.inspect.custom] () {

package/packages/dd-trace/src/plugins/util/ci.js

@@ -103,42 +103,129 @@ function getGitHubEventPayload () {
   return JSON.parse(readFileSync(path, 'utf8'))
 }
 
-function getJobIDFromDiagFile (runnerTemp) {
-  if (!runnerTemp || !existsSync(runnerTemp)) { return null }
+const uniq = (items) => [...new Set(items)]
+
+/**
+ * GitHub runner diagnostic logs live under the runner installation directory in `_diag`.
+ * On many runners, we can derive the installation directory from RUNNER_TEMP:
+ *   <runnerRoot>/_work/_temp  ->  <runnerRoot>/_diag
+ *
+ * This is much more robust than relying on hardcoded paths, especially on self-hosted runners
+ * and GHES environments where the runner may be installed under arbitrary directories/users.
+ */
+function getGithubDiagnosticDirsFromEnv (runnerTemp) {
+  const dirs = []
+
+  if (runnerTemp) {
+    // RUNNER_TEMP is typically: <runnerRoot>/_work/_temp
+    const runnerRoot = path.resolve(runnerTemp, '..', '..').replaceAll(path.sep, '/')
+    // Bounded-depth patterns cover every runner layout we've observed
+    // (including cached/<version>/_diag) without assuming a `cached` wrapper
+    // and without walking the whole tree.
+    dirs.push(
+      path.posix.join(runnerRoot, 'actions-runner', '_diag'),
+      `${runnerRoot}/actions-runner/*/_diag`,
+      `${runnerRoot}/actions-runner/*/*/_diag`,
+      path.posix.join(runnerRoot, '_diag'),
+      `${runnerRoot}/*/_diag`,
+      `${runnerRoot}/*/*/_diag`
+    )
+  }
 
-  // RUNNER_TEMP usually looks like:
-  // Linux/mac hosted:   /home/runner/work/_temp
-  // Windows hosted:     C:\actions-runner\_work\_temp
-  // Self-hosted (unix): /opt/actions-runner/_work/_temp
+  return uniq(dirs.filter(Boolean))
+}
 
-  const workDir = path.dirname(runnerTemp) // .../work or .../_work
-  const runnerRoot = path.dirname(workDir) // /home/runner/ (runner root)
+function hasMagicChars (str) {
+  return str.includes('*') || str.includes('?')
+}
 
-  const dirs = [
-    path.join(runnerRoot, 'cached', '_diag'),
-    path.join(runnerRoot, '_diag'),
-    path.join(runnerRoot, 'actions-runner', 'cached', '_diag'),
-    path.join(runnerRoot, 'actions-runner', '_diag'),
-  ]
+// Expands a glob pattern with only `*`/`?` at path-segment boundaries (no `**`)
+// into matching concrete paths using readdirSync — no external dependency needed.
+function expandGlobPattern (pattern) {
+  const parts = pattern.split(/[/\\]/)
+  const wildcardIdx = parts.findIndex(p => hasMagicChars(p))
+  if (wildcardIdx === -1) return [pattern]
 
-  const isWin = process.platform === 'win32'
+  const prefix = parts.slice(0, wildcardIdx).join('/')
+  const results = []
 
-  // Hardcoded fallbacks
-  if (isWin) {
-    dirs.push(
-      'C:/actions-runner/cached/_diag',
-      'C:/actions-runner/_diag',
-    )
-  } else {
-    dirs.push(
-      '/home/runner/actions-runner/cached/_diag',
-      '/home/runner/actions-runner/_diag',
-      '/opt/actions-runner/_diag',
-    )
+  function walk (dir, segIdx) {
+    if (segIdx === parts.length) {
+      results.push(dir)
+      return
+    }
+    const seg = parts[segIdx]
+    if (!hasMagicChars(seg)) {
+      walk(`${dir}/${seg}`, segIdx + 1)
+      return
+    }
+    try {
+      const re = new RegExp(
+        '^' + seg.replaceAll(/[.+^${}()|[\]\\]/g, String.raw`\$&`).replaceAll('*', String.raw`[^/\\]*`).replaceAll('?', String.raw`[^/\\]`) + '$'
+      )
+      for (const entry of readdirSync(dir)) {
+        if (re.test(entry)) {
+          walk(`${dir}/${entry}`, segIdx + 1)
+        }
+      }
+    } catch {
+      // directory doesn't exist or isn't accessible
+    }
   }
 
-  // Remove duplicates
-  const possibleDiagsPaths = [...new Set(dirs)]
+  walk(prefix, wildcardIdx)
+  return results
+}
+
+/**
+ * Expands a mixed list of literal directories and glob patterns into concrete
+ * directories. Literals pass through unchanged (existence is checked later).
+ */
+function expandDiagnosticDirCandidates (candidates) {
+  const expanded = []
+  for (const candidate of candidates) {
+    if (hasMagicChars(candidate)) {
+      expanded.push(...expandGlobPattern(candidate))
+    } else {
+      expanded.push(candidate)
+    }
+  }
+
+  return uniq(expanded)
+}
+
+const githubWellKnownDiagnosticDirsUnix = [
+  '/home/runner/actions-runner/_diag',
+  '/opt/actions-runner/_diag',
+]
+const githubWellKnownDiagnosticDirsWin = [
+  'C:/actions-runner/_diag',
+]
+
+// Glob patterns covering layouts that namespace `_diag` under one or two
+// intermediate directories. This includes both observed SaaS layouts
+// (<runnerRoot>/cached/_diag pre-2.334.0, <runnerRoot>/cached/<version>/_diag
+// since v2.334.0) and hypothetical future layouts that follow the same shape
+// without a `cached` wrapper (e.g. <runnerRoot>/<version>/_diag). Depth is
+// bounded on purpose: `*` matches a single segment, so no filesystem walk.
+const githubWellKnownDiagnosticDirPatternsUnix = [
+  '/home/runner/actions-runner/*/_diag',
+  '/home/runner/actions-runner/*/*/_diag',
+]
+const githubWellKnownDiagnosticDirPatternsWin = ['C:/actions-runner/*/_diag', 'C:/actions-runner/*/*/_diag']
+
+const githubJobIDRegex = /"job":\s*{[\s\S]*?"v"\s*:\s*(\d+)(?:\.0)?/
+
+function getJobIDFromDiagFile () {
+  const runnerTemp = getValueFromEnvSources('RUNNER_TEMP')
+  if (!runnerTemp || !existsSync(runnerTemp)) { return null }
+
+  const isWin = process.platform === 'win32'
+  const patterns = isWin ? githubWellKnownDiagnosticDirPatternsWin : githubWellKnownDiagnosticDirPatternsUnix
+  const literals = isWin ? githubWellKnownDiagnosticDirsWin : githubWellKnownDiagnosticDirsUnix
+  const possibleDiagsPaths = expandDiagnosticDirCandidates([
+    ...getGithubDiagnosticDirsFromEnv(runnerTemp), ...patterns, ...literals,
+  ])
 
   // This will hold the names of the worker log files that (potentially) contain the Job ID
   let workerLogFiles = []
@@ -177,7 +264,7 @@ function getJobIDFromDiagFile (runnerTemp) {
     const filePath = path.posix.join(chosenDiagPath, logFile)
     const content = readFileSync(filePath, 'utf8')
 
-    const match = content.match(/"job":\s*{[\s\S]*?"v"\s*:\s*(\d+)(?:\.0)?/)
+    const match = content.match(githubJobIDRegex)
 
     // match[1] is the captured group with the display name
     if (match && match[1]) { return match[1] }
@@ -188,6 +275,7 @@ function getJobIDFromDiagFile (runnerTemp) {
 
 module.exports = {
   normalizeRef,
+  expandGlobPattern,
   getJobIDFromDiagFile,
   getCIMetadata () {
     const env = getEnvironmentVariables()
@@ -366,7 +454,6 @@ module.exports = {
         GITHUB_RUN_ATTEMPT,
         GITHUB_JOB,
         GITHUB_BASE_REF,
-        RUNNER_TEMP,
         JOB_CHECK_RUN_ID,
       } = env
 
@@ -378,7 +465,7 @@ module.exports = {
       }
 
       // Build the job url extracting the job ID. If extraction fails, job url is constructed as a generalized url
-      const GITHUB_JOB_ID = JOB_CHECK_RUN_ID ?? getJobIDFromDiagFile(RUNNER_TEMP)
+      const GITHUB_JOB_ID = JOB_CHECK_RUN_ID ?? getJobIDFromDiagFile()
       const jobUrl =
         GITHUB_JOB_ID === null
           ? `${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/commit/${GITHUB_SHA}/checks`