dd-trace 2.6.0 → 2.7.0

package/LICENSE-3rdparty.csv

@@ -39,8 +39,6 @@ dev,eslint-plugin-import,MIT,Copyright 2015 Ben Mosher
 dev,eslint-plugin-node,MIT,Copyright 2015 Toru Nagashima
 dev,eslint-plugin-promise,ISC,jden and other contributors
 dev,eslint-plugin-standard,MIT,Copyright 2015 Jamund Ferguson
-dev,mocha-junit-reporter,MIT,Copyright 2015 Michael Allen
-dev,mocha-multi-reporters,MIT,Copyright 2015 Stanley Ng 2019 Yousaf Nabi
 dev,express,MIT,Copyright 2009-2014 TJ Holowaychuk 2013-2014 Roman Shtylman 2014-2015 Douglas Christopher Wilson
 dev,get-port,MIT,Copyright Sindre Sorhus
 dev,glob,ISC,Copyright Isaac Z. Schlueter and Contributors

package/index.d.ts

@@ -575,7 +575,6 @@ interface Plugins {
   "kafkajs": plugins.kafkajs
   "knex": plugins.knex;
   "koa": plugins.koa;
-  "limitd-client": plugins.limitd_client;
   "memcached": plugins.memcached;
   "microgateway-core": plugins.microgateway_core;
   "mocha": plugins.mocha;
@@ -1159,12 +1158,6 @@ declare namespace plugins {
    */
   interface kafkajs extends Instrumentation {}
 
-  /**
-   * This plugin automatically instruments the
-   * [limitd-client](https://github.com/limitd/node-client) module.
-   */
-  interface limitd_client extends Integration {}
-
   /**
    * This plugin automatically instruments the
    * [memcached](https://github.com/3rd-Eden/memcached) module.

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "dd-trace",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
   "scripts": {
     "preinstall": "node scripts/preinstall.js",
-    "postpublish": "node scripts/postpublish.js",
     "bench": "node benchmark",
     "bench:profiler": "node benchmark/profiler",
     "bench:e2e": "SERVICES=mongo yarn services && cd benchmark/e2e && node benchmark-run.js --duration=30",
@@ -16,24 +15,23 @@
     "lint": "node scripts/check_licenses.js && eslint . && yarn audit --groups dependencies",
     "services": "node ./scripts/install_plugin_modules && node packages/dd-trace/test/setup/services",
     "tdd": "node scripts/tdd.js",
-    "test": "SERVICES=* yarn services && mocha --exit --expose-gc 'packages/dd-trace/test/setup/node.js' 'packages/*/test/**/*.spec.js'",
-    "test:trace:core": "mocha --exit --expose-gc --file packages/dd-trace/test/setup/core.js \"packages/dd-trace/test/**/*.spec.js\"",
-    "test:trace:core:ci": "nyc --include \"packages/dd-trace/src/**/*.js\" -- npm run test:trace:core --  --reporter mocha-multi-reporters --reporter-options configFile=mocha-reporter-config.json",
-    "test:instrumentations": "mocha --file 'packages/dd-trace/test/setup/core.js' 'packages/datadog-instrumentations/test/**/*.spec.js'",
-    "test:instrumentations:ci": "nyc --include 'packages/datadog-instrumentations/src/**/*.js' -- npm run test:instrumentations -- --reporter mocha-multi-reporters --reporter-options configFile=mocha-reporter-config.json",
-    "test:core": "mocha --file packages/datadog-core/test/setup.js 'packages/datadog-core/test/**/*.spec.js'",
-    "test:core:ci": "nyc --include 'packages/datadog-core/src/**/*.js' -- npm run test:core -- --reporter mocha-multi-reporters --reporter-options configFile=mocha-reporter-config.json",
-    "test:plugins": "mocha --exit --file \"packages/dd-trace/test/setup/core.js\" \"packages/datadog-plugin-@($(echo $PLUGINS))/test/**/*.spec.js\"",
-    "test:plugins:ci": "yarn services && nyc --include \"packages/datadog-plugin-@($(echo $PLUGINS))/src/**/*.js\" -- npm run test:plugins -- --reporter mocha-multi-reporters --reporter-options configFile=mocha-reporter-config.json",
+    "test": "SERVICES=* yarn services && mocha --colors --exit --expose-gc 'packages/dd-trace/test/setup/node.js' 'packages/*/test/**/*.spec.js'",
+    "test:trace:core": "mocha --colors --exit --expose-gc --file packages/dd-trace/test/setup/core.js --exclude \"packages/dd-trace/test/profiling/**/*.spec.js\" \"packages/dd-trace/test/**/*.spec.js\"",
+    "test:trace:core:ci": "nyc --no-clean --include \"packages/dd-trace/src/**/*.js\" --exclude \"packages/dd-trace/src/profiling/**/*.js\" -- npm run test:trace:core",
+    "test:instrumentations": "mocha --colors --file 'packages/dd-trace/test/setup/core.js' 'packages/datadog-instrumentations/test/**/*.spec.js'",
+    "test:instrumentations:ci": "nyc --no-clean --include 'packages/datadog-instrumentations/src/**/*.js' -- npm run test:instrumentations",
+    "test:core": "mocha --colors --file packages/datadog-core/test/setup.js 'packages/datadog-core/test/**/*.spec.js'",
+    "test:core:ci": "nyc --no-clean --include 'packages/datadog-core/src/**/*.js' -- npm run test:core",
+    "test:plugins": "mocha --colors --exit --file \"packages/dd-trace/test/setup/core.js\" \"packages/datadog-instrumentations/test/@($(echo $PLUGINS)).spec.js\" \"packages/datadog-plugin-@($(echo $PLUGINS))/test/**/*.spec.js\"",
+    "test:plugins:ci": "yarn services && nyc --no-clean --include \"packages/datadog-instrumentations/src/@($(echo $PLUGINS)).js\" --include \"packages/datadog-instrumentations/src/@($(echo $PLUGINS))/**/*.js\" --include \"packages/datadog-plugin-@($(echo $PLUGINS))/src/**/*.js\" -- npm run test:plugins",
     "test:plugins:upstream": "node ./packages/dd-trace/test/plugins/suite.js",
-    "test:profiler": "mocha --exit --file \"packages/dd-trace/test/setup/core.js\" \"packages/dd-trace/test/profiling/**/*.spec.js\"",
-    "test:integration": "mocha --timeout 30000 \"integration-tests/**/*.spec.js\"",
-    "test:shimmer": "mocha 'packages/datadog-shimmer/test/**/*.spec.js'",
-    "test:shimmer:ci": "nyc --include 'packages/datadog-shimmer/src/**/*.js' -- npm run test:shimmer -- --reporter mocha-multi-reporters --reporter-options configFile=mocha-reporter-config.json",
+    "test:profiler": "mocha --colors --exit --file \"packages/dd-trace/test/setup/core.js\" \"packages/dd-trace/test/profiling/**/*.spec.js\"",
+    "test:profiler:ci": "nyc --no-clean --include \"packages/dd-trace/src/profiling/**/*.js\" -- npm run test:profiler",
+    "test:integration": "mocha --colors --timeout 30000 \"integration-tests/**/*.spec.js\"",
+    "test:shimmer": "mocha --colors 'packages/datadog-shimmer/test/**/*.spec.js'",
+    "test:shimmer:ci": "nyc --no-clean --include 'packages/datadog-shimmer/src/**/*.js' -- npm run test:shimmer",
     "leak:core": "node ./scripts/install_plugin_modules && (cd packages/memwatch && yarn) && NODE_PATH=./packages/memwatch/node_modules node --no-warnings ./node_modules/.bin/tape 'packages/dd-trace/test/leak/**/*.js'",
     "leak:plugins": "yarn services && (cd packages/memwatch && yarn) && NODE_PATH=./packages/memwatch/node_modules node --no-warnings ./node_modules/.bin/tape \"packages/datadog-plugin-@($(echo $PLUGINS))/test/leak.js\"",
-    "cover:merge": "nyc merge ./.nyc_output ./.nyc_merge/$CIRCLE_JOB.json",
-    "cover:report": "nyc report -t ./.nyc_merge -n 'packages/**/*.js'",
     "codecov": "codecov",
     "junit:upload": "node ./scripts/junit_report.js"
   },
@@ -97,7 +95,7 @@
     "cli-table3": "^0.5.1",
     "codecov": "3.8.1",
     "dotenv": "8.2.0",
-    "eslint": "^4.15.0",
+    "eslint": "^7.32.0",
     "eslint-config-standard": "^11.0.0-beta.0",
     "eslint-plugin-import": "^2.8.0",
     "eslint-plugin-node": "^5.2.1",
@@ -111,8 +109,6 @@
     "jszip": "^3.5.0",
     "mkdirp": "^0.5.1",
     "mocha": "8",
-    "mocha-junit-reporter": "^2.0.0",
-    "mocha-multi-reporters": "^1.5.1",
     "msgpack-lite": "^0.1.26",
     "nock": "^11.3.3",
     "nyc": "^15.1.0",

package/packages/datadog-instrumentations/index.js

@@ -5,14 +5,22 @@ require('./src/amqp10')
 require('./src/bluebird')
 require('./src/bunyan')
 require('./src/cassandra-driver')
+require('./src/connect')
 require('./src/couchbase')
 require('./src/cucumber')
 require('./src/dns')
 require('./src/elasticsearch')
+require('./src/express')
+require('./src/fastify')
+require('./src/find-my-way')
 require('./src/generic-pool')
+require('./src/google-cloud-pubsub')
 require('./src/http')
 require('./src/ioredis')
 require('./src/jest')
+require('./src/kafkajs')
+require('./src/knex')
+require('./src/koa')
 require('./src/memcached')
 require('./src/mongodb-core')
 require('./src/mongoose')
@@ -20,14 +28,19 @@ require('./src/mysql')
 require('./src/mysql2')
 require('./src/mocha')
 require('./src/net')
+require('./src/oracledb')
+require('./src/paperplane')
 require('./src/pino')
 require('./src/pg')
 require('./src/promise')
 require('./src/promise-js')
 require('./src/q')
 require('./src/redis')
+require('./src/restify')
+require('./src/router')
 require('./src/rhea')
 require('./src/sharedb')
 require('./src/tedious')
 require('./src/when')
 require('./src/winston')
+require('./src/limitd-client')

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

@@ -0,0 +1,111 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+
+const enterChannel = channel('apm:connect:middleware:enter')
+const errorChannel = channel('apm:connect:middleware:error')
+const exitChannel = channel('apm:connect:middleware:exit')
+const handleChannel = channel('apm:connect:request:handle')
+
+function wrapConnect (connect) {
+  if (typeof connect !== 'function') return connect
+
+  return function connectWithTrace () {
+    const app = connect()
+
+    if (!app) return app
+
+    shimmer.wrap(app, 'use', wrapUse)
+    shimmer.wrap(app, 'handle', wrapHandle)
+
+    return app
+  }
+}
+
+function wrapUse (use) {
+  if (typeof use !== 'function') return use
+
+  return function useWithTrace (route, fn) {
+    const result = use.apply(this, arguments)
+
+    if (!this || !Array.isArray(this.stack)) return result
+
+    const index = this.stack.length - 1
+    const layer = this.stack[index]
+
+    if (layer && layer.handle) {
+      this.stack[index].handle = wrapLayerHandle(layer)
+    }
+
+    return result
+  }
+}
+
+function wrapHandle (handle) {
+  return function handleWithTrace (req, res) {
+    if (handleChannel.hasSubscribers) {
+      handleChannel.publish({ req, res })
+    }
+
+    return handle.apply(this, arguments)
+  }
+}
+
+function wrapLayerHandle (layer) {
+  if (typeof layer.handle !== 'function') return layer.handle
+
+  const original = layer.handle
+
+  return shimmer.wrap(original, function () {
+    if (!enterChannel.hasSubscribers) return original.apply(this, arguments)
+
+    const middlewareResource = new AsyncResource('bound-anonymous-fn')
+    const lastIndex = arguments.length - 1
+    const name = original._name || original.name
+    const req = arguments[arguments.length > 3 ? 1 : 0]
+    const next = AsyncResource.bind(arguments[lastIndex])
+
+    if (typeof next === 'function') {
+      arguments[lastIndex] = wrapNext(req, middlewareResource.bind(next))
+    }
+
+    return middlewareResource.runInAsyncScope(() => {
+      const route = layer.route
+
+      enterChannel.publish({ name, req, route })
+
+      try {
+        return original.apply(this, arguments)
+      } catch (e) {
+        errorChannel.publish(e)
+        exitChannel.publish({ req })
+
+        throw e
+      }
+    })
+  })
+}
+
+function wrapNext (req, next) {
+  return function (error) {
+    if (error) {
+      errorChannel.publish(error)
+    }
+
+    exitChannel.publish({ req })
+
+    next.apply(null, arguments)
+  }
+}
+
+addHook({ name: 'connect', versions: ['>=3'] }, connect => {
+  return shimmer.wrap(connect, wrapConnect(connect))
+})
+
+addHook({ name: 'connect', versions: ['2.2.2'] }, connect => {
+  shimmer.wrap(connect.proto, 'use', wrapUse)
+  shimmer.wrap(connect.proto, 'handle', wrapHandle)
+
+  return connect
+})

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

@@ -0,0 +1,27 @@
+'use strict'
+
+const { createWrapRouterMethod } = require('./router')
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel } = require('./helpers/instrument')
+
+const handleChannel = channel('apm:express:request:handle')
+
+function wrapHandle (handle) {
+  return function handleWithTrace (req, res) {
+    if (handleChannel.hasSubscribers) {
+      handleChannel.publish({ req })
+    }
+
+    return handle.apply(this, arguments)
+  }
+}
+
+const wrapRouterMethod = createWrapRouterMethod('express')
+
+addHook({ name: 'express', versions: ['>=4'] }, express => {
+  shimmer.wrap(express.application, 'handle', wrapHandle)
+  shimmer.wrap(express.Router, 'use', wrapRouterMethod)
+  shimmer.wrap(express.Router, 'route', wrapRouterMethod)
+
+  return express
+})

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

@@ -0,0 +1,187 @@
+'use strict'
+
+const methods = require('methods').concat('all')
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+
+const errorChannel = channel('apm:fastify:middleware:error')
+const handleChannel = channel('apm:fastify:request:handle')
+
+const requestResources = new WeakMap()
+
+function wrapFastify (fastify) {
+  if (typeof fastify !== 'function') return fastify
+
+  return function fastifyWithTrace () {
+    const app = fastify.apply(this, arguments)
+
+    if (!app) return app
+
+    if (typeof app.addHook === 'function') {
+      app.addHook('onRequest', onRequest)
+      app.addHook = wrapAddHook(app.addHook)
+      app.addHook('preHandler', preHandler)
+    }
+
+    methods.forEach(method => {
+      app[method] = wrapMethod(app[method])
+    })
+
+    app.route = wrapRoute(app.route)
+
+    return app
+  }
+}
+
+function wrapAddHook (addHook) {
+  return function addHookWithTrace (name, fn) {
+    fn = arguments[arguments.length - 1]
+
+    if (typeof fn !== 'function') return addHook.apply(this, arguments)
+
+    arguments[arguments.length - 1] = shimmer.wrap(fn, function (request, reply, done) {
+      const req = getReq(request)
+      const requestResource = requestResources.get(req)
+
+      if (!requestResource) return fn.apply(this, arguments)
+
+      requestResource.runInAsyncScope(() => {
+        const hookResource = new AsyncResource('bound-anonymous-fn')
+
+        try {
+          if (typeof done === 'function') {
+            done = arguments[arguments.length - 1]
+
+            arguments[arguments.length - 1] = hookResource.bind(function (err) {
+              errorChannel.publish(err)
+              return done.apply(this, arguments)
+            })
+
+            return hookResource.bind(fn).apply(this, arguments)
+          } else {
+            const promise = hookResource.bind(fn).apply(this, arguments)
+
+            if (promise && typeof promise.catch === 'function') {
+              return promise.catch(err => {
+                errorChannel.publish(err)
+                throw err
+              })
+            }
+
+            return promise
+          }
+        } catch (e) {
+          errorChannel.publish(e)
+          throw e
+        }
+      })
+    })
+
+    return addHook.apply(this, arguments)
+  }
+}
+
+function onRequest (request, reply, next) {
+  if (typeof next !== 'function') return
+
+  const req = getReq(request)
+  const res = getRes(reply)
+
+  requestResources.set(req, new AsyncResource('bound-anonymous-fn'))
+  handleChannel.publish({ req, res })
+
+  return next()
+}
+
+function preHandler (request, reply, next) {
+  if (typeof next !== 'function') return
+  if (!reply || typeof reply.send !== 'function') return next()
+
+  const req = getReq(request)
+
+  reply.send = requestResources.get(req).bind(wrapSend(reply.send))
+
+  next()
+}
+
+function wrapSend (send) {
+  return function sendWithTrace (payload) {
+    if (payload instanceof Error) {
+      errorChannel.publish(payload)
+    }
+
+    return send.apply(this, arguments)
+  }
+}
+
+function wrapRoute (route) {
+  if (typeof route !== 'function') return route
+
+  return function routeWithTrace (opts) {
+    opts.handler = wrapHandler(opts.handler)
+
+    return route.apply(this, arguments)
+  }
+}
+
+function wrapMethod (method) {
+  if (typeof method !== 'function') return method
+
+  return function methodWithTrace (url, opts, handler) {
+    const lastIndex = arguments.length - 1
+
+    handler = arguments[lastIndex]
+
+    if (typeof handler === 'function') {
+      arguments[lastIndex] = wrapHandler(handler)
+    } else if (handler) {
+      arguments[lastIndex].handler = wrapHandler(handler.handler)
+    }
+
+    return method.apply(this, arguments)
+  }
+}
+
+function wrapHandler (handler) {
+  if (!handler || typeof handler !== 'function' || handler.name === 'handlerWithTrace') {
+    return handler
+  }
+
+  return function handlerWithTrace (request, reply) {
+    const req = getReq(request)
+
+    return requestResources.get(req).runInAsyncScope(() => {
+      return handler.apply(this, arguments)
+    })
+  }
+}
+
+function getReq (request) {
+  return request && (request.raw || request.req || request)
+}
+
+function getRes (reply) {
+  return reply && (reply.raw || reply.res || reply)
+}
+
+addHook({ name: 'fastify', versions: ['>=3.25.2'] }, fastify => {
+  const wrapped = shimmer.wrap(fastify, wrapFastify(fastify, false))
+
+  wrapped.fastify = wrapped
+  wrapped.default = wrapped
+
+  return wrapped
+})
+
+addHook({ name: 'fastify', versions: ['3 - 3.25.1'] }, fastify => {
+  const wrapped = shimmer.wrap(fastify, wrapFastify(fastify, true))
+
+  wrapped.fastify = wrapped
+  wrapped.default = wrapped
+
+  return wrapped
+})
+
+addHook({ name: 'fastify', versions: ['1 - 2'] }, fastify => {
+  return shimmer.wrap(fastify, wrapFastify(fastify, true))
+})

package/packages/datadog-instrumentations/src/find-my-way.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel } = require('./helpers/instrument')
+
+const routeChannel = channel('apm:find-my-way:request:route')
+
+function wrapOn (on) {
+  return function onWithTrace (method, path, opts) {
+    const index = typeof opts === 'function' ? 2 : 3
+    const handler = arguments[index]
+    const wrapper = function (req) {
+      routeChannel.publish({ req, route: path })
+
+      return handler.apply(this, arguments)
+    }
+
+    if (typeof handler === 'function') {
+      arguments[index] = wrapper
+    }
+
+    return on.apply(this, arguments)
+  }
+}
+
+addHook({ name: 'find-my-way', versions: ['>=1'] }, Router => {
+  shimmer.wrap(Router.prototype, 'on', wrapOn)
+
+  return Router
+})

package/packages/datadog-instrumentations/src/google-cloud-pubsub.js

@@ -0,0 +1,100 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const requestStartCh = channel('apm:google-cloud-pubsub:request:start')
+const requestFinishCh = channel('apm:google-cloud-pubsub:request:finish')
+const requestErrorCh = channel('apm:google-cloud-pubsub:request:error')
+
+const receiveStartCh = channel(`apm:google-cloud-pubsub:receive:start`)
+const receiveFinishCh = channel('apm:google-cloud-pubsub:receive:finish')
+const receiveErrorCh = channel('apm:google-cloud-pubsub:receive:error')
+
+addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'] }, (obj) => {
+  const PubSub = obj.PubSub
+  const Subscription = obj.Subscription
+
+  shimmer.wrap(PubSub.prototype, 'request', request => function (cfg = { reqOpts: {} }, cb) {
+    if (!requestStartCh.hasSubscribers) {
+      return request.apply(this, arguments)
+    }
+
+    const innerAsyncResource = new AsyncResource('bound-anonymous-fn')
+    const outerAsyncResource = new AsyncResource('bound-anonymous-fn')
+
+    return innerAsyncResource.runInAsyncScope(() => {
+      let messages = []
+      if (cfg.reqOpts && cfg.method === 'publish') {
+        messages = cfg.reqOpts.messages
+      }
+
+      requestStartCh.publish({ cfg, projectId: this.projectId, messages })
+      cb = outerAsyncResource.bind(cb)
+
+      const fn = () => {
+        arguments[1] = innerAsyncResource.bind(function (error) {
+          if (error) {
+            requestErrorCh.publish(error)
+          }
+          requestFinishCh.publish(undefined)
+          return cb.apply(this, arguments)
+        })
+        return request.apply(this, arguments)
+      }
+
+      try {
+        return fn.apply(this, arguments)
+      } catch (e) {
+        requestErrorCh.publish(e)
+        throw e
+      }
+    })
+  })
+
+  shimmer.wrap(Subscription.prototype, 'emit', emit => function (eventName, message) {
+    if (eventName !== 'message' || !message) return emit.apply(this, arguments)
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+    return asyncResource.runInAsyncScope(() => {
+      try {
+        return emit.apply(this, arguments)
+      } catch (err) {
+        receiveErrorCh.publish({ err, message })
+        throw err
+      }
+    })
+  })
+
+  return obj
+})
+
+addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'], file: 'build/src/lease-manager.js' }, (obj) => {
+  const LeaseManager = obj.LeaseManager
+
+  shimmer.wrap(LeaseManager.prototype, '_dispense', dispense => function (message) {
+    if (receiveStartCh.hasSubscribers) {
+      receiveStartCh.publish({ message })
+    }
+    return dispense.apply(this, arguments)
+  })
+
+  shimmer.wrap(LeaseManager.prototype, 'remove', remove => function (message) {
+    receiveFinishCh.publish({ message })
+    return remove.apply(this, arguments)
+  })
+
+  shimmer.wrap(LeaseManager.prototype, 'clear', clear => function () {
+    for (const message of this._messages) {
+      receiveFinishCh.publish({ message })
+    }
+    return clear.apply(this, arguments)
+  })
+
+  return obj
+})

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

@@ -9,7 +9,7 @@ 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')
+const asyncEndServerCh = channel('apm:http:server:request:finish')
 
 addHook({ name: 'https' }, http => {
   // http.ServerResponse not present on https