dd-trace 2.3.1 → 2.4.2

package/packages/datadog-instrumentations/src/helpers/instrument.js

@@ -3,11 +3,10 @@
 const dc = require('diagnostics_channel')
 const path = require('path')
 const semver = require('semver')
-const iitm = require('../../../dd-trace/src/iitm')
-const ritm = require('../../../dd-trace/src/ritm')
-const parse = require('module-details-from-path')
+const Hook = require('./hook')
 const requirePackageJson = require('../../../dd-trace/src/require-package-json')
 const { AsyncResource } = require('async_hooks')
+const log = require('../../../dd-trace/src/log')
 
 const pathSepExpr = new RegExp(`\\${path.sep}`, 'g')
 const channelMap = {}
@@ -20,18 +19,22 @@ exports.channel = function channel (name) {
 }
 
 exports.addHook = function addHook ({ name, versions, file }, hook) {
-  file = filename(name, file)
-  const loaderHook = (moduleExports, moduleName, moduleBaseDir) => {
+  const fullFilename = filename(name, file)
+
+  Hook([name], (moduleExports, moduleName, moduleBaseDir) => {
     moduleName = moduleName.replace(pathSepExpr, '/')
-    const moduleVersion = getVersion(moduleBaseDir)
-    if (moduleName !== file || !matchVersion(moduleVersion, versions)) {
+
+    if (moduleName !== fullFilename || !matchVersion(getVersion(moduleBaseDir), versions)) {
       return moduleExports
     }
-    return hook(moduleExports)
-  }
-  ritm([name], loaderHook)
-  cjsPostLoad({ name, versions, file }, hook)
-  iitm([name], loaderHook)
+
+    try {
+      return hook(moduleExports)
+    } catch (e) {
+      log.error(e)
+      return moduleExports
+    }
+  })
 }
 
 function matchVersion (version, ranges) {
@@ -48,48 +51,9 @@ function filename (name, file) {
   return [name, file].filter(val => val).join('/')
 }
 
-// TODO this is basically Loader#_getModules + running the hook. DRY up.
-function cjsPostLoad (instrumentation, hook) {
-  const ids = Object.keys(require.cache)
-
-  let pkg
-
-  for (let i = 0, l = ids.length; i < l; i++) {
-    if (ids[i] === instrumentation.name) {
-      hook(require.cache[ids[i]].exports)
-      continue
-    }
-
-    const id = ids[i].replace(pathSepExpr, '/')
-
-    if (!id.includes(`/node_modules/${instrumentation.name}/`)) continue
-
-    if (instrumentation.file) {
-      if (!id.endsWith(`/node_modules/${filename(instrumentation)}`)) continue
-
-      const basedir = getBasedir(ids[i])
-
-      pkg = requirePackageJson(basedir, module)
-    } else {
-      const basedir = getBasedir(ids[i])
-
-      pkg = requirePackageJson(basedir, module)
-
-      const mainFile = path.posix.normalize(pkg.main || 'index.js')
-      if (!id.endsWith(`/node_modules/${instrumentation.name}/${mainFile}`)) continue
-    }
-
-    if (!matchVersion(pkg.version, instrumentation.versions)) continue
-
-    hook(require.cache[ids[i]].exports)
-  }
-}
-
-function getBasedir (id) {
-  return parse(id).basedir.replace(pathSepExpr, '/')
-}
-
-if (semver.satisfies(process.versions.node, '>=16.0.0')) {
+// AsyncResource.bind exists and binds `this` properly only from 17.8.0 and up.
+// https://nodejs.org/api/async_context.html#asyncresourcebindfn-thisarg
+if (semver.satisfies(process.versions.node, '>=17.8.0')) {
   exports.AsyncResource = AsyncResource
 } else {
   exports.AsyncResource = class extends AsyncResource {
@@ -98,9 +62,18 @@ if (semver.satisfies(process.versions.node, '>=16.0.0')) {
       return (new exports.AsyncResource(type || 'bound-anonymous-fn')).bind(fn, thisArg)
     }
 
-    bind (fn, thisArg = this) {
-      const ret = this.runInAsyncScope.bind(this, fn, thisArg)
-      Object.defineProperties(ret, {
+    bind (fn, thisArg) {
+      let bound
+      if (thisArg === undefined) {
+        const resource = this
+        bound = function (...args) {
+          args.unshift(fn, this)
+          return Reflect.apply(resource.runInAsyncScope, resource, args)
+        }
+      } else {
+        bound = this.runInAsyncScope.bind(this, fn, thisArg)
+      }
+      Object.defineProperties(bound, {
         'length': {
           configurable: true,
           enumerable: false,
@@ -114,7 +87,7 @@ if (semver.satisfies(process.versions.node, '>=16.0.0')) {
           writable: true
         }
       })
-      return ret
+      return bound
     }
   }
 }

package/packages/datadog-instrumentations/src/http/client.js

@@ -0,0 +1,170 @@
+'use strict'
+
+/* eslint-disable no-fallthrough */
+
+const url = require('url')
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('../helpers/instrument')
+const shimmer = require('../../../datadog-shimmer')
+
+const log = require('../../../dd-trace/src/log')
+
+const startClientCh = channel('apm:http:client:request:start')
+const asyncEndClientCh = channel('apm:http:client:request:async-end')
+const endClientCh = channel('apm:http:client:request:end')
+const errorClientCh = channel('apm:http:client:request:error')
+
+addHook({ name: 'https' }, hookFn)
+
+addHook({ name: 'http' }, hookFn)
+
+function hookFn (http) {
+  patch(http, 'request')
+  patch(http, 'get')
+
+  return http
+}
+
+function patch (http, methodName) {
+  shimmer.wrap(http, methodName, instrumentRequest)
+
+  function instrumentRequest (request) {
+    return function () {
+      if (!startClientCh.hasSubscribers) {
+        return request.apply(this, arguments)
+      }
+      const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+      let args
+
+      try {
+        args = normalizeArgs.apply(null, arguments)
+      } catch (e) {
+        log.error(e)
+        return request.apply(this, arguments)
+      }
+      startClientCh.publish({ args, http })
+
+      const ar = new AsyncResource('bound-anonymous-fn')
+
+      let finished = false
+      let callback = args.callback
+
+      if (callback) {
+        callback = asyncResource.bind(callback)
+      }
+
+      const options = args.options
+      const req = ar.bind(request).call(this, options, callback)
+      const emit = req.emit
+
+      const finish = (req, res) => {
+        if (!finished) {
+          finished = true
+          asyncEndClientCh.publish({ req, res })
+        }
+      }
+
+      req.emit = function (eventName, arg) {
+        ar.runInAsyncScope(() => {
+          switch (eventName) {
+            case 'response': {
+              const res = arg
+              const listener = ar.bind(() => finish(req, res))
+              res.on('end', listener)
+              res.on('error', listener)
+              break
+            }
+            case 'connect':
+            case 'upgrade':
+              finish(req, arg)
+              break
+            case 'error':
+              errorClientCh.publish(arg)
+            case 'abort': // deprecated and replaced by `close` in node 17
+            case 'timeout':
+            case 'close':
+              finish(req)
+          }
+        })
+
+        return emit.apply(this, arguments)
+      }
+
+      endClientCh.publish(undefined)
+
+      return req
+    }
+  }
+
+  function normalizeArgs (inputURL, inputOptions, cb) {
+    inputURL = normalizeOptions(inputURL)
+
+    const [callback, inputOptionsNormalized] = normalizeCallback(inputOptions, cb, inputURL)
+    const options = combineOptions(inputURL, inputOptionsNormalized)
+    normalizeHeaders(options)
+    const uri = url.format(options)
+
+    return { uri, options, callback }
+  }
+
+  function combineOptions (inputURL, inputOptions) {
+    if (typeof inputOptions === 'object') {
+      return Object.assign(inputURL || {}, inputOptions)
+    } else {
+      return inputURL
+    }
+  }
+  function normalizeHeaders (options) {
+    options.headers = options.headers || {}
+  }
+
+  function normalizeCallback (inputOptions, callback, inputURL) {
+    if (typeof inputOptions === 'function') {
+      return [inputOptions, inputURL || {}]
+    } else {
+      return [callback, inputOptions]
+    }
+  }
+
+  function normalizeOptions (inputURL) {
+    if (typeof inputURL === 'string') {
+      try {
+        return urlToOptions(new url.URL(inputURL))
+      } catch (e) {
+        return url.parse(inputURL)
+      }
+    } else if (inputURL instanceof url.URL) {
+      return urlToOptions(inputURL)
+    } else {
+      return inputURL
+    }
+  }
+
+  function urlToOptions (url) {
+    const agent = url.agent || http.globalAgent
+    const options = {
+      protocol: url.protocol || agent.protocol,
+      hostname: typeof url.hostname === 'string' && url.hostname.startsWith('[')
+        ? url.hostname.slice(1, -1)
+        : url.hostname ||
+          url.host ||
+          'localhost',
+      hash: url.hash,
+      search: url.search,
+      pathname: url.pathname,
+      path: `${url.pathname || ''}${url.search || ''}`,
+      href: url.href
+    }
+    if (url.port !== '') {
+      options.port = Number(url.port)
+    }
+    if (url.username || url.password) {
+      options.auth = `${url.username}:${url.password}`
+    }
+    return options
+  }
+}

package/packages/datadog-instrumentations/src/http/server.js

@@ -0,0 +1,61 @@
+'use strict'
+
+const {
+  channel,
+  addHook
+} = require('../helpers/instrument')
+const shimmer = require('../../../datadog-shimmer')
+
+const startServerCh = channel('apm:http:server:request:start')
+const endServerCh = channel('apm:http:server:request:end')
+const errorServerCh = channel('apm:http:server:request:error')
+const asyncEndServerCh = channel('apm:http:server:request:async-end')
+
+addHook({ name: 'https' }, http => {
+  // http.ServerResponse not present on https
+  shimmer.wrap(http.Server.prototype, 'emit', wrapEmit)
+  return http
+})
+
+addHook({ name: 'http' }, http => {
+  shimmer.wrap(http.ServerResponse.prototype, 'emit', wrapResponseEmit)
+  shimmer.wrap(http.Server.prototype, 'emit', wrapEmit)
+  return http
+})
+
+function wrapResponseEmit (emit) {
+  return function (eventName, event) {
+    if (!startServerCh.hasSubscribers) {
+      return emit.apply(this, arguments)
+    }
+
+    if (eventName === 'finish') {
+      asyncEndServerCh.publish({ req: this.req })
+    }
+
+    return emit.apply(this, arguments)
+  }
+}
+function wrapEmit (emit) {
+  return function (eventName, req, res) {
+    if (!startServerCh.hasSubscribers) {
+      return emit.apply(this, arguments)
+    }
+
+    if (eventName === 'request') {
+      res.req = req
+      startServerCh.publish({ req, res })
+
+      try {
+        return emit.apply(this, arguments)
+      } catch (err) {
+        errorServerCh.publish(err)
+
+        throw err
+      } finally {
+        endServerCh.publish(undefined)
+      }
+    }
+    return emit.apply(this, arguments)
+  }
+}

package/packages/datadog-instrumentations/src/http.js

@@ -0,0 +1,4 @@
+'use strict'
+
+require('./http/client')
+require('./http/server')

package/packages/datadog-instrumentations/src/mocha.js

@@ -0,0 +1,139 @@
+const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const testStartCh = channel('ci:mocha:test:start')
+const errorCh = channel('ci:mocha:test:error')
+const skipCh = channel('ci:mocha:test:skip')
+const testEndCh = channel('ci:mocha:test:end')
+const testAsyncEndCh = channel('ci:mocha:test:async-end')
+const suiteEndCh = channel('ci:mocha:suite:end')
+const hookErrorCh = channel('ci:mocha:hook:error')
+const parameterizedTestCh = channel('ci:mocha:test:parameterize')
+const testRunEndCh = channel('ci:mocha:run:end')
+
+// TODO: remove when root hooks and fixtures are implemented
+const patched = new WeakSet()
+
+function isRetry (test) {
+  return test._currentRetry !== undefined && test._currentRetry !== 0
+}
+
+function getAllTestsInSuite (root) {
+  const tests = []
+  function getTests (suiteOrTest) {
+    suiteOrTest.tests.forEach(test => {
+      tests.push(test)
+    })
+    suiteOrTest.suites.forEach(suite => {
+      getTests(suite)
+    })
+  }
+  getTests(root)
+  return tests
+}
+
+function mochaHook (Runner) {
+  if (patched.has(Runner)) return Runner
+
+  patched.add(Runner)
+
+  shimmer.wrap(Runner.prototype, 'runTest', runTest => function () {
+    if (!testStartCh.hasSubscribers) {
+      return runTest.apply(this, arguments)
+    }
+
+    if (!isRetry(this.test)) {
+      testStartCh.publish(this.test)
+    }
+
+    this.once('test end', AsyncResource.bind(() => {
+      let status
+
+      if (this.test.pending) {
+        status = 'skipped'
+      } else if (this.test.state !== 'failed' && !this.test.timedOut) {
+        status = 'pass'
+      } else {
+        status = 'fail'
+      }
+
+      testAsyncEndCh.publish(status)
+    }))
+
+    this.once('fail', AsyncResource.bind((test, err) => {
+      errorCh.publish(err)
+    }))
+
+    this.once('pending', AsyncResource.bind((test) => {
+      skipCh.publish(test)
+    }))
+
+    try {
+      return runTest.apply(this, arguments)
+    } catch (err) {
+      errorCh.publish(err)
+      throw err
+    } finally {
+      testEndCh.publish(undefined)
+    }
+  })
+
+  shimmer.wrap(Runner.prototype, 'runTests', runTests => function () {
+    if (!suiteEndCh.hasSubscribers) {
+      return runTests.apply(this, arguments)
+    }
+    this.once('end', AsyncResource.bind(() => {
+      testRunEndCh.publish(undefined)
+    }))
+    runTests.apply(this, arguments)
+    const suite = arguments[0]
+    // We call `getAllTestsInSuite` with the root suite so every skipped test
+    // should already have an associated test span.
+    const tests = getAllTestsInSuite(suite)
+    suiteEndCh.publish(tests)
+  })
+
+  shimmer.wrap(Runner.prototype, 'fail', fail => function (hook, error) {
+    if (!hookErrorCh.hasSubscribers) {
+      return fail.apply(this, arguments)
+    }
+    if (error && hook.ctx && hook.ctx.currentTest) {
+      error.message = `${hook.title}: ${error.message}`
+      hookErrorCh.publish({ test: hook.ctx.currentTest, error })
+    }
+    return fail.apply(this, arguments)
+  })
+
+  return Runner
+}
+
+function mochaEachHook (mochaEach) {
+  if (patched.has(mochaEach)) return mochaEach
+
+  patched.add(mochaEach)
+
+  return shimmer.wrap(mochaEach, function () {
+    const [params] = arguments
+    const { it, ...rest } = mochaEach.apply(this, arguments)
+    return {
+      it: function (name) {
+        parameterizedTestCh.publish({ name, params })
+        it.apply(this, arguments)
+      },
+      ...rest
+    }
+  })
+}
+
+addHook({
+  name: 'mocha',
+  versions: ['>=5.2.0'],
+  file: 'lib/runner.js'
+}, mochaHook)
+
+addHook({
+  name: 'mocha-each',
+  versions: ['>=2.0.1']
+}, mochaEachHook)
+
+module.exports = { mochaHook, mochaEachHook }

package/packages/datadog-instrumentations/src/mongodb-core.js

@@ -0,0 +1,179 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const startCh = channel(`apm:mongodb:query:start`)
+const endCh = channel(`apm:mongodb:query:end`)
+const asyncEndCh = channel(`apm:mongodb:query:async-end`)
+const errorCh = channel(`apm:mongodb:query:error`)
+
+addHook({ name: 'mongodb-core', versions: ['2 - 3.1.9'] }, Server => {
+  const serverProto = Server.Server.prototype
+  shimmer.wrap(serverProto, 'command', command => wrapCommand(command, 'command'))
+  shimmer.wrap(serverProto, 'insert', insert => wrapCommand(insert, 'insert', 'insert'))
+  shimmer.wrap(serverProto, 'update', update => wrapCommand(update, 'update', 'update'))
+  shimmer.wrap(serverProto, 'remove', remove => wrapCommand(remove, 'remove', 'remove'))
+
+  const cursorProto = Server.Cursor.prototype
+  shimmer.wrap(cursorProto, '_getmore', _getmore => wrapCursor(_getmore, 'getMore', 'getMore'))
+  shimmer.wrap(cursorProto, '_find', _find => wrapQuery(_find, '_find'))
+  shimmer.wrap(cursorProto, 'kill', kill => wrapCursor(kill, 'killCursors', 'killCursors'))
+  return Server
+})
+
+addHook({ name: 'mongodb', versions: ['>=4'], file: 'lib/cmap/connection.js' }, Connection => {
+  const proto = Connection.Connection.prototype
+  shimmer.wrap(proto, 'command', command => wrapConnectionCommand(command, 'command'))
+  shimmer.wrap(proto, 'query', query => wrapConnectionCommand(query, 'query'))
+  return Connection
+})
+
+addHook({ name: 'mongodb', versions: ['>=3.3 <4'], file: 'lib/core/wireprotocol/index.js' }, wp => wrapWp(wp))
+
+addHook({ name: 'mongodb-core', versions: ['>=3.2'], file: 'lib/wireprotocol/index.js' }, wp => wrapWp(wp))
+
+addHook({ name: 'mongodb-core', versions: ['~3.1.10'], file: 'lib/wireprotocol/3_2_support.js' }, WireProtocol => {
+  shimmer.wrap(WireProtocol.prototype, 'command', command => wrapUnifiedCommand(command, 'command'))
+  return WireProtocol
+})
+
+addHook({ name: 'mongodb-core', versions: ['~3.1.10'], file: 'lib/wireprotocol/2_6_support.js' }, WireProtocol => {
+  shimmer.wrap(WireProtocol.prototype, 'command', command => wrapUnifiedCommand(command, 'command'))
+  return WireProtocol
+})
+
+addHook({ name: 'mongodb', versions: ['>=3.5.4'], file: 'lib/utils.js' }, util => {
+  shimmer.wrap(util, 'maybePromise', maybePromise => function (parent, callback, fn) {
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    const callbackIndex = arguments.length - 2
+
+    callback = arguments[callbackIndex]
+
+    if (typeof callback === 'function') {
+      arguments[callbackIndex] = asyncResource.bind(callback)
+    }
+
+    return maybePromise.apply(this, arguments)
+  })
+  return util
+})
+
+function wrapWp (wp) {
+  shimmer.wrap(wp, 'command', command => wrapUnifiedCommand(command, 'command'))
+  shimmer.wrap(wp, 'insert', insert => wrapUnifiedCommand(insert, 'insert', 'insert'))
+  shimmer.wrap(wp, 'update', update => wrapUnifiedCommand(update, 'update', 'update'))
+  shimmer.wrap(wp, 'remove', remove => wrapUnifiedCommand(remove, 'remove', 'remove'))
+  shimmer.wrap(wp, 'query', query => wrapUnifiedCommand(query, 'query'))
+  shimmer.wrap(wp, 'getMore', getMore => wrapUnifiedCommand(getMore, 'getMore', 'getMore'))
+  shimmer.wrap(wp, 'killCursors', killCursors => wrapUnifiedCommand(killCursors, 'killCursors', 'killCursors'))
+  return wp
+}
+
+function wrapUnifiedCommand (command, operation, name) {
+  const wrapped = function (server, ns, ops) {
+    if (!startCh.hasSubscribers) {
+      return command.apply(this, arguments)
+    }
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    return instrument(asyncResource, operation, command, this, arguments, server, ns, ops, { name })
+  }
+  return shimmer.wrap(command, wrapped)
+}
+
+function wrapConnectionCommand (command, operation, name) {
+  const wrapped = function (ns, ops) {
+    if (!startCh.hasSubscribers) {
+      return command.apply(this, arguments)
+    }
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    const hostParts = typeof this.address === 'string' ? this.address.split(':') : ''
+    const options = hostParts.length === 2
+      ? { host: hostParts[0], port: hostParts[1] }
+      : {} // no port means the address is a random UUID so no host either
+    const topology = { s: { options } }
+
+    ns = `${ns.db}.${ns.collection}`
+    return instrument(asyncResource, operation, command, this, arguments, topology, ns, ops, { name })
+  }
+  return shimmer.wrap(command, wrapped)
+}
+
+function wrapQuery (query, operation, name) {
+  const wrapped = function () {
+    if (!startCh.hasSubscribers) {
+      return query.apply(this, arguments)
+    }
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    const pool = this.server.s.pool
+    const ns = this.ns
+    const ops = this.cmd
+    return instrument(asyncResource, operation, query, this, arguments, pool, ns, ops)
+  }
+
+  return shimmer.wrap(query, wrapped)
+}
+
+function wrapCursor (cursor, operation, name) {
+  const wrapped = function () {
+    if (!startCh.hasSubscribers) {
+      return cursor.apply(this, arguments)
+    }
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    const pool = this.server.s.pool
+    const ns = this.ns
+    return instrument(asyncResource, operation, cursor, this, arguments, pool, ns, {}, { name })
+  }
+  return shimmer.wrap(cursor, wrapped)
+}
+
+function wrapCommand (command, operation, name) {
+  const wrapped = function (ns, ops) {
+    if (!startCh.hasSubscribers) {
+      return command.apply(this, arguments)
+    }
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    return instrument(asyncResource, operation, command, this, arguments, this, ns, ops, { name })
+  }
+  return shimmer.wrap(command, wrapped)
+}
+
+function instrument (ar, operation, command, ctx, args, server, ns, ops, options = {}) {
+  const name = options.name || (ops && Object.keys(ops)[0])
+  const index = args.length - 1
+  let callback = args[index]
+
+  if (typeof callback !== 'function') return command.apply(ctx, args)
+
+  callback = ar.bind(callback)
+
+  const serverInfo = server && server.s && server.s.options
+
+  startCh.publish({ ns, ops, options: serverInfo, name })
+
+  args[index] = AsyncResource.bind(function (err, res) {
+    if (err) {
+      errorCh.publish(err)
+    }
+
+    asyncEndCh.publish(undefined)
+
+    if (callback) {
+      return callback.apply(this, arguments)
+    }
+  })
+
+  try {
+    return command.apply(ctx, args)
+  } catch (err) {
+    errorCh.publish(err)
+
+    throw err
+  } finally {
+    endCh.publish(undefined)
+  }
+}