dd-trace 5.108.0 → 5.110.0

package/packages/dd-trace/src/debugger/devtools_client/probe_sampler.js

@@ -0,0 +1,83 @@
+'use strict'
+
+const { DD_TRACE_SYMBOL, PROBE_SAMPLER_SYMBOL } = require('../probe_sampler_constants')
+
+const SAMPLER_EXPRESSION = `globalThis[Symbol.for(${JSON.stringify(DD_TRACE_SYMBOL)})]?.` +
+  `[Symbol.for(${JSON.stringify(PROBE_SAMPLER_SYMBOL)})]`
+
+module.exports = {
+  compileBreakpointCondition,
+  getRemoveProbeExpression,
+}
+
+/**
+ * Build the expression that removes a probe from runtime sampler state. Called by the devtools worker and evaluated on
+ * the debuggee.
+ *
+ * @param {string} id - The probe id.
+ * @returns {string}
+ */
+function getRemoveProbeExpression (id) {
+  return `${SAMPLER_EXPRESSION}?.remove(${JSON.stringify(id)})`
+}
+
+/**
+ * Build a Chrome DevTools breakpoint condition that samples all matching probes at a location. Called by the devtools
+ * worker.
+ *
+ * @param {{
+ *   id: string,
+ *   samplingIndex: number,
+ *   nsBetweenSampling: bigint,
+ *   condition?: string,
+ *   captureSnapshot?: boolean,
+ *   compiledCaptureExpressions?: object[]
+ * }[]} probes - The probes at the breakpoint location.
+ * @returns {string}
+ */
+function compileBreakpointCondition (probes) {
+  const probeConditions = []
+  for (const probe of probes) {
+    probeConditions.push(compileProbeCondition(probe))
+  }
+
+  // NOTE: $dd_sampler is read from the realm-local `globalThis` where it was installed (the main
+  // realm). A probe whose code runs in a different V8 realm (e.g. a `vm.createContext` script with a
+  // file-path filename) won't see it and will silently never fire. Known limitation: a breakpoint
+  // condition has no realm-independent handle to reach, so we degrade rather than crash.
+  return `(() => {
+    const $dd_sampler = ${SAMPLER_EXPRESSION}
+    if ($dd_sampler === undefined) return false
+    let $dd_sampled = false
+    ${probeConditions.join('\n    ')}
+    return $dd_sampled
+  })()`
+}
+
+/**
+ * Build the condition fragment for a single probe. Called by the devtools worker while building breakpoint conditions.
+ *
+ * @param {{
+ *   id: string,
+ *   samplingIndex: number,
+ *   nsBetweenSampling: bigint,
+ *   condition?: string,
+ *   captureSnapshot?: boolean,
+ *   compiledCaptureExpressions?: object[]
+ * }} probe - The probe to sample.
+ * @returns {string}
+ */
+function compileProbeCondition (probe) {
+  const sample = `$dd_sampler.makeSampleDecision(${probe.samplingIndex}, ${JSON.stringify(probe.id)}, ` +
+    `${probe.nsBetweenSampling}n, ${probe.captureSnapshot === true || probe.compiledCaptureExpressions !== undefined})`
+
+  if (probe.condition === undefined) {
+    return `$dd_sampled = ${sample} || $dd_sampled`
+  }
+
+  return `try {
+      if ((${probe.condition}) === true) {
+        $dd_sampled = ${sample} || $dd_sampled
+      }
+    } catch {}`
+}

package/packages/dd-trace/src/debugger/devtools_client/state.js

@@ -33,6 +33,7 @@ module.exports = {
   locationToBreakpoint: new Map(),
   breakpointToProbes: new Map(),
   probeToLocation: new Map(),
+  samplingIndexToProbe: new Map(),
 
   _loadedScripts: loadedScripts, // Only exposed for testing
   _scriptUrls: scriptUrls, // Only exposed for testing

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

@@ -8,6 +8,7 @@ const log = require('../log')
 const { fetchAgentInfo } = require('../agent/info')
 const getDebuggerConfig = require('./config')
 const { DEBUGGER_DIAGNOSTICS_V1, DEBUGGER_INPUT_V2 } = require('./constants')
+const { installProbeSampler, uninstallProbeSampler } = require('./probe_sampler')
 
 /**
  * @typedef {ReturnType<import('../config')>} Config
@@ -65,6 +66,8 @@ function start (config, rcInstance) {
 
   globalThis[Symbol.for('dd-trace')].utilTypes = types
 
+  const probeSamplerBuffer = installProbeSampler()
+
   readProbeFile(config.dynamicInstrumentation.probeFile, (probes) => {
     const action = 'apply'
     for (const probe of probes) {
@@ -110,6 +113,7 @@ function start (config, rcInstance) {
           probePort: probeChannel.port1,
           logPort: logChannel.port1,
           configPort: configChannel.port1,
+          probeSamplerBuffer,
         },
         transferList: [probeChannel.port1, logChannel.port1, configChannel.port1],
       }
@@ -187,6 +191,7 @@ function cleanup (error) {
     worker.removeAllListeners()
     worker = null
   }
+  uninstallProbeSampler()
   configChannel = null
   inputPath = null
 

package/packages/dd-trace/src/debugger/probe_sampler.js

@@ -0,0 +1,112 @@
+'use strict'
+
+const { MAX_SNAPSHOTS_PER_SECOND_GLOBALLY } = require('./devtools_client/defaults')
+const {
+  DD_TRACE_SYMBOL,
+  MAX_SAMPLED_PROBES_PER_PAUSE,
+  PROBE_SAMPLER_SYMBOL,
+  SAMPLED_PROBE_COUNT_INDEX,
+  SAMPLED_PROBE_INDEXES_START,
+  SAMPLED_PROBE_OVERFLOW_INDEX,
+} = require('./probe_sampler_constants')
+
+const ddTraceGlobal = /** @type {Record<symbol, SharedArrayBuffer | object | undefined>} */ (
+  /** @type {Record<symbol, unknown>} */ (globalThis)[Symbol.for(DD_TRACE_SYMBOL)]
+)
+
+module.exports = {
+  installProbeSampler,
+  uninstallProbeSampler,
+}
+
+/**
+ * Install the runtime sampler in the debuggee context.
+ *
+ * @returns {SharedArrayBuffer} The shared sampler buffer to pass to the debugger worker.
+ */
+function installProbeSampler () {
+  const buffer = createProbeSamplerBuffer()
+
+  const lastCaptureNsByProbeId = new Map()
+  const sampledProbeIndexes = new Int32Array(buffer)
+  Atomics.store(sampledProbeIndexes, SAMPLED_PROBE_COUNT_INDEX, 0)
+  Atomics.store(sampledProbeIndexes, SAMPLED_PROBE_OVERFLOW_INDEX, 0)
+
+  const oneSecondNs = 1_000_000_000n
+  let globalSnapshotSamplingRateWindowStart = 0n
+  let snapshotsSampledWithinTheLastSecond = 0
+
+  ddTraceGlobal[Symbol.for(PROBE_SAMPLER_SYMBOL)] = {
+    /**
+     * Decide if a probe should be sampled and store sampled probe indexes for the debugger worker.
+     *
+     * @param {number} probeIndex - The worker-side probe sampling index.
+     * @param {string} probeId - The probe id.
+     * @param {bigint} nsBetweenSampling - Minimum nanoseconds between samples for this probe.
+     * @param {boolean} isSnapshotProducingProbe - Whether this probe counts toward the global snapshot sample limit.
+     * @returns {boolean} Whether this probe should make the breakpoint condition pause.
+     */
+    makeSampleDecision (probeIndex, probeId, nsBetweenSampling, isSnapshotProducingProbe) {
+      const now = process.hrtime.bigint()
+      const lastCaptureNs = lastCaptureNsByProbeId.get(probeId)
+      if (lastCaptureNs !== undefined && now - lastCaptureNs < nsBetweenSampling) return false
+
+      let shouldResetGlobalSnapshotRateWindow = false
+      if (isSnapshotProducingProbe === true) {
+        if (now - globalSnapshotSamplingRateWindowStart > oneSecondNs) {
+          shouldResetGlobalSnapshotRateWindow = true
+        } else if (snapshotsSampledWithinTheLastSecond >= MAX_SNAPSHOTS_PER_SECOND_GLOBALLY) {
+          return false
+        }
+      }
+
+      const sampledProbeCount = Atomics.add(sampledProbeIndexes, SAMPLED_PROBE_COUNT_INDEX, 1)
+      if (sampledProbeCount >= MAX_SAMPLED_PROBES_PER_PAUSE) {
+        Atomics.store(sampledProbeIndexes, SAMPLED_PROBE_OVERFLOW_INDEX, 1)
+        return false
+      }
+
+      if (isSnapshotProducingProbe === true) {
+        if (shouldResetGlobalSnapshotRateWindow === true) {
+          snapshotsSampledWithinTheLastSecond = 1
+          globalSnapshotSamplingRateWindowStart = now
+        } else {
+          snapshotsSampledWithinTheLastSecond++
+        }
+      }
+
+      lastCaptureNsByProbeId.set(probeId, now)
+      Atomics.store(sampledProbeIndexes, SAMPLED_PROBE_INDEXES_START + sampledProbeCount, probeIndex)
+      return true
+    },
+
+    /**
+     * Remove cached sampling state for a probe.
+     *
+     * @param {string} probeId - The probe id.
+     */
+    remove (probeId) {
+      lastCaptureNsByProbeId.delete(probeId)
+    },
+  }
+
+  return buffer
+}
+
+/**
+ * Remove the runtime sampler from the debuggee context.
+ */
+function uninstallProbeSampler () {
+  delete ddTraceGlobal[Symbol.for(PROBE_SAMPLER_SYMBOL)]
+}
+
+/**
+ * Create the shared buffer used to hand sampled probe indexes from breakpoint conditions to the debugger worker.
+ *
+ * @returns {SharedArrayBuffer}
+ */
+function createProbeSamplerBuffer () {
+  return new SharedArrayBuffer(
+    (SAMPLED_PROBE_INDEXES_START + MAX_SAMPLED_PROBES_PER_PAUSE) * Int32Array.BYTES_PER_ELEMENT
+  )
+}

package/packages/dd-trace/src/debugger/probe_sampler_constants.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const DD_TRACE_SYMBOL = 'dd-trace'
+const PROBE_SAMPLER_SYMBOL = 'dd-trace.debugger.probeSampler'
+
+// Shared sampler contract used by the main debugger bootstrap and the devtools worker.
+const MAX_SAMPLED_PROBES_PER_PAUSE = 256
+const SAMPLED_PROBE_COUNT_INDEX = 0
+const SAMPLED_PROBE_OVERFLOW_INDEX = 1
+const SAMPLED_PROBE_INDEXES_START = 2
+
+module.exports = {
+  DD_TRACE_SYMBOL,
+  MAX_SAMPLED_PROBES_PER_PAUSE,
+  PROBE_SAMPLER_SYMBOL,
+  SAMPLED_PROBE_COUNT_INDEX,
+  SAMPLED_PROBE_INDEXES_START,
+  SAMPLED_PROBE_OVERFLOW_INDEX,
+}

package/packages/dd-trace/src/dogstatsd.js

@@ -3,11 +3,14 @@
 const dgram = require('dgram')
 const isIP = require('net').isIP
 
+const { storage } = require('../../datadog-core')
 const request = require('./exporters/common/request')
 const log = require('./log')
 const Histogram = require('./histogram')
 const { entityId } = require('./exporters/common/docker')
 
+const legacyStorage = storage('legacy')
+
 const MAX_BUFFER_SIZE = 1024 // limit from the agent
 
 const TYPE_COUNTER = 'c'
@@ -98,14 +101,18 @@ class DogStatsDClient {
   }
 
   _sendUdp (queue) {
-    if (this._family === 0) {
-      this.#lookup(this._host, (err, address, family) => {
-        if (err) return log.error('DogStatsDClient: Host not found', err)
-        this._sendUdpFromQueue(queue, address, family)
-      })
-    } else {
-      this._sendUdpFromQueue(queue, this._host, this._family)
-    }
+    // dgram resolves the local address via the instrumented dns.lookup when it
+    // binds on first send; the noop store keeps that self-traffic off the trace.
+    legacyStorage.run({ noop: true }, () => {
+      if (this._family === 0) {
+        this.#lookup(this._host, (error, address, family) => {
+          if (error) return log.error('DogStatsDClient: Host not found', error)
+          this._sendUdpFromQueue(queue, address, family)
+        })
+      } else {
+        this._sendUdpFromQueue(queue, this._host, this._family)
+      }
+    })
   }
 
   _sendUdpFromQueue (queue, address, family) {

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

@@ -1,6 +1,6 @@
 'use strict'
 const { version: ddTraceVersion } = require('../../../../package.json')
-const { ITR_CORRELATION_ID } = require('../../src/plugins/util/test')
+const { ITR_CORRELATION_ID, TEST_LEVELS_METADATA } = require('../../src/plugins/util/test')
 const id = require('../../src/id')
 const {
   distributionMetric,
@@ -9,10 +9,15 @@ const {
 } = require('../ci-visibility/telemetry')
 const { MsgpackChunk } = require('../msgpack')
 const { AgentEncoder } = require('./0.4')
-const { truncateSpanTestOpt, normalizeSpan } = require('./tags-processors')
+const {
+  truncateSpanTestOpt,
+  normalizeSpan,
+  MAX_META_VALUE_LENGTH_TEST_OPTIMIZATION,
+} = require('./tags-processors')
 
 const ENCODING_VERSION = 1
 const ALLOWED_CONTENT_TYPES = new Set(['test_session_end', 'test_module_end', 'test_suite_end', 'test'])
+const ALLOWED_METADATA_TARGETS = new Set([...ALLOWED_CONTENT_TYPES, TEST_LEVELS_METADATA])
 
 const TEST_SUITE_KEYS_LENGTH = 12
 const TEST_MODULE_KEYS_LENGTH = 11
@@ -36,6 +41,33 @@ function formatSpan (span) {
   }
 }
 
+function isAllowedMetadataTarget (target) {
+  return ALLOWED_METADATA_TARGETS.has(target)
+}
+
+function isEncodableMetadataValue (value) {
+  return typeof value === 'string' || typeof value === 'number'
+}
+
+function truncateTestLevelMetadataValue (value) {
+  if (typeof value !== 'string' || value.length <= MAX_META_VALUE_LENGTH_TEST_OPTIMIZATION) {
+    return value
+  }
+  return `${value.slice(0, MAX_META_VALUE_LENGTH_TEST_OPTIMIZATION)}...`
+}
+
+function truncateTestLevelMetadataTags (tags) {
+  const truncatedTags = {}
+  let hasTags = false
+  for (const key of Object.keys(tags)) {
+    const value = truncateTestLevelMetadataValue(tags[key])
+    if (!isEncodableMetadataValue(value)) continue
+    truncatedTags[key] = value
+    hasTags = true
+  }
+  return hasTags ? truncatedTags : undefined
+}
+
 class AgentlessCiVisibilityEncoder extends AgentEncoder {
   constructor (writer, { runtimeId, service, env }) {
     super(writer, INTAKE_SOFT_LIMIT)
@@ -49,6 +81,7 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
 
     this.metadataTags = {}
     this.wildcardMetadataTags = {}
+    this.testLevelsMetadataKeys = []
 
     this.reset()
   }
@@ -60,12 +93,39 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
         ...tags['*'],
       }
     }
-    for (const type of ALLOWED_CONTENT_TYPES) {
-      if (tags[type]) {
-        this.metadataTags[type] = {
-          ...this.metadataTags[type],
-          ...tags[type],
-        }
+
+    for (const target of Object.keys(tags)) {
+      if (target === '*' || !tags[target] || !isAllowedMetadataTarget(target)) continue
+
+      const targetTags = target === TEST_LEVELS_METADATA
+        ? truncateTestLevelMetadataTags(tags[target])
+        : tags[target]
+      if (!targetTags) continue
+
+      this.metadataTags[target] = {
+        ...this.metadataTags[target],
+        ...targetTags,
+      }
+
+      if (target === TEST_LEVELS_METADATA) {
+        this.testLevelsMetadataKeys = Object.keys(this.metadataTags[target])
+      }
+    }
+  }
+
+  _removeDuplicateTestLevelsMetadata (event) {
+    if (!ALLOWED_CONTENT_TYPES.has(event.type)) return
+
+    const meta = event.content.meta
+    if (!meta) return
+
+    const testLevelsMetadataTags = this.metadataTags[TEST_LEVELS_METADATA]
+    const testLevelsMetadataKeys = this.testLevelsMetadataKeys
+
+    for (let i = 0; i < testLevelsMetadataKeys.length; i++) {
+      const key = testLevelsMetadataKeys[i]
+      if (meta[key] === testLevelsMetadataTags[key]) {
+        delete meta[key]
       }
     }
   }
@@ -276,7 +336,11 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
 
     this._eventCount += events.length
 
+    const hasTestLevelsMetadata = this.testLevelsMetadataKeys.length !== 0
     for (const event of events) {
+      if (hasTestLevelsMetadata) {
+        this._removeDuplicateTestLevelsMetadata(event)
+      }
       this._encodeEvent(bytes, event)
     }
     distributionMetric(
@@ -343,24 +407,11 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     this._encodeString(bytes, 'version')
     bytes.writeNumber(payload.version)
     this._encodeString(bytes, 'metadata')
-    bytes.writeMapPrefix(Object.keys(payload.metadata).length)
-    this._encodeString(bytes, '*')
-    this._encodeMap(bytes, payload.metadata['*'])
-    if (payload.metadata.test) {
-      this._encodeString(bytes, 'test')
-      this._encodeMap(bytes, payload.metadata.test)
-    }
-    if (payload.metadata.test_suite_end) {
-      this._encodeString(bytes, 'test_suite_end')
-      this._encodeMap(bytes, payload.metadata.test_suite_end)
-    }
-    if (payload.metadata.test_module_end) {
-      this._encodeString(bytes, 'test_module_end')
-      this._encodeMap(bytes, payload.metadata.test_module_end)
-    }
-    if (payload.metadata.test_session_end) {
-      this._encodeString(bytes, 'test_session_end')
-      this._encodeMap(bytes, payload.metadata.test_session_end)
+    const metadataKeys = Object.keys(payload.metadata)
+    bytes.writeMapPrefix(metadataKeys.length)
+    for (const metadataKey of metadataKeys) {
+      this._encodeString(bytes, metadataKey)
+      this._encodeMap(bytes, payload.metadata[metadataKey])
     }
     this._encodeString(bytes, 'events')
     this._eventsOffset = bytes.length

package/packages/dd-trace/src/exporters/agentless/index.js

@@ -7,6 +7,7 @@ const log = require('../../log')
 const { entityId } = require('../common/docker')
 const tracerVersion = require('../../../../../package.json').version
 const Writer = require('./writer')
+const { computeIntakeUrl } = require('./intake')
 
 /**
  * Agentless exporter for APM trace intake.
@@ -15,6 +16,7 @@ const Writer = require('./writer')
  */
 class AgentlessExporter {
   #timer
+  #config
 
   /**
    * @param {object} config - Configuration object
@@ -24,13 +26,13 @@ class AgentlessExporter {
    * @param {object} [config.tags] - Tags including runtime-id
    */
   constructor (config) {
-    this._config = config
+    this.#config = config
     const site = config.site ?? 'datadoghq.com'
 
     try {
-      // Agentless traffic carries the Datadog API key, so the intake is always the public https
-      // endpoint; never derive it from config.url (the agent's cleartext http) or the key leaks.
-      this._url = new URL(`https://public-trace-http-intake.logs.${site}`)
+      // Agentless traffic carries the Datadog API key, so the intake is always an https endpoint
+      // derived from the site; never config.url (the agent's cleartext http) or the key leaks.
+      this._url = new URL(computeIntakeUrl(site))
     } catch (err) {
       log.error('Invalid site for agentless exporter. site=%s. Error: %s', site, err.message)
       this._url = null
@@ -89,7 +91,7 @@ class AgentlessExporter {
   export (spans) {
     this._writer.append(spans)
 
-    const { flushInterval } = this._config
+    const { flushInterval } = this.#config
 
     if (flushInterval === 0) {
       try {

package/packages/dd-trace/src/exporters/agentless/intake.js

@@ -0,0 +1,43 @@
+'use strict'
+
+// Per-site hosts for the agentless JSON span intake. Regional data centers serve it from
+// browser-intake-* hosts rather than public-trace-http-intake.logs.<site>, so a single template
+// silently drops spans on us3/us5/ap1/ap2. Mirrors dd-trace-py's AgentlessTraceWriter.INTAKE_URLS
+// (DataDog/dd-trace-py#18514).
+const INTAKE_URLS = {
+  'datadoghq.com': 'https://public-trace-http-intake.logs.datadoghq.com',
+  'datadoghq.eu': 'https://public-trace-http-intake.logs.datadoghq.eu',
+  'us3.datadoghq.com': 'https://trace.browser-intake-us3-datadoghq.com',
+  'us5.datadoghq.com': 'https://trace.browser-intake-us5-datadoghq.com',
+  'ap1.datadoghq.com': 'https://browser-intake-ap1-datadoghq.com',
+  'ap2.datadoghq.com': 'https://browser-intake-ap2-datadoghq.com',
+  'uk1.datadoghq.com': 'https://browser-intake-uk1-datadoghq.com',
+  'datad0g.com': 'https://public-trace-http-intake.logs.datad0g.com',
+}
+
+// Path of the JSON span intake on every intake host.
+const INTAKE_PATH = '/api/v2/spans'
+
+/**
+ * Resolves the agentless intake origin for a Datadog site.
+ *
+ * Unknown sites fall back to the browser-intake naming: strip the TLD, dash-join the rest, then
+ * reattach the TLD, e.g. 'us2.ddog-gov.com' -> 'https://browser-intake-us2-ddog-gov.com'.
+ *
+ * @param {string} [site] - The Datadog site, e.g. 'us3.datadoghq.com'. Defaults to 'datadoghq.com'.
+ * @returns {string} The intake origin, without a path.
+ */
+function computeIntakeUrl (site = 'datadoghq.com') {
+  const normalized = site.toLowerCase()
+  const known = INTAKE_URLS[normalized]
+  if (known !== undefined) {
+    return known
+  }
+
+  const lastDot = normalized.lastIndexOf('.')
+  const prefix = lastDot === -1 ? '' : normalized.slice(0, lastDot)
+  const tld = lastDot === -1 ? normalized : normalized.slice(lastDot + 1)
+  return `https://browser-intake-${prefix.replaceAll('.', '-')}.${tld}`
+}
+
+module.exports = { INTAKE_URLS, INTAKE_PATH, computeIntakeUrl }

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

@@ -7,6 +7,7 @@ const tracerVersion = require('../../../../../package.json').version
 
 const BaseWriter = require('../common/writer')
 const { AgentlessJSONEncoder } = require('../../encode/agentless-json')
+const { computeIntakeUrl, INTAKE_PATH } = require('./intake')
 
 /**
  * Writer for agentless APM trace intake.
@@ -28,7 +29,7 @@ class AgentlessWriter extends BaseWriter {
 
     if (!url) {
       try {
-        this._url = new URL(`https://public-trace-http-intake.logs.${site}`)
+        this._url = new URL(computeIntakeUrl(site))
       } catch (err) {
         log.error(
           'Invalid site value for agentless intake: %s. Cannot construct URL. Error: %s',
@@ -121,7 +122,7 @@ class AgentlessWriter extends BaseWriter {
     this.#apiKeyMissing = false
 
     const options = {
-      path: '/v1/input',
+      path: INTAKE_PATH,
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -140,7 +141,7 @@ class AgentlessWriter extends BaseWriter {
 
     request(data, options, (err, res, statusCode) => {
       if (err) {
-        this._logRequestError(err, statusCode, count)
+        this.#logRequestError(err, statusCode, count)
         done()
         return
       }
@@ -156,7 +157,7 @@ class AgentlessWriter extends BaseWriter {
    * @param {number} statusCode - HTTP status code (if available)
    * @param {number} count - Number of traces that were being sent
    */
-  _logRequestError (err, statusCode, count) {
+  #logRequestError (err, statusCode, count) {
     if (statusCode === 401 || statusCode === 403) {
       log.error(
         'Authentication failed sending %d trace(s) (status %s). Verify DD_API_KEY is valid.',

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

@@ -11,7 +11,7 @@ const zlib = require('zlib')
 
 const { storage } = require('../../../../datadog-core')
 const log = require('../../log')
-const { urlToHttpOptions } = require('./url-to-http-options-polyfill')
+const { parseUrl } = require('./url')
 const docker = require('./docker')
 const { httpAgent, httpsAgent } = require('./agents')
 const {
@@ -27,25 +27,6 @@ const maxActiveBufferSize = 1024 * 1024 * 64
 
 let activeBufferSize = 0
 
-/**
- * @param {string|URL|object} urlObjOrString
- * @returns {object}
- */
-function parseUrl (urlObjOrString) {
-  if (urlObjOrString !== null && typeof urlObjOrString === 'object') return urlToHttpOptions(urlObjOrString)
-
-  const url = urlToHttpOptions(new URL(urlObjOrString))
-
-  // Special handling if we're using named pipes on Windows
-  if (url.protocol === 'unix:' && url.hostname === '.') {
-    const udsPath = urlObjOrString.slice(5)
-    url.path = udsPath
-    url.pathname = udsPath
-  }
-
-  return url
-}
-
 /**
  * @param {string} hostname Host as resolved by {@link parseUrl}; IPv6 is unbracketed (`::1`).
  */

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

@@ -0,0 +1,34 @@
+'use strict'
+
+const { urlToHttpOptions } = require('./url-to-http-options-polyfill')
+
+/**
+ * Convert an agent/intake URL into Node http(s) request options.
+ *
+ * A Windows named pipe (`unix://./pipe/<name>`) parses the `.` as the URL
+ * authority, dropping it from the path. Fold it back so the socket path stays
+ * `//./pipe/<name>`; otherwise it collapses to `/pipe/<name>` and misses the
+ * pipe. Exporters receive `config.url` as a URL object, so this must run for
+ * both string and object input.
+ *
+ * @param {string|URL|object} urlObjOrString
+ * @returns {object}
+ */
+function parseUrl (urlObjOrString) {
+  // `urlToHttpOptions` returns `pathname` at runtime, but @types/node narrows it
+  // to `ClientRequestArgs`, which omits it; cast so the named-pipe fold below can
+  // read and rewrite it.
+  const url = /** @type {import('node:http').ClientRequestArgs & { pathname: string }} */ (
+    urlObjOrString !== null && typeof urlObjOrString === 'object'
+      ? urlToHttpOptions(urlObjOrString)
+      : urlToHttpOptions(new URL(urlObjOrString))
+  )
+
+  if (url.protocol === 'unix:' && url.hostname === '.') {
+    url.path = url.pathname = `//.${url.pathname}`
+  }
+
+  return url
+}
+
+module.exports = { parseUrl }

package/packages/dd-trace/src/exporters/span-stats/writer.js

@@ -37,9 +37,7 @@ function makeRequest (data, url, cb) {
       'Datadog-Meta-Tracer-Version': pkg.version,
       'Content-Type': 'application/msgpack',
     },
-    protocol: url.protocol,
-    hostname: url.hostname,
-    port: url.port,
+    url,
   }
 
   log.debug('Request to the intake: %j', options)