dd-trace 2.3.1 → 2.4.2

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

@@ -109,6 +109,11 @@ class Config {
       process.env.DD_TRACE_EXPERIMENTAL_B3_ENABLED,
       false
     )
+    const DD_TRACE_TRACEPARENT_ENABLED = coalesce(
+      options.experimental && options.experimental.traceparent,
+      process.env.DD_TRACE_EXPERIMENTAL_TRACEPARENT_ENABLED,
+      false
+    )
     const DD_TRACE_RUNTIME_ID_ENABLED = coalesce(
       options.experimental && options.experimental.runtimeId,
       process.env.DD_TRACE_EXPERIMENTAL_RUNTIME_ID_ENABLED,
@@ -187,6 +192,7 @@ class Config {
     this.runtimeMetrics = isTrue(DD_RUNTIME_METRICS_ENABLED)
     this.experimental = {
       b3: isTrue(DD_TRACE_B3_ENABLED),
+      traceparent: isTrue(DD_TRACE_TRACEPARENT_ENABLED),
       runtimeId: isTrue(DD_TRACE_RUNTIME_ID_ENABLED),
       exporter: DD_TRACE_EXPORTER,
       enableGetRumData: isTrue(DD_TRACE_GET_RUM_DATA_ENABLED),

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

@@ -8,5 +8,9 @@ if (semver.satisfies(process.versions.node, '^12.20.0 || >=14.13.1')) {
 } else {
   logger.warn('ESM is not fully supported by this version of Node.js, ' +
     'so dd-trace will not intercept ESM loading.')
-  module.exports = () => {}
+  module.exports = () => ({
+    unhook: () => {}
+  })
+  module.exports.addHook = () => {}
+  module.exports.removeHook = () => {}
 }

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

@@ -1,8 +1,7 @@
 'use strict'
 
 const semver = require('semver')
-const hook = require('./ritm')
-const esmHook = require('./iitm')
+const Hook = require('../../datadog-instrumentations/src/helpers/hook')
 const parse = require('module-details-from-path')
 const path = require('path')
 const uniq = require('lodash.uniq')
@@ -18,6 +17,7 @@ class Loader {
 
   reload (plugins) {
     this._plugins = plugins
+    this._patched = []
 
     const instrumentations = Array.from(this._plugins.keys())
       .reduce((prev, current) => prev.concat(current), [])
@@ -28,8 +28,10 @@ class Loader {
     this._names = new Set(instrumentations
       .map(instrumentation => filename(instrumentation)))
 
-    hook(instrumentedModules, this._hookModule.bind(this))
-    esmHook(instrumentedModules, this._hookModule.bind(this))
+    this._hook && this._hook.unhook()
+    this._hook = Hook(instrumentedModules, (moduleExports, moduleName, moduleBaseDir) => {
+      return this._hookModule(moduleExports, moduleName, moduleBaseDir)
+    })
   }
 
   load (instrumentation, config) {

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

@@ -38,6 +38,10 @@ class NoopTracer extends Tracer {
   _startSpan (name, options) {
     return this._span
   }
+
+  setUser () {
+    return this
+  }
 }
 
 module.exports = NoopTracer

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

@@ -26,6 +26,8 @@ const baggageExpr = new RegExp(`^${baggagePrefix}(.+)$`)
 const ddKeys = [traceKey, spanKey, samplingKey, originKey]
 const b3Keys = [b3TraceKey, b3SpanKey, b3ParentKey, b3SampledKey, b3FlagsKey, b3HeaderKey]
 const logKeys = ddKeys.concat(b3Keys)
+const traceparentExpr = /^(\d{2})-([A-Fa-f0-9]{32})-([A-Fa-f0-9]{16})-(\d{2})$/i
+const traceparentKey = 'traceparent'
 
 class TextMapPropagator {
   constructor (config) {
@@ -40,6 +42,7 @@ class TextMapPropagator {
     this._injectSamplingPriority(spanContext, carrier)
     this._injectBaggageItems(spanContext, carrier)
     this._injectB3(spanContext, carrier)
+    this._injectTraceparent(spanContext, carrier)
 
     log.debug(() => `Inject into carrier: ${JSON.stringify(pick(carrier, logKeys))}.`)
   }
@@ -92,8 +95,20 @@ class TextMapPropagator {
     }
   }
 
+  _injectTraceparent (spanContext, carrier) {
+    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')
+    carrier[traceparentKey] = `01-${traceId}-${spanId}-${sampling}`
+  }
+
   _extractSpanContext (carrier) {
-    return this._extractDatadogContext(carrier) || this._extractB3Context(carrier) || this._extractSqsdContext(carrier)
+    return this._extractDatadogContext(carrier) ||
+      this._extractTraceparentContext(carrier) ||
+      this._extractB3Context(carrier) ||
+      this._extractSqsdContext(carrier)
   }
 
   _extractDatadogContext (carrier) {
@@ -146,6 +161,24 @@ class TextMapPropagator {
     return this._extractDatadogContext(parsed)
   }
 
+  _extractTraceparentContext (carrier) {
+    if (!this._config.experimental.traceparent) return null
+
+    const headerValue = carrier[traceparentKey]
+    if (!headerValue) {
+      return null
+    }
+    const matches = headerValue.match(traceparentExpr)
+    if (matches.length) {
+      return new DatadogSpanContext({
+        traceId: id(matches[2], 16),
+        spanId: id(matches[3], 16),
+        sampling: { priority: matches[4] === '01' ? 1 : 0 }
+      })
+    }
+    return null
+  }
+
   _extractGenericContext (carrier, traceKey, spanKey, radix) {
     if (carrier[traceKey] && carrier[spanKey]) {
       return new DatadogSpanContext({

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

@@ -1,16 +1,23 @@
 '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 semver = require('semver')
 const Span = opentracing.Span
 const SpanContext = require('./span_context')
 const id = require('../id')
 const tagger = require('../tagger')
+const metrics = require('../metrics')
 const log = require('../log')
 const { storage } = require('../../../datadog-core')
 
 const { DD_TRACE_EXPERIMENTAL_STATE_TRACKING } = process.env
 
+const unfinishedRegistry = createRegistry('unfinished')
+const finishedRegistry = createRegistry('finished')
+
 class DatadogSpan extends Span {
   constructor (tracer, processor, prioritySampler, fields, debug) {
     super()
@@ -25,6 +32,7 @@ class DatadogSpan extends Span {
     this._processor = processor
     this._prioritySampler = prioritySampler
     this._store = storage.getStore()
+    this._name = operationName
 
     this._spanContext = this._createContext(parent)
     this._spanContext._name = operationName
@@ -32,6 +40,13 @@ class DatadogSpan extends Span {
     this._spanContext._hostname = hostname
 
     this._startTime = fields.startTime || this._getTime()
+
+    if (this._debug && unfinishedRegistry) {
+      metrics.increment('runtime.node.spans.unfinished')
+      metrics.increment('runtime.node.spans.unfinished.by.name', `span_name:${operationName}`)
+
+      unfinishedRegistry.register(this, operationName, this)
+    }
   }
 
   toString () {
@@ -122,6 +137,16 @@ class DatadogSpan extends Span {
       }
     }
 
+    if (this._debug && finishedRegistry) {
+      metrics.decrement('runtime.node.spans.unfinished')
+      metrics.decrement('runtime.node.spans.unfinished.by.name', `span_name:${this._name}`)
+      metrics.increment('runtime.node.spans.finished')
+      metrics.increment('runtime.node.spans.finished.by.name', `span_name:${this._name}`)
+
+      unfinishedRegistry.unregister(this)
+      finishedRegistry.register(this, this._name)
+    }
+
     finishTime = parseFloat(finishTime) || this._getTime()
 
     this._duration = finishTime - this._startTime
@@ -131,4 +156,13 @@ class DatadogSpan extends Span {
   }
 }
 
+function createRegistry (type) {
+  if (!semver.satisfies(process.version, '>=14.6')) return
+
+  return new global.FinalizationRegistry(name => {
+    metrics.decrement(`runtime.node.spans.${type}`)
+    metrics.decrement(`runtime.node.spans.${type}.by.name`, [`span_name:${name}`])
+  })
+}
+
 module.exports = DatadogSpan

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

@@ -55,6 +55,10 @@ module.exports = class PluginManager {
         }
         this.configurePlugin(name, pluginConfig)
       }
+    } else {
+      for (const name in this._pluginsByName) {
+        this.configurePlugin(name, false)
+      }
     }
   }
 

package/packages/dd-trace/src/plugins/plugin.js

@@ -8,7 +8,6 @@ class Subscription {
     this._channel = dc.channel(event)
     this._handler = (message, name) => {
       const store = storage.getStore()
-
       if (!store || !store.noop) {
         handler(message, name)
       }
@@ -58,6 +57,9 @@ module.exports = class Plugin {
   }
 
   configure (config) {
+    if (typeof config === 'boolean') {
+      config = { enabled: config }
+    }
     this.config = config
     if (config.enabled && !this._enabled) {
       this._enabled = true

package/packages/dd-trace/src/plugins/util/web.js

@@ -52,10 +52,36 @@ const web = {
     })
   },
 
+  startSpan (tracer, config, req, res, name) {
+    const context = this.patch(req)
+    context.config = config
+
+    let span
+
+    if (context.span) {
+      context.span.context()._name = name
+      span = context.span
+    } else {
+      span = web.startChildSpan(tracer, name, req.headers)
+    }
+
+    context.tracer = tracer
+    context.span = span
+    context.res = res
+
+    return span
+  },
+  wrap (req) {
+    const context = contexts.get(req)
+    if (!context.instrumented) {
+      this.wrapEnd(context)
+      this.wrapEvents(context)
+      context.instrumented = true
+    }
+  },
   // Start a span and activate a scope for a request.
   instrument (tracer, config, req, res, name, callback) {
-    const context = this.patch(req)
-    const span = startSpan(tracer, config, req, res, name)
+    const span = this.startSpan(tracer, config, req, res, name)
 
     if (!config.filter(req.url)) {
       span.setTag(MANUAL_DROP, true)
@@ -67,12 +93,7 @@ const web = {
 
     analyticsSampler.sample(span, config.measured, true)
 
-    if (!context.instrumented) {
-      wrapEnd(context)
-      wrapEvents(context)
-
-      context.instrumented = true
-    }
+    this.wrap(req)
 
     return callback && tracer.scope().activate(span, () => callback(span))
   },
@@ -199,6 +220,7 @@ const web = {
   // Extract the parent span from the headers and start a new span as its child
   startChildSpan (tracer, name, headers) {
     const childOf = tracer.scope().active() || tracer.extract(FORMAT_HTTP_HEADERS, headers)
+
     const span = tracer.startSpan(name, { childOf })
 
     return span
@@ -221,103 +243,94 @@ const web = {
       const context = contexts.get(req)
       context.error = context.error || error
     }
-  }
-}
-
-function startSpan (tracer, config, req, res, name) {
-  const context = contexts.get(req)
-
-  context.config = config
-
-  let span
-
-  if (context.span) {
-    context.span.context()._name = name
-    span = context.span
-  } else {
-    span = web.startChildSpan(tracer, name, req.headers)
-  }
-
-  context.tracer = tracer
-  context.span = span
-  context.res = res
-
-  return span
-}
+  },
 
-function finish (context) {
-  const { req, res } = context
+  finishMiddleware (context) {
+    if (context.finished) return
 
-  if (context.finished && !req.stream) return
+    let span
 
-  addRequestTags(context)
-  addResponseTags(context)
+    while ((span = context.middleware.pop())) {
+      span.finish()
+    }
+  },
 
-  context.config.hooks.request(context.span, req, res)
-  addResourceTag(context)
+  finishSpan (context) {
+    const { req, res } = context
 
-  context.span.finish()
-  context.finished = true
-}
+    if (context.finished && !req.stream) return
 
-function finishMiddleware (context) {
-  if (context.finished) return
+    addRequestTags(context)
+    addResponseTags(context)
 
-  let span
+    context.config.hooks.request(context.span, req, res)
+    addResourceTag(context)
 
-  while ((span = context.middleware.pop())) {
-    span.finish()
-  }
-}
+    context.span.finish()
+    context.finished = true
+  },
+  wrapWriteHead (context) {
+    const { req, res } = context
+    const writeHead = res.writeHead
 
-function wrapEnd (context) {
-  const scope = context.tracer.scope()
-  const req = context.req
-  const res = context.res
-  const end = res.end
+    return function (statusCode, statusMessage, headers) {
+      headers = typeof statusMessage === 'string' ? headers : statusMessage
+      headers = Object.assign(res.getHeaders(), headers)
 
-  res.writeHead = wrapWriteHead(context)
+      if (req.method.toLowerCase() === 'options' && isOriginAllowed(req, headers)) {
+        addAllowHeaders(req, res, headers)
+      }
 
-  ends.set(res, function () {
-    for (const beforeEnd of context.beforeEnd) {
-      beforeEnd()
+      return writeHead.apply(this, arguments)
     }
+  },
+  getContext (req) {
+    return contexts.get(req)
+  },
+  wrapRes (context, req, res, end) {
+    return function () {
+      for (const beforeEnd of context.beforeEnd) {
+        beforeEnd()
+      }
 
-    finishMiddleware(context)
-
-    if (incomingHttpRequestEnd.hasSubscribers) incomingHttpRequestEnd.publish({ req, res })
-
-    const returnValue = end.apply(res, arguments)
-
-    finish(context)
-
-    return returnValue
-  })
+      web.finishMiddleware(context)
 
-  Object.defineProperty(res, 'end', {
-    configurable: true,
-    get () {
-      return ends.get(this)
-    },
-    set (value) {
-      ends.set(this, scope.bind(value, context.span))
-    }
-  })
-}
+      if (incomingHttpRequestEnd.hasSubscribers) {
+        incomingHttpRequestEnd.publish({ req, res })
+      }
 
-function wrapWriteHead (context) {
-  const { req, res } = context
-  const writeHead = res.writeHead
+      const returnValue = end.apply(res, arguments)
 
-  return function (statusCode, statusMessage, headers) {
-    headers = typeof statusMessage === 'string' ? headers : statusMessage
-    headers = Object.assign(res.getHeaders(), headers)
+      web.finishSpan(context)
 
-    if (req.method.toLowerCase() === 'options' && isOriginAllowed(req, headers)) {
-      addAllowHeaders(req, res, headers)
+      return returnValue
     }
+  },
+  wrapEnd (context) {
+    const scope = context.tracer.scope()
+    const req = context.req
+    const res = context.res
+    const end = res.end
+
+    res.writeHead = web.wrapWriteHead(context)
+
+    ends.set(res, this.wrapRes(context, req, res, end))
+
+    Object.defineProperty(res, 'end', {
+      configurable: true,
+      get () {
+        return ends.get(this)
+      },
+      set (value) {
+        ends.set(this, scope.bind(value, context.span))
+      }
+    })
+  },
+  wrapEvents (context) {
+    const scope = context.tracer.scope()
+    const res = context.res
 
-    return writeHead.apply(this, arguments)
+    scope.bind(res, context.span)
   }
 }
 
@@ -354,13 +367,6 @@ function splitHeader (str) {
   return typeof str === 'string' ? str.split(/\s*,\s*/) : []
 }
 
-function wrapEvents (context) {
-  const scope = context.tracer.scope()
-  const res = context.res
-
-  scope.bind(res, context.span)
-}
-
 function reactivate (req, fn) {
   const context = contexts.get(req)
 

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

@@ -141,6 +141,10 @@ class Tracer extends BaseTracer {
   getRumData () {
     return this._tracer.getRumData.apply(this._tracer, arguments)
   }
+
+  setUser () {
+    return this._tracer.setUser.apply(this.tracer, arguments)
+  }
 }
 
 module.exports = Tracer

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

@@ -10,9 +10,10 @@ const origRequire = Module.prototype.require
 
 module.exports = Hook
 
-Hook.reset = function () {
-  Module.prototype.require = origRequire
-}
+let moduleHooks = Object.create(null)
+let cache = Object.create(null)
+let patching = Object.create(null)
+let patchedRequire = null
 
 function Hook (modules, options, onrequire) {
   if (!(this instanceof Hook)) return new Hook(modules, options, onrequire)
@@ -25,35 +26,40 @@ function Hook (modules, options, onrequire) {
     options = {}
   }
 
+  modules = modules || []
   options = options || {}
 
-  this.cache = {}
-  this._unhooked = false
-  this._origRequire = Module.prototype.require
+  this.modules = modules
+  this.options = options
+  this.onrequire = onrequire
 
-  const self = this
-  const patching = {}
+  if (Array.isArray(modules)) {
+    for (const mod of modules) {
+      const hooks = moduleHooks[mod]
 
-  this._require = Module.prototype.require = function (request) {
-    if (self._unhooked) {
-      // if the patched require function could not be removed because
-      // someone else patched it after it was patched here, we just
-      // abort and pass the request onwards to the original require
-      return self._origRequire.apply(this, arguments)
+      if (hooks) {
+        hooks.push(onrequire)
+      } else {
+        moduleHooks[mod] = [onrequire]
+      }
     }
+  }
 
+  if (patchedRequire) return
+
+  patchedRequire = Module.prototype.require = function (request) {
     const filename = Module._resolveFilename(request, this)
     const core = filename.indexOf(path.sep) === -1
-    let name, basedir
+    let name, basedir, hooks
 
     // return known patched modules immediately
-    if (self.cache.hasOwnProperty(filename)) {
+    if (cache[filename]) {
       // require.cache was potentially altered externally
-      if (require.cache[filename] && require.cache[filename].exports !== self.cache[filename].original) {
+      if (require.cache[filename] && require.cache[filename].exports !== cache[filename].original) {
         return require.cache[filename].exports
       }
 
-      return self.cache[filename].exports
+      return cache[filename].exports
     }
 
     // Check if this module has a patcher in-progress already.
@@ -63,7 +69,7 @@ function Hook (modules, options, onrequire) {
       patching[filename] = true
     }
 
-    const exports = self._origRequire.apply(this, arguments)
+    const exports = origRequire.apply(this, arguments)
 
     // If it's already patched, just return it as-is.
     if (patched) return exports
@@ -73,7 +79,8 @@ function Hook (modules, options, onrequire) {
     delete patching[filename]
 
     if (core) {
-      if (modules && modules.indexOf(filename) === -1) return exports // abort if module name isn't on whitelist
+      hooks = moduleHooks[filename]
+      if (!hooks) return exports // abort if module name isn't on whitelist
       name = filename
     } else {
       const stat = parse(filename)
@@ -81,7 +88,8 @@ function Hook (modules, options, onrequire) {
       name = stat.name
       basedir = stat.basedir
 
-      if (modules && modules.indexOf(name) === -1) return exports // abort if module name isn't on whitelist
+      hooks = moduleHooks[name]
+      if (!hooks) return exports // abort if module name isn't on whitelist
 
       // figure out if this is the main module file, or a file inside the module
       const paths = Module._resolveLookupPaths(name, this, true)
@@ -99,10 +107,37 @@ function Hook (modules, options, onrequire) {
 
     // ensure that the cache entry is assigned a value before calling
     // onrequire, in case calling onrequire requires the same module.
-    self.cache[filename] = { exports }
-    self.cache[filename].original = exports
-    self.cache[filename].exports = onrequire(exports, name, basedir)
+    cache[filename] = { exports }
+    cache[filename].original = exports
+
+    for (const hook of hooks) {
+      cache[filename].exports = hook(cache[filename].exports, name, basedir)
+    }
+
+    return cache[filename].exports
+  }
+}
+
+Hook.reset = function () {
+  Module.prototype.require = origRequire
+  patchedRequire = null
+  patching = Object.create(null)
+  cache = Object.create(null)
+  moduleHooks = Object.create(null)
+}
+
+Hook.prototype.unhook = function () {
+  for (const mod of this.modules) {
+    const hooks = (moduleHooks[mod] || []).filter(hook => hook !== this.onrequire)
+
+    if (hooks.length > 0) {
+      moduleHooks[mod] = hooks
+    } else {
+      delete moduleHooks[mod]
+    }
+  }
 
-    return self.cache[filename].exports
+  if (Object.keys(moduleHooks).length === 0) {
+    Hook.reset()
   }
 }

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

@@ -122,6 +122,22 @@ class DatadogTracer extends Tracer {
 <meta name="dd-trace-id" content="${traceId}" />\
 <meta name="dd-trace-time" content="${traceTime}" />`
   }
+
+  setUser (user) {
+    if (!user || !user.id) return this
+
+    const span = this.scope().active()
+    if (!span) return this
+
+    const rootSpan = span._spanContext._trace.started[0]
+    if (!rootSpan) return this
+
+    for (const k of Object.keys(user)) {
+      rootSpan.setTag(`usr.${k}`, '' + user[k])
+    }
+
+    return this
+  }
 }
 
 function addError (span, error) {