dd-trace 6.11.0 → 6.12.0

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

@@ -4,4 +4,5 @@ module.exports = {
   DEBUGGER_DIAGNOSTICS_V1: '/debugger/v1/diagnostics',
   DEBUGGER_INPUT_V1: '/debugger/v1/input',
   DEBUGGER_INPUT_V2: '/debugger/v2/input',
+  INSPECT_SEGMENT_GLOBAL_PROPERTY: 'debuggerInspectSegment',
 }

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

@@ -55,7 +55,7 @@ function compileSegments (segments) {
       ? `(() => {
           try {
             const result = ${compile(json)}
-            return typeof result === 'string' ? result : $dd_inspect(result, $dd_segmentInspectOptions)
+            return typeof result === 'string' ? result : $dd_inspectSegment(result)
           } catch (e) {
             return { expr: ${JSON.stringify(dsl)}, message: \`\${e.name}: \${e.message}\` }
           }

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

@@ -4,6 +4,7 @@ const { randomUUID } = require('crypto')
 const { workerData: { probeSamplerBuffer } } = require('worker_threads')
 const { version } = require('../../../../../package.json')
 const processTags = require('../../process-tags')
+const { INSPECT_SEGMENT_GLOBAL_PROPERTY } = require('../constants')
 const {
   MAX_SAMPLED_PROBES_PER_PAUSE,
   SAMPLED_PROBE_COUNT_INDEX,
@@ -23,16 +24,8 @@ require('./remote_config')
 
 /** @typedef {import('node:inspector').Debugger.EvaluateOnCallFrameReturnType} EvaluateOnCallFrameResult */
 
-const templateExpressionSetupCode = `
-  const $dd_inspect = global.require('node:util').inspect;
-  const $dd_segmentInspectOptions = {
-    depth: 0,
-    customInspect: false,
-    maxArrayLength: 3,
-    maxStringLength: 8 * 1024,
-    breakLength: Infinity
-  };
-`
+const templateExpressionSetupCode = 'const $dd_inspectSegment = ' +
+  `globalThis[Symbol.for('dd-trace')][${JSON.stringify(INSPECT_SEGMENT_GLOBAL_PROPERTY)}];`
 
 // Expression to run on a call frame of the paused thread to get its active trace and span id.
 const getDDTagsExpression = `(() => {

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

@@ -7,7 +7,7 @@ const { Worker, MessageChannel, threadId: parentThreadId } = require('worker_thr
 const log = require('../log')
 const { fetchAgentInfo } = require('../agent/info')
 const getDebuggerConfig = require('./config')
-const { DEBUGGER_DIAGNOSTICS_V1, DEBUGGER_INPUT_V2 } = require('./constants')
+const { DEBUGGER_DIAGNOSTICS_V1, DEBUGGER_INPUT_V2, INSPECT_SEGMENT_GLOBAL_PROPERTY } = require('./constants')
 const { installProbeSampler, uninstallProbeSampler } = require('./probe_sampler')
 
 /**
@@ -64,7 +64,9 @@ function start (config, rcInstance) {
   const logChannel = new MessageChannel()
   configChannel = new MessageChannel()
 
-  globalThis[Symbol.for('dd-trace')].utilTypes = types
+  const debuggerGlobals = globalThis[Symbol.for('dd-trace')]
+  debuggerGlobals.utilTypes = types
+  debuggerGlobals[INSPECT_SEGMENT_GLOBAL_PROPERTY] = require('./inspect-segment')
 
   const probeSamplerBuffer = installProbeSampler()
 

package/packages/dd-trace/src/debugger/inspect-segment.js

@@ -0,0 +1,154 @@
+'use strict'
+
+const { inspect, types } = require('node:util')
+
+const { NODE_MAJOR } = require('../../../../version')
+
+/** @typedef {NonNullable<ReturnType<typeof globalThis.Object.getOwnPropertyDescriptor>>} PropertyDescriptor */
+/** @typedef {Map<unknown, unknown> | Set<unknown>} Collection */
+
+const mapEntries = Map.prototype.entries
+const mapSet = Map.prototype.set
+const mapSizeGetter = Object.getOwnPropertyDescriptor(Map.prototype, 'size').get
+const setAdd = Set.prototype.add
+const setSizeGetter = Object.getOwnPropertyDescriptor(Set.prototype, 'size').get
+const setValues = Set.prototype.values
+const mapIteratorNext = Object.getPrototypeOf(mapEntries.call(new Map())).next
+const setIteratorNext = Object.getPrototypeOf(setValues.call(new Set())).next
+
+const maxCollectionEntries = 3
+const maxProperties = 5
+const segmentInspectOptions = {
+  depth: 0,
+  customInspect: false,
+  maxArrayLength: maxCollectionEntries,
+  maxStringLength: 8 * 1024,
+  breakLength: Infinity,
+}
+
+module.exports = inspectSegment
+
+/**
+ * Inspect a dynamic-instrumentation template value without invoking user code.
+ * Unlike collections, `util.inspect` has no option for limiting the number of object properties, so this function
+ * truncates objects before inspecting them.
+ *
+ * @param {unknown} value
+ * @returns {string}
+ */
+function inspectSegment (value) {
+  if (value === null || (typeof value !== 'object' && typeof value !== 'function')) {
+    return inspect(value, segmentInspectOptions)
+  }
+  if (types.isProxy(value)) return '[Proxy]'
+  if (types.isMap(value)) return inspectCollection(value, true)
+  if (types.isSet(value)) return inspectCollection(value, false)
+  if (
+    Array.isArray(value) ||
+    types.isTypedArray(value) ||
+    types.isAnyArrayBuffer(value) ||
+    types.isDataView(value) ||
+    types.isWeakMap(value) ||
+    types.isWeakSet(value) ||
+    types.isMapIterator(value) ||
+    types.isSetIterator(value)
+  ) {
+    return inspect(value, segmentInspectOptions)
+  }
+
+  /** @type {(string | symbol)[]} */
+  const keys = Object.keys(value)
+  let propertyCount = keys.length
+  const symbols = Object.getOwnPropertySymbols(value)
+  for (let i = 0; i < symbols.length; i++) {
+    if (Object.getOwnPropertyDescriptor(value, symbols[i])?.enumerable === true) {
+      propertyCount++
+      if (keys.length < maxProperties) keys.push(symbols[i])
+    }
+  }
+
+  if (propertyCount <= maxProperties) {
+    // TODO: Decide whether allowing util.inspect to invoke Symbol.toStringTag getters is acceptable. If it is,
+    // remove inspectionCanRunUserCode and the related omission paths.
+    if (inspectionCanRunUserCode(value)) {
+      return '[Value omitted: inspection may execute user code]'
+    }
+    return inspect(value, segmentInspectOptions)
+  }
+
+  const truncated = {}
+  for (let i = 0; i < maxProperties; i++) {
+    const descriptor = /** @type {PropertyDescriptor} */ (Object.getOwnPropertyDescriptor(value, keys[i]))
+    if (
+      (keys[i] === Symbol.toStringTag && descriptor.get !== undefined) ||
+      (descriptor.value !== value && inspectionCanRunUserCode(descriptor.value))
+    ) {
+      return '[Value omitted: inspection may execute user code]'
+    }
+    if (descriptor.value === value) descriptor.value = truncated
+    Object.defineProperty(truncated, keys[i], descriptor)
+  }
+
+  const omitted = propertyCount - maxProperties
+  const inspected = inspect(truncated, segmentInspectOptions)
+  return `${inspected.slice(0, -2)}, ... ${omitted} more ${omitted === 1 ? 'property' : 'properties'} }`
+}
+
+/**
+ * Inspect a Map or Set while bounding the number of entries on Node.js 18, where `util.inspect` does not.
+ *
+ * @param {Collection} value
+ * @param {boolean} isMap
+ * @returns {string}
+ */
+function inspectCollection (value, isMap) {
+  if (NODE_MAJOR !== 18) return inspect(value, segmentInspectOptions)
+
+  const size = (isMap ? mapSizeGetter : setSizeGetter).call(value)
+  if (size <= maxCollectionEntries) return inspect(value, segmentInspectOptions)
+
+  const truncated = isMap ? new Map() : new Set()
+  const iterator = (isMap ? mapEntries : setValues).call(value)
+  const iteratorNext = isMap ? mapIteratorNext : setIteratorNext
+
+  for (let i = 0; i < maxCollectionEntries; i++) {
+    const result = iteratorNext.call(iterator)
+    if (result.done) break
+
+    if (isMap) {
+      const entry = result.value
+      const key = entry[0] === value ? truncated : entry[0]
+      const entryValue = entry[1] === value ? truncated : entry[1]
+      mapSet.call(truncated, key, entryValue)
+    } else {
+      const entryValue = result.value === value ? truncated : result.value
+      setAdd.call(truncated, entryValue)
+    }
+  }
+
+  const type = isMap ? 'Map' : 'Set'
+  const inspected = inspect(truncated, segmentInspectOptions)
+  const normalized = inspected.replace(`${type}(${maxCollectionEntries})`, `${type}(${size})`)
+  const remaining = size - maxCollectionEntries
+  return `${normalized.slice(0, -2)}, ... ${remaining} more item${remaining === 1 ? '' : 's'} }`
+}
+
+/**
+ * Determine whether inspecting a value could invoke a proxy trap or toStringTag getter.
+ *
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+function inspectionCanRunUserCode (value) {
+  const type = typeof value
+  if (value === null || (type !== 'object' && type !== 'function')) return false
+  if (types.isProxy(value)) return true
+
+  let current = value
+  while (current !== null) {
+    if (Object.getOwnPropertyDescriptor(current, Symbol.toStringTag)?.get !== undefined) return true
+    current = Object.getPrototypeOf(current)
+    if (types.isProxy(current)) return true
+  }
+  return false
+}

package/packages/dd-trace/src/evp_proxy/constants.js

@@ -0,0 +1,8 @@
+'use strict'
+
+module.exports = {
+  EVP_PROXY_PATH_V2: '/evp_proxy/v2',
+  EVP_PROXY_PATH_V4: '/evp_proxy/v4',
+  EVP_SUBDOMAIN_HEADER_NAME: 'X-Datadog-EVP-Subdomain',
+  EVP_EVENT_PLATFORM_SUBDOMAIN: 'event-platform-intake',
+}

package/packages/dd-trace/src/evp_proxy/direct.js

@@ -0,0 +1,64 @@
+'use strict'
+
+const { format } = require('node:url')
+
+const { HttpsProxyAgent } = require('../../../../vendor/dist/https-proxy-agent')
+const { getProxyForUrl } = require('../../../../vendor/dist/proxy-from-env')
+const log = require('../log')
+
+/**
+ * @typedef {object} DirectEVPRoute
+ * @property {URL} url - Direct intake URL
+ * @property {string} basePath - Direct intake base path
+ * @property {object} headers - Direct intake authentication headers
+ * @property {import('node:https').Agent} [agent] - Optional HTTPS proxy agent
+ */
+
+/**
+ * Creates an authenticated direct EVP intake route.
+ *
+ * This helper does not perform local receiver discovery.
+ *
+ * @param {import('../config/config-base')} config - Tracer configuration
+ * @param {string} intake - EVP intake subdomain
+ * @returns {DirectEVPRoute|undefined} Direct route when credentials and site are available
+ */
+function createDirectEVPRoute (config, intake) {
+  const apiKey = config.DD_API_KEY
+  if (!apiKey || !config.site) return
+
+  try {
+    const hostname = `${intake}.${config.site}`.toLowerCase()
+    const url = new URL(format({
+      protocol: 'https:',
+      hostname,
+    }))
+    if (
+      url.hostname !== hostname ||
+      url.username ||
+      url.password ||
+      url.port ||
+      url.pathname !== '/' ||
+      url.search ||
+      url.hash
+    ) {
+      throw new Error('Invalid direct EVP intake URL')
+    }
+
+    const proxyUrl = getProxyForUrl(url.href)
+    const agent = proxyUrl ? new HttpsProxyAgent(proxyUrl) : undefined
+
+    return {
+      url,
+      basePath: '',
+      headers: {
+        'DD-API-KEY': apiKey,
+      },
+      ...(agent && { agent }),
+    }
+  } catch (error) {
+    log.debug('Unable to configure direct EVP intake: %s', error.message)
+  }
+}
+
+module.exports = { createDirectEVPRoute }

package/packages/dd-trace/src/evp_proxy/discovery.js

@@ -0,0 +1,133 @@
+'use strict'
+
+const { fetchAgentInfo } = require('../agent/info')
+const log = require('../log')
+
+const TRAILING_SLASHES = /\/+$/
+
+/**
+ * Receiver discovery contract
+ *
+ * The tracer sends `GET /info` to its configured local Agent URL. An
+ * Agent-compatible trace receiver produces the response. The tracer does not.
+ *
+ * The full Agent and serverless-init embed the same trace receiver. A future
+ * in-process receiver can expose the same contract. Callers can therefore
+ * select capabilities without detecting the receiver implementation.
+ *
+ * For EVP discovery, `endpoints` advertises registered proxy paths.
+ * `evp_proxy_allowed_headers` advertises headers that the proxy forwards to
+ * intake. It does not include routing headers that the proxy consumes, such as
+ * `X-Datadog-EVP-Subdomain`.
+ *
+ * An advertised route is not a health check. The receiver can register an EVP
+ * route while configuration disables its handler. The request then returns
+ * `405`. The `/info` version also identifies the embedded Agent code, not a
+ * serverless-init image or deployment type.
+ *
+ * This module only discovers a candidate route. A missing or unresponsive
+ * `/info` endpoint returns an error through the shared request timeout and
+ * retry policy. A valid response without a compatible path returns no route.
+ * Discovery sends no events, so the caller can safely select direct intake
+ * after either result. The caller also owns later delivery failures. Exposure
+ * delivery uses retries and can therefore produce duplicates. After local
+ * retries fail, the caller can retry through direct intake and use that route
+ * for future batches.
+ *
+ * Reference implementations:
+ *
+ * Agent `/info` and EVP proxy:
+ * https://github.com/DataDog/datadog-agent/tree/main/pkg/trace/api
+ *
+ * serverless-init entry point and embedded trace receiver:
+ * https://github.com/DataDog/datadog-agent/blob/main/cmd/serverless-init/main.go
+ * https://github.com/DataDog/datadog-agent/blob/main/pkg/serverless/trace/trace.go
+ */
+
+/**
+ * Selects the first advertised EVP proxy path that the caller supports.
+ *
+ * @param {object} agentInfo - Agent `/info` response
+ * @param {object} options - Selection options
+ * @param {string[]} options.supportedPaths - Supported paths in preference order
+ * @param {string[]} [options.requiredHeaders] - Headers that the proxy must forward unchanged to intake. Each
+ * header must appear in `evp_proxy_allowed_headers`. Do not include routing headers that the Agent consumes.
+ * @returns {string|undefined} Selected normalized path
+ */
+function selectEVPProxyPath (agentInfo, { supportedPaths, requiredHeaders = [] } = {}) {
+  if (!Array.isArray(agentInfo?.endpoints) ||
+      !Array.isArray(supportedPaths) ||
+      !Array.isArray(requiredHeaders) ||
+      requiredHeaders.some(header => typeof header !== 'string')) {
+    return
+  }
+
+  const allowedHeaders = agentInfo.evp_proxy_allowed_headers
+  if (allowedHeaders !== undefined) {
+    if (!Array.isArray(allowedHeaders)) return
+
+    const normalizedHeaders = new Set()
+    for (const header of allowedHeaders) {
+      if (typeof header === 'string') {
+        normalizedHeaders.add(header.toLowerCase())
+      }
+    }
+
+    if (requiredHeaders.some(header => !normalizedHeaders.has(header.toLowerCase()))) {
+      return
+    }
+  }
+
+  const advertisedPaths = new Set()
+  for (const endpoint of agentInfo.endpoints) {
+    if (typeof endpoint === 'string') {
+      advertisedPaths.add(endpoint.replace(TRAILING_SLASHES, ''))
+    }
+  }
+
+  for (const supportedPath of supportedPaths) {
+    if (typeof supportedPath !== 'string') continue
+
+    const normalizedPath = supportedPath.replace(TRAILING_SLASHES, '')
+    if (advertisedPaths.has(normalizedPath)) {
+      return normalizedPath
+    }
+  }
+}
+
+/**
+ * Discovers an EVP proxy route through the configured Agent URL.
+ *
+ * This function performs discovery only when the caller invokes it. It stores
+ * no state. The Agent information client owns its existing response cache.
+ *
+ * @param {URL} url - Configured Agent URL
+ * @param {object} options - Selection options
+ * @param {string[]} options.supportedPaths - Supported paths in preference order
+ * @param {string[]} [options.requiredHeaders] - Headers that the proxy must forward unchanged to intake. Each
+ * header must appear in `evp_proxy_allowed_headers`. Do not include routing headers that the Agent consumes.
+ * @param {(error: Error|null, route?: {url: URL, basePath: string}) => void} callback - Result callback
+ * @returns {void}
+ */
+function discoverEVPProxy (url, options, callback) {
+  fetchAgentInfo(url, (error, agentInfo) => {
+    if (error) {
+      callback(error)
+      return
+    }
+
+    const basePath = selectEVPProxyPath(agentInfo, options)
+    if (basePath === undefined) {
+      callback(null)
+      return
+    }
+
+    log.debug('EVP proxy route %s discovered through the configured local receiver', basePath)
+    callback(null, { url, basePath })
+  })
+}
+
+module.exports = {
+  discoverEVPProxy,
+  selectEVPProxyPath,
+}

package/packages/dd-trace/src/evp_proxy/path.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const LEADING_SLASHES = /^\/+/
+const TRAILING_SLASHES = /\/+$/
+
+/**
+ * Joins a caller-supplied EVP proxy path and product endpoint.
+ *
+ * This utility does not perform EVP proxy discovery.
+ *
+ * @param {string} basePath - EVP proxy base path
+ * @param {string} endpoint - Product intake endpoint
+ * @returns {string} Joined request path
+ */
+function joinEVPProxyPath (basePath, endpoint) {
+  const normalizedBasePath = basePath.replace(TRAILING_SLASHES, '')
+  const normalizedEndpoint = endpoint.replace(LEADING_SLASHES, '')
+
+  return `${normalizedBasePath}/${normalizedEndpoint}`
+}
+
+module.exports = { joinEVPProxyPath }

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

@@ -93,7 +93,10 @@ function request (data, options, callback) {
 
   docker.inject(options.headers)
 
-  options.agent = isSecure ? httpsAgent : httpAgent
+  const connectionOptions = {
+    ...options,
+    agent: options.agent ?? (isSecure ? httpsAgent : httpAgent),
+  }
 
   /**
    * @param {import('node:http').IncomingMessage} res
@@ -218,7 +221,7 @@ function request (data, options, callback) {
         }
       }
 
-      const req = client.request(options, (res) => onResponse(res, complete, handleError))
+      const req = client.request(connectionOptions, (res) => onResponse(res, complete, handleError))
 
       req.once('close', finalize)
       req.once('timeout', finalize)

package/packages/dd-trace/src/llmobs/experiments/client.js

@@ -33,7 +33,8 @@ function datasetRecordFromResource (resource) {
     attrs.input ?? null,
     attrs.expected_output ?? null,
     attrs.metadata ?? {},
-    id
+    id,
+    attrs.tags ?? []
   )
 }
 
@@ -195,7 +196,7 @@ class ExperimentsClient {
     const resources = Array.isArray(response?.records)
       ? response.records
       : (Array.isArray(response?.data) ? response.data : [])
-    return resources.map(datasetRecordFromResource)
+    return datasetMutationResultFromResources(resources)
   }
 
   async batchUpdateDatasetRecords (projectId, datasetId, attributes) {
@@ -226,6 +227,9 @@ class ExperimentsClient {
     const query = new URLSearchParams()
     if (options.cursor) query.set('page[cursor]', options.cursor)
     if (options.version !== undefined && options.version !== null) query.set('filter[version]', String(options.version))
+    if (Array.isArray(options.tags)) {
+      for (const tag of options.tags) query.append('filter[tags]', tag)
+    }
     const response = await this.request(
       'GET',
       `${API_BASE_PATH}/${projectId}/datasets/${datasetId}/records?${query.toString()}`