dd-trace 5.51.0 → 5.53.0

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

@@ -0,0 +1,36 @@
+'use strict'
+
+const { storage } = require('../../datadog-core')
+const baggageStorage = storage('baggage')
+
+function setBaggageItem (key, value) {
+  storage('baggage').enterWith({ ...baggageStorage.getStore(), [key]: value })
+  return storage('baggage').getStore()
+}
+
+function getBaggageItem (key) {
+  return storage('baggage').getStore()?.[key]
+}
+
+function getAllBaggageItems () {
+  return storage('baggage').getStore()
+}
+
+function removeBaggageItem (keyToRemove) {
+  const { [keyToRemove]: _, ...newBaggage } = storage('baggage').getStore()
+  storage('baggage').enterWith(newBaggage)
+  return newBaggage
+}
+
+function removeAllBaggageItems () {
+  storage('baggage').enterWith({})
+  return storage('baggage').getStore()
+}
+
+module.exports = {
+  setBaggageItem,
+  getBaggageItem,
+  getAllBaggageItems,
+  removeBaggageItem,
+  removeAllBaggageItems
+}

package/packages/dd-trace/src/ci-visibility/test-management/get-test-management-tests.js

@@ -7,7 +7,8 @@ function getTestManagementTests ({
   evpProxyPrefix,
   isGzipCompatible,
   repositoryUrl,
-  commitMessage
+  commitMessage,
+  sha
 }, done) {
   const options = {
     path: '/api/v2/test/libraries/test-management/tests',
@@ -41,7 +42,8 @@ function getTestManagementTests ({
       type: 'ci_app_libraries_tests_request',
       attributes: {
         repository_url: repositoryUrl,
-        commit_message: commitMessage
+        commit_message: commitMessage,
+        sha
       }
     }
   })

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

@@ -139,7 +139,7 @@ const qsRegex = '(?:p(?:ass)?w(?:or)?d|pass(?:_?phrase)?|secret|(?:api_?|private
 // eslint-disable-next-line @stylistic/js/max-len
 const defaultWafObfuscatorKeyRegex = '(?i)pass|pw(?:or)?d|secret|(?:api|private|public|access)[_-]?key|token|consumer[_-]?(?:id|key|secret)|sign(?:ed|ature)|bearer|authorization|jsessionid|phpsessid|asp\\.net[_-]sessionid|sid|jwt'
 // eslint-disable-next-line @stylistic/js/max-len
-const defaultWafObfuscatorValueRegex = '(?i)(?:p(?:ass)?w(?:or)?d|pass(?:[_-]?phrase)?|secret(?:[_-]?key)?|(?:(?:api|private|public|access)[_-]?)key(?:[_-]?id)?|(?:(?:auth|access|id|refresh)[_-]?)?token|consumer[_-]?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?|jsessionid|phpsessid|asp\\.net(?:[_-]|-)sessionid|sid|jwt)(?:\\s*=[^;]|"\\s*:\\s*"[^"]+")|bearer\\s+[a-z0-9\\._\\-]+|token:[a-z0-9]{13}|gh[opsu]_[0-9a-zA-Z]{36}|ey[I-L][\\w=-]+\\.ey[I-L][\\w=-]+(?:\\.[\\w.+\\/=-]+)?|[\\-]{5}BEGIN[a-z\\s]+PRIVATE\\sKEY[\\-]{5}[^\\-]+[\\-]{5}END[a-z\\s]+PRIVATE\\sKEY|ssh-rsa\\s*[a-z0-9\\/\\.+]{100,}'
+const defaultWafObfuscatorValueRegex = '(?i)(?:p(?:ass)?w(?:or)?d|pass(?:[_-]?phrase)?|secret(?:[_-]?key)?|(?:(?:api|private|public|access)[_-]?)key(?:[_-]?id)?|(?:(?:auth|access|id|refresh)[_-]?)?token|consumer[_-]?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?|jsessionid|phpsessid|asp\\.net(?:[_-]|-)sessionid|sid|jwt)(?:\\s*=([^;&]+)|"\\s*:\\s*("[^"]+"|\\d+))|bearer\\s+([a-z0-9\\._\\-]+)|token\\s*:\\s*([a-z0-9]{13})|gh[opsu]_([0-9a-zA-Z]{36})|ey[I-L][\\w=-]+\\.(ey[I-L][\\w=-]+(?:\\.[\\w.+\\/=-]+)?)|[\\-]{5}BEGIN[a-z\\s]+PRIVATE\\sKEY[\\-]{5}([^\\-]+)[\\-]{5}END[a-z\\s]+PRIVATE\\sKEY|ssh-rsa\\s*([a-z0-9\\/\\.+]{100,})'
 const runtimeId = uuid()
 
 function maybeFile (filepath) {
@@ -481,7 +481,8 @@ class Config {
     this._setValue(defaults, 'clientIpEnabled', false)
     this._setValue(defaults, 'clientIpHeader', null)
     this._setValue(defaults, 'crashtracking.enabled', true)
-    this._setValue(defaults, 'codeOriginForSpans.enabled', false)
+    this._setValue(defaults, 'codeOriginForSpans.enabled', true)
+    this._setValue(defaults, 'codeOriginForSpans.experimental.exit_spans.enabled', false)
     this._setValue(defaults, 'dbmPropagationMode', 'disabled')
     this._setValue(defaults, 'dogstatsd.hostname', '127.0.0.1')
     this._setValue(defaults, 'dogstatsd.port', '8125')
@@ -660,6 +661,7 @@ class Config {
       DD_APPSEC_WAF_TIMEOUT,
       DD_CRASHTRACKING_ENABLED,
       DD_CODE_ORIGIN_FOR_SPANS_ENABLED,
+      DD_CODE_ORIGIN_FOR_SPANS_EXPERIMENTAL_EXIT_SPANS_ENABLED,
       DD_DATA_STREAMS_ENABLED,
       DD_DBM_PROPAGATION_MODE,
       DD_DOGSTATSD_HOSTNAME,
@@ -825,6 +827,11 @@ class Config {
       !this._isInServerlessEnvironment()
     ))
     this._setBoolean(env, 'codeOriginForSpans.enabled', DD_CODE_ORIGIN_FOR_SPANS_ENABLED)
+    this._setBoolean(
+      env,
+      'codeOriginForSpans.experimental.exit_spans.enabled',
+      DD_CODE_ORIGIN_FOR_SPANS_EXPERIMENTAL_EXIT_SPANS_ENABLED
+    )
     this._setString(env, 'dbmPropagationMode', DD_DBM_PROPAGATION_MODE)
     this._setString(env, 'dogstatsd.hostname', DD_DOGSTATSD_HOST || DD_DOGSTATSD_HOSTNAME)
     this._setString(env, 'dogstatsd.port', DD_DOGSTATSD_PORT)
@@ -1029,6 +1036,11 @@ class Config {
     this._setValue(opts, 'baggageMaxBytes', options.baggageMaxBytes)
     this._setValue(opts, 'baggageMaxItems', options.baggageMaxItems)
     this._setBoolean(opts, 'codeOriginForSpans.enabled', options.codeOriginForSpans?.enabled)
+    this._setBoolean(
+      opts,
+      'codeOriginForSpans.experimental.exit_spans.enabled',
+      options.codeOriginForSpans?.experimental?.exit_spans?.enabled
+    )
     this._setString(opts, 'dbmPropagationMode', options.dbmPropagationMode)
     if (options.dogstatsd) {
       this._setString(opts, 'dogstatsd.hostname', options.dogstatsd.hostname)

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

@@ -5,10 +5,35 @@ const { getGeneratedPosition } = require('./source-maps')
 const session = require('./session')
 const { compile: compileCondition, compileSegments, templateRequiresEvaluation } = require('./condition')
 const { MAX_SNAPSHOTS_PER_SECOND_PER_PROBE, MAX_NON_SNAPSHOTS_PER_SECOND_PER_PROBE } = require('./defaults')
-const { findScriptFromPartialPath, locationToBreakpoint, breakpointToProbes, probeToLocation } = require('./state')
+const {
+  findScriptFromPartialPath,
+  clearState,
+  locationToBreakpoint,
+  breakpointToProbes,
+  probeToLocation
+} = require('./state')
 const log = require('../../log')
 
 let sessionStarted = false
+const probes = new Map()
+let scriptLoadingStabilizedResolve
+const scriptLoadingStabilized = new Promise((resolve) => { scriptLoadingStabilizedResolve = resolve })
+
+// There's a race condition when a probe is first added, where the actual script that the probe is supposed to match
+// hasn't been loaded yet. This will result in either the probe not being added at all, or an incorrect script being
+// matched as the probe target.
+//
+// Therefore, once new scripts has been loaded, all probes are re-evaluated. If the matched `scriptId` has changed, we
+// simply remove the old probe (if it was added to the wrong script) and apply it again.
+session.on('scriptLoadingStabilized', () => {
+  log.debug('[debugger:devtools_client] Re-evaluating probes')
+  scriptLoadingStabilizedResolve()
+  for (const probe of probes.values()) {
+    reEvaluateProbe(probe).catch(err => {
+      log.error('[debugger:devtools_client] Error re-evaluating probe %s', probe.id, err)
+    })
+  }
+})
 
 module.exports = {
   addBreakpoint,
@@ -18,13 +43,14 @@ module.exports = {
 async function addBreakpoint (probe) {
   if (!sessionStarted) await start()
 
+  probes.set(probe.id, probe)
+
   const file = probe.where.sourceFile
   let lineNumber = Number(probe.where.lines[0]) // Tracer doesn't support multiple-line breakpoints
   let columnNumber = 0 // Probes do not contain/support column information
 
   // Optimize for sending data to /debugger/v1/input endpoint
   probe.location = { file, lines: [String(lineNumber)] }
-  delete probe.where
 
   // Optimize for fast calculations when probe is hit
   probe.templateRequiresEvaluation = templateRequiresEvaluation(probe.segments)
@@ -47,6 +73,8 @@ async function addBreakpoint (probe) {
   if (!script) throw new Error(`No loaded script found for ${file} (probe: ${probe.id}, version: ${probe.version})`)
   const { url, scriptId, sourceMapURL, source } = script
 
+  probe.scriptId = scriptId // Needed for detecting script changes during re-evaluation
+
   if (sourceMapURL) {
     log.debug(
       '[debugger:devtools_client] Translating location using source map for %s:%d:%d (probe: %s, version: %d)',
@@ -109,6 +137,8 @@ async function removeBreakpoint ({ id }) {
     throw Error(`Unknown probe id: ${id}`)
   }
 
+  probes.delete(id)
+
   const release = await lock()
 
   try {
@@ -173,23 +203,47 @@ async function updateBreakpoint (breakpoint, probe) {
   }
 }
 
-function start () {
+async function reEvaluateProbe (probe) {
+  const script = findScriptFromPartialPath(probe.where.sourceFile)
+  log.debug('[debugger:devtools_client] re-evaluating probe %s: %s => %s', probe.id, probe.scriptId, script?.scriptId)
+
+  if (probe.scriptId !== script?.scriptId) {
+    log.debug('[debugger:devtools_client] Better match found for probe %s, re-evaluating', probe.id)
+    if (probeToLocation.has(probe.id)) {
+      await removeBreakpoint(probe)
+    }
+    await addBreakpoint(probe)
+  }
+}
+
+async function start () {
   sessionStarted = true
-  return session.post('Debugger.enable')
+  log.debug('[debugger:devtools_client] Starting debugger')
+  await session.post('Debugger.enable')
+
+  // Wait until there's a pause in script-loading to avoid accidentally adding probes to incorrect scripts. This is not
+  // a guarantee, but best effort.
+  log.debug('[debugger:devtools_client] Waiting for script-loading to stabilize')
+  await scriptLoadingStabilized
+  log.debug('[debugger:devtools_client] Script loading stabilized')
 }
 
 function stop () {
   sessionStarted = false
+  clearState()
+  log.debug('[debugger:devtools_client] Stopping debugger')
   return session.post('Debugger.disable')
 }
 
 // Only if all probes have a condition can we use a compound condition.
 // Otherwise, we need to evaluate each probe individually once the breakpoint is hit.
-// TODO: Handle errors - if there's 2 conditons, and one fails but the other returns true, we should still pause the
-// breakpoint
 function compileCompoundCondition (probes) {
+  if (probes.length === 1) return probes[0].condition
+
   return probes.every(p => p.condition)
-    ? probes.map(p => p.condition).filter(Boolean).join(' || ')
+    ? probes
+      .map((p) => `(() => { try { return ${p.condition} } catch { return false } })()`)
+      .join(' || ')
     : undefined
 }
 

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

@@ -6,7 +6,7 @@ const session = require('./session')
 const { getLocalStateForCallFrame } = require('./snapshot')
 const send = require('./send')
 const { getStackFromCallFrames } = require('./state')
-const { ackEmitting, ackError } = require('./status')
+const { ackEmitting } = require('./status')
 const { parentThreadId } = require('./config')
 const { MAX_SNAPSHOTS_PER_SECOND_GLOBALLY } = require('./defaults')
 const log = require('../../log')
@@ -36,7 +36,6 @@ const getDDTagsExpression = `(() => {
 const threadId = parentThreadId === 0 ? `pid:${process.pid}` : `pid:${process.pid};tid:${parentThreadId}`
 const threadName = parentThreadId === 0 ? 'MainThread' : `WorkerThread:${parentThreadId}`
 
-const SUPPORT_ITERATOR_METHODS = NODE_MAJOR >= 22
 const SUPPORT_ARRAY_BUFFER_RESIZE = NODE_MAJOR >= 20
 const oneSecondNs = 1_000_000_000n
 let globalSnapshotSamplingRateWindowStart = 0n
@@ -77,14 +76,6 @@ session.on('Debugger.paused', async ({ params }) => {
       }
     }
 
-    // If all the probes have a condition, we know that it triggered. If at least one probe doesn't have a condition, we
-    // need to verify which conditions are met.
-    const shouldVerifyConditions = (
-      SUPPORT_ITERATOR_METHODS
-        ? probesAtLocation.values()
-        : Array.from(probesAtLocation.values())
-    ).some((probe) => probe.condition === undefined)
-
     for (const probe of probesAtLocation.values()) {
       if (start - probe.lastCaptureNs < probe.nsBetweenSampling) {
         continue
@@ -109,7 +100,7 @@ session.on('Debugger.paused', async ({ params }) => {
         maxLength = highestOrUndefined(probe.capture.maxLength, maxLength)
       }
 
-      if (shouldVerifyConditions && probe.condition !== undefined) {
+      if (probe.condition !== undefined) {
         // TODO: Bundle all conditions and evaluate them in a single call
         // TODO: Handle errors
         const { result } = await session.post('Debugger.evaluateOnCallFrame', {
@@ -153,20 +144,11 @@ session.on('Debugger.paused', async ({ params }) => {
     evalResults = result?.value ?? []
   }
 
-  let processLocalState
-  if (numberOfProbesWithSnapshots !== 0) {
-    try {
-      // TODO: Create unique states for each affected probe based on that probes unique `capture` settings (DEBUG-2863)
-      processLocalState = await getLocalStateForCallFrame(
-        params.callFrames[0],
-        { maxReferenceDepth, maxCollectionSize, maxFieldCount, maxLength }
-      )
-    } catch (err) {
-      for (let i = 0; i < numberOfProbesWithSnapshots; i++) {
-        ackError(err, probes[snapshotProbeIndex[i]]) // TODO: Ok to continue after sending ackError?
-      }
-    }
-  }
+  // TODO: Create unique states for each affected probe based on that probes unique `capture` settings (DEBUG-2863)
+  const processLocalState = numberOfProbesWithSnapshots !== 0 && await getLocalStateForCallFrame(
+    params.callFrames[0],
+    { maxReferenceDepth, maxCollectionSize, maxFieldCount, maxLength }
+  )
 
   await session.post('Debugger.resume')
   const diff = process.hrtime.bigint() - start // TODO: Recored as telemetry (DEBUG-2858)
@@ -206,7 +188,9 @@ session.on('Debugger.paused', async ({ params }) => {
 
     if (probe.captureSnapshot) {
       const state = processLocalState()
-      if (state) {
+      if (state instanceof Error) {
+        snapshot.captureError = state.message
+      } else if (state) {
         snapshot.captures = {
           lines: { [probe.location.lines[0]]: { locals: state } }
         }

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

@@ -13,7 +13,8 @@ const { version } = require('../../../../../package.json')
 module.exports = send
 
 const MAX_MESSAGE_LENGTH = 8 * 1024 // 8KB
-const MAX_LOG_PAYLOAD_SIZE = 1024 * 1024 // 1MB
+const MAX_LOG_PAYLOAD_SIZE_MB = 1
+const MAX_LOG_PAYLOAD_SIZE_BYTES = MAX_LOG_PAYLOAD_SIZE_MB * 1024 * 1024
 
 const ddsource = 'dd_debugger'
 const hostname = getHostname()
@@ -48,13 +49,13 @@ function send (message, logger, dd, snapshot) {
   let json = JSON.stringify(payload)
   let size = Buffer.byteLength(json)
 
-  if (size > MAX_LOG_PAYLOAD_SIZE) {
+  if (size > MAX_LOG_PAYLOAD_SIZE_BYTES) {
     // TODO: This is a very crude way to handle large payloads. Proper pruning will be implemented later (DEBUG-2624)
-    const line = Object.values(payload.debugger.snapshot.captures.lines)[0]
-    line.locals = {
-      notCapturedReason: 'Snapshot was too large',
-      size: Object.keys(line.locals).length
-    }
+    delete payload.debugger.snapshot.captures
+    payload.debugger.snapshot.captureError =
+      `Snapshot was too large (max allowed size is ${MAX_LOG_PAYLOAD_SIZE_MB} MiB). ` +
+      'Consider reducing the capture depth or turn off "Capture Variables" completely, ' +
+      'and instead include the variables of interest directly in the message template.'
     json = JSON.stringify(payload)
     size = Buffer.byteLength(json)
   }

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

@@ -2,6 +2,7 @@
 
 const { getRuntimeObject } = require('./collector')
 const { processRawState } = require('./processor')
+const log = require('../../../log')
 
 const DEFAULT_MAX_REFERENCE_DEPTH = 3
 const DEFAULT_MAX_COLLECTION_SIZE = 100
@@ -24,13 +25,20 @@ async function getLocalStateForCallFrame (
   const rawState = []
   let processedState = null
 
-  await Promise.all(callFrame.scopeChain.map(async (scope) => {
-    if (scope.type === 'global') return // The global scope is too noisy
-    rawState.push(...await getRuntimeObject(
-      scope.object.objectId,
-      { maxReferenceDepth, maxCollectionSize, maxFieldCount }
-    ))
-  }))
+  try {
+    await Promise.all(callFrame.scopeChain.map(async (scope) => {
+      if (scope.type === 'global') return // The global scope is too noisy
+      rawState.push(...await getRuntimeObject(
+        scope.object.objectId,
+        { maxReferenceDepth, maxCollectionSize, maxFieldCount }
+      ))
+    }))
+  } catch (err) {
+    // TODO: We might be able to get part of the scope chain.
+    // Consider if we could set errors just for the part of the scope chain that throws during collection.
+    log.error('[debugger:devtools_client] Error getting local state for call frame', err)
+    return () => new Error('Error getting local state')
+  }
 
   // Deplay calling `processRawState` so the caller gets a chance to resume the main thread before processing `rawState`
   return () => {

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

@@ -9,12 +9,16 @@ const WINDOWS_DRIVE_LETTER_REGEX = /[a-zA-Z]/
 
 const loadedScripts = []
 const scriptUrls = new Map()
+let reEvaluateProbesTimer = null
 
 module.exports = {
   locationToBreakpoint: new Map(),
   breakpointToProbes: new Map(),
   probeToLocation: new Map(),
 
+  _loadedScripts: loadedScripts, // Only exposed for testing
+  _scriptUrls: scriptUrls, // Only exposed for testing
+
   /**
    * Find the script to inspect based on a partial or absolute path. Handles both Windows and POSIX paths.
    *
@@ -88,11 +92,15 @@ module.exports = {
       }
     }
 
-    return maxMatchLength > -1 ? bestMatch : null
+    return maxMatchLength !== -1 ? bestMatch : null
   },
 
   getStackFromCallFrames (callFrames) {
     return callFrames.map((frame) => {
+      // TODO: Possible race condition: If the breakpoint is in the process of being removed, and this is the last
+      // breakpoint, it will also stop the debugging session, which in turn will clear the state, which means clearing
+      // the `scriptUrls` map. That might result in this the `scriptUrls.get` call above returning `undefined`, which
+      // will throw when `startsWith` is called on it.
       let fileName = scriptUrls.get(frame.location.scriptId)
       if (fileName.startsWith('file://')) fileName = fileName.substr(7) // TODO: This might not be required
       return {
@@ -102,6 +110,14 @@ module.exports = {
         columnNumber: frame.location.columnNumber + 1 // Beware! columnNumber is zero-indexed
       }
     })
+  },
+
+  // The maps locationToBreakpoint, breakpointToProbes, and probeToLocation are always updated when breakpoints are
+  // removed. Therefore they do not need to get manually cleared. Only the state internal to this file needs to be
+  // cleared.
+  clearState () {
+    loadedScripts.length = 0
+    scriptUrls.clear()
   }
 }
 
@@ -112,7 +128,6 @@ module.exports = {
 // Unknown params.url values:
 // - `structured-stack` - Not sure what this is, but should just be ignored
 // - `` - Not sure what this is, but should just be ignored
-// TODO: Event fired for all files, every time debugger is enabled. So when we disable it, we need to reset the state
 session.on('Debugger.scriptParsed', ({ params }) => {
   scriptUrls.set(params.scriptId, params.url)
   if (params.url.startsWith('file:')) {
@@ -142,5 +157,10 @@ session.on('Debugger.scriptParsed', ({ params }) => {
     } else {
       loadedScripts.push(params)
     }
+
+    clearTimeout(reEvaluateProbesTimer)
+    reEvaluateProbesTimer = setTimeout(() => {
+      session.emit('scriptLoadingStabilized')
+    }, 500)
   }
 })

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

@@ -392,6 +392,8 @@ class CustomMetrics {
    * These are translated into [ 'tagName:tagValue' ] for internal use
    */
   static tagTranslator (objTags) {
+    if (Array.isArray(objTags)) return objTags
+
     const arrTags = []
 
     if (!objTags) return arrTags

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

@@ -10,43 +10,25 @@ const uuidSource =
 '[0-9a-f]{8}[-_][0-9a-f]{4}[-_][0-9a-f]{4}[-_][0-9a-f]{4}[-_][0-9a-f]{12}|[0-9a-f]{8}(?:-[0-9a-f]{4}){4}$'
 const containerSource = '[0-9a-f]{64}'
 const taskSource = '[0-9a-f]{32}-\\d+'
-const lineReg = /^(\d+):([^:]*):(.+)$/
+const lineReg = /^(\d+):([^:]*):(.+)$/m
 const entityReg = new RegExp(`.*(${uuidSource}|${containerSource}|${taskSource})(?:\\.scope)?$`, 'm')
 
-const cgroup = readControlGroup()
-const entityId = getEntityId()
-const inode = getInode()
+let inode = 0
+let cgroup = ''
+let entityId
 
-function getEntityId () {
-  const match = cgroup.match(entityReg) || []
+try {
+  cgroup = fs.readFileSync('/proc/self/cgroup', 'utf8').trim()
+  entityId = cgroup.match(entityReg)?.[1]
+} catch { /* Ignore error */ }
 
-  return match[1]
-}
-
-function getInode () {
-  const match = cgroup.match(lineReg) || []
-
-  return readInode(match[3])
-}
+const inodePath = cgroup.match(lineReg)?.[3]
+if (inodePath) {
+  const strippedPath = inodePath.replace(/^\/|\/$/g, '')
 
-function readControlGroup () {
   try {
-    return fs.readFileSync('/proc/self/cgroup').toString().trim()
-  } catch (err) {
-    return ''
-  }
-}
-
-function readInode (path) {
-  if (!path) return 0
-
-  const strippedPath = path.replace(/^\//, '').replace(/\/$/, '')
-
-  try {
-    return fs.statSync(`/sys/fs/cgroup/${strippedPath}`).ino
-  } catch (err) {
-    return 0
-  }
+    inode = fs.statSync(`/sys/fs/cgroup/${strippedPath}`).ino
+  } catch { /* Ignore error */ }
 }
 
 module.exports = {

package/packages/dd-trace/src/guardrails/telemetry.js

@@ -14,11 +14,8 @@ if (!process.env.DD_INJECTION_ENABLED) {
   module.exports = function () {}
 }
 
-if (!process.env.DD_TELEMETRY_FORWARDER_PATH) {
-  module.exports = function () {}
-}
-
-if (!fs.existsSync(process.env.DD_TELEMETRY_FORWARDER_PATH)) {
+var telemetryForwarderPath = process.env.DD_TELEMETRY_FORWARDER_PATH
+if (typeof telemetryForwarderPath !== 'string' || !fs.existsSync(telemetryForwarderPath)) {
   module.exports = function () {}
 }
 

package/packages/dd-trace/src/llmobs/tagger.js

@@ -148,12 +148,12 @@ class LLMObsTagger {
   }
 
   tagSpanTags (span, tags) {
-    // new tags will be merged with existing tags
     const currentTags = registry.get(span)?.[TAGS]
     if (currentTags) {
-      Object.assign(tags, currentTags)
+      Object.assign(currentTags, tags)
+    } else {
+      this._setTag(span, TAGS, tags)
     }
-    this._setTag(span, TAGS, tags)
   }
 
   changeKind (span, newKind) {

package/packages/dd-trace/src/llmobs/writers/base.js

@@ -41,6 +41,18 @@ class BaseLLMObsWriter {
     this._destroyed = false
   }
 
+  get url () {
+    if (this._agentless == null) return null
+
+    const baseUrl = this._baseUrl.href
+    const endpoint = this._endpoint
+
+    // Split on protocol separator to preserve it
+    // path.join will remove some slashes unnecessarily
+    const [protocol, rest] = baseUrl.split('://')
+    return protocol + '://' + path.join(rest, endpoint)
+  }
+
   append (event, byteLength) {
     if (this._buffer.length >= this._bufferLimit) {
       logger.warn(`${this.constructor.name} event buffer full (limit is ${this._bufferLimit}), dropping event`)
@@ -69,7 +81,7 @@ class BaseLLMObsWriter {
     const options = this._getOptions()
 
     request(payload, options, (err, resp, code) => {
-      parseResponseAndLog(err, code, events.length, options.url.href, this._eventType)
+      parseResponseAndLog(err, code, events.length, this.url, this._eventType)
     })
   }
 
@@ -87,17 +99,23 @@ class BaseLLMObsWriter {
 
   setAgentless (agentless) {
     this._agentless = agentless
-    this._url = this._getUrl()
-    logger.debug(`Configuring ${this.constructor.name} to ${this._url.href}`)
+    const { url, endpoint } = this._getUrlAndPath()
+
+    this._baseUrl = url
+    this._endpoint = endpoint
+
+    logger.debug(`Configuring ${this.constructor.name} to ${this.url}`)
   }
 
-  _getUrl () {
+  _getUrlAndPath () {
     if (this._agentless) {
-      return new URL(format({
-        protocol: 'https:',
-        hostname: `${this._intake}.${this._config.site}`,
-        pathname: this._endpoint
-      }))
+      return {
+        url: new URL(format({
+          protocol: 'https:',
+          hostname: `${this._intake}.${this._config.site}`
+        })),
+        endpoint: this._endpoint
+      }
     }
 
     const { hostname, port } = this._config
@@ -107,8 +125,10 @@ class BaseLLMObsWriter {
       port
     }))
 
-    const proxyPath = path.join(EVP_PROXY_AGENT_BASE_PATH, this._endpoint)
-    return new URL(proxyPath, base)
+    return {
+      url: base,
+      endpoint: path.join(EVP_PROXY_AGENT_BASE_PATH, this._endpoint)
+    }
   }
 
   _getOptions () {
@@ -118,7 +138,8 @@ class BaseLLMObsWriter {
       },
       method: 'POST',
       timeout: this._timeout,
-      url: this._url
+      url: this._baseUrl,
+      path: this._endpoint
     }
 
     if (this._agentless) {

package/packages/dd-trace/src/noop/proxy.js

@@ -16,6 +16,11 @@ class NoopProxy {
     this.appsec = noopAppsec
     this.dogstatsd = noopDogStatsDClient
     this.llmobs = noopLLMObs
+    this.setBaggageItem = () => {}
+    this.getBaggageItem = () => {}
+    this.getAllBaggageItems = () => {}
+    this.removeBaggageItem = () => {}
+    this.removeAllBaggageItems = () => {}
   }
 
   init () {

package/packages/dd-trace/src/opentelemetry/context_manager.js

@@ -12,6 +12,7 @@ class ContextManager {
     this._store = storage('opentelemetry')
   }
 
+  // converts dd to otel
   active () {
     const activeSpan = tracer.scope().active()
     const store = this._store.getStore()
@@ -54,6 +55,7 @@ class ContextManager {
       : wrappedContext
   }
 
+  // converts otel to dd
   with (context, fn, thisArg, ...args) {
     const span = trace.getSpan(context)
     const ddScope = tracer.scope()