dd-trace 5.21.0 → 5.23.0

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

@@ -0,0 +1,57 @@
+'use strict'
+
+const { randomUUID } = require('crypto')
+const { breakpoints } = require('./state')
+const session = require('./session')
+const send = require('./send')
+const { ackEmitting } = require('./status')
+const { parentThreadId } = require('./config')
+const log = require('../../log')
+const { version } = require('../../../../../package.json')
+
+require('./remote_config')
+
+// There doesn't seem to be an official standard for the content of these fields, so we're just populating them with
+// something that should be useful to a Node.js developer.
+const threadId = parentThreadId === 0 ? `pid:${process.pid}` : `pid:${process.pid};tid:${parentThreadId}`
+const threadName = parentThreadId === 0 ? 'MainThread' : `WorkerThread:${parentThreadId}`
+
+session.on('Debugger.paused', async ({ params }) => {
+  const start = process.hrtime.bigint()
+  const timestamp = Date.now()
+  const probes = params.hitBreakpoints.map((id) => breakpoints.get(id))
+  await session.post('Debugger.resume')
+  const diff = process.hrtime.bigint() - start // TODO: Should this be recored as telemetry?
+
+  log.debug(`Finished processing breakpoints - main thread paused for: ${Number(diff) / 1000000} ms`)
+
+  const logger = {
+    // We can safely use `location.file` from the first probe in the array, since all probes hit by `hitBreakpoints`
+    // must exist in the same file since the debugger can only pause the main thread in one location.
+    name: probes[0].location.file, // name of the class/type/file emitting the snapshot
+    method: params.callFrames[0].functionName, // name of the method/function emitting the snapshot
+    version,
+    thread_id: threadId,
+    thread_name: threadName
+  }
+
+  // TODO: Send multiple probes in one HTTP request as an array
+  for (const probe of probes) {
+    const snapshot = {
+      id: randomUUID(),
+      timestamp,
+      probe: {
+        id: probe.id,
+        version: probe.version,
+        location: probe.location
+      },
+      language: 'javascript'
+    }
+
+    // TODO: Process template
+    send(probe.template, logger, snapshot, (err) => {
+      if (err) log.error(err)
+      else ackEmitting(probe)
+    })
+  }
+})

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

@@ -0,0 +1,23 @@
+'use strict'
+
+const { builtinModules } = require('node:module')
+
+if (builtinModules.includes('inspector/promises')) {
+  module.exports = require('node:inspector/promises')
+} else {
+  const inspector = require('node:inspector')
+  const { promisify } = require('node:util')
+
+  // The rest of the code in this file is lifted from:
+  // https://github.com/nodejs/node/blob/1d4d76ff3fb08f9a0c55a1d5530b46c4d5d550c7/lib/inspector/promises.js
+  class Session extends inspector.Session {
+    constructor () { super() } // eslint-disable-line no-useless-constructor
+  }
+
+  Session.prototype.post = promisify(inspector.Session.prototype.post)
+
+  module.exports = {
+    ...inspector,
+    Session
+  }
+}

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

@@ -0,0 +1,164 @@
+'use strict'
+
+const { workerData: { rcPort } } = require('node:worker_threads')
+const { getScript, probes, breakpoints } = require('./state')
+const session = require('./session')
+const { ackReceived, ackInstalled, ackError } = require('./status')
+const log = require('../../log')
+
+let sessionStarted = false
+
+// Example log line probe (simplified):
+// {
+//   id: '100c9a5c-45ad-49dc-818b-c570d31e11d1',
+//   version: 0,
+//   type: 'LOG_PROBE',
+//   where: { sourceFile: 'index.js', lines: ['25'] }, // only use first array element
+//   template: 'Hello World 2',
+//   segments: [...],
+//   captureSnapshot: true,
+//   capture: { maxReferenceDepth: 1 },
+//   sampling: { snapshotsPerSecond: 1 },
+//   evaluateAt: 'EXIT' // only used for method probes
+// }
+//
+// Example log method probe (simplified):
+// {
+//   id: 'd692ee6d-5734-4df7-9d86-e3bc6449cc8c',
+//   version: 0,
+//   type: 'LOG_PROBE',
+//   where: { typeName: 'index.js', methodName: 'handlerA' },
+//   template: 'Executed index.js.handlerA, it took {@duration}ms',
+//   segments: [...],
+//   captureSnapshot: false,
+//   capture: { maxReferenceDepth: 3 },
+//   sampling: { snapshotsPerSecond: 5000 },
+//   evaluateAt: 'EXIT' // only used for method probes
+// }
+rcPort.on('message', async ({ action, conf: probe, ackId }) => {
+  try {
+    await processMsg(action, probe)
+    rcPort.postMessage({ ackId })
+  } catch (err) {
+    rcPort.postMessage({ ackId, error: err })
+    ackError(err, probe)
+  }
+})
+rcPort.on('messageerror', (err) => log.error(err))
+
+async function start () {
+  sessionStarted = true
+  return session.post('Debugger.enable') // return instead of await to reduce number of promises created
+}
+
+async function stop () {
+  sessionStarted = false
+  return session.post('Debugger.disable') // return instead of await to reduce number of promises created
+}
+
+async function processMsg (action, probe) {
+  log.debug(`Received request to ${action} ${probe.type} probe (id: ${probe.id}, version: ${probe.version})`)
+
+  if (action !== 'unapply') ackReceived(probe)
+
+  if (probe.type !== 'LOG_PROBE') {
+    throw new Error(`Unsupported probe type: ${probe.type} (id: ${probe.id}, version: ${probe.version})`)
+  }
+  if (!probe.where.sourceFile && !probe.where.lines) {
+    throw new Error(
+      // eslint-disable-next-line max-len
+      `Unsupported probe insertion point! Only line-based probes are supported (id: ${probe.id}, version: ${probe.version})`
+    )
+  }
+
+  // This lock is to ensure that we don't get the following race condition:
+  //
+  // When a breakpoint is being removed and there are no other breakpoints, we disable the debugger by calling
+  // `Debugger.disable` to free resources. However, if a new breakpoint is being added around the same time, we might
+  // have a race condition where the new breakpoint thinks that the debugger is already enabled because the removal of
+  // the other breakpoint hasn't had a chance to call `Debugger.disable` yet. Then once the code that's adding the new
+  // breakpoints tries to call `Debugger.setBreakpoint` it fails because in the meantime `Debugger.disable` was called.
+  //
+  // If the code is ever refactored to not tear down the debugger if there's no active breakpoints, we can safely remove
+  // this lock.
+  const release = await lock()
+
+  try {
+    switch (action) {
+      case 'unapply':
+        await removeBreakpoint(probe)
+        break
+      case 'apply':
+        await addBreakpoint(probe)
+        break
+      case 'modify':
+        // TODO: Can we modify in place?
+        await removeBreakpoint(probe)
+        await addBreakpoint(probe)
+        break
+      default:
+        throw new Error(
+          // eslint-disable-next-line max-len
+          `Cannot process probe ${probe.id} (version: ${probe.version}) - unknown remote configuration action: ${action}`
+        )
+    }
+  } finally {
+    release()
+  }
+}
+
+async function addBreakpoint (probe) {
+  if (!sessionStarted) await start()
+
+  const file = probe.where.sourceFile
+  const line = Number(probe.where.lines[0]) // Tracer doesn't support multiple-line breakpoints
+
+  // Optimize for sending data to /debugger/v1/input endpoint
+  probe.location = { file, lines: [line] }
+  delete probe.where
+
+  // TODO: Inbetween `await session.post('Debugger.enable')` and here, the scripts are parsed and cached.
+  // Maybe there's a race condition here or maybe we're guraenteed that `await session.post('Debugger.enable')` will
+  // not continue untill all scripts have been parsed?
+  const script = getScript(file)
+  if (!script) throw new Error(`No loaded script found for ${file} (probe: ${probe.id}, version: ${probe.version})`)
+  const [path, scriptId] = script
+
+  log.debug(`Adding breakpoint at ${path}:${line} (probe: ${probe.id}, version: ${probe.version})`)
+
+  const { breakpointId } = await session.post('Debugger.setBreakpoint', {
+    location: {
+      scriptId,
+      lineNumber: line - 1 // Beware! lineNumber is zero-indexed
+    }
+  })
+
+  probes.set(probe.id, breakpointId)
+  breakpoints.set(breakpointId, probe)
+
+  ackInstalled(probe)
+}
+
+async function removeBreakpoint ({ id }) {
+  if (!sessionStarted) {
+    // We should not get in this state, but abort if we do, so the code doesn't fail unexpected
+    throw Error(`Cannot remove probe ${id}: Debugger not started`)
+  }
+  if (!probes.has(id)) {
+    throw Error(`Unknown probe id: ${id}`)
+  }
+
+  const breakpointId = probes.get(id)
+  await session.post('Debugger.removeBreakpoint', { breakpointId })
+  probes.delete(id)
+  breakpoints.delete(breakpointId)
+
+  if (breakpoints.size === 0) await stop()
+}
+
+async function lock () {
+  if (lock.p) await lock.p
+  let resolve
+  lock.p = new Promise((_resolve) => { resolve = _resolve }).then(() => { lock.p = null })
+  return resolve
+}

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

@@ -0,0 +1,28 @@
+'use strict'
+
+const config = require('./config')
+const request = require('../../exporters/common/request')
+
+module.exports = send
+
+const ddsource = 'dd_debugger'
+const service = config.service
+
+function send (message, logger, snapshot, cb) {
+  const opts = {
+    method: 'POST',
+    url: config.url,
+    path: '/debugger/v1/input',
+    headers: { 'Content-Type': 'application/json; charset=utf-8' }
+  }
+
+  const payload = {
+    ddsource,
+    service,
+    message,
+    logger,
+    'debugger.snapshot': snapshot
+  }
+
+  request(JSON.stringify(payload), opts, cb)
+}

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

@@ -0,0 +1,7 @@
+'use strict'
+
+const inspector = require('./inspector_promises_polyfill')
+
+const session = module.exports = new inspector.Session()
+
+session.connectToMainThread()

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

@@ -0,0 +1,47 @@
+'use strict'
+
+const session = require('./session')
+
+const scripts = []
+
+module.exports = {
+  probes: new Map(),
+  breakpoints: new Map(),
+
+  /**
+   * Find the matching script that can be inspected based on a partial path.
+   *
+   * Algorithm: Find the sortest url that ends in the requested path.
+   *
+   * Will identify the correct script as long as Node.js doesn't load a module from a `node_modules` folder outside the
+   * project root. If so, there's a risk that this path is shorter than the expected path inside the project root.
+   * Example of mismatch where path = `index.js`:
+   *
+   * Expected match:       /www/code/my-projects/demo-project1/index.js
+   * Actual shorter match: /www/node_modules/dd-trace/index.js
+   *
+   * To fix this, specify a more unique file path, e.g `demo-project1/index.js` instead of `index.js`
+   *
+   * @param {string} path
+   * @returns {[string, string] | undefined}
+   */
+  getScript (path) {
+    return scripts
+      .filter(([url]) => url.endsWith(path))
+      .sort(([a], [b]) => a.length - b.length)[0]
+  }
+}
+
+// Known params.url protocols:
+// - `node:` - Ignored, as we don't want to instrument Node.js internals
+// - `wasm:` - Ignored, as we don't support instrumenting WebAssembly
+// - `file:` - Regular on-disk file
+// 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 }) => {
+  if (params.url.startsWith('file:')) {
+    scripts.push([params.url, params.scriptId])
+  }
+})

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

@@ -0,0 +1,109 @@
+'use strict'
+
+const LRUCache = require('lru-cache')
+const config = require('./config')
+const request = require('../../exporters/common/request')
+const FormData = require('../../exporters/common/form-data')
+const log = require('../../log')
+
+module.exports = {
+  ackReceived,
+  ackInstalled,
+  ackEmitting,
+  ackError
+}
+
+const ddsource = 'dd_debugger'
+const service = config.service
+const runtimeId = config.runtimeId
+
+const cache = new LRUCache({
+  ttl: 1000 * 60 * 60, // 1 hour
+  // Unfortunate requirement when using LRUCache:
+  // It will emit a warning unless `ttlAutopurge`, `max`, or `maxSize` is set when using `ttl`.
+  // TODO: Consider alternative as this is NOT performant :(
+  ttlAutopurge: true
+})
+
+const STATUSES = {
+  RECEIVED: 'RECEIVED',
+  INSTALLED: 'INSTALLED',
+  EMITTING: 'EMITTING',
+  ERROR: 'ERROR',
+  BLOCKED: 'BLOCKED' // TODO: Implement once support for allow list, deny list or max probe limit has been added
+}
+
+function ackReceived ({ id: probeId, version }) {
+  onlyUniqueUpdates(
+    STATUSES.RECEIVED, probeId, version,
+    () => send(statusPayload(probeId, version, STATUSES.RECEIVED))
+  )
+}
+
+function ackInstalled ({ id: probeId, version }) {
+  onlyUniqueUpdates(
+    STATUSES.INSTALLED, probeId, version,
+    () => send(statusPayload(probeId, version, STATUSES.INSTALLED))
+  )
+}
+
+function ackEmitting ({ id: probeId, version }) {
+  onlyUniqueUpdates(
+    STATUSES.EMITTING, probeId, version,
+    () => send(statusPayload(probeId, version, STATUSES.EMITTING))
+  )
+}
+
+function ackError (err, { id: probeId, version }) {
+  log.error(err)
+
+  onlyUniqueUpdates(STATUSES.ERROR, probeId, version, () => {
+    const payload = statusPayload(probeId, version, STATUSES.ERROR)
+
+    payload.debugger.diagnostics.exception = {
+      type: err.code,
+      message: err.message,
+      stacktrace: err.stack
+    }
+
+    send(payload)
+  })
+}
+
+function send (payload) {
+  const form = new FormData()
+
+  form.append(
+    'event',
+    JSON.stringify(payload),
+    { filename: 'event.json', contentType: 'application/json; charset=utf-8' }
+  )
+
+  const options = {
+    method: 'POST',
+    url: config.url,
+    path: '/debugger/v1/diagnostics',
+    headers: form.getHeaders()
+  }
+
+  request(form, options, (err) => {
+    if (err) log.error(err)
+  })
+}
+
+function statusPayload (probeId, version, status) {
+  return {
+    ddsource,
+    service,
+    debugger: {
+      diagnostics: { probeId, runtimeId, version, status }
+    }
+  }
+}
+
+function onlyUniqueUpdates (type, id, version, fn) {
+  const key = `${type}-${id}-${version}`
+  if (cache.has(key)) return
+  fn()
+  cache.set(key)
+}

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

@@ -0,0 +1,92 @@
+'use strict'
+
+const { join } = require('path')
+const { Worker, MessageChannel, threadId: parentThreadId } = require('worker_threads')
+const log = require('../log')
+
+let worker = null
+let configChannel = null
+
+const { NODE_OPTIONS, ...env } = process.env
+
+module.exports = {
+  start,
+  configure
+}
+
+function start (config, rc) {
+  if (worker !== null) return
+
+  log.debug('Starting Dynamic Instrumentation client...')
+
+  const rcAckCallbacks = new Map()
+  const rcChannel = new MessageChannel()
+  configChannel = new MessageChannel()
+
+  rc.setProductHandler('LIVE_DEBUGGING', (action, conf, id, ack) => {
+    const ackId = `${id}-${conf.version}`
+    rcAckCallbacks.set(ackId, ack)
+    rcChannel.port2.postMessage({ action, conf, ackId })
+  })
+
+  rcChannel.port2.on('message', ({ ackId, error }) => {
+    rcAckCallbacks.get(ackId)(error)
+    rcAckCallbacks.delete(ackId)
+  })
+  rcChannel.port2.on('messageerror', (err) => log.error(err))
+
+  worker = new Worker(
+    join(__dirname, 'devtools_client', 'index.js'),
+    {
+      execArgv: [], // Avoid worker thread inheriting the `-r` command line argument
+      env, // Avoid worker thread inheriting the `NODE_OPTIONS` environment variable (in case it contains `-r`)
+      workerData: {
+        config: serializableConfig(config),
+        parentThreadId,
+        rcPort: rcChannel.port1,
+        configPort: configChannel.port1
+      },
+      transferList: [rcChannel.port1, configChannel.port1]
+    }
+  )
+
+  worker.unref()
+
+  worker.on('online', () => {
+    log.debug(`Dynamic Instrumentation worker thread started successfully (thread id: ${worker.threadId})`)
+  })
+
+  worker.on('error', (err) => log.error(err))
+  worker.on('messageerror', (err) => log.error(err))
+
+  worker.on('exit', (code) => {
+    const error = new Error(`Dynamic Instrumentation worker thread exited unexpectedly with code ${code}`)
+
+    log.error(error)
+
+    // Be nice, clean up now that the worker thread encounted an issue and we can't continue
+    rc.removeProductHandler('LIVE_DEBUGGING')
+    worker.removeAllListeners()
+    configChannel = null
+    for (const ackId of rcAckCallbacks.keys()) {
+      rcAckCallbacks.get(ackId)(error)
+      rcAckCallbacks.delete(ackId)
+    }
+  })
+}
+
+function configure (config) {
+  if (configChannel === null) return
+  configChannel.port2.postMessage(serializableConfig(config))
+}
+
+// TODO: Refactor the Config class so it never produces any config objects that are incompatible with MessageChannel
+function serializableConfig (config) {
+  // URL objects cannot be serialized over the MessageChannel, so we need to convert them to strings first
+  if (config.url instanceof URL) {
+    config = { ...config }
+    config.url = config.url.toString()
+  }
+
+  return config
+}

package/packages/dd-trace/src/encode/agentless-ci-visibility.js

@@ -43,9 +43,15 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     // length of `payload.events` when calling `makePayload`
     this._eventCount = 0
 
+    this.metadataTags = {}
+
     this.reset()
   }
 
+  setMetadataTags (tags) {
+    this.metadataTags = tags
+  }
+
   _encodeTestSuite (bytes, content) {
     let keysLength = TEST_SUITE_KEYS_LENGTH
     const itrCorrelationId = content.meta[ITR_CORRELATION_ID]
@@ -277,6 +283,10 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
   }
 
   _encode (bytes, trace) {
+    if (this._isReset) {
+      this._encodePayloadStart(bytes)
+      this._isReset = false
+    }
     const startTime = Date.now()
 
     const rawEvents = trace.map(formatSpan)
@@ -330,7 +340,8 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
         '*': {
           language: 'javascript',
           library_version: ddTraceVersion
-        }
+        },
+        ...this.metadataTags
       },
       events: []
     }
@@ -349,6 +360,22 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     this._encodeMapPrefix(bytes, Object.keys(payload.metadata).length)
     this._encodeString(bytes, '*')
     this._encodeMap(bytes, payload.metadata['*'])
+    if (payload.metadata.test) {
+      this._encodeString(bytes, 'test')
+      this._encodeMap(bytes, payload.metadata.test)
+    }
+    if (payload.metadata.test_suite_end) {
+      this._encodeString(bytes, 'test_suite_end')
+      this._encodeMap(bytes, payload.metadata.test_suite_end)
+    }
+    if (payload.metadata.test_module_end) {
+      this._encodeString(bytes, 'test_module_end')
+      this._encodeMap(bytes, payload.metadata.test_module_end)
+    }
+    if (payload.metadata.test_session_end) {
+      this._encodeString(bytes, 'test_session_end')
+      this._encodeMap(bytes, payload.metadata.test_session_end)
+    }
     this._encodeString(bytes, 'events')
     // Get offset of the events list to update the length of the array when calling `makePayload`
     this._eventsOffset = bytes.length
@@ -359,7 +386,7 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
   reset () {
     this._reset()
     this._eventCount = 0
-    this._encodePayloadStart(this._traceBytes)
+    this._isReset = true
   }
 }
 

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

@@ -183,7 +183,7 @@ function request (data, options, callback) {
 }
 
 function byteLength (data) {
-  return data.length > 0 ? data.reduce((prev, next) => prev + next.length, 0) : 0
+  return data.length > 0 ? data.reduce((prev, next) => prev + Buffer.byteLength(next, 'utf8'), 0) : 0
 }
 
 Object.defineProperty(request, 'writable', {

package/packages/dd-trace/src/lambda/handler.js

@@ -93,6 +93,7 @@ exports.datadog = function datadog (lambdaHandler) {
         return res
       })
     }
+    clearTimeout(__lambdaTimeout)
     return result
   }
 }

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

@@ -2,4 +2,15 @@
 
 const { registerLambdaHook } = require('./runtime/ritm')
 
-registerLambdaHook()
+/**
+ * It is safe to do it this way, since customers will never be expected to disable
+ * this specific instrumentation through the init config object.
+ */
+const _DD_TRACE_DISABLED_INSTRUMENTATIONS = process.env.DD_TRACE_DISABLED_INSTRUMENTATIONS || ''
+const _disabledInstrumentations = new Set(
+  _DD_TRACE_DISABLED_INSTRUMENTATIONS ? _DD_TRACE_DISABLED_INSTRUMENTATIONS.split(',') : []
+)
+
+if (!_disabledInstrumentations.has('lambda')) {
+  registerLambdaHook()
+}

package/packages/dd-trace/src/opentracing/propagation/text_map.js

@@ -236,8 +236,7 @@ class TextMapPropagator {
   }
 
   _hasParentIdInTags (spanContext) {
-    return tags.DD_PARENT_ID in spanContext._trace.tags &&
-      spanContext._trace.tags[tags.DD_PARENT_ID] !== zeroTraceId
+    return tags.DD_PARENT_ID in spanContext._trace.tags
   }
 
   _updateParentIdFromDdHeaders (carrier, firstSpanContext) {
@@ -445,10 +444,6 @@ class TextMapPropagator {
         }
       })
 
-      if (!spanContext._trace.tags[tags.DD_PARENT_ID]) {
-        spanContext._trace.tags[tags.DD_PARENT_ID] = zeroTraceId
-      }
-
       this._extractBaggageItems(carrier, spanContext)
       return spanContext
     }

package/packages/dd-trace/src/payload-tagging/config/aws.json

@@ -0,0 +1,30 @@
+{
+  "sns": {
+    "request": [
+      "$.Attributes.KmsMasterKeyId",
+      "$.Attributes.PlatformCredential",
+      "$.Attributes.PlatformPrincipal",
+      "$.Attributes.Token",
+      "$.AWSAccountId",
+      "$.Endpoint",
+      "$.OneTimePassword",
+      "$.phoneNumber",
+      "$.PhoneNumber",
+      "$.Token"
+    ],
+    "response": [
+      "$.Attributes.KmsMasterKeyId",
+      "$.Attributes.Token",
+      "$.Endpoints.*.Token",
+      "$.PhoneNumber",
+      "$.PhoneNumbers",
+      "$.phoneNumbers",
+      "$.PlatformApplication.*.PlatformCredential",
+      "$.PlatformApplication.*.PlatformPrincipal",
+      "$.Subscriptions.*.Endpoint"
+    ],
+    "expand": [
+      "$.MessageAttributes.*.StringValue"
+    ]
+  }
+}