dd-trace 2.12.2 → 2.15.0

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

@@ -0,0 +1,155 @@
+'use strict'
+
+const { AgentEncoder } = require('./0.4')
+
+const {
+  MAX_NAME_LENGTH,
+  MAX_SERVICE_LENGTH,
+  MAX_RESOURCE_NAME_LENGTH,
+  MAX_TYPE_LENGTH,
+  DEFAULT_SPAN_NAME,
+  DEFAULT_SERVICE_NAME
+} = require('./tags-processors')
+
+function truncate (value, maxLength, suffix = '') {
+  if (!value) {
+    return value
+  }
+  if (value.length > maxLength) {
+    return `${value.slice(0, maxLength)}${suffix}`
+  }
+  return value
+}
+
+class SpanStatsEncoder extends AgentEncoder {
+  _encodeBool (bytes, value) {
+    this._encodeByte(bytes, value ? 0xc3 : 0xc2)
+  }
+
+  makePayload () {
+    const traceSize = this._traceBytes.length
+    const buffer = Buffer.allocUnsafe(traceSize)
+    this._traceBytes.copy(buffer, 0, traceSize)
+    this._reset()
+    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)
+
+    this._encodeString(bytes, 'Service')
+    const service = stat.Service || DEFAULT_SERVICE_NAME
+    this._encodeString(bytes, truncate(service, MAX_SERVICE_LENGTH))
+
+    this._encodeString(bytes, 'Name')
+    const name = stat.Name || DEFAULT_SPAN_NAME
+    this._encodeString(bytes, truncate(name, MAX_NAME_LENGTH))
+
+    this._encodeString(bytes, 'Resource')
+    this._encodeString(bytes, truncate(stat.Resource, MAX_RESOURCE_NAME_LENGTH, '...'))
+
+    this._encodeString(bytes, 'HTTPStatusCode')
+    this._encodeInteger(bytes, stat.HTTPStatusCode)
+
+    this._encodeString(bytes, 'Type')
+    this._encodeString(bytes, truncate(stat.Type, MAX_TYPE_LENGTH))
+
+    this._encodeString(bytes, 'Hits')
+    this._encodeLong(bytes, stat.Hits)
+
+    this._encodeString(bytes, 'Errors')
+    this._encodeLong(bytes, stat.Errors)
+
+    this._encodeString(bytes, 'Duration')
+    this._encodeLong(bytes, stat.Duration)
+
+    this._encodeString(bytes, 'OkSummary')
+    this._encodeBuffer(bytes, stat.OkSummary)
+
+    this._encodeString(bytes, 'ErrorSummary')
+    this._encodeBuffer(bytes, stat.ErrorSummary)
+
+    this._encodeString(bytes, 'Synthetics')
+    this._encodeBool(bytes, stat.Synthetics)
+
+    this._encodeString(bytes, 'TopLevelHits')
+    this._encodeLong(bytes, stat.TopLevelHits)
+  }
+
+  _encodeBucket (bytes, bucket) {
+    this._encodeMapPrefix(bytes, 3)
+
+    this._encodeString(bytes, 'Start')
+    this._encodeLong(bytes, bucket.Start)
+
+    this._encodeString(bytes, 'Duration')
+    this._encodeLong(bytes, bucket.Duration)
+
+    this._encodeString(bytes, 'Stats')
+    this._encodeArrayPrefix(bytes, bucket.Stats)
+    for (const stat of bucket.Stats) {
+      this._encodeStat(bytes, stat)
+    }
+  }
+
+  _encode (bytes, stats) {
+    this._encodeMapPrefix(bytes, 8)
+
+    this._encodeString(bytes, 'Hostname')
+    this._encodeString(bytes, stats.Hostname)
+
+    this._encodeString(bytes, 'Env')
+    this._encodeString(bytes, stats.Env)
+
+    this._encodeString(bytes, 'Version')
+    this._encodeString(bytes, stats.Version)
+
+    this._encodeString(bytes, 'Stats')
+    this._encodeArrayPrefix(bytes, stats.Stats)
+    for (const bucket of stats.Stats) {
+      this._encodeBucket(bytes, bucket)
+    }
+
+    this._encodeString(bytes, 'Lang')
+    this._encodeString(bytes, stats.Lang)
+
+    this._encodeString(bytes, 'TracerVersion')
+    this._encodeString(bytes, stats.TracerVersion)
+
+    this._encodeString(bytes, 'RuntimeID')
+    this._encodeString(bytes, stats.RuntimeID)
+
+    this._encodeString(bytes, 'Sequence')
+    this._encodeLong(bytes, stats.Sequence)
+  }
+}
+
+module.exports = {
+  SpanStatsEncoder
+}

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

@@ -3,17 +3,28 @@
 const URL = require('url').URL
 const log = require('../../log')
 const Writer = require('./writer')
-const Scheduler = require('../scheduler')
 
 class AgentExporter {
-  constructor ({ url, hostname, port, flushInterval, lookup, protocolVersion }, prioritySampler) {
+  constructor (config, prioritySampler) {
+    this._config = config
+    const { url, hostname, port, lookup, protocolVersion, stats = {} } = config
     this._url = url || new URL(`http://${hostname || 'localhost'}:${port}`)
-    this._writer = new Writer({ url: this._url, prioritySampler, lookup, protocolVersion })
 
-    if (flushInterval > 0) {
-      this._scheduler = new Scheduler(() => this._writer.flush(), flushInterval)
+    const headers = {}
+    if (stats.enabled) {
+      headers['Datadog-Client-Computed-Stats'] = 'yes'
     }
-    this._scheduler && this._scheduler.start()
+
+    this._writer = new Writer({
+      url: this._url,
+      prioritySampler,
+      lookup,
+      protocolVersion,
+      headers
+    })
+
+    this._timer = undefined
+    process.once('beforeExit', () => this._writer.flush())
   }
 
   setUrl (url) {
@@ -29,8 +40,15 @@ class AgentExporter {
   export (spans) {
     this._writer.append(spans)
 
-    if (!this._scheduler) {
+    const { flushInterval } = this._config
+
+    if (flushInterval === 0) {
       this._writer.flush()
+    } else if (flushInterval > 0 && !this._timer) {
+      this._timer = setTimeout(() => {
+        this._writer.flush()
+        this._timer = clearTimeout(this._timer)
+      }, flushInterval).unref()
     }
   }
 }

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

@@ -10,7 +10,7 @@ const BaseWriter = require('../common/writer')
 const METRIC_PREFIX = 'datadog.tracer.node.exporter.agent'
 
 class Writer extends BaseWriter {
-  constructor ({ prioritySampler, lookup, protocolVersion }) {
+  constructor ({ prioritySampler, lookup, protocolVersion, headers }) {
     super(...arguments)
     const AgentEncoder = getEncoder(protocolVersion)
 
@@ -18,12 +18,14 @@ class Writer extends BaseWriter {
     this._lookup = lookup
     this._protocolVersion = protocolVersion
     this._encoder = new AgentEncoder(this)
+    this._headers = headers
   }
 
   _sendPayload (data, count, done) {
     metrics.increment(`${METRIC_PREFIX}.requests`, true)
 
-    makeRequest(this._protocolVersion, data, count, this._url, this._lookup, true, (err, res, status) => {
+    const { _headers, _lookup, _protocolVersion, _url } = this
+    makeRequest(_protocolVersion, data, count, _url, _headers, _lookup, true, (err, res, status) => {
       if (status) {
         metrics.increment(`${METRIC_PREFIX}.responses`, true)
         metrics.increment(`${METRIC_PREFIX}.responses.by.status`, `status:${status}`, true)
@@ -73,11 +75,12 @@ function getEncoder (protocolVersion) {
   }
 }
 
-function makeRequest (version, data, count, url, lookup, needsStartupLog, cb) {
+function makeRequest (version, data, count, url, headers, lookup, needsStartupLog, cb) {
   const options = {
     path: `/v${version}/traces`,
     method: 'PUT',
     headers: {
+      ...headers,
       'Content-Type': 'application/msgpack',
       'Datadog-Meta-Tracer-Version': tracerVersion,
       'X-Datadog-Trace-Count': String(count)
@@ -99,7 +102,7 @@ function makeRequest (version, data, count, url, lookup, needsStartupLog, cb) {
 
   log.debug(() => `Request to the agent: ${JSON.stringify(options)}`)
 
-  request(data, options, true, (err, res, status) => {
+  request(data, options, (err, res, status) => {
     if (needsStartupLog) {
       // Note that logging will only happen once, regardless of how many times this is called.
       startupLog({

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

@@ -3,10 +3,12 @@
 // TODO: Add test with slow or unresponsive agent.
 // TODO: Add telemetry for things like dropped requests, errors, etc.
 
+const { Readable } = require('stream')
 const http = require('http')
 const https = require('https')
 const docker = require('./docker')
 const { storage } = require('../../../../datadog-core')
+const log = require('../../log')
 
 const keepAlive = true
 const maxTotalSockets = 1
@@ -17,26 +19,28 @@ const containerId = docker.id()
 
 let activeRequests = 0
 
-function request (data, options, keepAlive, callback) {
+function request (data, options, callback) {
   if (!options.headers) {
     options.headers = {}
   }
 
+  const isReadable = data instanceof Readable
+
   // The timeout should be kept low to avoid excessive queueing.
   const timeout = options.timeout || 2000
   const isSecure = options.protocol === 'https:'
   const client = isSecure ? https : http
   const dataArray = [].concat(data)
 
-  options.headers['Content-Length'] = byteLength(dataArray)
+  if (!isReadable) {
+    options.headers['Content-Length'] = byteLength(dataArray)
+  }
 
   if (containerId) {
     options.headers['Datadog-Container-ID'] = containerId
   }
 
-  if (keepAlive) {
-    options.agent = isSecure ? httpsAgent : httpAgent
-  }
+  options.agent = isSecure ? httpsAgent : httpAgent
 
   const onResponse = res => {
     let responseData = ''
@@ -59,7 +63,10 @@ function request (data, options, keepAlive, callback) {
   }
 
   const makeRequest = onError => {
-    if (!request.writable) return callback(null)
+    if (!request.writable) {
+      log.debug('Maximum number of active requests reached: payload is discarded.')
+      return callback(null)
+    }
 
     activeRequests++
 
@@ -74,15 +81,23 @@ function request (data, options, keepAlive, callback) {
       onError(err)
     })
 
-    dataArray.forEach(buffer => req.write(buffer))
-
     req.setTimeout(timeout, req.abort)
-    req.end()
+
+    if (isReadable) {
+      data.pipe(req) // TODO: Validate whether this is actually retriable.
+    } else {
+      dataArray.forEach(buffer => req.write(buffer))
+      req.end()
+    }
 
     storage.enterWith(store)
   }
 
-  makeRequest(() => makeRequest(callback))
+  // TODO: Figure out why setTimeout is needed to avoid losing the async context
+  // in the retry request before socket.connect() is called.
+  // 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)))
 }
 
 function byteLength (data) {

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

@@ -23,16 +23,19 @@ class Writer {
     }
   }
 
-  append (spans) {
-    if (!request.writable) return
+  append (payload) {
+    if (!request.writable) {
+      log.debug(() => `Maximum number of active requests reached. Payload discarded: ${JSON.stringify(payload)}`)
+      return
+    }
 
-    log.debug(() => `Encoding trace: ${JSON.stringify(spans)}`)
+    log.debug(() => `Encoding payload: ${JSON.stringify(payload)}`)
 
-    this._encode(spans)
+    this._encode(payload)
   }
 
-  _encode (trace) {
-    this._encoder.encode(trace)
+  _encode (payload) {
+    this._encoder.encode(payload)
   }
 
   setUrl (url) {

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

@@ -0,0 +1,20 @@
+const { URL } = require('url')
+
+const { Writer } = require('./writer')
+
+class SpanStatsExporter {
+  constructor (config) {
+    const { hostname = '127.0.0.1', port = 8126, tags, url } = config
+    this._url = url || new URL(`http://${hostname || 'localhost'}:${port}`)
+    this._writer = new Writer({ url: this._url, tags })
+  }
+
+  export (payload) {
+    this._writer.append(payload)
+    this._writer.flush()
+  }
+}
+
+module.exports = {
+  SpanStatsExporter
+}

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

@@ -0,0 +1,54 @@
+
+const { SpanStatsEncoder } = require('../../encode/span-stats')
+
+const pkg = require('../../../../../package.json')
+
+const BaseWriter = require('../common/writer')
+const request = require('../common/request')
+const log = require('../../log')
+
+class Writer extends BaseWriter {
+  constructor ({ url }) {
+    super(...arguments)
+    this._url = url
+    this._encoder = new SpanStatsEncoder(this)
+  }
+
+  _sendPayload (data, _, done) {
+    makeRequest(data, this._url, (err, res) => {
+      if (err) {
+        log.error(err)
+        done()
+        return
+      }
+      log.debug(`Response from the intake: ${res}`)
+      done()
+    })
+  }
+}
+
+function makeRequest (data, url, cb) {
+  const options = {
+    path: '/v0.6/stats',
+    method: 'PUT',
+    headers: {
+      'Datadog-Meta-Lang': 'javascript',
+      'Datadog-Meta-Tracer-Version': pkg.version,
+      'Content-Type': 'application/msgpack'
+    }
+  }
+
+  options.protocol = url.protocol
+  options.hostname = url.hostname
+  options.port = url.port
+
+  log.debug(() => `Request to the intake: ${JSON.stringify(options)}`)
+
+  request(data, options, (err, res) => {
+    cb(err, res)
+  })
+}
+
+module.exports = {
+  Writer
+}

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

@@ -12,6 +12,7 @@ const SAMPLING_AGENT_DECISION = constants.SAMPLING_AGENT_DECISION
 const MEASURED = tags.MEASURED
 const ORIGIN_KEY = constants.ORIGIN_KEY
 const HOSTNAME_KEY = constants.HOSTNAME_KEY
+const TOP_LEVEL_KEY = constants.TOP_LEVEL_KEY
 
 const map = {
   'service.name': 'service',
@@ -110,6 +111,7 @@ function extractRootTags (trace, span) {
   addTag({}, trace.metrics, SAMPLING_RULE_DECISION, context._trace[SAMPLING_RULE_DECISION])
   addTag({}, trace.metrics, SAMPLING_LIMIT_DECISION, context._trace[SAMPLING_LIMIT_DECISION])
   addTag({}, trace.metrics, SAMPLING_AGENT_DECISION, context._trace[SAMPLING_AGENT_DECISION])
+  addTag({}, trace.metrics, TOP_LEVEL_KEY, 1)
 }
 
 function extractChunkTags (trace, span) {

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

@@ -14,17 +14,17 @@ let batch = 0
 
 // Internal representation of a trace or span ID.
 class Identifier {
-  constructor (value, radix) {
+  constructor (value, radix = 16) {
     this._isUint64BE = true // msgpack-lite compatibility
-    this._buffer = typeof radix === 'number'
-      ? fromString(value, radix)
-      : createBuffer(value)
+    this._buffer = radix === 16
+      ? createBuffer(value)
+      : fromString(value, radix)
   }
 
-  toString (radix) {
-    return typeof radix === 'number'
-      ? toNumberString(this._buffer, radix)
-      : toHexString(this._buffer)
+  toString (radix = 16) {
+    return radix === 16
+      ? toHexString(this._buffer)
+      : toNumberString(this._buffer, radix)
   }
 
   toBuffer () {
@@ -49,10 +49,13 @@ function createBuffer (value) {
   if (value === '0') return zeroId
   if (!value) return pseudoRandom()
 
-  const size = Math.ceil(value.length / 2)
-  const buffer = new Array(size)
+  const size = Math.ceil(value.length / 16) * 16
+  const bytes = size / 2
+  const buffer = new Array(bytes)
 
-  for (let i = 0; i < size; i++) {
+  value = value.padStart(size, '0')
+
+  for (let i = 0; i < bytes; i++) {
     buffer[i] = parseInt(value.substring(i * 2, i * 2 + 2), 16)
   }
 
@@ -100,8 +103,8 @@ function fromString (str, raddix) {
 
 // Convert a buffer to a numerical string.
 function toNumberString (buffer, radix) {
-  let high = readInt32(buffer, 0)
-  let low = readInt32(buffer, 4)
+  let high = readInt32(buffer, buffer.length - 8)
+  let low = readInt32(buffer, buffer.length - 4)
   let str = ''
 
   radix = radix || 10

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

@@ -2,8 +2,19 @@
 
 const semver = require('semver')
 const logger = require('./log')
+const { addHook } = require('import-in-the-middle')
+const dc = require('diagnostics_channel')
 
 if (semver.satisfies(process.versions.node, '^12.20.0 || >=14.13.1')) {
+  const moduleLoadStartChannel = dc.channel('dd-trace:moduleLoadStart')
+  addHook((name, namespace) => {
+    if (moduleLoadStartChannel.hasSubscribers) {
+      moduleLoadStartChannel.publish({
+        filename: name,
+        module: namespace
+      })
+    }
+  })
   module.exports = require('import-in-the-middle')
 } else {
   logger.warn('ESM is not fully supported by this version of Node.js, ' +

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

@@ -0,0 +1,10 @@
+'use strict'
+
+const { isFalse } = require('./util')
+
+// Global `jest` is only present in Jest workers.
+const inJestWorker = typeof jest !== 'undefined'
+
+module.exports = isFalse(process.env.DD_TRACE_ENABLED) || inJestWorker
+  ? require('./noop/proxy')
+  : require('./proxy')

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

@@ -0,0 +1,87 @@
+'use strict'
+
+const NoopTracer = require('./tracer')
+
+const noop = new NoopTracer()
+
+class Tracer {
+  constructor () {
+    this._tracer = noop
+  }
+
+  init () {
+    return this
+  }
+
+  use () {
+    return this
+  }
+
+  trace (name, options, fn) {
+    if (!fn) {
+      fn = options
+      options = {}
+    }
+
+    if (typeof fn !== 'function') return
+
+    options = options || {}
+
+    return this._tracer.trace(name, options, fn)
+  }
+
+  wrap (name, options, fn) {
+    if (!fn) {
+      fn = options
+      options = {}
+    }
+
+    if (typeof fn !== 'function') return fn
+
+    options = options || {}
+
+    return this._tracer.wrap(name, options, fn)
+  }
+
+  setUrl () {
+    this._tracer.setUrl.apply(this._tracer, arguments)
+    return this
+  }
+
+  startSpan () {
+    return this._tracer.startSpan.apply(this._tracer, arguments)
+  }
+
+  inject () {
+    return this._tracer.inject.apply(this._tracer, arguments)
+  }
+
+  extract () {
+    return this._tracer.extract.apply(this._tracer, arguments)
+  }
+
+  scope () {
+    return this._tracer.scope.apply(this._tracer, arguments)
+  }
+
+  currentSpan () {
+    return this._tracer.currentSpan.apply(this._tracer, arguments)
+  }
+
+  bind (callback) {
+    return callback
+  }
+
+  bindEmitter () {}
+
+  getRumData () {
+    return this._tracer.getRumData.apply(this._tracer, arguments)
+  }
+
+  setUser () {
+    this._tracer.setUser.apply(this._tracer, arguments)
+    return this
+  }
+}
+
+module.exports = Tracer