dd-trace 5.100.0 → 5.101.0

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

@@ -22,6 +22,7 @@ const TYPE_HISTOGRAM = 'h'
  */
 class DogStatsDClient {
   #lookup
+  #tagsPrefix
   constructor (options) {
     this.#lookup = options.lookup
     if (options.metricsProxyUrl) {
@@ -36,6 +37,7 @@ class DogStatsDClient {
     this._family = isIP(this._host)
     this._port = options.port
     this._tags = options.tags
+    this.#tagsPrefix = this._tags?.length ? `|#${this._tags.join(',')}` : ''
     this._queue = []
     this._buffer = ''
     this._offset = 0
@@ -66,9 +68,9 @@ class DogStatsDClient {
   flush () {
     const queue = this._enqueue()
 
-    log.debug('Flushing %s metrics via', queue.length, this._httpOptions ? 'HTTP' : 'UDP')
+    if (queue.length === 0) return
 
-    if (this._queue.length === 0) return
+    log.debug('Flushing %s metrics via %s', queue.length, this._httpOptions ? 'HTTP' : 'UDP')
 
     this._queue = []
 
@@ -119,11 +121,12 @@ class DogStatsDClient {
   _add (stat, value, type, tags) {
     let message = `${stat}:${value}|${type}`
 
-    // Don't manipulate this._tags as it is still used
-    tags = tags ? [...this._tags, ...tags] : this._tags
-
-    if (tags.length > 0) {
-      message += `|#${tags.join(',')}`
+    if (tags?.length) {
+      message += this.#tagsPrefix
+        ? `${this.#tagsPrefix},${tags.join(',')}`
+        : `|#${tags.join(',')}`
+    } else {
+      message += this.#tagsPrefix
     }
 
     if (entityId) {

package/packages/dd-trace/src/encode/0.4.js

@@ -3,12 +3,12 @@
 const getConfig = require('../config')
 const { MsgpackChunk, MsgpackEncoder } = require('../msgpack')
 const log = require('../log')
-const { truncateSpan, normalizeSpan } = require('./tags-processors')
+const { normalizeSpan } = require('./tags-processors')
 
 const SOFT_LIMIT = 8 * 1024 * 1024 // 8MB
 
 function formatSpan (span, config) {
-  span = normalizeSpan(truncateSpan(span, false))
+  span = normalizeSpan(span)
   if (span.span_events) {
     // ensure span events are encoded as tags if agent doesn't support native top level span events
     if (config.DD_TRACE_NATIVE_SPAN_EVENTS) {

package/packages/dd-trace/src/encode/0.5.js

@@ -1,13 +1,13 @@
 'use strict'
 
-const { truncateSpan, normalizeSpan } = require('./tags-processors')
+const { normalizeSpan } = require('./tags-processors')
 const { AgentEncoder: BaseEncoder } = require('./0.4')
 
 const ARRAY_OF_TWO = 0x92
 const ARRAY_OF_TWELVE = 0x9C
 
 function formatSpan (span) {
-  span = normalizeSpan(truncateSpan(span, false))
+  span = normalizeSpan(span)
   // ensure span events are encoded as tags
   if (span.span_events) {
     span.meta.events = JSON.stringify(span.span_events)

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

@@ -2,7 +2,7 @@
 
 const log = require('../log')
 const { TOP_LEVEL_KEY } = require('../constants')
-const { truncateSpan, normalizeSpan } = require('./tags-processors')
+const { normalizeSpan } = require('./tags-processors')
 
 // Soft limit for estimated payload size. Triggers an early flush to stay under intake request size limits.
 const SOFT_LIMIT = 8 * 1024 * 1024 // 8MB
@@ -14,7 +14,7 @@ const SOFT_LIMIT = 8 * 1024 * 1024 // 8MB
  * @returns {object} The formatted span
  */
 function formatSpan (span, isFirstSpan) {
-  span = normalizeSpan(truncateSpan(span, false))
+  span = normalizeSpan(span)
 
   // Remove _dd.p.tid (the upper 64 bits of a 128-bit trace ID) since trace_id is truncated to lower 64 bits
   delete span.meta['_dd.p.tid']

package/packages/dd-trace/src/encode/tags-processors.js

@@ -25,35 +25,10 @@ const MAX_SERVICE_LENGTH = 100
 // MAX_TYPE_LENGTH the maximum length a span type can have
 const MAX_TYPE_LENGTH = 100
 
-// TODO (bengl) Pretty much everything in this file should happen in
-// `format.js`, so that we're not iterating over all the spans and modifying
-// them yet again.
-
-// normally the agent truncates the resource and parses it in certain scenarios (e.g. SQL Queries)
-function truncateSpan (span, shouldTruncateResourceName = true) {
-  if (shouldTruncateResourceName && span.resource && span.resource.length > MAX_RESOURCE_NAME_LENGTH) {
+function truncateSpan (span) {
+  if (span.resource && span.resource.length > MAX_RESOURCE_NAME_LENGTH) {
     span.resource = `${span.resource.slice(0, MAX_RESOURCE_NAME_LENGTH)}...`
   }
-  for (let metaKey of Object.keys(span.meta)) {
-    const val = span.meta[metaKey]
-    if (metaKey.length > MAX_META_KEY_LENGTH) {
-      delete span.meta[metaKey]
-      metaKey = `${metaKey.slice(0, MAX_META_KEY_LENGTH)}...`
-      span.meta[metaKey] = val
-    }
-    if (val && val.length > MAX_META_VALUE_LENGTH) {
-      span.meta[metaKey] = `${val.slice(0, MAX_META_VALUE_LENGTH)}...`
-    }
-  }
-  for (let metricsKey of Object.keys(span.metrics)) {
-    const val = span.metrics[metricsKey]
-    if (metricsKey.length > MAX_METRIC_KEY_LENGTH) {
-      delete span.metrics[metricsKey]
-      metricsKey = `${metricsKey.slice(0, MAX_METRIC_KEY_LENGTH)}...`
-      span.metrics[metricsKey] = val
-    }
-  }
-
   return span
 }
 

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

@@ -13,6 +13,12 @@ const log = require('../../log')
 const { urlToHttpOptions } = require('./url-to-http-options-polyfill')
 const docker = require('./docker')
 const { httpAgent, httpsAgent } = require('./agents')
+const {
+  getMaxAttempts,
+  getRetryDelay,
+  isRetriableNetworkError,
+  markEndpointReached,
+} = require('./retry')
 
 const maxActiveBufferSize = 1024 * 1024 * 64
 
@@ -92,6 +98,8 @@ function request (data, options, callback) {
   options.agent = isSecure ? httpsAgent : httpAgent
 
   const onResponse = (res, finalize) => {
+    markEndpointReached(options)
+
     const chunks = []
 
     res.setTimeout(timeout)
@@ -142,7 +150,10 @@ function request (data, options, callback) {
     })
   }
 
-  const makeRequest = onError => {
+  // Retries always run via setTimeout so the AsyncLocalStorage store survives
+  // the gap before socket.connect(); ALS.run() does not call ALS.enterWith()
+  // outside AsyncContextFrame, so a synchronous re-entry would lose the store.
+  const attempt = attemptIndex => {
     if (!request.writable) {
       log.debug('Maximum number of active requests reached: payload is discarded.')
       return callback(null)
@@ -163,9 +174,16 @@ function request (data, options, callback) {
       req.once('close', finalize)
       req.once('timeout', finalize)
 
-      req.once('error', err => {
+      req.once('error', error => {
         finalize()
-        onError(err)
+        if (attemptIndex < getMaxAttempts(options) && isRetriableNetworkError(error)) {
+          // Unref so a pending retry never keeps the host process alive past
+          // its natural exit point; long-running apps still retry because the
+          // event loop is held open by their own work.
+          setTimeout(attempt, getRetryDelay(options, attemptIndex), attemptIndex + 1).unref()
+        } else {
+          callback(error)
+        }
       })
 
       req.setTimeout(timeout, () => {
@@ -185,14 +203,7 @@ function request (data, options, callback) {
     })
   }
 
-  // The setTimeout is needed to avoid losing the async context in the retry
-  // request before socket.connect() is called. This is a workaround for the
-  // issue that the AsyncLocalStorage.run() method does not call the
-  // AsyncLocalStorage.enterWith() method when not using AsyncContextFrame.
-  //
-  // TODO: Test that this doesn't trace itself on retry when the diagnostics
-  // channel events are available in the agent exporter.
-  makeRequest(() => setTimeout(() => makeRequest(callback)))
+  attempt(1)
 }
 
 function byteLength (data) {

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

@@ -0,0 +1,104 @@
+'use strict'
+
+const RATE_LIMIT_MAX_WAIT_MS = 30_000
+
+const SINGLE_RETRY_BASE_MS = 5000
+const SINGLE_RETRY_JITTER_MS = 2500
+
+const STARTUP_GRACE_MS = 30_000
+const STARTUP_BACKOFF_BASE_MS = 1000
+const STARTUP_BACKOFF_MAX_MS = 8000
+const STARTUP_BACKOFF_JITTER_MS = 500
+const STARTUP_MAX_ATTEMPTS = 5
+const POST_STARTUP_MAX_ATTEMPTS = 2
+
+// `ECONNREFUSED` and `ENOENT` cover the agent-not-yet-listening cases (TCP and
+// UDS). `EAI_AGAIN` covers transient DNS in agentless intake. `ENOTFOUND` is
+// excluded because it usually means a misconfigured host, not a transient state.
+const RETRIABLE_NETWORK_CODES = new Set([
+  'EAI_AGAIN',
+  'ECONNREFUSED',
+  'ECONNRESET',
+  'ENOENT',
+  'EPIPE',
+  'ETIMEDOUT',
+])
+
+const startedAtMs = Date.now()
+const reachedEndpoints = new Set()
+
+/**
+ * @typedef {object} EndpointOptions
+ * @property {string} [socketPath]
+ * @property {string} [hostname]
+ * @property {string} [host]
+ * @property {string|number} [port]
+ */
+
+/**
+ * @param {Error & { code?: string }} error
+ */
+function isRetriableNetworkError (error) {
+  return error?.code !== undefined && RETRIABLE_NETWORK_CODES.has(error.code)
+}
+
+function singleJitteredDelay () {
+  return SINGLE_RETRY_BASE_MS + Math.random() * SINGLE_RETRY_JITTER_MS
+}
+
+/**
+ * Stable key identifying the destination so the startup-phase gate is scoped
+ * per endpoint. UDS path beats host:port because both can coexist on the same
+ * options object after `parseUrl` runs.
+ *
+ * @param {EndpointOptions} options
+ */
+function getEndpointKey (options) {
+  if (options.socketPath) return options.socketPath
+  return `${options.hostname || options.host || ''}:${options.port || ''}`
+}
+
+/**
+ * @param {EndpointOptions} options
+ */
+function inStartupPhase (options) {
+  if ((Date.now() - startedAtMs) >= STARTUP_GRACE_MS) return false
+  return !reachedEndpoints.has(getEndpointKey(options))
+}
+
+/**
+ * Wait time before the next attempt when the previous one just failed. Bounded
+ * exponential backoff with small jitter inside the startup grace window;
+ * single 5–7.5 s jittered retry afterwards.
+ *
+ * @param {EndpointOptions} options
+ * @param {number} previousAttempt 1-based index of the attempt that just failed.
+ */
+function getRetryDelay (options, previousAttempt) {
+  if (!inStartupPhase(options)) return singleJitteredDelay()
+  const exp = Math.min(STARTUP_BACKOFF_MAX_MS, STARTUP_BACKOFF_BASE_MS << (previousAttempt - 1))
+  return exp + Math.random() * STARTUP_BACKOFF_JITTER_MS
+}
+
+/**
+ * @param {EndpointOptions} options
+ */
+function getMaxAttempts (options) {
+  return inStartupPhase(options) ? STARTUP_MAX_ATTEMPTS : POST_STARTUP_MAX_ATTEMPTS
+}
+
+/**
+ * @param {EndpointOptions} options
+ */
+function markEndpointReached (options) {
+  reachedEndpoints.add(getEndpointKey(options))
+}
+
+module.exports = {
+  RATE_LIMIT_MAX_WAIT_MS,
+  getMaxAttempts,
+  getRetryDelay,
+  isRetriableNetworkError,
+  markEndpointReached,
+  singleJitteredDelay,
+}

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

@@ -0,0 +1,66 @@
+'use strict'
+
+const fs = require('node:fs')
+const path = require('node:path')
+
+const log = require('./log')
+const { GIT_COMMIT_SHA, GIT_REPOSITORY_URL } = require('./plugins/util/tags')
+const {
+  getGitMetadataFromGitProperties,
+  getRemoteOriginURL,
+  removeUserSensitiveInfo,
+  resolveGitHeadSHA,
+} = require('./config/git_properties')
+
+/** @type {{ commitSHA: string | undefined, repositoryUrl: string | undefined } | undefined} */
+let cached
+
+/**
+ * @param {import('./config/config-types').ConfigProperties} config
+ */
+function getGitMetadata (config) {
+  if (cached) return cached
+
+  if (!config.DD_TRACE_GIT_METADATA_ENABLED) {
+    cached = { commitSHA: undefined, repositoryUrl: undefined }
+    return cached
+  }
+
+  let repositoryUrl = removeUserSensitiveInfo(config.DD_GIT_REPOSITORY_URL ?? config.tags[GIT_REPOSITORY_URL])
+  let commitSHA = config.DD_GIT_COMMIT_SHA ?? config.tags[GIT_COMMIT_SHA]
+
+  if (!repositoryUrl || !commitSHA) {
+    const propertiesFile = config.DD_GIT_PROPERTIES_FILE
+    const gitPropertiesFile = propertiesFile ?? `${process.cwd()}/git.properties`
+    try {
+      const fromProperties = getGitMetadataFromGitProperties(fs.readFileSync(gitPropertiesFile, 'utf8'))
+      commitSHA ??= fromProperties.commitSHA
+      repositoryUrl ??= fromProperties.repositoryUrl
+    } catch (error) {
+      if (propertiesFile) {
+        log.error('Error reading DD_GIT_PROPERTIES_FILE: %s', gitPropertiesFile, error)
+      }
+    }
+  }
+
+  const folderPath = config.DD_GIT_FOLDER_PATH
+  const gitFolderPath = folderPath ?? path.join(process.cwd(), '.git')
+
+  if (!repositoryUrl) {
+    const gitConfigPath = path.join(gitFolderPath, 'config')
+    try {
+      repositoryUrl = getRemoteOriginURL(fs.readFileSync(gitConfigPath, 'utf8'))
+    } catch (error) {
+      if (folderPath) {
+        log.error('Error reading git config: %s', gitConfigPath, error)
+      }
+    }
+  }
+
+  commitSHA ??= resolveGitHeadSHA(gitFolderPath)
+
+  cached = { commitSHA, repositoryUrl }
+  return cached
+}
+
+module.exports = getGitMetadata

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

@@ -1,17 +1,25 @@
 'use strict'
 
 const { SCI_COMMIT_SHA, SCI_REPOSITORY_URL } = require('./constants')
+const getGitMetadata = require('./git_metadata')
 
 class GitMetadataTagger {
+  #commitSHA
+  #repositoryUrl
+  #enabled
+
   constructor (config) {
-    this._config = config
+    this.#enabled = config.DD_TRACE_GIT_METADATA_ENABLED
+    const { commitSHA, repositoryUrl } = getGitMetadata(config)
+    this.#commitSHA = commitSHA
+    this.#repositoryUrl = repositoryUrl
   }
 
   tagGitMetadata (spanContext) {
-    if (this._config.DD_TRACE_GIT_METADATA_ENABLED) {
-      // These tags are added only to the local root span
-      spanContext._trace.tags[SCI_COMMIT_SHA] = this._config.commitSHA
-      spanContext._trace.tags[SCI_REPOSITORY_URL] = this._config.repositoryUrl
+    if (this.#enabled) {
+      const tags = spanContext._trace.tags
+      tags[SCI_COMMIT_SHA] = this.#commitSHA
+      tags[SCI_REPOSITORY_URL] = this.#repositoryUrl
     }
   }
 }

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

@@ -7,19 +7,19 @@ const UINT_MAX = 4_294_967_296
 const data = new Uint8Array(8 * 8192)
 const zeroId = new Uint8Array(8)
 
-const map = Array.prototype.map
-const pad = byte => `${byte < 16 ? '0' : ''}${byte.toString(16)}`
-
 let batch = 0
 
 // Internal representation of a trace or span ID.
 class Identifier {
+  /** @type {number[] | Uint8Array} */
+  #buffer
+
   /**
    * @param {string} value
    * @param {number} [radix]
    */
   constructor (value, radix = 16) {
-    this._buffer = radix === 16
+    this.#buffer = radix === 16
       ? createBuffer(value)
       : fromString(value, radix)
   }
@@ -30,32 +30,32 @@ class Identifier {
    */
   toString (radix = 16) {
     return radix === 16
-      ? toHexString(this._buffer)
-      : toNumberString(this._buffer, radix)
+      ? Buffer.from(this.#buffer).toString('hex')
+      : toNumberString(this.#buffer, radix)
   }
 
   /**
    * @returns {bigint}
    */
   toBigInt () {
-    return Buffer.from(this._buffer).readBigUInt64BE(0)
+    return Buffer.from(this.#buffer).readBigUInt64BE(0)
   }
 
   /**
    * @returns {number[] | Uint8Array}
    */
   toBuffer () {
-    return this._buffer
+    return this.#buffer
   }
 
   /**
    * @returns {number[] | Uint8Array}
    */
   toArray () {
-    if (this._buffer.length === 8) {
-      return this._buffer
+    if (this.#buffer.length === 8) {
+      return this.#buffer
     }
-    return this._buffer.slice(-8)
+    return this.#buffer.slice(-8)
   }
 
   /**
@@ -70,12 +70,10 @@ class Identifier {
    * @returns {boolean}
    */
   equals (other) {
-    const length = this._buffer.length
-    const otherLength = other._buffer.length
-
-    // Only compare the bytes available in both IDs.
-    for (let i = length, j = otherLength; i >= 0 && j >= 0; i--, j--) {
-      if (this._buffer[i] !== other._buffer[j]) return false
+    // Big-endian suffix compare: when buffers differ in length, only the
+    // rightmost `min(this.length, other.length)` bytes are checked.
+    for (let i = this.#buffer.length - 1, j = other.#buffer.length - 1; i >= 0 && j >= 0; i--, j--) {
+      if (this.#buffer[i] !== other.#buffer[j]) return false
     }
 
     return true
@@ -174,15 +172,6 @@ function toNumberString (buffer, radix) {
   return str
 }
 
-// Convert a buffer to a hexadecimal string.
-/**
- * @param {number[] | Uint8Array} buffer
- * @returns {string}
- */
-function toHexString (buffer) {
-  return map.call(buffer, pad).join('')
-}
-
 // Simple pseudo-random 64-bit ID generator.
 /**
  * @returns {number[] | Uint8Array}

package/packages/dd-trace/src/llmobs/constants/tags.js

@@ -7,7 +7,9 @@ module.exports = {
   DECORATOR: '_ml_obs.decorator',
   INTEGRATION: '_ml_obs.integration',
   METADATA: '_ml_obs.meta.metadata',
+  COST_TAGS: '_ml_obs.meta.metadata._dd.cost_tags',
   METRICS: '_ml_obs.metrics',
+  TOOL_DEFINITIONS: '_ml_obs.meta.tool_definitions',
   ML_APP: '_ml_obs.meta.ml_app',
   PROPAGATED_PARENT_ID_KEY: '_dd.p.llmobs_parent_id',
   PROPAGATED_ML_APP_KEY: '_dd.p.llmobs_ml_app',

package/packages/dd-trace/src/llmobs/plugins/anthropic/index.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const { UNKNOWN_MODEL_PROVIDER } = require('../../constants/tags')
+const { safeJsonParse } = require('../../util')
 const LLMObsPlugin = require('../base')
 const { appendMessage } = require('./util')
 
@@ -47,6 +48,8 @@ class AnthropicLLMObsPlugin extends LLMObsPlugin {
             const { type } = contentBlock
             if (type === 'text') {
               response.content.push({ type, text: contentBlock.text })
+            } else if (type === 'thinking') {
+              response.content.push({ type, thinking: contentBlock.thinking ?? '' })
             } else if (type === 'tool_use') {
               response.content.push({ type, name: contentBlock.name, input: '', id: contentBlock.id })
             }
@@ -56,20 +59,29 @@ class AnthropicLLMObsPlugin extends LLMObsPlugin {
             const { delta } = chunk
             if (!delta) continue
 
-            const { text } = delta
-            if (text) response.content[response.content.length - 1].text += text
-
-            const partialJson = delta.partial_json
-            if (partialJson && delta.type === 'input_json_delta') {
-              response.content[response.content.length - 1].input += partialJson
+            const lastBlock = response.content[response.content.length - 1]
+            if (!lastBlock) continue
+
+            if (delta.type === 'thinking_delta') {
+              const { thinking } = delta
+              if (thinking) lastBlock.thinking += thinking
+            } else if (delta.type === 'signature_delta') {
+              // Signature is for internal verification only; skip it.
+            } else if (delta.type === 'input_json_delta') {
+              const partialJson = delta.partial_json
+              if (partialJson) lastBlock.input += partialJson
+            } else {
+              const { text } = delta
+              if (text) lastBlock.text += text
             }
             break
           }
           case 'content_block_stop': {
-            const type = response.content[response.content.length - 1].type
-            if (type === 'tool_use') {
-              const input = response.content[response.content.length - 1].input ?? '{}'
-              response.content[response.content.length - 1].input = JSON.parse(input)
+            const lastBlock = response.content[response.content.length - 1]
+            if (!lastBlock) break
+            if (lastBlock.type === 'tool_use') {
+              const input = lastBlock.input ?? '{}'
+              lastBlock.input = safeJsonParse(input, {})
             }
             break
           }
@@ -167,18 +179,17 @@ class AnthropicLLMObsPlugin extends LLMObsPlugin {
 
     const outputMessages = []
     for (const block of content) {
+      if (block.type === 'thinking') {
+        outputMessages.push({ content: block.thinking ?? '', role: 'reasoning' })
+        continue
+      }
       const { text } = block
       if (typeof text === 'string') {
         outputMessages.push({ content: text, role })
       } else if (block.type === 'tool_use') {
-        let input = block.input
-        if (typeof input === 'string') {
-          input = JSON.parse(input)
-        }
-
         const toolCall = {
           name: block.name,
-          arguments: input,
+          arguments: safeJsonParse(block.input, {}),
           toolId: block.id,
           type: block.type,
         }

package/packages/dd-trace/src/llmobs/plugins/anthropic/util.js

@@ -3,6 +3,7 @@
 /**
  * @typedef {{type: 'text', text: string}} TextBlock
  * @typedef {{type: 'image'}} ImageBlock
+ * @typedef {{type: 'thinking', thinking: string, signature?: string}} ThinkingBlock
  * @typedef {{
  *  type: 'tool_use', text: string, name: string, id: string, input: string | Record<string, unknown>
  * }} ToolUseBlock
@@ -70,6 +71,8 @@ function appendMessage (messages, { role, content }) {
       messages.push({ content: block.text, role })
     } else if (block.type === 'image') {
       messages.push({ content: '([IMAGE DETECTED])', role })
+    } else if (block.type === 'thinking') {
+      messages.push({ content: block.thinking ?? '', role: 'reasoning' })
     } else if (block.type === 'tool_use') {
       const { text, name, id, type } = block
       let input = block.input