dd-trace 2.2.0 → 2.3.1

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) {

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

@@ -1,35 +1,53 @@
 'use strict'
 
-/**
- * @description The enum values in this map are not exposed from ShareDB, so the keys are hard-coded here.
- * The values were derived from: https://github.com/share/sharedb/blob/master/lib/client/connection.js#L196
- */
-const READABLE_ACTION_NAMES = {
-  hs: 'handshake',
-  qf: 'query-fetch',
-  qs: 'query-subscribe',
-  qu: 'query-unsubscribe',
-  bf: 'bulk-fetch',
-  bs: 'bulk-subscribe',
-  bu: 'bulk-unsubscribe',
-  f: 'fetch',
-  s: 'subscribe',
-  u: 'unsubscribe',
-  op: 'op',
-  nf: 'snapshot-fetch',
-  nt: 'snapshot-fetch-by-ts',
-  p: 'presence-broadcast',
-  pr: 'presence-request',
-  ps: 'presence-subscribe',
-  pu: 'presence-unsubscribe'
-}
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
+
+class SharedbPlugin extends Plugin {
+  static get name () {
+    return 'sharedb'
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub(`apm:sharedb:request:start`, ({ actionName, request }) => {
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
+      const span = this.tracer.startSpan('sharedb.request', {
+        childOf,
+        tags: {
+          'service.name': this.config.service || this.tracer._service,
+          'span.kind': 'server',
+          'sharedb.action': actionName,
+          'resource.name': getReadableResourceName(actionName, request.c, request.q)
+        }
+      })
+
+      if (this.config.hooks && this.config.hooks.receive) {
+        this.config.hooks.receive(span, request)
+      }
 
-function getReadableActionName (action) {
-  const actionName = READABLE_ACTION_NAMES[action]
-  if (actionName === undefined) {
-    return action
+      this.enter(span, store)
+    })
+
+    this.addSub(`apm:sharedb:request:end`, () => {
+      this.exit()
+    })
+
+    this.addSub(`apm:sharedb:request:error`, err => {
+      const span = storage.getStore().span
+      span.setTag('error', err)
+    })
+
+    this.addSub(`apm:sharedb:request:async-end`, ({ request, res }) => {
+      const span = storage.getStore().span
+      if (this.config.hooks && this.config.hooks.reply) {
+        this.config.hooks.reply(span, request, res)
+      }
+      span.finish()
+    })
   }
-  return actionName
 }
 
 function getReadableResourceName (readableActionName, collection, query) {
@@ -60,62 +78,4 @@ function isObject (val) {
   return typeof val === 'object' && val !== null && !(val instanceof Array)
 }
 
-function wrapCallback (config, tracer, request, span, done) {
-  return tracer.scope().bind((err, res) => {
-    if (err) {
-      span.setTag('error', err)
-    }
-
-    if (config.hooks && config.hooks.reply) {
-      config.hooks.reply(span, request, res)
-    }
-
-    span.finish()
-
-    if (done) {
-      done(err, res)
-    }
-  })
-}
-
-function createAgentWrapHandle (tracer, config) {
-  return function wrapHandleMessage (origHandleMessageFn) { // called once
-    return function handleMessageWithTrace (request, callback) { // called for each trigger
-      const action = request.a
-
-      const actionName = getReadableActionName(action)
-
-      const scope = tracer.scope()
-      const childOf = scope.active()
-      const span = tracer.startSpan('sharedb.request', {
-        childOf,
-        tags: {
-          'service.name': config.service || tracer._service,
-          'span.kind': 'server',
-          'sharedb.action': actionName,
-          'resource.name': getReadableResourceName(actionName, request.c, request.q)
-        }
-      })
-
-      if (config.hooks && config.hooks.receive) {
-        config.hooks.receive(span, request)
-      }
-
-      arguments[1] = wrapCallback(config, tracer, request, span, callback)
-
-      return tracer.scope().bind(origHandleMessageFn, span).apply(this, arguments)
-    }
-  }
-}
-
-module.exports = {
-  name: 'sharedb',
-  versions: ['>=1'],
-  file: 'lib/agent.js',
-  patch (Agent, tracer, config) {
-    this.wrap(Agent.prototype, '_handleMessage', createAgentWrapHandle(tracer, config))
-  },
-  unpatch (Agent) {
-    this.unwrap(Agent.prototype, '_handleMessage')
-  }
-}
+module.exports = SharedbPlugin

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

@@ -1,118 +1,10 @@
 'use strict'
 
-const { LOG } = require('../../../ext/formats')
+const LogPlugin = require('../../dd-trace/src/plugins/log_plugin')
 
-const hasOwn = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop)
-
-function chunkProxy (chunk, holder) {
-  return new Proxy(chunk, {
-    get (target, p, receiver) {
-      switch (p) {
-        case Symbol.toStringTag:
-          return Object.prototype.toString.call(target).slice(8, -1)
-        case 'dd':
-          return holder.dd
-        default:
-          return Reflect.get(target, p, receiver)
-      }
-    },
-    ownKeys (target) {
-      const ownKeys = Reflect.ownKeys(target)
-      return hasOwn(target, 'dd') ? ownKeys : ['dd', ...ownKeys]
-    },
-    getOwnPropertyDescriptor (target, p) {
-      return Reflect.getOwnPropertyDescriptor(p === 'dd' ? holder : target, p)
-    }
-  })
-}
-
-function createWrapWrite (tracer, config) {
-  return function wrapWrite (write) {
-    return function writeWithTrace (chunk, encoding, callback) {
-      const span = tracer.scope().active()
-
-      const holder = {}
-      tracer.inject(span, LOG, holder)
-      arguments[0] = chunkProxy(chunk, holder)
-
-      return write.apply(this, arguments)
-    }
+class WinstonPlugin extends LogPlugin {
+  static get name () {
+    return 'winston'
   }
 }
-
-function createWrapMethod (tracer, config) {
-  return function wrapMethod (method) {
-    return function methodWithTrace () {
-      const result = method.apply(this, arguments)
-
-      for (const name in this.transports) {
-        const transport = this.transports[name]
-
-        if (transport._dd_patched || typeof transport.log !== 'function') continue
-
-        transport.log = createWrapLog(tracer, config)(transport.log)
-        transport._dd_patched = true
-      }
-
-      return result
-    }
-  }
-}
-
-function createWrapLog (tracer, config) {
-  return function wrapLog (log) {
-    return function logWithTrace (level, msg, meta, callback) {
-      const span = tracer.scope().active()
-
-      meta = meta || {}
-
-      const holder = {}
-      tracer.inject(span, LOG, holder)
-
-      arguments[2] = chunkProxy(meta, holder)
-
-      return log.apply(this, arguments)
-    }
-  }
-}
-
-module.exports = [
-  {
-    name: 'winston',
-    file: 'lib/winston/logger.js',
-    versions: ['>=3'],
-    patch (Logger, tracer, config) {
-      if (!tracer._logInjection) return
-      this.wrap(Logger.prototype, 'write', createWrapWrite(tracer, config))
-    },
-    unpatch (Logger) {
-      this.unwrap(Logger.prototype, 'write')
-    }
-  },
-  {
-    name: 'winston',
-    file: 'lib/winston/logger.js',
-    versions: ['2'],
-    patch (logger, tracer, config) {
-      if (!tracer._logInjection) return
-      this.wrap(logger.Logger.prototype, 'configure', createWrapMethod(tracer, config))
-      this.wrap(logger.Logger.prototype, 'add', createWrapMethod(tracer, config))
-    },
-    unpatch (logger) {
-      this.unwrap(logger.Logger.prototype, 'configure')
-      this.unwrap(logger.Logger.prototype, 'add')
-    }
-  },
-  {
-    name: 'winston',
-    file: 'lib/winston/logger.js',
-    versions: ['1'],
-    patch (logger, tracer, config) {
-      if (!tracer._logInjection) return
-      this.wrap(logger.Logger.prototype, 'add', createWrapMethod(tracer, config))
-    },
-    unpatch (logger) {
-      this.unwrap(logger.Logger.prototype, 'add')
-    }
-  }
-]
+module.exports = WinstonPlugin

package/packages/datadog-shimmer/src/shimmer.js

@@ -132,7 +132,7 @@ function assertFunction (target) {
 }
 
 function assertNotClass (target) {
-  if (target.toString && target.toString().startsWith('class')) {
+  if (Function.prototype.toString.call(target).startsWith('class')) {
     throw new Error('Target is a native class constructor and cannot be wrapped.')
   }
 }

package/packages/dd-trace/lib/version.js

@@ -1 +1 @@
-module.exports = '2.2.0'
+module.exports = '2.3.1'