dd-trace 2.4.0 → 2.5.0

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/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/pkg.js

@@ -11,7 +11,14 @@ function findRoot () {
 
 function findPkg () {
   const cwd = findRoot()
-  const filePath = findUp('package.json', cwd)
+  const directory = path.resolve(cwd)
+  const res = path.parse(directory)
+
+  if (!res) return {}
+
+  const { root } = res
+
+  const filePath = findUp('package.json', root, directory)
 
   try {
     return JSON.parse(fs.readFileSync(filePath, 'utf8'))
@@ -20,18 +27,16 @@ function findPkg () {
   }
 }
 
-function findUp (name, cwd) {
-  let directory = path.resolve(cwd)
-  const { root } = path.parse(directory)
-
+function findUp (name, root, directory) {
   while (true) {
     const current = path.resolve(directory, name)
 
     if (fs.existsSync(current)) return current
+
     if (directory === root) return
 
     directory = path.dirname(directory)
   }
 }
 
-module.exports = findPkg()
+module.exports = Object.assign(findPkg(), { findRoot, findUp })

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/test.js

@@ -1,4 +1,7 @@
 const path = require('path')
+const fs = require('fs')
+
+const ignore = require('ignore')
 
 const { getGitMetadata } = require('./git')
 const { getUserProviderGitMetadata } = require('./user-provided-git')
@@ -25,6 +28,7 @@ const TEST_STATUS = 'test.status'
 const TEST_PARAMETERS = 'test.parameters'
 const TEST_SKIP_REASON = 'test.skip_reason'
 const TEST_IS_RUM_ACTIVE = 'test.is_rum_active'
+const TEST_CODE_OWNERS = 'test.codeowners'
 
 const ERROR_TYPE = 'error.type'
 const ERROR_MESSAGE = 'error.msg'
@@ -35,6 +39,7 @@ const CI_APP_ORIGIN = 'ciapp-test'
 const JEST_TEST_RUNNER = 'test.jest.test_runner'
 
 module.exports = {
+  TEST_CODE_OWNERS,
   TEST_FRAMEWORK,
   TEST_FRAMEWORK_VERSION,
   JEST_TEST_RUNNER,
@@ -53,7 +58,9 @@ module.exports = {
   getTestParametersString,
   finishAllTraceSpans,
   getTestParentSpan,
-  getTestSuitePath
+  getTestSuitePath,
+  getCodeOwnersFileEntries,
+  getCodeOwnersForFilename
 }
 
 function getTestEnvironmentMetadata (testFramework, config) {
@@ -140,3 +147,55 @@ function getTestSuitePath (testSuiteAbsolutePath, sourceRoot) {
 
   return testSuitePath.replace(path.sep, '/')
 }
+
+const POSSIBLE_CODEOWNERS_LOCATIONS = [
+  'CODEOWNERS',
+  '.github/CODEOWNERS',
+  'docs/CODEOWNERS',
+  '.gitlab/CODEOWNERS'
+]
+
+function getCodeOwnersFileEntries (rootDir = process.cwd()) {
+  let codeOwnersContent
+
+  POSSIBLE_CODEOWNERS_LOCATIONS.forEach(location => {
+    try {
+      codeOwnersContent = fs.readFileSync(`${rootDir}/${location}`).toString()
+    } catch (e) {
+      // retry with next path
+    }
+  })
+  if (!codeOwnersContent) {
+    return null
+  }
+
+  const entries = []
+  const lines = codeOwnersContent.split('\n')
+
+  for (const line of lines) {
+    const [content] = line.split('#')
+    const trimmed = content.trim()
+    if (trimmed === '') continue
+    const [pattern, ...owners] = trimmed.split(/\s+/)
+    entries.push({ pattern, owners })
+  }
+  // Reverse because rules defined last take precedence
+  return entries.reverse()
+}
+
+function getCodeOwnersForFilename (filename, entries) {
+  if (!entries) {
+    return null
+  }
+  for (const entry of entries) {
+    try {
+      const isResponsible = ignore().add(entry.pattern).ignores(filename)
+      if (isResponsible) {
+        return JSON.stringify(entry.owners)
+      }
+    } catch (e) {
+      return null
+    }
+  }
+  return null
+}

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/profiling/exporters/agent.js

@@ -5,7 +5,7 @@ const { request } = require('http')
 const FormData = require('form-data')
 
 // TODO: avoid using dd-trace internals. Make this a separate module?
-const docker = require('../../exporters/agent/docker')
+const docker = require('../../exporters/common/docker')
 const version = require('../../../lib/version')
 
 const containerId = docker.id()

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

@@ -10,6 +10,7 @@ const metrics = require('./metrics')
 const log = require('./log')
 const { isFalse } = require('./util')
 const { setStartupLogInstrumenter } = require('./startup-log')
+const telemetry = require('./telemetry')
 
 const noop = new NoopTracer()
 
@@ -63,6 +64,7 @@ class Tracer extends BaseTracer {
         this._instrumenter.enable(config)
         this._pluginManager.configure(config)
         setStartupLogInstrumenter(this._instrumenter)
+        telemetry.start(config, this._instrumenter, this._pluginManager)
       }
     } catch (e) {
       log.error(e)

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()
   }
 }