dd-trace 2.4.2 → 2.7.0

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

@@ -0,0 +1,128 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const connectionAttributes = new WeakMap()
+const poolAttributes = new WeakMap()
+
+const executeStartChannel = channel('apm:oracledb:execute:start')
+const executeErrorChannel = channel('apm:oracledb:execute:error')
+const executeFinishChannel = channel('apm:oracledb:execute:finish')
+
+function finish (err) {
+  if (err) {
+    executeErrorChannel.publish(err)
+  }
+  executeFinishChannel.publish(undefined)
+}
+
+addHook({ name: 'oracledb', versions: ['5'] }, oracledb => {
+  shimmer.wrap(oracledb.Connection.prototype, 'execute', execute => {
+    return function wrappedExecute (dbQuery, ...args) {
+      if (!executeStartChannel.hasSubscribers) {
+        return execute.apply(this, arguments)
+      }
+
+      if (arguments.length && typeof arguments[arguments.length - 1] === 'function') {
+        const cb = arguments[arguments.length - 1]
+        const outerAr = new AsyncResource('apm:oracledb:outer-scope')
+        arguments[arguments.length - 1] = function wrappedCb (err, result) {
+          finish(err)
+          return outerAr.runInAsyncScope(() => cb.apply(this, arguments))
+        }
+      }
+
+      return new AsyncResource('apm:oracledb:inner-scope').runInAsyncScope(() => {
+        const connAttrs = connectionAttributes.get(this)
+        executeStartChannel.publish({ query: dbQuery, connAttrs })
+        try {
+          let result = execute.apply(this, arguments)
+
+          if (result && typeof result.then === 'function') {
+            result = result.then(
+              x => {
+                finish()
+                return x
+              },
+              e => {
+                finish(e)
+                throw e
+              }
+            )
+          }
+
+          return result
+        } catch (err) {
+          executeErrorChannel.publish(err)
+          throw err
+        }
+      })
+    }
+  })
+  shimmer.wrap(oracledb, 'getConnection', getConnection => {
+    return function wrappedGetConnection (connAttrs, callback) {
+      if (callback) {
+        arguments[1] = (err, connection) => {
+          if (connection) {
+            connectionAttributes.set(connection, connAttrs)
+          }
+          callback(err, connection)
+        }
+
+        getConnection.apply(this, arguments)
+      } else {
+        return getConnection.apply(this, arguments).then((connection) => {
+          connectionAttributes.set(connection, connAttrs)
+          return connection
+        })
+      }
+    }
+  })
+  shimmer.wrap(oracledb, 'createPool', createPool => {
+    return function wrappedCreatePool (poolAttrs, callback) {
+      if (callback) {
+        arguments[1] = (err, pool) => {
+          if (pool) {
+            poolAttributes.set(pool, poolAttrs)
+          }
+          callback(err, pool)
+        }
+
+        createPool.apply(this, arguments)
+      } else {
+        return createPool.apply(this, arguments).then((pool) => {
+          poolAttributes.set(pool, poolAttrs)
+          return pool
+        })
+      }
+    }
+  })
+  shimmer.wrap(oracledb.Pool.prototype, 'getConnection', getConnection => {
+    return function wrappedGetConnection () {
+      let callback
+      if (typeof arguments[arguments.length - 1] === 'function') {
+        callback = arguments[arguments.length - 1]
+      }
+      if (callback) {
+        arguments[arguments.length - 1] = (err, connection) => {
+          if (connection) {
+            connectionAttributes.set(connection, poolAttributes.get(this))
+          }
+          callback(err, connection)
+        }
+        getConnection.apply(this, arguments)
+      } else {
+        return getConnection.apply(this, arguments).then((connection) => {
+          connectionAttributes.set(connection, poolAttributes.get(this))
+          return connection
+        })
+      }
+    }
+  })
+  return oracledb
+})

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

@@ -0,0 +1,77 @@
+'use strict'
+
+const { addHook, channel } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const logChannel = channel('apm:paperplane:log')
+const handleChannel = channel('apm:paperplane:request:handle')
+const routeChannel = channel('apm:paperplane:request:route')
+
+const nodeMajor = Number(process.versions.node.split('.')[0])
+const name = 'paperplane'
+const versions = nodeMajor <= 12 ? ['>=2.3.2'] : nodeMajor <= 14 ? ['>=3.1.1'] : []
+
+const wrapRoute = handler => req => {
+  const { original, route } = req
+
+  if (routeChannel.hasSubscribers) {
+    routeChannel.publish({ req: original, route })
+  }
+
+  return handler(req)
+}
+
+const wrapLogger = logger => record => {
+  const event = { message: record }
+
+  logChannel.publish(event)
+
+  return logger(event.message)
+}
+
+const wrapMount = mount => opts => {
+  const handler = mount(opts)
+
+  return function (req, res) {
+    handleChannel.publish(req)
+
+    return handler.apply(this, arguments)
+  }
+}
+
+const wrapRoutes = routes => handlers => {
+  const traced = {}
+
+  for (const route in handlers) {
+    traced[route] = wrapRoute(handlers[route])
+  }
+
+  return routes(traced)
+}
+
+addHook({ name, versions, file: 'lib/logger.js' }, exports => {
+  shimmer.wrap(exports, 'logger', wrapLogger)
+
+  return exports
+})
+
+addHook({ name, versions, file: 'lib/mount.js' }, exports => {
+  shimmer.wrap(exports, 'mount', wrapMount)
+
+  return exports
+})
+
+addHook({ name, versions, file: 'lib/routes.js' }, exports => {
+  shimmer.wrap(exports, 'routes', wrapRoutes)
+
+  return exports
+})
+
+if (nodeMajor <= 12) {
+  addHook({ name, versions: ['2.3.0 - 2.3.1'] }, paperplane => {
+    shimmer.wrap(paperplane, 'mount', wrapMount)
+    shimmer.wrap(paperplane, 'routes', wrapRoutes)
+
+    return paperplane
+  })
+}

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

@@ -12,12 +12,12 @@ const asyncEndCh = channel('apm:pg:query:async-end')
 const endCh = channel('apm:pg:query:end')
 const errorCh = channel('apm:pg:query:error')
 
-addHook({ name: 'pg', versions: ['>=4'] }, pg => {
+addHook({ name: 'pg', versions: ['>=4.5.5'] }, pg => {
   shimmer.wrap(pg.Client.prototype, 'query', query => wrapQuery(query))
   return pg
 })
 
-addHook({ name: 'pg', file: 'lib/native/index.js', versions: ['>=4'] }, Client => {
+addHook({ name: 'pg', file: 'lib/native/index.js', versions: ['>=4.5.5'] }, Client => {
   shimmer.wrap(Client.prototype, 'query', query => wrapQuery(query))
   return Client
 })

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

@@ -0,0 +1,58 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+const handlers = ['use', 'pre']
+const methods = ['del', 'get', 'head', 'opts', 'post', 'put', 'patch']
+
+const handleChannel = channel('apm:restify:request:handle')
+const routeChannel = channel('apm:restify:request:route')
+
+function wrapSetupRequest (setupRequest) {
+  return function setupRequestWithTrace (req, res) {
+    handleChannel.publish({ req, res })
+    return setupRequest.apply(this, arguments)
+  }
+}
+
+function wrapMethod (method) {
+  return function methodWithTrace (path) {
+    const middleware = wrapMiddleware(Array.prototype.slice.call(arguments, 1))
+
+    return method.apply(this, [path].concat(middleware))
+  }
+}
+
+function wrapHandler (method) {
+  return function methodWithTrace () {
+    return method.apply(this, wrapMiddleware(arguments))
+  }
+}
+
+function wrapMiddleware (middleware) {
+  return Array.prototype.map.call(middleware, wrapFn)
+}
+
+function wrapFn (fn) {
+  if (Array.isArray(fn)) return wrapMiddleware(fn)
+
+  return function (req, res, next) {
+    if (typeof next === 'function') {
+      arguments[2] = AsyncResource.bind(next)
+    }
+
+    if (req.route) {
+      routeChannel.publish({ req, route: req.route })
+    }
+
+    return fn.apply(this, arguments)
+  }
+}
+
+addHook({ name: 'restify', versions: ['>=3'], file: 'lib/server.js' }, Server => {
+  shimmer.wrap(Server.prototype, '_setupRequest', wrapSetupRequest)
+  shimmer.massWrap(Server.prototype, handlers, wrapHandler)
+  shimmer.wrap(Server.prototype, methods, wrapMethod)
+
+  return Server
+})

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

@@ -147,7 +147,7 @@ function wrapDeliveryUpdate (obj, update) {
 function patchCircularBuffer (proto, Session) {
   Object.defineProperty(proto, 'outgoing', {
     configurable: true,
-    get () {},
+    get () { return undefined },
     set (outgoing) {
       delete proto.outgoing // removes the setter on the prototype
       this.outgoing = outgoing // assigns on the instance, like normal

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

@@ -0,0 +1,177 @@
+'use strict'
+
+const METHODS = require('methods').concat('all')
+const pathToRegExp = require('path-to-regexp')
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+
+function createWrapRouterMethod (name) {
+  const enterChannel = channel(`apm:${name}:middleware:enter`)
+  const errorChannel = channel(`apm:${name}:middleware:error`)
+  const exitChannel = channel(`apm:${name}:middleware:exit`)
+
+  const layerMatchers = new WeakMap()
+  const regexpCache = Object.create(null)
+
+  function wrapLayerHandle (layer, original) {
+    original._name = original._name || layer.name
+
+    const handle = shimmer.wrap(original, function () {
+      if (!enterChannel.hasSubscribers) return original.apply(this, arguments)
+
+      const matchers = layerMatchers.get(layer)
+      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(() => {
+        let route
+
+        if (matchers) {
+          // Try to guess which path actually matched
+          for (let i = 0; i < matchers.length; i++) {
+            if (matchers[i].test(layer)) {
+              route = matchers[i].path
+
+              break
+            }
+          }
+        }
+
+        enterChannel.publish({ name, req, route })
+
+        try {
+          return original.apply(this, arguments)
+        } catch (e) {
+          errorChannel.publish(e)
+          exitChannel.publish({ req })
+
+          throw e
+        }
+      })
+    })
+
+    // This is a workaround for the `loopback` library so that it can find the correct express layer
+    // that contains the real handle function
+    handle._datadog_orig = original
+
+    return handle
+  }
+
+  function wrapStack (stack, offset, matchers) {
+    [].concat(stack).slice(offset).forEach(layer => {
+      if (layer.__handle) { // express-async-errors
+        layer.__handle = wrapLayerHandle(layer, layer.__handle)
+      } else {
+        layer.handle = wrapLayerHandle(layer, layer.handle)
+      }
+
+      layerMatchers.set(layer, matchers)
+
+      if (layer.route) {
+        METHODS.forEach(method => {
+          if (typeof layer.route.stack === 'function') {
+            layer.route.stack = [{ handle: layer.route.stack }]
+          }
+
+          layer.route[method] = wrapMethod(layer.route[method])
+        })
+      }
+    })
+  }
+
+  function wrapNext (req, next) {
+    return function (error) {
+      if (error) {
+        errorChannel.publish(error)
+      }
+
+      exitChannel.publish({ req })
+
+      next.apply(null, arguments)
+    }
+  }
+
+  function extractMatchers (fn) {
+    const arg = flatten([].concat(fn))
+
+    if (typeof arg[0] === 'function') {
+      return []
+    }
+
+    return arg.map(pattern => ({
+      path: pattern instanceof RegExp ? `(${pattern})` : pattern,
+      test: layer => {
+        const matchers = layerMatchers.get(layer)
+
+        return !isFastStar(layer, matchers) &&
+          !isFastSlash(layer, matchers) &&
+          cachedPathToRegExp(pattern).test(layer.path)
+      }
+    }))
+  }
+
+  function isFastStar (layer, matchers) {
+    if (layer.regexp.fast_star !== undefined) {
+      return layer.regexp.fast_star
+    }
+
+    return matchers.some(matcher => matcher.path === '*')
+  }
+
+  function isFastSlash (layer, matchers) {
+    if (layer.regexp.fast_slash !== undefined) {
+      return layer.regexp.fast_slash
+    }
+
+    return matchers.some(matcher => matcher.path === '/')
+  }
+
+  function flatten (arr) {
+    return arr.reduce((acc, val) => Array.isArray(val) ? acc.concat(flatten(val)) : acc.concat(val), [])
+  }
+
+  function cachedPathToRegExp (pattern) {
+    const maybeCached = regexpCache[pattern]
+    if (maybeCached) {
+      return maybeCached
+    }
+    const regexp = pathToRegExp(pattern)
+    regexpCache[pattern] = regexp
+    return regexp
+  }
+
+  function wrapMethod (original) {
+    return function methodWithTrace (fn) {
+      const offset = this.stack ? [].concat(this.stack).length : 0
+      const router = original.apply(this, arguments)
+
+      if (typeof this.stack === 'function') {
+        this.stack = [{ handle: this.stack }]
+      }
+
+      wrapStack(this.stack, offset, extractMatchers(fn))
+
+      return router
+    }
+  }
+
+  return wrapMethod
+}
+
+const wrapRouterMethod = createWrapRouterMethod('router')
+
+addHook({ name: 'router', versions: ['>=1'] }, Router => {
+  shimmer.wrap(Router.prototype, 'use', wrapRouterMethod)
+  shimmer.wrap(Router.prototype, 'route', wrapRouterMethod)
+
+  return Router
+})
+
+module.exports = { createWrapRouterMethod }

package/packages/datadog-plugin-aws-sdk/src/helpers.js

@@ -19,7 +19,7 @@ function getService (Service) {
 }
 
 const helpers = {
-  finish (span, err) {
+  finish (config, span, response, err) {
     if (err) {
       span.setTag('error', err)
 
@@ -28,6 +28,8 @@ const helpers = {
       }
     }
 
+    config.hooks.request(span, response)
+
     span.finish()
   },
 
@@ -43,14 +45,12 @@ const helpers = {
       : true
   },
 
-  addResponseTags (span, response, serviceName, config) {
+  addResponseTags (span, response, serviceName) {
     if (!span) return
 
     if (response.request) {
       this.addServicesTags(span, response, serviceName)
     }
-
-    config.hooks.request(span, response)
   },
 
   addServicesTags (span, response, serviceName) {

package/packages/datadog-plugin-aws-sdk/src/index.js

@@ -36,7 +36,7 @@ function createWrapRequest (tracer, config) {
         if (!span) return
 
         awsHelpers.addResponseTags(span, response, serviceIdentifier, config, tracer)
-        awsHelpers.finish(span, response.error)
+        awsHelpers.finish(config, span, response, response.error)
       })
 
       analyticsSampler.sample(span, config.measured)

package/packages/datadog-plugin-connect/src/index.js

@@ -1,123 +1,19 @@
 'use strict'
 
-const web = require('../../dd-trace/src/plugins/util/web')
+const RouterPlugin = require('../../datadog-plugin-router/src')
 
-function createWrapConnect (tracer, config) {
-  return function wrapConnect (connect) {
-    if (typeof connect !== 'function') return connect
-
-    return function connectWithTrace () {
-      const app = connect()
-
-      if (!app) return app
-
-      app.use = createWrapUse()(app.use)
-      app.handle = createWrapHandle(tracer, config)(app.handle)
-
-      return app
-    }
-  }
-}
-
-function createWrapUse () {
-  return 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
-    }
+class ConnectPlugin extends RouterPlugin {
+  static get name () {
+    return 'connect'
   }
-}
-
-function createWrapHandle (tracer, config) {
-  config = web.normalizeConfig(config)
 
-  return function wrapHandle (handle) {
-    if (typeof handle !== 'function') return handle
+  constructor (...args) {
+    super(...args)
 
-    return function handleWithTrace (req, res, out) {
-      return web.instrument(tracer, config, req, res, 'connect.request', () => {
-        return handle.apply(this, arguments)
-      })
-    }
+    this.addSub('apm:connect:request:handle', ({ req }) => {
+      this.setFramework(req, 'connect', this.config)
+    })
   }
 }
 
-function wrapLayerHandle (layer) {
-  if (typeof layer.handle !== 'function') return layer.handle
-
-  const handle = layer.handle
-
-  if (layer.handle.length === 4) {
-    return function (error, req, res, next) {
-      return callLayerHandle(layer, handle, req, [error, req, res, wrapNext(layer, req, next)])
-    }
-  } else {
-    return function (req, res, next) {
-      return callLayerHandle(layer, handle, req, [req, res, wrapNext(layer, req, next)])
-    }
-  }
-}
-
-function callLayerHandle (layer, handle, req, args) {
-  const route = layer.route
-
-  if (route !== '/') {
-    web.enterRoute(req, route)
-  }
-
-  return web.wrapMiddleware(req, handle, 'connect.middleware', () => {
-    return handle.apply(layer, args)
-  })
-}
-
-function wrapNext (layer, req, next) {
-  if (typeof next !== 'function' || !web.active(req)) return next
-
-  return function nextWithTrace (error) {
-    if (!error && layer.route !== '/') {
-      web.exitRoute(req)
-    }
-
-    web.finish(req, error)
-
-    next.apply(this, arguments)
-  }
-}
-
-module.exports = [
-  {
-    name: 'connect',
-    versions: ['>=3'],
-    patch (connect, tracer, config) {
-      // `connect` is a function so we return a wrapper that will replace its export.
-      return this.wrapExport(connect, createWrapConnect(tracer, config)(connect))
-    },
-    unpatch (connect) {
-      this.unwrapExport(connect)
-    }
-  },
-  {
-    name: 'connect',
-    versions: ['2.2.2'],
-    patch (connect, tracer, config) {
-      this.wrap(connect.proto, 'use', createWrapUse())
-      this.wrap(connect.proto, 'handle', createWrapHandle(tracer, config))
-    },
-    unpatch (connect) {
-      this.unwrap(connect.proto, 'use')
-      this.unwrap(connect.proto, 'handle')
-    }
-  }
-]
+module.exports = ConnectPlugin