dd-trace 2.4.0 → 2.5.0

package/LICENSE-3rdparty.csv

@@ -7,6 +7,7 @@ require,@types/node,MIT,Copyright Authors
 require,crypto-randomuuid,MIT,Copyright 2021 Node.js Foundation and contributors
 require,diagnostics_channel,MIT,Copyright 2021 Simon D.
 require,form-data,MIT,Copyright 2012 Felix Geisendörfer and contributors
+require,ignore,MIT,Copyright 2013 Kael Zhang and contributors
 require,import-in-the-middle,Apache license 2.0,Copyright 2021 Datadog Inc.
 require,koalas,MIT,Copyright 2013-2017 Brian Woodward
 require,limiter,MIT,Copyright 2011 John Hurliman

package/ci/init.js

@@ -1,12 +1,42 @@
+const path = require('path')
 const tracer = require('../packages/dd-trace')
 const { ORIGIN_KEY } = require('../packages/dd-trace/src/constants')
+const { mochaHook } = require('../packages/datadog-instrumentations/src/mocha')
+const { pickleHook, testCaseHook } = require('../packages/datadog-instrumentations/src/cucumber')
 
-tracer.init({
+const options = {
   startupLogs: false,
   tags: {
     [ORIGIN_KEY]: 'ciapp-test'
   }
-})
+}
+
+if (process.env.DD_CIVISIBILITY_AGENTLESS_ENABLED && (process.env.DATADOG_API_KEY || process.env.DD_API_KEY)) {
+  options.experimental = {
+    exporter: 'datadog'
+  }
+}
+
+// TODO: remove this in a later major version since we now recommend using
+// `NODE_OPTIONS='-r dd-trace/ci/init'`.
+try {
+  for (const filename in require.cache) {
+    const cache = require.cache[filename]
+    const id = filename.split(path.sep).join('/')
+
+    if (id.includes('/node_modules/mocha/lib/runner.js')) {
+      cache.exports = mochaHook(cache.exports)
+    } else if (id.includes('/node_modules/@cucumber/cucumber/lib/runtime/pickle_runner.js')) {
+      cache.exports = pickleHook(cache.exports)
+    } else if (id.includes('/node_modules/@cucumber/cucumber/lib/runtime/test_case_runner.js')) {
+      cache.exports = testCaseHook(cache.exports)
+    }
+  }
+} catch (e) {
+  // ignore error and let the tracer initialize anyway
+}
+
+tracer.init(options)
 
 tracer.use('fs', false)
 

package/ci/jest/env.js

@@ -1,13 +1,26 @@
 const tracer = require('../../packages/dd-trace')
 const { ORIGIN_KEY } = require('../../packages/dd-trace/src/constants')
 
-tracer.init({
+const options = {
   startupLogs: false,
-  flushInterval: 400000,
   tags: {
     [ORIGIN_KEY]: 'ciapp-test'
   }
-})
+}
+
+if (process.env.DD_CIVISIBILITY_AGENTLESS_ENABLED && (process.env.DATADOG_API_KEY || process.env.DD_API_KEY)) {
+  tracer.init({
+    ...options,
+    experimental: {
+      exporter: 'datadog'
+    }
+  })
+} else {
+  tracer.init({
+    ...options,
+    flushInterval: 400000
+  })
+}
 
 tracer.use('fs', false)
 

package/ext/exporters.d.ts

@@ -1,6 +1,7 @@
 declare const exporters: {
   LOG: 'log',
-  AGENT: 'agent'
+  AGENT: 'agent',
+  DATADOG: 'datadog'
 }
 
 export = exporters

package/ext/exporters.js

@@ -1,5 +1,6 @@
 'use strict'
 module.exports = {
   LOG: 'log',
-  AGENT: 'agent'
+  AGENT: 'agent',
+  DATADOG: 'datadog'
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -61,7 +61,7 @@
     "node": ">=12"
   },
   "dependencies": {
-    "@datadog/native-appsec": "^0.8.2",
+    "@datadog/native-appsec": "^1.0.1",
     "@datadog/native-metrics": "^1.1.0",
     "@datadog/pprof": "^0.3.0",
     "@datadog/sketches-js": "^1.0.4",
@@ -69,6 +69,7 @@
     "crypto-randomuuid": "^1.0.0",
     "diagnostics_channel": "^1.1.0",
     "form-data": "^3.0.0",
+    "ignore": "^5.2.0",
     "import-in-the-middle": "^1.2.1",
     "koalas": "^1.0.2",
     "limiter": "^1.1.4",

package/packages/datadog-instrumentations/index.js

@@ -10,6 +10,7 @@ require('./src/cucumber')
 require('./src/dns')
 require('./src/elasticsearch')
 require('./src/generic-pool')
+require('./src/http')
 require('./src/ioredis')
 require('./src/memcached')
 require('./src/mongodb-core')
@@ -17,6 +18,7 @@ require('./src/mongoose')
 require('./src/mysql')
 require('./src/mysql2')
 require('./src/mocha')
+require('./src/net')
 require('./src/pino')
 require('./src/pg')
 require('./src/promise')

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

@@ -38,7 +38,7 @@ addHook({ name: 'amqplib', file: 'lib/channel.js', versions: ['>=0.5'] }, channe
 
 function instrument (send, channel, args, method, fields, message) {
   if (!startCh.hasSubscribers) {
-    return send.apply(this, arguments)
+    return send.apply(channel, args)
   }
   startCh.publish({ channel, method, fields, message })
 

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

@@ -10,6 +10,9 @@ const runStepStartCh = channel('ci:cucumber:run-step:start')
 const runStepEndCh = channel('ci:cucumber:run-step:end')
 const errorCh = channel('ci:cucumber:error')
 
+// TODO: remove in a later major version
+const patched = new WeakSet()
+
 function getStatusFromResult (result) {
   if (result.status === 1) {
     return { status: 'pass' }
@@ -37,6 +40,10 @@ function getStatusFromResultLatest (result) {
 }
 
 function wrapRun (pl, isLatestVersion) {
+  if (patched.has(pl)) return
+
+  patched.add(pl)
+
   shimmer.wrap(pl.prototype, 'run', run => function () {
     if (!runStartCh.hasSubscribers) {
       return run.apply(this, arguments)
@@ -93,26 +100,32 @@ function wrapRun (pl, isLatestVersion) {
   })
 }
 
-addHook({
-  name: '@cucumber/cucumber',
-  versions: ['7.0.0 - 7.2.1'],
-  file: 'lib/runtime/pickle_runner.js'
-}, (PickleRunner) => {
+function pickleHook (PickleRunner) {
   const pl = PickleRunner.default
 
   wrapRun(pl, false)
 
   return PickleRunner
-})
+}
 
-addHook({
-  name: '@cucumber/cucumber',
-  versions: ['>=7.3.0'],
-  file: 'lib/runtime/test_case_runner.js'
-}, (TestCaseRunner) => {
+function testCaseHook (TestCaseRunner) {
   const pl = TestCaseRunner.default
 
   wrapRun(pl, true)
 
   return TestCaseRunner
-})
+}
+
+addHook({
+  name: '@cucumber/cucumber',
+  versions: ['7.0.0 - 7.2.1'],
+  file: 'lib/runtime/pickle_runner.js'
+}, pickleHook)
+
+addHook({
+  name: '@cucumber/cucumber',
+  versions: ['>=7.3.0'],
+  file: 'lib/runtime/test_case_runner.js'
+}, testCaseHook)
+
+module.exports = { pickleHook, testCaseHook }

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

@@ -0,0 +1,8 @@
+const { addHook } = require('./helpers/instrument')
+
+// No handler because this is only useful for testing.
+// Cypress plugin does not patch any library.
+addHook({
+  name: 'cypress',
+  versions: ['>=6.7.0']
+})

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

@@ -0,0 +1,44 @@
+'use strict'
+
+const path = require('path')
+const iitm = require('../../../dd-trace/src/iitm')
+const ritm = require('../../../dd-trace/src/ritm')
+
+function Hook (modules, onrequire) {
+  if (!(this instanceof Hook)) return new Hook(modules, onrequire)
+
+  this._patched = Object.create(null)
+
+  const safeHook = (moduleExports, moduleName, moduleBaseDir) => {
+    const parts = [moduleBaseDir, moduleName].filter(v => v)
+    const filename = path.join(...parts)
+
+    if (this._patched[filename]) return moduleExports
+
+    this._patched[filename] = true
+
+    return onrequire(moduleExports, moduleName, moduleBaseDir)
+  }
+
+  this._ritmHook = ritm(modules, {}, safeHook)
+  this._iitmHook = iitm(modules, {}, (moduleExports, moduleName, moduleBaseDir) => {
+    // TODO: Move this logic to import-in-the-middle and only do it for CommonJS
+    // modules and not ESM. In the meantime, all the modules we instrument are
+    // CommonJS modules for which the default export is always moved to
+    // `default` anyway.
+    if (moduleExports && moduleExports.default) {
+      moduleExports.default = safeHook(moduleExports.default, moduleName, moduleBaseDir)
+      return moduleExports
+    } else {
+      return safeHook(moduleExports, moduleName, moduleBaseDir)
+    }
+  })
+}
+
+Hook.prototype.unhook = function () {
+  this._ritmHook.unhook()
+  this._iitmHook.unhook()
+  this._patched = Object.create(null)
+}
+
+module.exports = Hook

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 = {}
@@ -21,17 +20,21 @@ exports.channel = function channel (name) {
 
 exports.addHook = function addHook ({ name, versions, file }, hook) {
   const fullFilename = filename(name, file)
-  const loaderHook = (moduleExports, moduleName, moduleBaseDir) => {
+
+  Hook([name], (moduleExports, moduleName, moduleBaseDir) => {
     moduleName = moduleName.replace(pathSepExpr, '/')
-    const moduleVersion = getVersion(moduleBaseDir)
-    if (moduleName !== fullFilename || !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.name, instrumentation.file)}`)) 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')