dd-trace 3.0.0-pre.1 → 3.1.0

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

@@ -3,39 +3,44 @@
 // 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 = 8
+const maxTotalSockets = 1
+const maxActiveRequests = 8
 const httpAgent = new http.Agent({ keepAlive, maxTotalSockets })
 const httpsAgent = new https.Agent({ keepAlive, maxTotalSockets })
 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 = ''
@@ -58,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++
 
@@ -73,10 +81,14 @@ 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)
+    } else {
+      dataArray.forEach(buffer => req.write(buffer))
+      req.end()
+    }
 
     storage.enterWith(store)
   }
@@ -90,7 +102,7 @@ function byteLength (data) {
 
 Object.defineProperty(request, 'writable', {
   get () {
-    return activeRequests < maxTotalSockets
+    return activeRequests < maxActiveRequests
   }
 })
 

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/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

@@ -3,7 +3,7 @@
 const semver = require('semver')
 const logger = require('./log')
 
-if (semver.satisfies(process.versions.node, '^12.20.0 || >=14.13.1')) {
+if (semver.satisfies(process.versions.node, '>=14.13.1')) {
   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,77 @@
+'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)
+  }
+
+  getRumData () {
+    return this._tracer.getRumData.apply(this._tracer, arguments)
+  }
+
+  setUser () {
+    this._tracer.setUser.apply(this._tracer, arguments)
+    return this
+  }
+}
+
+module.exports = Tracer

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

@@ -11,12 +11,8 @@ class Scope {
     return callback()
   }
 
-  bind (target, span) {
-    return target
-  }
-
-  unbind (target) {
-    return target
+  bind (fn, span) {
+    return fn
   }
 }
 

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

@@ -1,26 +1,26 @@
 'use strict'
 
-const Span = require('opentracing').Span
-const NoopSpanContext = require('../noop/span_context')
+const NoopSpanContext = require('./span_context')
 const id = require('../id')
 const { storage } = require('../../../datadog-core') // TODO: noop storage?
 
-class NoopSpan extends Span {
+class NoopSpan {
   constructor (tracer, parent) {
-    super()
-
     this._store = storage.getStore()
     this._noopTracer = tracer
     this._noopContext = this._createContext(parent)
   }
 
-  _context () {
-    return this._noopContext
-  }
-
-  _tracer () {
-    return this._noopTracer
-  }
+  context () { return this._noopContext }
+  tracer () { return this._noopTracer }
+  setOperationName (name) { return this }
+  setBaggageItem (key, value) { return this }
+  getBaggageItem (key) {}
+  setTag (key, value) { return this }
+  addTags (keyValueMap) { return this }
+  log () { return this }
+  logEvent () {}
+  finish (finishTime) {}
 
   _createContext (parent) {
     const spanId = id()

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

@@ -1,13 +1,10 @@
 'use strict'
 
-const Tracer = require('opentracing').Tracer
 const Scope = require('../noop/scope')
 const Span = require('./span')
 
-class NoopTracer extends Tracer {
+class NoopTracer {
   constructor (config) {
-    super(config)
-
     this._scope = new Scope()
     this._span = new Span(this)
   }
@@ -31,10 +28,16 @@ class NoopTracer extends Tracer {
   setUrl () {
   }
 
-  _startSpan (name, options) {
+  startSpan (name, options) {
     return this._span
   }
 
+  inject (spanContext, format, carrier) {}
+
+  extract (format, carrier) {
+    return this._span.context()
+  }
+
   setUser () {
     return this
   }

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

@@ -82,8 +82,8 @@ class TextMapPropagator {
   _injectB3 (spanContext, carrier) {
     if (!this._config.experimental.b3) return
 
-    carrier[b3TraceKey] = spanContext._traceId.toString('hex')
-    carrier[b3SpanKey] = spanContext._spanId.toString('hex')
+    carrier[b3TraceKey] = spanContext._traceId.toString(16)
+    carrier[b3SpanKey] = spanContext._spanId.toString(16)
     carrier[b3SampledKey] = spanContext._sampling.priority >= AUTO_KEEP ? '1' : '0'
 
     if (spanContext._sampling.priority > AUTO_KEEP) {
@@ -91,7 +91,7 @@ class TextMapPropagator {
     }
 
     if (spanContext._parentId) {
-      carrier[b3ParentKey] = spanContext._parentId.toString('hex')
+      carrier[b3ParentKey] = spanContext._parentId.toString(16)
     }
   }
 
@@ -99,8 +99,8 @@ class TextMapPropagator {
     if (!this._config.experimental.traceparent) return
 
     const sampling = spanContext._sampling.priority >= AUTO_KEEP ? '01' : '00'
-    const traceId = spanContext._traceId.toString('hex').padStart(32, '0')
-    const spanId = spanContext._spanId.toString('hex').padStart(16, '0')
+    const traceId = spanContext._traceId.toString(16).padStart(32, '0')
+    const spanId = spanContext._spanId.toString(16).padStart(16, '0')
     carrier[traceparentKey] = `01-${traceId}-${spanId}-${sampling}`
   }
 
@@ -129,7 +129,7 @@ class TextMapPropagator {
     const b3 = this._extractB3Headers(carrier)
     const debug = b3[b3FlagsKey] === '1'
     const priority = this._getPriority(b3[b3SampledKey], debug)
-    const spanContext = this._extractGenericContext(b3, b3TraceKey, b3SpanKey)
+    const spanContext = this._extractGenericContext(b3, b3TraceKey, b3SpanKey, 16)
 
     if (priority !== undefined) {
       if (!spanContext) {

package/packages/dd-trace/src/opentracing/span.js

@@ -1,11 +1,9 @@
 'use strict'
 
 // TODO (new internal tracer): use DC events for lifecycle metrics and test them
-
-const opentracing = require('opentracing')
-const now = require('performance-now')
+const now = require('perf_hooks').performance.now
+const dateNow = Date.now
 const semver = require('semver')
-const Span = opentracing.Span
 const SpanContext = require('./span_context')
 const id = require('../id')
 const tagger = require('../tagger')
@@ -21,10 +19,8 @@ const {
 const unfinishedRegistry = createRegistry('unfinished')
 const finishedRegistry = createRegistry('finished')
 
-class DatadogSpan extends Span {
+class DatadogSpan {
   constructor (tracer, processor, prioritySampler, fields, debug) {
-    super()
-
     const operationName = fields.operationName
     const parent = fields.parent || null
     const tags = Object.assign({}, fields.tags)
@@ -70,66 +66,45 @@ class DatadogSpan extends Span {
     return `Span${json}`
   }
 
-  _createContext (parent) {
-    let spanContext
-
-    if (parent) {
-      spanContext = new SpanContext({
-        traceId: parent._traceId,
-        spanId: id(),
-        parentId: parent._spanId,
-        sampling: parent._sampling,
-        baggageItems: Object.assign({}, parent._baggageItems),
-        trace: parent._trace
-      })
-    } else {
-      const spanId = id()
-      spanContext = new SpanContext({
-        traceId: spanId,
-        spanId
-      })
-    }
-
-    spanContext._trace.started.push(this)
-    spanContext._trace.startTime = spanContext._trace.startTime || Date.now()
-    spanContext._trace.ticks = spanContext._trace.ticks || now()
-
-    return spanContext
-  }
-
-  _getTime () {
-    const { startTime, ticks } = this._spanContext._trace
-
-    return startTime + now() - ticks
-  }
-
-  _context () {
+  context () {
     return this._spanContext
   }
 
-  _tracer () {
+  tracer () {
     return this._parentTracer
   }
 
-  _setOperationName (name) {
+  setOperationName (name) {
     this._spanContext._name = name
+    return this
   }
 
-  _setBaggageItem (key, value) {
+  setBaggageItem (key, value) {
     this._spanContext._baggageItems[key] = value
+    return this
   }
 
-  _getBaggageItem (key) {
+  getBaggageItem (key) {
     return this._spanContext._baggageItems[key]
   }
 
-  _addTags (keyValuePairs) {
-    tagger.add(this._spanContext._tags, keyValuePairs)
+  setTag (key, value) {
+    this._addTags({ [key]: value })
+    return this
+  }
 
-    this._prioritySampler.sample(this, false)
+  addTags (keyValueMap) {
+    this._addTags(keyValueMap)
+    return this
+  }
+
+  log () {
+    return this
   }
 
-  _finish (finishTime) {
+  logEvent () {}
+
+  finish (finishTime) {
     if (this._duration !== undefined) {
       return
     }
@@ -157,6 +132,45 @@ class DatadogSpan extends Span {
     this._spanContext._isFinished = true
     this._processor.process(this)
   }
+
+  _createContext (parent) {
+    let spanContext
+
+    if (parent) {
+      spanContext = new SpanContext({
+        traceId: parent._traceId,
+        spanId: id(),
+        parentId: parent._spanId,
+        sampling: parent._sampling,
+        baggageItems: Object.assign({}, parent._baggageItems),
+        trace: parent._trace
+      })
+    } else {
+      const spanId = id()
+      spanContext = new SpanContext({
+        traceId: spanId,
+        spanId
+      })
+    }
+
+    spanContext._trace.started.push(this)
+    spanContext._trace.startTime = spanContext._trace.startTime || dateNow()
+    spanContext._trace.ticks = spanContext._trace.ticks || now()
+
+    return spanContext
+  }
+
+  _getTime () {
+    const { startTime, ticks } = this._spanContext._trace
+
+    return startTime + now() - ticks
+  }
+
+  _addTags (keyValuePairs) {
+    tagger.add(this._spanContext._tags, keyValuePairs)
+
+    this._prioritySampler.sample(this, false)
+  }
 }
 
 function createRegistry (type) {

package/packages/dd-trace/src/opentracing/span_context.js

@@ -1,11 +1,7 @@
 'use strict'
 
-const SpanContext = require('opentracing').SpanContext
-
-class DatadogSpanContext extends SpanContext {
+class DatadogSpanContext {
   constructor (props) {
-    super()
-
     props = props || {}
 
     this._traceId = props.traceId