dd-trace 4.52.0 → 4.53.0

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

@@ -55,7 +55,7 @@ function ackEmitting ({ id: probeId, version }) {
 }
 
 function ackError (err, { id: probeId, version }) {
-  log.error(err)
+  log.error('[debugger:devtools_client] ackError', err)
 
   onlyUniqueUpdates(STATUSES.ERROR, probeId, version, () => {
     const payload = statusPayload(probeId, version, STATUSES.ERROR)
@@ -87,16 +87,16 @@ function send (payload) {
   }
 
   request(form, options, (err) => {
-    if (err) log.error(err)
+    if (err) log.error('[debugger:devtools_client] Error sending debugger payload', err)
   })
 }
 
-function statusPayload (probeId, version, status) {
+function statusPayload (probeId, probeVersion, status) {
   return {
     ddsource,
     service,
     debugger: {
-      diagnostics: { probeId, runtimeId, version, status }
+      diagnostics: { probeId, runtimeId, probeVersion, status }
     }
   }
 }

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

@@ -18,7 +18,7 @@ module.exports = {
 function start (config, rc) {
   if (worker !== null) return
 
-  log.debug('Starting Dynamic Instrumentation client...')
+  log.debug('[debugger] Starting Dynamic Instrumentation client...')
 
   const rcAckCallbacks = new Map()
   const rcChannel = new MessageChannel()
@@ -33,14 +33,14 @@ function start (config, rc) {
     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
-      log.error(`Received an unknown ackId: ${ackId}`)
-      if (error) log.error(error)
+      log.error('[debugger] Received an unknown ackId: %s', ackId)
+      if (error) log.error('[debugger] Error starting Dynamic Instrumentation client', error)
       return
     }
     ack(error)
     rcAckCallbacks.delete(ackId)
   })
-  rcChannel.port2.on('messageerror', (err) => log.error(err))
+  rcChannel.port2.on('messageerror', (err) => log.error('[debugger] received "messageerror" on RC port', err))
 
   worker = new Worker(
     join(__dirname, 'devtools_client', 'index.js'),
@@ -57,19 +57,17 @@ function start (config, rc) {
     }
   )
 
-  worker.unref()
-
   worker.on('online', () => {
-    log.debug(`Dynamic Instrumentation worker thread started successfully (thread id: ${worker.threadId})`)
+    log.debug('[debugger] Dynamic Instrumentation worker thread started successfully (thread id: %d)', worker.threadId)
   })
 
-  worker.on('error', (err) => log.error(err))
-  worker.on('messageerror', (err) => log.error(err))
+  worker.on('error', (err) => log.error('[debugger] worker thread error', err))
+  worker.on('messageerror', (err) => log.error('[debugger] received "messageerror" from worker', err))
 
   worker.on('exit', (code) => {
     const error = new Error(`Dynamic Instrumentation worker thread exited unexpectedly with code ${code}`)
 
-    log.error(error)
+    log.error('[debugger] worker thread exited unexpectedly', error)
 
     // Be nice, clean up now that the worker thread encounted an issue and we can't continue
     rc.removeProductHandler('LIVE_DEBUGGING')
@@ -80,6 +78,12 @@ function start (config, rc) {
       rcAckCallbacks.delete(ackId)
     }
   })
+
+  worker.unref()
+  rcChannel.port1.unref()
+  rcChannel.port2.unref()
+  configChannel.port1.unref()
+  configChannel.port2.unref()
 }
 
 function configure (config) {

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

@@ -71,7 +71,7 @@ class DogStatsDClient {
     const buffer = Buffer.concat(queue)
     request(buffer, this._httpOptions, (err) => {
       if (err) {
-        log.error('HTTP error from agent: ' + err.stack)
+        log.error('DogStatsDClient: HTTP error from agent: %s', err.message, err)
         if (err.status === 404) {
           // Inside this if-block, we have connectivity to the agent, but
           // we're not getting a 200 from the proxy endpoint. If it's a 404,
@@ -89,7 +89,7 @@ class DogStatsDClient {
       this._sendUdpFromQueue(queue, this._host, this._family)
     } else {
       lookup(this._host, (err, address, family) => {
-        if (err) return log.error(err)
+        if (err) return log.error('DogStatsDClient: Host not found', err)
         this._sendUdpFromQueue(queue, address, family)
       })
     }

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

@@ -1,26 +1,20 @@
 'use strict'
 
 const { truncateSpan, normalizeSpan } = require('./tags-processors')
-const Chunk = require('./chunk')
+const { Chunk, MsgpackEncoder } = require('../msgpack')
 const log = require('../log')
 const { isTrue } = require('../util')
 const coalesce = require('koalas')
 
 const SOFT_LIMIT = 8 * 1024 * 1024 // 8MB
 
-const float64Array = new Float64Array(1)
-const uInt8Float64Array = new Uint8Array(float64Array.buffer)
-
-float64Array[0] = -1
-
-const bigEndian = uInt8Float64Array[7] === 0
-
 function formatSpan (span) {
   return normalizeSpan(truncateSpan(span, false))
 }
 
 class AgentEncoder {
   constructor (writer, limit = SOFT_LIMIT) {
+    this._msgpack = new MsgpackEncoder()
     this._limit = limit
     this._traceBytes = new Chunk()
     this._stringBytes = new Chunk()
@@ -84,11 +78,11 @@ class AgentEncoder {
       bytes.reserve(1)
 
       if (span.type && span.meta_struct) {
-        bytes.buffer[bytes.length++] = 0x8d
+        bytes.buffer[bytes.length - 1] = 0x8d
       } else if (span.type || span.meta_struct) {
-        bytes.buffer[bytes.length++] = 0x8c
+        bytes.buffer[bytes.length - 1] = 0x8c
       } else {
-        bytes.buffer[bytes.length++] = 0x8b
+        bytes.buffer[bytes.length - 1] = 0x8b
       }
 
       if (span.type) {
@@ -135,43 +129,31 @@ class AgentEncoder {
     this._cacheString('')
   }
 
-  _encodeArrayPrefix (bytes, value) {
-    const length = value.length
-    const offset = bytes.length
+  _encodeBuffer (bytes, buffer) {
+    this._msgpack.encodeBin(bytes, buffer)
+  }
 
-    bytes.reserve(5)
-    bytes.length += 5
+  _encodeBool (bytes, value) {
+    this._msgpack.encodeBoolean(bytes, value)
+  }
 
-    bytes.buffer[offset] = 0xdd
-    bytes.buffer[offset + 1] = length >> 24
-    bytes.buffer[offset + 2] = length >> 16
-    bytes.buffer[offset + 3] = length >> 8
-    bytes.buffer[offset + 4] = length
+  _encodeArrayPrefix (bytes, value) {
+    this._msgpack.encodeArrayPrefix(bytes, value)
   }
 
   _encodeMapPrefix (bytes, keysLength) {
-    const offset = bytes.length
-
-    bytes.reserve(5)
-    bytes.length += 5
-    bytes.buffer[offset] = 0xdf
-    bytes.buffer[offset + 1] = keysLength >> 24
-    bytes.buffer[offset + 2] = keysLength >> 16
-    bytes.buffer[offset + 3] = keysLength >> 8
-    bytes.buffer[offset + 4] = keysLength
+    this._msgpack.encodeMapPrefix(bytes, keysLength)
   }
 
   _encodeByte (bytes, value) {
-    bytes.reserve(1)
-
-    bytes.buffer[bytes.length++] = value
+    this._msgpack.encodeByte(bytes, value)
   }
 
+  // TODO: Use BigInt instead.
   _encodeId (bytes, id) {
     const offset = bytes.length
 
     bytes.reserve(9)
-    bytes.length += 9
 
     id = id.toArray()
 
@@ -186,36 +168,16 @@ class AgentEncoder {
     bytes.buffer[offset + 8] = id[7]
   }
 
-  _encodeInteger (bytes, value) {
-    const offset = bytes.length
-
-    bytes.reserve(5)
-    bytes.length += 5
+  _encodeNumber (bytes, value) {
+    this._msgpack.encodeNumber(bytes, value)
+  }
 
-    bytes.buffer[offset] = 0xce
-    bytes.buffer[offset + 1] = value >> 24
-    bytes.buffer[offset + 2] = value >> 16
-    bytes.buffer[offset + 3] = value >> 8
-    bytes.buffer[offset + 4] = value
+  _encodeInteger (bytes, value) {
+    this._msgpack.encodeInteger(bytes, value)
   }
 
   _encodeLong (bytes, value) {
-    const offset = bytes.length
-    const hi = (value / Math.pow(2, 32)) >> 0
-    const lo = value >>> 0
-
-    bytes.reserve(9)
-    bytes.length += 9
-
-    bytes.buffer[offset] = 0xcf
-    bytes.buffer[offset + 1] = hi >> 24
-    bytes.buffer[offset + 2] = hi >> 16
-    bytes.buffer[offset + 3] = hi >> 8
-    bytes.buffer[offset + 4] = hi
-    bytes.buffer[offset + 5] = lo >> 24
-    bytes.buffer[offset + 6] = lo >> 16
-    bytes.buffer[offset + 7] = lo >> 8
-    bytes.buffer[offset + 8] = lo
+    this._msgpack.encodeLong(bytes, value)
   }
 
   _encodeMap (bytes, value) {
@@ -252,23 +214,7 @@ class AgentEncoder {
   }
 
   _encodeFloat (bytes, value) {
-    float64Array[0] = value
-
-    const offset = bytes.length
-    bytes.reserve(9)
-    bytes.length += 9
-
-    bytes.buffer[offset] = 0xcb
-
-    if (bigEndian) {
-      for (let i = 0; i <= 7; i++) {
-        bytes.buffer[offset + i + 1] = uInt8Float64Array[i]
-      }
-    } else {
-      for (let i = 7; i >= 0; i--) {
-        bytes.buffer[bytes.length - i - 1] = uInt8Float64Array[i]
-      }
-    }
+    this._msgpack.encodeFloat(bytes, value)
   }
 
   _encodeMetaStruct (bytes, value) {
@@ -294,7 +240,6 @@ class AgentEncoder {
     const offset = bytes.length
 
     bytes.reserve(prefixLength)
-    bytes.length += prefixLength
 
     this._encodeObject(bytes, value)
 

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

@@ -251,37 +251,6 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     }
   }
 
-  _encodeNumber (bytes, value) {
-    if (Math.floor(value) !== value) { // float 64
-      return this._encodeFloat(bytes, value)
-    }
-    return this._encodeLong(bytes, value)
-  }
-
-  _encodeLong (bytes, value) {
-    const isPositive = value >= 0
-
-    const hi = isPositive ? (value / Math.pow(2, 32)) >> 0 : Math.floor(value / Math.pow(2, 32))
-    const lo = value >>> 0
-    const flag = isPositive ? 0xcf : 0xd3
-
-    const offset = bytes.length
-
-    // int 64
-    bytes.reserve(9)
-    bytes.length += 9
-
-    bytes.buffer[offset] = flag
-    bytes.buffer[offset + 1] = hi >> 24
-    bytes.buffer[offset + 2] = hi >> 16
-    bytes.buffer[offset + 3] = hi >> 8
-    bytes.buffer[offset + 4] = hi
-    bytes.buffer[offset + 5] = lo >> 24
-    bytes.buffer[offset + 6] = lo >> 16
-    bytes.buffer[offset + 7] = lo >> 8
-    bytes.buffer[offset + 8] = lo
-  }
-
   _encode (bytes, trace) {
     if (this._isReset) {
       this._encodePayloadStart(bytes)
@@ -380,7 +349,6 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     // Get offset of the events list to update the length of the array when calling `makePayload`
     this._eventsOffset = bytes.length
     bytes.reserve(5)
-    bytes.length += 5
   }
 
   reset () {

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

@@ -1,6 +1,6 @@
 'use strict'
 const { AgentEncoder } = require('./0.4')
-const Chunk = require('./chunk')
+const { Chunk } = require('../msgpack')
 
 const {
   distributionMetric,
@@ -82,7 +82,6 @@ class CoverageCIVisibilityEncoder extends AgentEncoder {
     // Get offset of the coverages list to update the length of the array when calling `makePayload`
     this._coveragesOffset = bytes.length
     bytes.reserve(5)
-    bytes.length += 5
   }
 
   makePayload () {

package/packages/dd-trace/src/encode/span-stats.js

@@ -22,10 +22,6 @@ function truncate (value, maxLength, suffix = '') {
 }
 
 class SpanStatsEncoder extends AgentEncoder {
-  _encodeBool (bytes, value) {
-    this._encodeByte(bytes, value ? 0xc3 : 0xc2)
-  }
-
   makePayload () {
     const traceSize = this._traceBytes.length
     const buffer = Buffer.allocUnsafe(traceSize)
@@ -34,32 +30,6 @@ class SpanStatsEncoder extends AgentEncoder {
     return buffer
   }
 
-  _encodeMapPrefix (bytes, length) {
-    const offset = bytes.length
-
-    bytes.reserve(1)
-    bytes.length += 1
-
-    bytes.buffer[offset] = 0x80 + length
-  }
-
-  _encodeBuffer (bytes, buffer) {
-    const length = buffer.length
-    const offset = bytes.length
-
-    bytes.reserve(5)
-    bytes.length += 5
-
-    bytes.buffer[offset] = 0xc6
-    bytes.buffer[offset + 1] = length >> 24
-    bytes.buffer[offset + 2] = length >> 16
-    bytes.buffer[offset + 3] = length >> 8
-    bytes.buffer[offset + 4] = length
-
-    buffer.copy(bytes.buffer, offset + 5)
-    bytes.length += length
-  }
-
   _encodeStat (bytes, stat) {
     this._encodeMapPrefix(bytes, 12)
 

package/packages/dd-trace/src/exporters/agent/writer.js

@@ -41,17 +41,17 @@ class Writer extends BaseWriter {
       startupLog({ agentError: err })
 
       if (err) {
-        log.error(err)
+        log.error('Error sending payload to the agent (status code: %s)', err.status, err)
         done()
         return
       }
 
-      log.debug(`Response from the agent: ${res}`)
+      log.debug('Response from the agent: %s', res)
 
       try {
         this._prioritySampler.update(JSON.parse(res).rate_by_service)
       } catch (e) {
-        log.error(e)
+        log.error('Error updating prioritySampler rates', e)
 
         runtimeMetrics.increment(`${METRIC_PREFIX}.errors`, true)
         runtimeMetrics.increment(`${METRIC_PREFIX}.errors.by.name`, `name:${e.name}`, true)

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

@@ -86,7 +86,7 @@ function request (data, options, callback) {
         if (isGzip) {
           zlib.gunzip(buffer, (err, result) => {
             if (err) {
-              log.error(`Could not gunzip response: ${err.message}`)
+              log.error('Could not gunzip response: %s', err.message)
               callback(null, '', res.statusCode)
             } else {
               callback(null, result.toString(), res.statusCode)

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

@@ -16,7 +16,7 @@ class Writer extends BaseWriter {
   _sendPayload (data, _, done) {
     makeRequest(data, this._url, (err, res) => {
       if (err) {
-        log.error(err)
+        log.error('Error sending span stats', err)
         done()
         return
       }

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

@@ -83,7 +83,7 @@ const flare = {
       headers: form.getHeaders()
     }, (err) => {
       if (err) {
-        log.error(err)
+        log.error('Error sending flare payload', err)
       }
     })
   }

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

@@ -0,0 +1,64 @@
+'use strict'
+
+/* eslint-disable no-var */
+
+var path = require('path')
+var Module = require('module')
+var isTrue = require('./util').isTrue
+var log = require('./log')
+var telemetry = require('./telemetry')
+var nodeVersion = require('../../../../version')
+
+var NODE_MAJOR = nodeVersion.NODE_MAJOR
+
+function guard (fn) {
+  var initBailout = false
+  var clobberBailout = false
+  var forced = isTrue(process.env.DD_INJECT_FORCE)
+  var engines = require('../../../../package.json').engines
+  var minMajor = parseInt(engines.node.replace(/[^0-9]/g, ''))
+  var version = process.versions.node
+
+  if (process.env.DD_INJECTION_ENABLED) {
+    // If we're running via single-step install, and we're in the app's
+    // node_modules, then we should not initialize the tracer. This prevents
+    // single-step-installed tracer from clobbering the manually-installed tracer.
+    var resolvedInApp
+    var entrypoint = process.argv[1]
+    try {
+      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.
+    }
+    if (resolvedInApp) {
+      var ourselves = path.normalize(path.join(__dirname, '..', '..', '..', '..', 'index.js'))
+      if (ourselves !== resolvedInApp) {
+        clobberBailout = true
+      }
+    }
+  }
+
+  // If the runtime doesn't match the engines field in package.json, then we
+  // should not initialize the tracer.
+  if (!clobberBailout && NODE_MAJOR < minMajor) {
+    initBailout = true
+    telemetry([
+      { name: 'abort', tags: ['reason:incompatible_runtime'] },
+      { name: 'abort.runtime', tags: [] }
+    ])
+    log.info('Aborting application instrumentation due to incompatible_runtime.')
+    log.info('Found incompatible runtime nodejs ' + version + ', Supported runtimes: nodejs ' + engines.node + '.')
+    if (forced) {
+      log.info('DD_INJECT_FORCE enabled, allowing unsupported runtimes and continuing.')
+    }
+  }
+
+  if (!clobberBailout && (!initBailout || forced)) {
+    var result = fn()
+    telemetry('complete', ['injection_forced:' + (forced && initBailout ? 'true' : 'false')])
+    log.info('Application instrumentation bootstrapping complete')
+    return result
+  }
+}
+
+module.exports = guard

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

@@ -0,0 +1,32 @@
+'use strict'
+
+/* eslint-disable no-var */
+/* eslint-disable no-console */
+
+var isTrue = require('./util').isTrue
+
+var DD_TRACE_DEBUG = process.env.DD_TRACE_DEBUG
+var DD_TRACE_LOG_LEVEL = process.env.DD_TRACE_LOG_LEVEL
+
+var logLevels = {
+  trace: 20,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  critical: 50,
+  off: 100
+}
+
+var logLevel = isTrue(DD_TRACE_DEBUG)
+  ? Number(DD_TRACE_LOG_LEVEL) || logLevels.debug
+  : logLevels.off
+
+var log = {
+  debug: logLevel <= 20 ? console.debug.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 () {}
+}
+
+module.exports = log

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

@@ -0,0 +1,78 @@
+'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
+var log = require('./log')
+
+module.exports = sendTelemetry
+
+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)) {
+  module.exports = function () {}
+}
+
+var metadata = {
+  language_name: 'nodejs',
+  language_version: process.versions.node,
+  runtime_name: 'nodejs',
+  runtime_version: process.versions.node,
+  tracer_version: tracerVersion,
+  pid: process.pid
+}
+
+var seen = []
+function hasSeen (point) {
+  if (point.name === 'abort') {
+    // This one can only be sent once, regardless of tags
+    return seen.includes('abort')
+  }
+  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)
+  }
+  return false
+}
+
+function sendTelemetry (name, tags) {
+  var points = name
+  if (typeof name === 'string') {
+    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 !hasSeen(p) })
+  for (var i = 0; i < points.length; i++) {
+    points[i].name = 'library_entrypoint.' + points[i].name
+  }
+  if (points.length === 0) {
+    return
+  }
+  var proc = spawn(process.env.DD_TELEMETRY_FORWARDER_PATH, ['library_entrypoint'], {
+    stdio: 'pipe'
+  })
+  proc.on('error', function () {
+    log.error('Failed to spawn telemetry forwarder')
+  })
+  proc.on('exit', function (code) {
+    if (code !== 0) {
+      log.error('Telemetry forwarder exited with code ' + code)
+    }
+  })
+  proc.stdin.on('error', function () {
+    log.error('Failed to write telemetry data to telemetry forwarder')
+  })
+  proc.stdin.end(JSON.stringify({ metadata: metadata, points: points }))
+}

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

@@ -0,0 +1,10 @@
+'use strict'
+
+/* eslint-disable object-shorthand */
+
+function isTrue (str) {
+  str = String(str).toLowerCase()
+  return str === 'true' || str === '1'
+}
+
+module.exports = { isTrue: isTrue }

package/packages/dd-trace/src/lambda/runtime/ritm.js

@@ -101,7 +101,7 @@ const registerLambdaHook = () => {
         try {
           moduleExports = hook(moduleExports)
         } catch (e) {
-          log.error(e)
+          log.error('Error executing lambda hook', e)
         }
       }
 
@@ -120,7 +120,7 @@ const registerLambdaHook = () => {
           try {
             moduleExports = hook(moduleExports)
           } catch (e) {
-            log.error(e)
+            log.error('Error executing lambda hook for datadog-lambda-js', e)
           }
         }
       }

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

@@ -1,7 +1,6 @@
 'use strict'
 
-// TODO: remove this and use namespaced storage once available
-const { AsyncLocalStorage } = require('async_hooks')
-const storage = new AsyncLocalStorage()
+const { storage: createStorage } = require('../../../datadog-core')
+const storage = createStorage('llmobs')
 
 module.exports = { storage }

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

@@ -74,11 +74,11 @@ class BaseLLMObsWriter {
     request(payload, options, (err, resp, code) => {
       if (err) {
         logger.error(
-          `Error sending ${events.length} LLMObs ${this._eventType} events to ${this._url}: ${err.message}`
+          'Error sending %d LLMObs %s events to %s: %s', events.length, this._eventType, this._url, err.message, err
         )
       } else if (code >= 300) {
         logger.error(
-          `Error sending ${events.length} LLMObs ${this._eventType} events to ${this._url}: ${code}`
+          'Error sending %d LLMObs %s events to %s: %s', events.length, this._eventType, this._url, code
         )
       } else {
         logger.debug(`Sent ${events.length} LLMObs ${this._eventType} events to ${this._url}`)