dd-trace 5.57.1 → 5.59.0

package/packages/dd-trace/src/datastreams/schemas/schema_builder.js

@@ -1,4 +1,6 @@
-const LRUCache = require('lru-cache')
+'use strict'
+
+const { LRUCache } = require('lru-cache')
 const { fnv64 } = require('../fnv')
 const { Schema } = require('./schema')
 
@@ -13,22 +15,24 @@ class SchemaBuilder {
     this.properties = 0
   }
 
+  // TODO: This is only used in tests. Let's refactor the code and stop exposing the cache.
   static getCache () {
     return CACHE
   }
 
   static getSchemaDefinition (schema) {
-    const noNones = convertToJsonCompatible(schema)
-    const definition = jsonStringify(noNones)
+    const definition = toJSON(schema)
     const id = fnv64(Buffer.from(definition, 'utf8')).toString()
     return new Schema(definition, id)
   }
 
   static getSchema (schemaName, iterator, builder) {
-    if (!CACHE.has(schemaName)) {
-      CACHE.set(schemaName, (builder ?? new SchemaBuilder(iterator)).build())
+    let entry = CACHE.get(schemaName)
+    if (!entry) {
+      entry = (builder ?? new SchemaBuilder(iterator)).build()
+      CACHE.set(schemaName, entry)
     }
-    return CACHE.get(schemaName)
+    return entry
   }
 
   build () {
@@ -92,42 +96,47 @@ class OpenApiComponents {
   }
 }
 
-function convertToJsonCompatible (obj) {
-  if (Array.isArray(obj)) {
-    return obj.filter(item => item !== null).map(item => convertToJsonCompatible(item))
-  } else if (obj && typeof obj === 'object') {
-    const jsonObj = {}
-    for (const [key, value] of Object.entries(obj)) {
-      if (value !== null) {
-        jsonObj[key] = convertToJsonCompatible(value)
+// This adds a single whitespace between entries without adding newlines.
+// This differs from JSON.stringify and is used to align with the output
+// in other platforms.
+// TODO: Add tests to verify this behavior. A couple of cases are not
+// covered by the existing tests.
+function toJSON (value) {
+  // eslint-disable-next-line eslint-rules/eslint-safe-typeof-object
+  if (typeof value === 'object') {
+    if (value === null) {
+      return 'null'
+    }
+    if (Array.isArray(value)) {
+      let result = '['
+      for (let i = 0; i < value.length; i++) {
+        if (value[i] !== null) {
+          if (i !== 0) {
+            result += ', '
+          }
+          result += value[i] === undefined ? 'null' : toJSON(value[i])
+        }
       }
+      return `${result}]`
     }
-    return jsonObj
-  }
-  return obj
-}
-
-function convertKey (key) {
-  if (key === 'enumValues') {
-    return 'enum'
+    let result = '{'
+    for (const [key, objectValue] of Object.entries(value)) {
+      if (objectValue != null && typeof key === 'string') {
+        const converted = toJSON(objectValue)
+        if (converted !== undefined) {
+          if (result !== '{') {
+            result += ', '
+          }
+          result += `"${key}": ${converted}`
+        }
+      }
+    }
+    return `${result}}`
   }
-  return key
-}
-
-function jsonStringify (obj, indent = 2) {
-  // made to stringify json exactly similar to python / java in order for hashing to be the same
-  const jsonString = JSON.stringify(obj, (_, value) => value, indent)
-  return jsonString.replaceAll(/^ +/gm, ' ') // Replace leading spaces with single space
-    .replaceAll('\n', '') // Remove newlines
-    .replaceAll('{ ', '{') // Remove space after '{'
-    .replaceAll(' }', '}') // Remove space before '}'
-    .replaceAll('[ ', '[') // Remove space after '['
-    .replaceAll(' ]', ']') // Remove space before ']'
+  return JSON.stringify(value)
 }
 
 module.exports = {
   SchemaBuilder,
   OpenApiSchema,
-  convertToJsonCompatible,
-  convertKey
 }

package/packages/dd-trace/src/datastreams/schemas/schema_sampler.js

@@ -1,3 +1,5 @@
+'use strict'
+
 const SAMPLE_INTERVAL_MILLIS = 30 * 1000
 
 class SchemaSampler {

package/packages/dd-trace/src/datastreams/writer.js

@@ -1,3 +1,5 @@
+'use strict'
+
 const pkg = require('../../../../package.json')
 const log = require('../log')
 const request = require('../exporters/common/request')

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

@@ -40,11 +40,19 @@ const SUPPORT_ARRAY_BUFFER_RESIZE = NODE_MAJOR >= 20
 const oneSecondNs = 1_000_000_000n
 let globalSnapshotSamplingRateWindowStart = 0n
 let snapshotsSampledWithinTheLastSecond = 0
-// TODO: Is a limit of 256 snapshots ever going to be a problem?
-const snapshotProbeIndexBuffer = new ArrayBuffer(1, { maxByteLength: 256 })
-// TODO: Is a limit of 256 probes ever going to be a problem?
+
 // TODO: Change to const once we drop support for Node.js 18
-let snapshotProbeIndex = new Uint8Array(snapshotProbeIndexBuffer)
+let snapshotProbeIndexBuffer, snapshotProbeIndex
+
+if (SUPPORT_ARRAY_BUFFER_RESIZE) {
+  // TODO: Is a limit of 256 snapshots ever going to be a problem?
+  // eslint-disable-next-line n/no-unsupported-features/es-syntax
+  snapshotProbeIndexBuffer = new ArrayBuffer(1, { maxByteLength: 256 })
+  // TODO: Is a limit of 256 probes ever going to be a problem?
+  snapshotProbeIndex = new Uint8Array(snapshotProbeIndexBuffer)
+} else {
+  snapshotProbeIndex = new Uint8Array(1)
+}
 
 // WARNING: The code above the line `await session.post('Debugger.resume')` is highly optimized. Please edit with care!
 session.on('Debugger.paused', async ({ params }) => {

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

@@ -1,5 +1,7 @@
 'use strict'
 
+/* eslint n/no-unsupported-features/node-builtins: ['error', { ignores: ['inspector/promises'] }] */
+
 const { builtinModules } = require('node:module')
 
 if (builtinModules.includes('inspector/promises')) {

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const { workerData: { rcPort } } = require('node:worker_threads')
+const { workerData: { probePort } } = require('node:worker_threads')
 const { addBreakpoint, removeBreakpoint, modifyBreakpoint } = require('./breakpoints')
 const { ackReceived, ackInstalled, ackError } = require('./status')
 const log = require('../../log')
@@ -32,16 +32,19 @@ const log = require('../../log')
 //   sampling: { snapshotsPerSecond: 5000 },
 //   evaluateAt: 'EXIT' // only used for method probes
 // }
-rcPort.on('message', async ({ action, conf: probe, ackId }) => {
+probePort.on('message', async ({ action, probe, ackId }) => {
   try {
     await processMsg(action, probe)
-    rcPort.postMessage({ ackId })
+    probePort.postMessage({ ackId })
   } catch (err) {
-    rcPort.postMessage({ ackId, error: err })
+    probePort.postMessage({ ackId, error: err })
     ackError(err, probe)
   }
 })
-rcPort.on('messageerror', (err) => log.error('[debugger:devtools_client] received "messageerror" on RC port', err))
+probePort.on(
+  'messageerror',
+  (err) => log.error('[debugger:devtools_client] received "messageerror" on probe port', err)
+)
 
 async function processMsg (action, probe) {
   log.debug(

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

@@ -1,4 +1,4 @@
-'use stict'
+'use strict'
 
 module.exports = {
   collectionSizeSym: Symbol('datadog.collectionSize'),

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

@@ -1,5 +1,6 @@
 'use strict'
 
+const { readFile } = require('fs')
 const { types } = require('util')
 const { join } = require('path')
 const { Worker, MessageChannel, threadId: parentThreadId } = require('worker_threads')
@@ -23,17 +24,24 @@ function start (config, rc) {
   log.debug('[debugger] Starting Dynamic Instrumentation client...')
 
   const rcAckCallbacks = new Map()
-  const rcChannel = new MessageChannel()
+  const probeChannel = new MessageChannel()
   configChannel = new MessageChannel()
 
   process[Symbol.for('datadog:node:util:types')] = types
 
-  rc.setProductHandler('LIVE_DEBUGGING', (action, conf, id, ack) => {
+  readProbeFile(config.dynamicInstrumentation.probeFile, (probes) => {
+    const action = 'apply'
+    for (const probe of probes) {
+      probeChannel.port2.postMessage({ action, probe })
+    }
+  })
+
+  rc.setProductHandler('LIVE_DEBUGGING', (action, probe, id, ack) => {
     rcAckCallbacks.set(++ackId, ack)
-    rcChannel.port2.postMessage({ action, conf, ackId })
+    probeChannel.port2.postMessage({ action, probe, ackId })
   })
 
-  rcChannel.port2.on('message', ({ ackId, error }) => {
+  probeChannel.port2.on('message', ({ ackId, error }) => {
     const ack = rcAckCallbacks.get(ackId)
     if (ack === undefined) {
       // This should never happen, but just in case something changes in the future, we should guard against it
@@ -44,7 +52,7 @@ function start (config, rc) {
     ack(error)
     rcAckCallbacks.delete(ackId)
   })
-  rcChannel.port2.on('messageerror', (err) => log.error('[debugger] received "messageerror" on RC port', err))
+  probeChannel.port2.on('messageerror', (err) => log.error('[debugger] received "messageerror" on probe port', err))
 
   worker = new Worker(
     join(__dirname, 'devtools_client', 'index.js'),
@@ -54,10 +62,10 @@ function start (config, rc) {
       workerData: {
         config: config.serialize(),
         parentThreadId,
-        rcPort: rcChannel.port1,
+        probePort: probeChannel.port1,
         configPort: configChannel.port1
       },
-      transferList: [rcChannel.port1, configChannel.port1]
+      transferList: [probeChannel.port1, configChannel.port1]
     }
   )
 
@@ -84,8 +92,8 @@ function start (config, rc) {
   })
 
   worker.unref()
-  rcChannel.port1.unref()
-  rcChannel.port2.unref()
+  probeChannel.port1.unref()
+  probeChannel.port2.unref()
   configChannel.port1.unref()
   configChannel.port2.unref()
 }
@@ -94,3 +102,22 @@ function configure (config) {
   if (configChannel === null) return
   configChannel.port2.postMessage(config.serialize())
 }
+
+function readProbeFile (path, cb) {
+  if (!path) return
+
+  log.debug('[debugger] Reading probe file: %s', path)
+  readFile(path, 'utf8', (err, data) => {
+    if (err) {
+      log.error('[debugger] Failed to read probe file: %s', path, err)
+      return
+    }
+    try {
+      const parsedData = JSON.parse(data)
+      log.debug('[debugger] Successfully parsed probe file: %s', path)
+      cb(parsedData)
+    } catch (err) {
+      log.error('[debugger] Probe file (%s) is not valid JSON', path, err)
+    }
+  })
+}

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

@@ -1,3 +1,5 @@
+'use strict'
+
 // From agent truncators: https://github.com/DataDog/datadog-agent/blob/main/pkg/trace/agent/truncator.go
 
 // Values from: https://github.com/DataDog/datadog-agent/blob/main/pkg/trace/traceutil/truncate.go#L22-L27

package/packages/dd-trace/src/exporters/common/agent-info-exporter.js

@@ -1,3 +1,5 @@
+'use strict'
+
 const { URL, format } = require('url')
 
 const request = require('./request')

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

@@ -19,7 +19,7 @@ const maxActiveRequests = 8
 let activeRequests = 0
 
 function parseUrl (urlObjOrString) {
-  if (typeof urlObjOrString === 'object') return urlToHttpOptions(urlObjOrString)
+  if (urlObjOrString !== null && typeof urlObjOrString === 'object') return urlToHttpOptions(urlObjOrString)
 
   const url = urlToHttpOptions(new URL(urlObjOrString))
 

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

@@ -1,3 +1,5 @@
+'use strict'
+
 const { getEnvironmentVariable } = require('../../config-helper')
 
 function safeJSONStringify (value) {

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

@@ -1,3 +1,5 @@
+'use strict'
+
 const { URL, format } = require('url')
 
 const { Writer } = require('./writer')

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

@@ -1,3 +1,5 @@
+'use strict'
+
 const { SpanStatsEncoder } = require('../../encode/span-stats')
 
 const pkg = require('../../../../../package.json')

package/packages/dd-trace/src/external-logger/src/index.js

@@ -1,3 +1,5 @@
+'use strict'
+
 const tracerLogger = require('../../log')// path to require tracer logger
 
 const https = require('https')

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

@@ -1,3 +1,5 @@
+'use strict'
+
 const { SCI_COMMIT_SHA, SCI_REPOSITORY_URL } = require('./constants')
 
 class GitMetadataTagger {

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

@@ -1,3 +1,5 @@
+'use strict'
+
 const commitSHARegex = /git\.commit\.sha=([a-f\d]{40})/
 const repositoryUrlRegex = /git\.repository_url=([\w\d:@/.-]+)/
 

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

@@ -1,7 +1,5 @@
 'use strict'
 
-/* eslint-disable no-var */
-
 var path = require('path')
 var Module = require('module')
 var isTrue = require('./util').isTrue
@@ -26,9 +24,11 @@ function guard (fn) {
     var resolvedInApp
     var entrypoint = process.argv[1]
     try {
+      // eslint-disable-next-line n/no-unsupported-features/node-builtins
       resolvedInApp = Module.createRequire(entrypoint).resolve('dd-trace')
     } catch (e) {
       // Ignore. If we can't resolve the module, we assume it's not in the app.
+      // TODO: There's also the possibility that this version of Node.js doesn't have Module.createRequire (pre v12.2.0)
     }
     if (resolvedInApp) {
       var ourselves = path.normalize(path.join(__dirname, '..', '..', '..', '..', 'index.js'))
@@ -54,8 +54,7 @@ function guard (fn) {
   }
 
   if (!clobberBailout && (!initBailout || forced)) {
-    // Ensure the instrumentation source is set for the current process and potential 
-    // child processes.
+    // Ensure the instrumentation source is set for the current process and potential child processes.
     var result = fn()
     telemetry('complete', ['injection_forced:' + (forced && initBailout ? 'true' : 'false')])
     log.info('Application instrumentation bootstrapping complete')

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

@@ -1,6 +1,5 @@
 'use strict'
 
-/* eslint-disable no-var */
 /* eslint-disable no-console */
 
 var isTrue = require('./util').isTrue
@@ -23,7 +22,8 @@ var logLevel = isTrue(DD_TRACE_DEBUG)
   : logLevels.off
 
 var log = {
-  debug: logLevel <= 20 ? console.debug.bind(console) : function () {},
+  /* eslint n/no-unsupported-features/node-builtins: ['error', { ignores: ['console.debug'] }] */
+  debug: logLevel <= 20 ? (console.debug || console.log).bind(console) : function () {},
   info: logLevel <= 30 ? console.info.bind(console) : function () {},
   warn: logLevel <= 40 ? console.warn.bind(console) : function () {},
   error: logLevel <= 50 ? console.error.bind(console) : function () {}

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

@@ -1,8 +1,5 @@
 'use strict'
 
-/* eslint-disable no-var */
-/* eslint-disable object-shorthand */
-
 var fs = require('fs')
 var spawn = require('child_process').spawn
 var tracerVersion = require('../../../../package.json').version
@@ -11,12 +8,12 @@ var log = require('./log')
 module.exports = sendTelemetry
 
 if (!process.env.DD_INJECTION_ENABLED) {
-  module.exports = function () {}
+  module.exports = function noop () {}
 }
 
 var telemetryForwarderPath = process.env.DD_TELEMETRY_FORWARDER_PATH
 if (typeof telemetryForwarderPath !== 'string' || !fs.existsSync(telemetryForwarderPath)) {
-  module.exports = function () {}
+  module.exports = function noop () {}
 }
 
 var metadata = {
@@ -28,18 +25,23 @@ var metadata = {
   pid: process.pid
 }
 
-var seen = []
-function hasSeen (point) {
+var seen = {}
+function shouldSend (point) {
   if (point.name === 'abort') {
     // This one can only be sent once, regardless of tags
-    return seen.includes('abort')
-  }
-  if (point.name === 'abort.integration') {
+    if (seen.abort) {
+      return false
+    }
+    seen.abort = true
+  } else if (point.name === 'abort.integration') {
     // For now, this is the only other one we want to dedupe
     var compiledPoint = point.name + point.tags.join('')
-    return seen.includes(compiledPoint)
+    if (seen[compiledPoint]) {
+      return false
+    }
+    seen[compiledPoint] = true
   }
-  return false
+  return true
 }
 
 function sendTelemetry (name, tags) {
@@ -48,9 +50,9 @@ function sendTelemetry (name, tags) {
     points = [{ name: name, tags: tags || [] }]
   }
   if (['1', 'true', 'True'].indexOf(process.env.DD_INJECT_FORCE) !== -1) {
-    points = points.filter(function (p) { return ['error', 'complete'].includes(p.name) })
+    points = points.filter(function (p) { return ['error', 'complete'].indexOf(p.name) !== -1 })
   }
-  points = points.filter(function (p) { return !hasSeen(p) })
+  points = points.filter(function (p) { return shouldSend(p) })
   for (var i = 0; i < points.length; i++) {
     points[i].name = 'library_entrypoint.' + points[i].name
   }

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

@@ -1,7 +1,5 @@
 'use strict'
 
-/* eslint-disable object-shorthand */
-
 function isTrue (str) {
   str = String(str).toLowerCase()
   return str === 'true' || str === '1'

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

@@ -0,0 +1,58 @@
+'use strict'
+
+const { join } = require('path')
+const { setImmediate, setTimeout } = require('timers/promises')
+const { format } = require('util')
+const { writeHeapSnapshot } = require('v8')
+const { threadId } = require('worker_threads')
+const log = require('./log')
+
+async function scheduleSnapshot (config, total) {
+  if (total > config.heapSnapshot.count) return
+
+  await setTimeout(config.heapSnapshot.interval * 1000, null, { ref: false })
+  await clearMemory()
+  writeHeapSnapshot(getName(config.heapSnapshot.destination))
+  await scheduleSnapshot(config, total + 1)
+}
+
+async function clearMemory () {
+  if (!globalThis.gc) return
+  globalThis.gc()
+  await setImmediate()
+  globalThis.gc() // Run full GC a second time for anything missed in first GC.
+}
+
+function pad (value) {
+  return String(value).padStart(2, 0)
+}
+
+function getName (destination) {
+  const date = new Date()
+  const filename = format(
+    'Heap-%s%s%s-%s%s%s-%s-%s.heapsnapshot',
+    date.getFullYear(),
+    pad(date.getMonth()),
+    pad(date.getDate()),
+    pad(date.getHours()),
+    pad(date.getMinutes()),
+    pad(date.getSeconds()),
+    process.pid,
+    threadId
+  )
+
+  return join(destination, filename)
+}
+
+module.exports = {
+  async start (config) {
+    const destination = config.heapSnapshot.destination
+
+    try {
+      await scheduleSnapshot(config, 1)
+      log.debug('Wrote heap snapshots to %s.', destination)
+    } catch (e) {
+      log.error('Failed to write heap snapshots to %s.', destination, e)
+    }
+  }
+}

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

@@ -39,7 +39,7 @@ class NoopLLMObs {
     const llmobs = this
     return function (target, ctxOrPropertyKey, descriptor) {
       if (!ctxOrPropertyKey) return target
-      if (typeof ctxOrPropertyKey === 'object') {
+      if (typeof ctxOrPropertyKey === 'object') { // eslint-disable-line eslint-rules/eslint-safe-typeof-object
         const ctx = ctxOrPropertyKey
         if (ctx.kind !== 'method') return target
 

package/packages/dd-trace/src/llmobs/plugins/bedrockruntime.js

@@ -1,3 +1,5 @@
+'use strict'
+
 const BaseLLMObsPlugin = require('./base')
 const { storage } = require('../../../../datadog-core')
 const llmobsStore = storage('llmobs')

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

@@ -8,9 +8,14 @@ const ROLE_MAPPINGS = {
 
 class LangChainLLMObsHandler {
   constructor (tagger) {
+    /** @type {import('../../../tagger')} */
     this._tagger = tagger
   }
 
+  getName ({ span }) {
+    return span?.context()._tags?.['resource.name']
+  }
+
   setMetaTags () {}
 
   formatIO (messages) {

package/packages/dd-trace/src/llmobs/plugins/langchain/handlers/tool.js

@@ -0,0 +1,15 @@
+'use strict'
+
+const LangChainLLMObsHandler = require('.')
+
+class LangChainLLMObsToolHandler extends LangChainLLMObsHandler {
+  getName ({ instance }) {
+    return instance.name
+  }
+
+  setMetaTags ({ span, inputs, results }) {
+    this._tagger.tagTextIO(span, inputs, results)
+  }
+}
+
+module.exports = LangChainLLMObsToolHandler

package/packages/dd-trace/src/llmobs/plugins/langchain/handlers/vectorstore.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const LangChainLLMObsHandler = require('.')
+const { spanHasError } = require('../../../util')
+
+class LangChainLLMObsVectorStoreHandler extends LangChainLLMObsHandler {
+  setMetaTags ({ span, inputs, results }) {
+    const input = this.formatIO(inputs)
+    if (spanHasError(span)) {
+      this._tagger.tagRetrievalIO(span, input)
+      return
+    }
+
+    const documents = []
+    for (const documentResult of results) {
+      let document, score
+      if (Array.isArray(documentResult)) {
+        document = documentResult[0]
+        score = documentResult[1]
+      } else {
+        document = documentResult
+      }
+
+      documents.push({
+        text: document.pageContent,
+        id: document.id,
+        name: document.metadata?.source,
+        score
+      })
+    }
+
+    this._tagger.tagRetrievalIO(span, input, documents)
+  }
+}
+
+module.exports = LangChainLLMObsVectorStoreHandler