dd-trace 2.3.0 → 2.4.1

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

@@ -141,6 +141,10 @@ class Tracer extends BaseTracer {
   getRumData () {
     return this._tracer.getRumData.apply(this._tracer, arguments)
   }
+
+  setUser () {
+    return this._tracer.setUser.apply(this.tracer, arguments)
+  }
 }
 
 module.exports = Tracer

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

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

@@ -122,6 +122,22 @@ class DatadogTracer extends Tracer {
 <meta name="dd-trace-id" content="${traceId}" />\
 <meta name="dd-trace-time" content="${traceTime}" />`
   }
+
+  setUser (user) {
+    if (!user || !user.id) return this
+
+    const span = this.scope().active()
+    if (!span) return this
+
+    const rootSpan = span._spanContext._trace.started[0]
+    if (!rootSpan) return this
+
+    for (const k of Object.keys(user)) {
+      rootSpan.setTag(`usr.${k}`, '' + user[k])
+    }
+
+    return this
+  }
 }
 
 function addError (span, error) {

package/packages/datadog-plugin-mongodb-core/src/legacy.js

@@ -1,59 +0,0 @@
-'use strict'
-
-const { instrument } = require('./util')
-
-function createWrapCommand (tracer, config, name) {
-  return function wrapCommand (command) {
-    return function commandWithTrace (ns, ops) {
-      return instrument(command, this, arguments, this, ns, ops, tracer, config, { name })
-    }
-  }
-}
-
-function createWrapQuery (tracer, config) {
-  return function wrapQuery (query) {
-    return function queryWithTrace () {
-      const pool = this.server.s.pool
-      const ns = this.ns
-      const ops = this.cmd
-
-      return instrument(query, this, arguments, pool, ns, ops, tracer, config)
-    }
-  }
-}
-
-function createWrapCursor (tracer, config, name) {
-  return function wrapCursor (cursor) {
-    return function cursorWithTrace () {
-      const pool = this.server.s.pool
-      const ns = this.ns
-
-      return instrument(cursor, this, arguments, pool, ns, {}, tracer, config, { name })
-    }
-  }
-}
-
-module.exports = [
-  {
-    name: 'mongodb-core',
-    versions: ['2 - 3.1.9'],
-    patch ({ Cursor, Server }, tracer, config) {
-      this.wrap(Server.prototype, 'command', createWrapCommand(tracer, config))
-      this.wrap(Server.prototype, 'insert', createWrapCommand(tracer, config, 'insert'))
-      this.wrap(Server.prototype, 'update', createWrapCommand(tracer, config, 'update'))
-      this.wrap(Server.prototype, 'remove', createWrapCommand(tracer, config, 'remove'))
-      this.wrap(Cursor.prototype, '_getmore', createWrapCursor(tracer, config, 'getMore'))
-      this.wrap(Cursor.prototype, '_find', createWrapQuery(tracer, config))
-      this.wrap(Cursor.prototype, 'kill', createWrapCursor(tracer, config, 'killCursors'))
-    },
-    unpatch ({ Cursor, Server }) {
-      this.unwrap(Server.prototype, 'command')
-      this.unwrap(Server.prototype, 'insert')
-      this.unwrap(Server.prototype, 'update')
-      this.unwrap(Server.prototype, 'remove')
-      this.unwrap(Cursor.prototype, '_getmore')
-      this.unwrap(Cursor.prototype, '_find')
-      this.unwrap(Cursor.prototype, 'kill')
-    }
-  }
-]

package/packages/datadog-plugin-mongodb-core/src/unified.js

@@ -1,138 +0,0 @@
-'use strict'
-
-const { instrument } = require('./util')
-
-function createWrapConnectionCommand (tracer, config, name) {
-  return function wrapCommand (command) {
-    return function commandWithTrace (ns, ops) {
-      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(command, this, arguments, topology, ns, ops, tracer, config, { name })
-    }
-  }
-}
-
-function createWrapCommand (tracer, config, name) {
-  return function wrapCommand (command) {
-    return function commandWithTrace (server, ns, ops) {
-      return instrument(command, this, arguments, server, ns, ops, tracer, config, { name })
-    }
-  }
-}
-
-function createWrapMaybePromise (tracer, config) {
-  return function wrapMaybePromise (maybePromise) {
-    return function maybePromiseWithTrace (parent, callback, fn) {
-      const callbackIndex = arguments.length - 2
-
-      callback = arguments[callbackIndex]
-
-      if (typeof callback === 'function') {
-        arguments[callbackIndex] = tracer.scope().bind(callback)
-      }
-
-      return maybePromise.apply(this, arguments)
-    }
-  }
-}
-
-function patch (wp, tracer, config) {
-  this.wrap(wp, 'command', createWrapCommand(tracer, config))
-  this.wrap(wp, 'insert', createWrapCommand(tracer, config, 'insert'))
-  this.wrap(wp, 'update', createWrapCommand(tracer, config, 'update'))
-  this.wrap(wp, 'remove', createWrapCommand(tracer, config, 'remove'))
-  this.wrap(wp, 'query', createWrapCommand(tracer, config))
-  this.wrap(wp, 'getMore', createWrapCommand(tracer, config, 'getMore'))
-  this.wrap(wp, 'killCursors', createWrapCommand(tracer, config, 'killCursors'))
-}
-
-function unpatch (wp) {
-  this.unwrap(wp, 'command')
-  this.unwrap(wp, 'insert')
-  this.unwrap(wp, 'update')
-  this.unwrap(wp, 'remove')
-  this.unwrap(wp, 'query')
-  this.unwrap(wp, 'getMore')
-  this.unwrap(wp, 'killCursors')
-}
-
-function patchConnection ({ Connection }, tracer, config) {
-  const proto = Connection.prototype
-
-  this.wrap(proto, 'command', createWrapConnectionCommand(tracer, config))
-  this.wrap(proto, 'query', createWrapConnectionCommand(tracer, config))
-  this.wrap(proto, 'getMore', createWrapConnectionCommand(tracer, config, 'getMore'))
-  this.wrap(proto, 'killCursors', createWrapConnectionCommand(tracer, config, 'killCursors'))
-}
-
-function unpatchConnection ({ Connection }) {
-  const proto = Connection.prototype
-
-  this.unwrap(proto, 'command')
-  this.unwrap(proto, 'query')
-  this.unwrap(proto, 'getMore')
-  this.unwrap(proto, 'killCursors')
-}
-
-function patchClass (WireProtocol, tracer, config) {
-  this.wrap(WireProtocol.prototype, 'command', createWrapCommand(tracer, config))
-}
-
-function unpatchClass (WireProtocol) {
-  this.unwrap(WireProtocol.prototype, 'command')
-}
-
-module.exports = [
-  {
-    name: 'mongodb',
-    versions: ['>=4'],
-    file: 'lib/cmap/connection.js',
-    patch: patchConnection,
-    unpatch: unpatchConnection
-  },
-  {
-    name: 'mongodb',
-    versions: ['>=3.5.4'],
-    file: 'lib/utils.js',
-    patch (util, tracer, config) {
-      this.wrap(util, 'maybePromise', createWrapMaybePromise(tracer, config))
-    },
-    unpatch (util) {
-      this.unwrap(util, 'maybePromise')
-    }
-  },
-  {
-    name: 'mongodb',
-    versions: ['>=3.3 <4'],
-    file: 'lib/core/wireprotocol/index.js',
-    patch,
-    unpatch
-  },
-  {
-    name: 'mongodb-core',
-    versions: ['>=3.2'],
-    file: 'lib/wireprotocol/index.js',
-    patch,
-    unpatch
-  },
-  {
-    name: 'mongodb-core',
-    versions: ['~3.1.10'],
-    file: 'lib/wireprotocol/3_2_support.js',
-    patch: patchClass,
-    unpatch: unpatchClass
-  },
-  {
-    name: 'mongodb-core',
-    versions: ['~3.1.10'],
-    file: 'lib/wireprotocol/2_6_support.js',
-    patch: patchClass,
-    unpatch: unpatchClass
-  }
-]