dd-trace 6.11.0 → 6.13.0

package/packages/dd-trace/src/config/generated-config-types.d.ts

@@ -272,6 +272,7 @@ export interface GeneratedConfig {
   DD_TRACE_HAPI_ENABLED: boolean;
   DD_TRACE_HAPI_HAPI_ENABLED: boolean;
   DD_TRACE_HONO_ENABLED: boolean;
+  DD_TRACE_HTTP_CLIENT_ERROR_STATUSES: string;
   DD_TRACE_HTTP_ENABLED: boolean;
   DD_TRACE_HTTP_SERVER_ERROR_STATUSES: string;
   DD_TRACE_HTTP2_ENABLED: boolean;
@@ -418,6 +419,7 @@ export interface GeneratedConfig {
       endpoint: string | undefined;
       maxContentSize: number;
       maxMessagesLength: number;
+      redactionEnabled: boolean;
       timeout: number;
     };
     appsec: {
@@ -473,6 +475,7 @@ export interface GeneratedConfig {
     agentlessEnabled: boolean | undefined;
     DD_LLMOBS_ENABLED: boolean;
     mlApp: string | undefined;
+    projectName: string | undefined;
     sampleRate: number;
   };
   logInjection: boolean;
@@ -614,6 +617,7 @@ export interface GeneratedEnvVarConfig {
   DD_AI_GUARD_ENDPOINT: string | undefined;
   DD_AI_GUARD_MAX_CONTENT_SIZE: number;
   DD_AI_GUARD_MAX_MESSAGES_LENGTH: number;
+  DD_AI_GUARD_REDACTION_ENABLED: boolean;
   DD_AI_GUARD_TIMEOUT: number;
   DD_API_KEY: string | undefined;
   DD_API_SECURITY_DOWNSTREAM_BODY_ANALYSIS_SAMPLE_RATE: number;
@@ -758,6 +762,7 @@ export interface GeneratedEnvVarConfig {
   DD_LLMOBS_AGENTLESS_ENABLED: boolean | undefined;
   DD_LLMOBS_ENABLED: boolean;
   DD_LLMOBS_ML_APP: string | undefined;
+  DD_LLMOBS_PROJECT_NAME: string | undefined;
   DD_LLMOBS_SAMPLE_RATE: number;
   DD_LOG_LEVEL: "debug" | "info" | "warn" | "error";
   DD_LOGS_INJECTION: boolean;
@@ -970,6 +975,7 @@ export interface GeneratedEnvVarConfig {
   DD_TRACE_HAPI_HAPI_ENABLED: boolean;
   DD_TRACE_HEADER_TAGS: string[];
   DD_TRACE_HONO_ENABLED: boolean;
+  DD_TRACE_HTTP_CLIENT_ERROR_STATUSES: string;
   DD_TRACE_HTTP_ENABLED: boolean;
   DD_TRACE_HTTP_SERVER_ERROR_STATUSES: string;
   DD_TRACE_HTTP2_ENABLED: boolean;

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

@@ -510,7 +510,8 @@ class Config extends ConfigBase {
     if (!this.llmobs.DD_LLMOBS_ENABLED &&
         !trackedConfigOrigins.has('llmobs.DD_LLMOBS_ENABLED') &&
         (trackedConfigOrigins.has('llmobs.agentlessEnabled') ||
-        trackedConfigOrigins.has('llmobs.mlApp'))) {
+        trackedConfigOrigins.has('llmobs.mlApp') ||
+        trackedConfigOrigins.has('llmobs.projectName'))) {
       setAndTrack(this, 'llmobs.DD_LLMOBS_ENABLED', true)
     }
 

package/packages/dd-trace/src/config/supported-configurations.json

@@ -93,6 +93,16 @@
         "default": "16"
       }
     ],
+    "DD_AI_GUARD_REDACTION_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "configurationNames": [
+          "experimental.aiguard.redactionEnabled"
+        ],
+        "default": "true"
+      }
+    ],
     "DD_AI_GUARD_TIMEOUT": [
       {
         "implementation": "A",
@@ -1341,6 +1351,16 @@
         "default": null
       }
     ],
+    "DD_LLMOBS_PROJECT_NAME": [
+      {
+        "implementation": "A",
+        "type": "string",
+        "configurationNames": [
+          "llmobs.projectName"
+        ],
+        "default": null
+      }
+    ],
     "DD_LLMOBS_SAMPLE_RATE": [
       {
         "implementation": "A",
@@ -2999,6 +3019,13 @@
         "default": "true"
       }
     ],
+    "DD_TRACE_HTTP_CLIENT_ERROR_STATUSES": [
+      {
+        "implementation": "A",
+        "type": "string",
+        "default": "400-499"
+      }
+    ],
     "DD_TRACE_HTTP_ENABLED": [
       {
         "implementation": "A",

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/devtools_client/send.js

@@ -141,7 +141,7 @@ function setInputPath (newPath) {
  * @returns {string} The serialized tags.
  */
 function buildTags (tags) {
-  const serializedTags = []
+  let serializedTags = ''
 
   for (const [key, rawValue] of tags) {
     if (rawValue === undefined) continue
@@ -151,8 +151,9 @@ function buildTags (tags) {
       continue
     }
 
-    serializedTags.push(`${key}:${rawValue}`)
+    if (serializedTags) serializedTags += ','
+    serializedTags += `${key}:${rawValue}`
   }
 
-  return serializedTags.join(',')
+  return serializedTags
 }

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/dogstatsd.js

@@ -8,6 +8,8 @@ const request = require('./exporters/common/request')
 const log = require('./log')
 const Histogram = require('./histogram')
 const { entityId } = require('./exporters/common/docker')
+const { registerTelemetryFlusher } = require('./flush')
+const { createServerlessDeliveryTracker } = require('./serverless')
 
 const legacyStorage = storage('legacy')
 
@@ -25,6 +27,8 @@ const TYPE_HISTOGRAM = 'h'
 class DogStatsDClient {
   #lookup
   #tagsPrefix
+  #serverlessDeliveryTracker
+
   constructor (options) {
     this.#lookup = options.lookup
     if (options.metricsProxyUrl) {
@@ -41,6 +45,7 @@ class DogStatsDClient {
     this._tags = options.tags
     this.#tagsPrefix = this._tags?.length ? `|#${this._tags.join(',')}` : ''
     this._queue = []
+    this.#serverlessDeliveryTracker = createServerlessDeliveryTracker()
     this._buffer = ''
     this._offset = 0
     this._udp4 = this._socket('udp4')
@@ -67,23 +72,30 @@ class DogStatsDClient {
     this._add(stat, value, TYPE_HISTOGRAM, tags)
   }
 
-  flush () {
+  flush (done) {
     const queue = this._enqueue()
 
-    if (queue.length === 0) return
+    if (queue.length === 0) {
+      if (this.#serverlessDeliveryTracker) return this.#serverlessDeliveryTracker.waitForIdle(done)
+      return done?.()
+    }
 
     log.debug('Flushing %s metrics via %s', queue.length, this._httpOptions ? 'HTTP' : 'UDP')
 
     this._queue = []
 
-    if (this._httpOptions) {
-      this._sendHttp(queue)
-    } else {
-      this._sendUdp(queue)
+    const send = complete => {
+      if (this._httpOptions) this._sendHttp(queue, complete)
+      else this._sendUdp(queue, complete)
+    }
+    if (this.#serverlessDeliveryTracker) {
+      this.#serverlessDeliveryTracker.track(send)
+      return this.#serverlessDeliveryTracker.waitForIdle(done)
     }
+    send(done)
   }
 
-  _sendHttp (queue) {
+  _sendHttp (queue, done) {
     const buffer = Buffer.concat(queue)
     request(buffer, this._httpOptions, (err) => {
       if (err) {
@@ -95,32 +107,46 @@ class DogStatsDClient {
           // options. Either way, we can give UDP a try.
           this._httpOptions = undefined
         }
-        this._sendUdp(queue)
+        this._sendUdp(queue, done)
+      } else {
+        done?.()
       }
     })
   }
 
-  _sendUdp (queue) {
+  _sendUdp (queue, done) {
     // 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)
+          if (error) {
+            log.error('DogStatsDClient: Host not found', error)
+            return done?.()
+          }
+          this._sendUdpFromQueue(queue, address, family, done)
         })
       } else {
-        this._sendUdpFromQueue(queue, this._host, this._family)
+        this._sendUdpFromQueue(queue, this._host, this._family, done)
       }
     })
   }
 
-  _sendUdpFromQueue (queue, address, family) {
+  _sendUdpFromQueue (queue, address, family, done) {
     const socket = family === 6 ? this._udp6 : this._udp4
+    let pending = queue.length
+    const complete = () => {
+      if (--pending === 0) done?.()
+    }
 
     for (const buffer of queue) {
       log.debug('Sending to DogStatsD: %s', buffer)
-      socket.send(buffer, 0, buffer.length, this._port, address)
+      try {
+        socket.send(buffer, 0, buffer.length, this._port, address, complete)
+      } catch (error) {
+        log.error('DogStatsDClient: UDP error sending metrics', error)
+        complete()
+      }
     }
   }
 
@@ -212,12 +238,12 @@ class MetricsAggregationClient {
     this.reset()
   }
 
-  flush () {
+  flush (done) {
     this._captureCounters()
     this._captureGauges()
     this._captureHistograms()
 
-    this._client.flush()
+    this._client.flush(done)
   }
 
   reset () {
@@ -370,6 +396,7 @@ class CustomMetrics {
     setInterval(flush, 10 * 1000).unref?.()
 
     globalThis[Symbol.for('dd-trace')].beforeExitHandlers.add(flush)
+    registerTelemetryFlusher(done => this.flush(done))
   }
 
   increment (stat, value = 1, tags) {
@@ -392,8 +419,8 @@ class CustomMetrics {
     this.#client.histogram(stat, value, CustomMetrics.tagTranslator(tags))
   }
 
-  flush () {
-    return this.#client.flush()
+  flush (done) {
+    return this.#client.flush(done)
   }
 
   /**

package/packages/dd-trace/src/encode/agentless-json.js

@@ -167,17 +167,18 @@ class AgentlessJSONEncoder {
       const metadataPrefix = metadataJson.slice(0, -1)
       const hasMetadata = metadataPrefix.length > 1 // more than just '{'
 
-      const traceParts = []
+      let tracesJson = ''
       for (const spanStrings of this._traces) {
         const spansJson = '[' + spanStrings.join(',') + ']'
+        if (tracesJson) tracesJson += ','
         if (hasMetadata) {
-          traceParts.push(metadataPrefix + ',"spans":' + spansJson + '}')
+          tracesJson += metadataPrefix + ',"spans":' + spansJson + '}'
         } else {
-          traceParts.push('{"spans":' + spansJson + '}')
+          tracesJson += '{"spans":' + spansJson + '}'
         }
       }
 
-      const payload = '{"traces":[' + traceParts.join(',') + ']}'
+      const payload = '{"traces":[' + tracesJson + ']}'
       this._reset()
       return Buffer.from(payload, 'utf8')
     } catch (err) {

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 }