dd-trace 2.2.0 → 2.2.1

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

@@ -1,164 +1,11 @@
 'use strict'
 
-const { LOG } = require('../../../ext/formats')
+const LogPlugin = require('../../dd-trace/src/plugins/log_plugin')
 
-function createWrapPino (tracer, config, symbol, wrapper) {
-  return function wrapPino (pino) {
-    return function pinoWithTrace () {
-      const instance = pino.apply(this, arguments)
-
-      Object.defineProperty(instance, symbol, {
-        configurable: true,
-        enumerable: true,
-        writable: true,
-        value: wrapper(tracer, config)(instance[symbol])
-      })
-
-      return instance
-    }
+class PinoPlugin extends LogPlugin {
+  static get name () {
+    return 'pino'
   }
 }
 
-function createWrapAsJson (tracer, config) {
-  return function wrapAsJson (asJson) {
-    return function asJsonWithTrace (obj, msg, num, time) {
-      const span = tracer.scope().active()
-
-      obj = arguments[0] = obj || {}
-
-      tracer.inject(span, LOG, obj)
-
-      const json = asJson.apply(this, arguments)
-
-      obj && delete obj.dd
-
-      return json
-    }
-  }
-}
-
-function createWrapMixin (tracer, config) {
-  return function wrapMixin (mixin) {
-    return function mixinWithTrace () {
-      let obj = {}
-
-      if (mixin) {
-        obj = mixin.apply(this, arguments)
-      }
-
-      const span = tracer.scope().active()
-
-      tracer.inject(span, LOG, obj)
-
-      return obj
-    }
-  }
-}
-
-function createWrapPrettifyObject (tracer, config) {
-  return function wrapPrettifyObject (prettifyObject) {
-    return function prettifyObjectWithTrace (input) {
-      const span = tracer.scope().active()
-
-      tracer.inject(span, LOG, input.input)
-
-      return prettifyObject.apply(this, arguments)
-    }
-  }
-}
-
-function createWrapPrettyFactory (tracer, config) {
-  return function wrapPrettyFactory (prettyFactory) {
-    return function prettyFactoryWithTrace () {
-      const pretty = prettyFactory.apply(this, arguments)
-
-      return function prettyWithTrace (obj) {
-        const span = tracer.scope().active()
-
-        tracer.inject(span, LOG, obj)
-
-        return pretty.apply(this, arguments)
-      }
-    }
-  }
-}
-
-module.exports = [
-  {
-    name: 'pino',
-    versions: ['2 - 3', '4', '>=5 <5.14.0'],
-    patch (pino, tracer, config) {
-      if (!tracer._logInjection) return
-
-      const asJsonSym = (pino.symbols && pino.symbols.asJsonSym) || 'asJson'
-
-      return this.wrapExport(pino, createWrapPino(tracer, config, asJsonSym, createWrapAsJson)(pino))
-    },
-    unpatch (pino) {
-      return this.unwrapExport(pino)
-    }
-  },
-  {
-    name: 'pino',
-    versions: ['>=5.14.0 <6.8.0'],
-    patch (pino, tracer, config) {
-      if (!tracer._logInjection) return
-
-      const mixinSym = pino.symbols.mixinSym
-
-      return this.wrapExport(pino, createWrapPino(tracer, config, mixinSym, createWrapMixin)(pino))
-    },
-    unpatch (pino) {
-      return this.unwrapExport(pino)
-    }
-  },
-  {
-    name: 'pino',
-    versions: ['>=6.8.0'],
-    patch (pino, tracer, config) {
-      if (!tracer._logInjection) return
-
-      const mixinSym = pino.symbols.mixinSym
-
-      const wrapped = this.wrapExport(pino, createWrapPino(tracer, config, mixinSym, createWrapMixin)(pino))
-
-      wrapped.pino = wrapped
-      wrapped.default = wrapped
-
-      return wrapped
-    },
-    unpatch (pino) {
-      const unwrapped = this.unwrapExport(pino)
-
-      unwrapped.pino = unwrapped
-      unwrapped.default = unwrapped
-
-      return unwrapped
-    }
-  },
-  {
-    name: 'pino-pretty',
-    versions: ['>=3'], // will only work starting from pino@5.0.0 as previous versions are not using pino-pretty
-    file: 'lib/utils.js',
-    patch (utils, tracer, config) {
-      if (!tracer._logInjection) return
-
-      this.wrap(utils, 'prettifyObject', createWrapPrettifyObject(tracer, config))
-    },
-    unpatch (utils) {
-      this.unwrap(utils, 'prettifyObject')
-    }
-  },
-  {
-    name: 'pino-pretty',
-    versions: ['1 - 2'],
-    patch (prettyFactory, tracer, config) {
-      if (!tracer._logInjection) return
-
-      return this.wrapExport(prettyFactory, createWrapPrettyFactory(tracer, config)(prettyFactory))
-    },
-    unpatch (prettyFactory) {
-      return this.unwrapExport(prettyFactory)
-    }
-  }
-]
+module.exports = PinoPlugin

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

@@ -1,104 +1,120 @@
 'use strict'
 
-// TODO: always use uppercase for command names
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
+const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
+const urlFilter = require('../../dd-trace/src/plugins/util/urlfilter')
+
+class RedisPlugin extends Plugin {
+  static get name () {
+    return 'redis'
+  }
 
-const tx = require('../../dd-trace/src/plugins/util/redis')
+  constructor (...args) {
+    super(...args)
 
-function createWrapAddCommand (tracer, config) {
-  return function wrapAddCommand (addCommand) {
-    return function addCommandWithTrace (command) {
-      const name = command[0]
-      const args = command.slice(1)
+    this.addSub(`apm:${this.constructor.name}:command:start`, (
+      { db, command, args, connectionOptions, connectionName }
+    ) => {
+      if (!this.config.filter(command)) {
+        return this.skip()
+      }
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
+      const span = this.tracer.startSpan('redis.command', {
+        childOf,
+        tags: {
+          'span.kind': 'client',
+          'resource.name': command,
+          'span.type': 'redis',
+          'db.type': 'redis',
+          'db.name': db || '0',
+          'redis.raw_command': formatCommand(command, args)
+        }
+      })
+
+      span.setTag('service.name', this.config.service || `${span.context()._tags['service.name']}-redis`)
+
+      analyticsSampler.sample(span, this.config.measured)
+
+      if (connectionOptions) {
+        span.addTags({
+          'out.host': connectionOptions.host,
+          'out.port': connectionOptions.port
+        })
+      }
 
-      if (!config.filter(name)) return addCommand.apply(this, arguments)
+      if (this.config.splitByInstance && connectionName) {
+        const service = this.config.service
+          ? `${this.config.service}-${connectionName}`
+          : connectionName
 
-      const scope = tracer.scope()
-      const span = startSpan(tracer, config, this, name, args)
+        span.setTag('service.name', service)
+      }
 
-      return tx.wrap(span, scope.bind(addCommand, span).apply(this, arguments))
-    }
-  }
-}
+      this.enter(span, store)
+    })
 
-function createWrapInternalSendCommand (tracer, config) {
-  return function wrapInternalSendCommand (internalSendCommand) {
-    return function internalSendCommandWithTrace (options) {
-      if (!config.filter(options.command)) return internalSendCommand.apply(this, arguments)
+    this.addSub(`apm:${this.constructor.name}:command:end`, () => {
+      this.exit()
+    })
 
-      const scope = tracer.scope()
-      const span = startSpan(tracer, config, this, options.command, options.args)
+    this.addSub(`apm:${this.constructor.name}:command:error`, err => {
+      const span = storage.getStore().span
+      span.setTag('error', err)
+    })
 
-      options.callback = scope.bind(tx.wrap(span, options.callback))
+    this.addSub(`apm:${this.constructor.name}:command:async-end`, () => {
+      const span = storage.getStore().span
+      span.finish()
+    })
+  }
 
-      return scope.bind(internalSendCommand, span).apply(this, arguments)
-    }
+  configure (config) {
+    super.configure(normalizeConfig(config))
   }
 }
 
-function createWrapSendCommand (tracer, config) {
-  return function wrapSendCommand (sendCommand) {
-    return function sendCommandWithTrace (command, args, callback) {
-      if (!config.filter(command)) return sendCommand.apply(this, arguments)
+function formatCommand (command, args) {
+  command = command.toUpperCase()
 
-      const scope = tracer.scope()
-      const span = startSpan(tracer, config, this, command, args)
+  if (!args || command === 'AUTH') return command
 
-      if (typeof callback === 'function') {
-        arguments[2] = scope.bind(tx.wrap(span, callback))
-      } else if (Array.isArray(args) && typeof args[args.length - 1] === 'function') {
-        args[args.length - 1] = scope.bind(tx.wrap(span, args[args.length - 1]))
-      } else {
-        arguments[2] = tx.wrap(span)
-      }
+  for (let i = 0, l = args.length; i < l; i++) {
+    if (typeof args[i] === 'function') continue
+
+    command = `${command} ${formatArg(args[i])}`
 
-      return scope.bind(sendCommand, span).apply(this, arguments)
-    }
+    if (command.length > 1000) return trim(command, 1000)
+  }
+
+  return command
+}
+
+function formatArg (arg) {
+  switch (typeof arg) {
+    case 'string':
+    case 'number':
+      return trim(String(arg), 100)
+    default:
+      return '?'
   }
 }
 
-function startSpan (tracer, config, client, command, args) {
-  const db = client.selected_db
-  const connectionOptions = client.connection_options || client.connection_option || client.connectionOption || {}
-  const span = tx.instrument(tracer, config, db, command, args)
+function trim (str, maxlen) {
+  if (str.length > maxlen) {
+    str = str.substr(0, maxlen - 3) + '...'
+  }
+
+  return str
+}
 
-  tx.setHost(span, connectionOptions.host, connectionOptions.port)
+function normalizeConfig (config) {
+  const filter = urlFilter.getFilter(config)
 
-  return span
+  return Object.assign({}, config, {
+    filter
+  })
 }
 
-module.exports = [
-  {
-    name: '@node-redis/client',
-    versions: ['>=1'],
-    file: 'dist/lib/client/commands-queue.js',
-    patch (redis, tracer, config) {
-      config = tx.normalizeConfig(config)
-      this.wrap(redis.default.prototype, 'addCommand', createWrapAddCommand(tracer, config))
-    },
-    unpatch (redis) {
-      this.unwrap(redis.default.prototype, 'addCommand')
-    }
-  },
-  {
-    name: 'redis',
-    versions: ['>=2.6 <4'],
-    patch (redis, tracer, config) {
-      config = tx.normalizeConfig(config)
-      this.wrap(redis.RedisClient.prototype, 'internal_send_command', createWrapInternalSendCommand(tracer, config))
-    },
-    unpatch (redis) {
-      this.unwrap(redis.RedisClient.prototype, 'internal_send_command')
-    }
-  },
-  {
-    name: 'redis',
-    versions: ['>=0.12 <2.6'],
-    patch (redis, tracer, config) {
-      config = tx.normalizeConfig(config)
-      this.wrap(redis.RedisClient.prototype, 'send_command', createWrapSendCommand(tracer, config))
-    },
-    unpatch (redis) {
-      this.unwrap(redis.RedisClient.prototype, 'send_command')
-    }
-  }
-]
+module.exports = RedisPlugin

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

@@ -4,14 +4,14 @@ const web = require('../../dd-trace/src/plugins/util/web')
 const handlers = ['use', 'pre']
 const methods = ['del', 'get', 'head', 'opts', 'post', 'put', 'patch']
 
-function createWrapSetupRequest (tracer, config) {
+function createWrapSetupRequest (tracer, config, withRoute) {
   config = web.normalizeConfig(config)
 
   return function wrapSetupRequest (setupRequest) {
     return function setupRequestWithTrace (req, res) {
       return web.instrument(tracer, config, req, res, 'restify.request', () => {
         web.beforeEnd(req, () => {
-          if (req.route && !req._datadog.routeEntered) {
+          if (req.route && withRoute) {
             web.enterRoute(req, req.route.path)
           }
         })
@@ -55,7 +55,7 @@ function wrapFn (fn) {
 module.exports = [
   {
     name: 'restify',
-    versions: ['>=3'],
+    versions: ['>=7'],
     file: 'lib/server.js',
     patch (Server, tracer, config) {
       this.wrap(Server.prototype, '_setupRequest', createWrapSetupRequest(tracer, config))
@@ -67,5 +67,20 @@ module.exports = [
       this.unwrap(Server.prototype, handlers)
       this.unwrap(Server.prototype, methods)
     }
+  },
+  {
+    name: 'restify',
+    versions: ['3 - 6'],
+    file: 'lib/server.js',
+    patch (Server, tracer, config) {
+      this.wrap(Server.prototype, '_setupRequest', createWrapSetupRequest(tracer, config, true))
+      this.wrap(Server.prototype, handlers, createWrapHandler(tracer, config))
+      this.wrap(Server.prototype, methods, createWrapMethod(tracer, config))
+    },
+    unpatch (Server) {
+      this.unwrap(Server.prototype, '_setupRequest')
+      this.unwrap(Server.prototype, handlers)
+      this.unwrap(Server.prototype, methods)
+    }
   }
 ]

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

@@ -6,6 +6,8 @@ const dd = Symbol('datadog')
 const circularBufferConstructor = Symbol('circularBufferConstructor')
 const inFlightDeliveries = Symbol('inFlightDeliveries')
 
+const patched = new WeakSet()
+
 function createWrapSend (tracer, config, instrumenter) {
   return function wrapSend (send) {
     return function sendWithTrace (msg, tag, format) {
@@ -133,9 +135,9 @@ function patchCircularBuffer (proto, instrumenter) {
         if (outgoing.deliveries) {
           CircularBuffer = outgoing.deliveries.constructor
         }
-        if (CircularBuffer && !CircularBuffer.prototype._datadog_patched) {
+        if (CircularBuffer && !patched.has(CircularBuffer.prototype)) {
           instrumenter.wrap(CircularBuffer.prototype, 'pop_if', createWrapCircularBufferPopIf())
-          CircularBuffer.prototype._datadog_patched = true
+          patched.add(CircularBuffer.prototype)
           const Session = proto.constructor
           if (Session) {
             Session[circularBufferConstructor] = CircularBuffer
@@ -260,9 +262,10 @@ module.exports = [
       patchCircularBuffer(Session.prototype, this)
     },
     unpatch (Session, tracer) {
-      if (Session[circularBufferConstructor]) {
-        delete Session[circularBufferConstructor].prototype._datadog_patched
-        this.unwrap(Session[circularBufferConstructor].prototype, 'pop_if')
+      const CircularBuffer = Session[circularBufferConstructor]
+      if (CircularBuffer) {
+        patched.delete(CircularBuffer.prototype)
+        this.unwrap(CircularBuffer.prototype, 'pop_if')
       }
     }
   }

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

@@ -5,9 +5,10 @@ const pathToRegExp = require('path-to-regexp')
 const shimmer = require('../../datadog-shimmer')
 const web = require('../../dd-trace/src/plugins/util/web')
 
-// TODO: clean this up to not use web util internals
 // TODO: stop checking for fast star and fast slash
 
+const contexts = new WeakMap()
+const layerMatchers = new WeakMap()
 const regexpCache = Object.create(null)
 
 function createWrapHandle (tracer, config) {
@@ -15,17 +16,17 @@ function createWrapHandle (tracer, config) {
     return function handleWithTrace (req, res, done) {
       web.patch(req)
 
-      if (!req._datadog.router) {
+      if (!contexts.has(req)) {
         const context = {
           route: '',
           stack: []
         }
 
         web.beforeEnd(req, () => {
-          req._datadog.paths = [context.route]
+          web.enterRoute(req, context.route)
         })
 
-        req._datadog.router = context
+        contexts.set(req, context)
       }
 
       return handle.apply(this, arguments)
@@ -78,7 +79,7 @@ function wrapStack (stack, offset, matchers) {
       layer.handle = wrapLayerHandle(layer, layer.handle)
     }
 
-    layer._datadog_matchers = matchers
+    layerMatchers.set(layer, matchers)
 
     if (layer.route) {
       METHODS.forEach(method => {
@@ -96,10 +97,12 @@ function wrapNext (layer, req, next) {
   if (!next || !web.active(req)) return next
 
   const originalNext = next
+  const context = contexts.get(req)
+  const matchers = layerMatchers.get(layer)
 
   return function (error) {
-    if (layer.path && !isFastStar(layer) && !isFastSlash(layer)) {
-      req._datadog.router.stack.pop()
+    if (layer.path && !isFastStar(layer, matchers) && !isFastSlash(layer, matchers)) {
+      context.stack.pop()
     }
 
     web.finish(req, error)
@@ -109,13 +112,13 @@ function wrapNext (layer, req, next) {
 }
 
 function callHandle (layer, handle, req, args) {
-  const matchers = layer._datadog_matchers
+  const matchers = layerMatchers.get(layer)
 
   if (web.active(req) && matchers) {
     // Try to guess which path actually matched
     for (let i = 0; i < matchers.length; i++) {
       if (matchers[i].test(layer)) {
-        const context = req._datadog.router
+        const context = contexts.get(req)
 
         context.stack.push(matchers[i].path)
 
@@ -145,24 +148,30 @@ function extractMatchers (fn) {
 
   return arg.map(pattern => ({
     path: pattern instanceof RegExp ? `(${pattern})` : pattern,
-    test: layer => !isFastStar(layer) && !isFastSlash(layer) && cachedPathToRegExp(pattern).test(layer.path)
+    test: layer => {
+      const matchers = layerMatchers.get(layer)
+
+      return !isFastStar(layer, matchers) &&
+        !isFastSlash(layer, matchers) &&
+        cachedPathToRegExp(pattern).test(layer.path)
+    }
   }))
 }
 
-function isFastStar (layer) {
+function isFastStar (layer, matchers) {
   if (layer.regexp.fast_star !== undefined) {
     return layer.regexp.fast_star
   }
 
-  return layer._datadog_matchers.some(matcher => matcher.path === '*')
+  return matchers.some(matcher => matcher.path === '*')
 }
 
-function isFastSlash (layer) {
+function isFastSlash (layer, matchers) {
   if (layer.regexp.fast_slash !== undefined) {
     return layer.regexp.fast_slash
   }
 
-  return layer._datadog_matchers.some(matcher => matcher.path === '/')
+  return matchers.some(matcher => matcher.path === '/')
 }
 
 function flatten (arr) {