dd-trace 2.0.0 → 2.2.0

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

@@ -1,171 +1,74 @@
 'use strict'
 
-const Tags = require('../../../ext/tags')
-const Kinds = require('../../../ext/kinds')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
-function startSpan (tracer, config, operation, resource) {
-  const childOf = tracer.scope().active()
-  const span = tracer.startSpan(`couchbase.${operation}`, {
-    childOf,
-    tags: {
+class CouchBasePlugin extends Plugin {
+  static get name () {
+    return 'couchbase'
+  }
+
+  addSubs (func, start, asyncEnd = defaultAsyncEnd) {
+    this.addSub(`apm:couchbase:${func}:start`, start)
+    this.addSub(`apm:couchbase:${func}:end`, this.exit.bind(this))
+    this.addSub(`apm:couchbase:${func}:error`, errorHandler)
+    this.addSub(`apm:couchbase:${func}:async-end`, asyncEnd)
+  }
+
+  startSpan (operation, customTags, store, bucket) {
+    const tags = {
       'db.type': 'couchbase',
       'component': 'couchbase',
-      'service.name': config.service || `${tracer._service}-couchbase`,
-      'resource.name': resource,
-      [Tags.SPAN_KIND]: Kinds.CLIENT
+      'service.name': this.config.service || `${this.tracer._service}-couchbase`,
+      'resource.name': `couchbase.${operation}`,
+      'span.kind': 'client'
     }
-  })
-
-  analyticsSampler.sample(span, config.measured)
-
-  return span
-}
-
-function onRequestFinish (emitter, span) {
-  emitter.once('rows', () => {
-    span.finish()
-  })
-  emitter.once('error', (err) => {
-    span.setTag(Tags.ERROR, err)
-    span.finish()
-  })
-}
-
-function createWrapMaybeInvoke (tracer) {
-  return function wrapMaybeInvoke (_maybeInvoke) {
-    return function maybeInvokeWithTrace (fn, args) {
-      if (!Array.isArray(args)) return _maybeInvoke.apply(this, arguments)
 
-      const scope = tracer.scope()
-      const callbackIndex = args.length - 1
-      const callback = args[callbackIndex]
-
-      if (callback instanceof Function) {
-        args[callbackIndex] = scope.bind(callback)
-      }
-
-      return scope.bind(_maybeInvoke).apply(this, arguments)
+    for (const tag in customTags) {
+      tags[tag] = customTags[tag]
     }
-  }
-}
-
-function createWrapQuery (tracer) {
-  return function wrapQuery (query) {
-    return function queryWithTrace (q, params, callback) {
-      const scope = tracer.scope()
+    const span = this.tracer.startSpan(`couchbase.${operation}`, {
+      childOf: store ? store.span : null,
+      tags
+    })
 
-      callback = arguments[arguments.length - 1]
+    span.setTag('couchbase.bucket.name', bucket.name || bucket._name)
 
-      if (typeof callback === 'function') {
-        arguments[arguments.length - 1] = scope.bind(callback)
-      }
-
-      return scope.bind(query.apply(this, arguments))
-    }
+    analyticsSampler.sample(span, this.config.measured)
+    return span
   }
-}
-
-function createWrapN1qlReq (tracer, config) {
-  return function wrapN1qlReq (_n1qlReq) {
-    return function n1qlReqWithTrace (host, q, adhoc, emitter) {
-      if (!emitter || !emitter.once) return _n1qlReq.apply(this, arguments)
-
-      const scope = tracer.scope()
-      const n1qlQuery = q && q.statement
-      const span = startSpan(tracer, config, 'query', n1qlQuery)
 
-      span.setTag('span.type', 'sql')
+  constructor (...args) {
+    super(...args)
 
-      addBucketTag(span, this)
-      onRequestFinish(emitter, span)
+    this.addSubs('query', ({ resource, bucket }) => {
+      const store = storage.getStore()
+      const span = this.startSpan('query', { 'span.type': 'sql', 'resource.name': resource }, store, bucket)
+      this.enter(span, store)
+    })
 
-      return scope.bind(_n1qlReq, span).apply(this, arguments)
-    }
+    this._addCommandSubs('upsert')
+    this._addCommandSubs('insert')
+    this._addCommandSubs('replace')
+    this._addCommandSubs('append')
+    this._addCommandSubs('prepend')
   }
-}
-
-function createWrapStore (tracer, config, operation) {
-  return function wrapStore (store) {
-    return function storeWithTrace (key, value, options, callback) {
-      const callbackIndex = findCallbackIndex(arguments)
-
-      if (callbackIndex < 0) return store.apply(this, arguments)
-
-      const scope = tracer.scope()
-      const span = startSpan(tracer, config, operation)
-
-      addBucketTag(span, this)
-
-      arguments[callbackIndex] = wrapCallback(span, arguments[callbackIndex])
-
-      return scope.bind(store, span).apply(this, arguments)
-    }
+  _addCommandSubs (name) {
+    this.addSubs(name, ({ bucket }) => {
+      const store = storage.getStore()
+      const span = this.startSpan(name, {}, store, bucket)
+      this.enter(span, store)
+    })
   }
 }
 
-function addBucketTag (span, bucket) {
-  span.setTag('couchbase.bucket.name', bucket.name || bucket._name)
-}
-
-function findCallbackIndex (args) {
-  for (let i = args.length - 1; i >= 2; i--) {
-    if (typeof args[i] === 'function') return i
-  }
-
-  return -1
+function defaultAsyncEnd () {
+  storage.getStore().span.finish()
 }
 
-function wrapCallback (span, callback) {
-  return function (err, result) {
-    span.setTag('error', err)
-    span.finish()
-
-    return callback.apply(this, arguments)
-  }
+function errorHandler (error) {
+  storage.getStore().span.setTag('error', error)
 }
 
-module.exports = [
-  {
-    name: 'couchbase',
-    versions: ['^2.6.5'],
-    file: 'lib/bucket.js',
-    patch (Bucket, tracer, config) {
-      tracer.scope().bind(Bucket.prototype)
-
-      this.wrap(Bucket.prototype, '_maybeInvoke', createWrapMaybeInvoke(tracer, config))
-      this.wrap(Bucket.prototype, 'query', createWrapQuery(tracer))
-      this.wrap(Bucket.prototype, '_n1qlReq', createWrapN1qlReq(tracer, config))
-      this.wrap(Bucket.prototype, 'upsert', createWrapStore(tracer, config, 'upsert'))
-      this.wrap(Bucket.prototype, 'insert', createWrapStore(tracer, config, 'insert'))
-      this.wrap(Bucket.prototype, 'replace', createWrapStore(tracer, config, 'replace'))
-      this.wrap(Bucket.prototype, 'append', createWrapStore(tracer, config, 'append'))
-      this.wrap(Bucket.prototype, 'prepend', createWrapStore(tracer, config, 'prepend'))
-    },
-    unpatch (Bucket, tracer) {
-      tracer.scope().unbind(Bucket.prototype)
-
-      this.unwrap(Bucket.prototype, '_maybeInvoke')
-      this.unwrap(Bucket.prototype, 'query')
-      this.unwrap(Bucket.prototype, '_n1qlReq')
-      this.unwrap(Bucket.prototype, 'upsert')
-      this.unwrap(Bucket.prototype, 'insert')
-      this.unwrap(Bucket.prototype, 'replace')
-      this.unwrap(Bucket.prototype, 'append')
-      this.unwrap(Bucket.prototype, 'prepend')
-    }
-  },
-  {
-    name: 'couchbase',
-    versions: ['^2.6.5'],
-    file: 'lib/cluster.js',
-    patch (Cluster, tracer, config) {
-      this.wrap(Cluster.prototype, '_maybeInvoke', createWrapMaybeInvoke(tracer, config))
-      this.wrap(Cluster.prototype, 'query', createWrapQuery(tracer))
-    },
-    unpatch (Cluster) {
-      this.unwrap(Cluster.prototype, '_maybeInvoke')
-      this.unwrap(Cluster.prototype, 'query')
-    }
-  }
-]
+module.exports = CouchBasePlugin

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

@@ -1,23 +1,29 @@
 'use strict'
 
-const Tags = require('opentracing').Tags
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
-function createWrapRequest (tracer, config) {
-  config = normalizeConfig(config)
-  return function wrapRequest (request) {
-    return function requestWithTrace (params, options, cb) {
-      if (!params) return request.apply(this, arguments)
+class ElasticsearchPlugin extends Plugin {
+  static get name () {
+    return 'elasticsearch'
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:elasticsearch:query:start', ({ params }) => {
+      this.config = normalizeConfig(this.config)
 
-      const lastIndex = arguments.length - 1
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
       const body = getBody(params.body || params.bulkBody)
-      const childOf = tracer.scope().active()
-      const span = tracer.startSpan('elasticsearch.query', {
+      const span = this.tracer.startSpan('elasticsearch.query', {
         childOf,
         tags: {
-          [Tags.SPAN_KIND]: Tags.SPAN_KIND_RPC_CLIENT,
-          [Tags.DB_TYPE]: 'elasticsearch',
-          'service.name': config.service || `${tracer._service}-elasticsearch`,
+          'db.type': 'elasticsearch',
+          'span.kind': 'client',
+          'service.name': this.config.service || `${this.tracer._service}-elasticsearch`,
           'resource.name': `${params.method} ${quantizePath(params.path)}`,
           'span.type': 'elasticsearch',
           'elasticsearch.url': params.path,
@@ -26,57 +32,25 @@ function createWrapRequest (tracer, config) {
           'elasticsearch.params': JSON.stringify(params.querystring || params.query)
         }
       })
+      analyticsSampler.sample(span, this.config.measured)
+      this.enter(span, store)
+    })
 
-      analyticsSampler.sample(span, config.measured)
-
-      cb = arguments[lastIndex]
-
-      if (typeof cb === 'function') {
-        arguments[lastIndex] = wrapCallback(tracer, span, params, config, cb)
-
-        return tracer.scope().activate(span, () => request.apply(this, arguments))
-      } else {
-        const promise = request.apply(this, arguments)
-
-        if (promise && typeof promise.then === 'function') {
-          promise.then(() => finish(span, params, config), e => finish(span, params, config, e))
-        } else {
-          finish(span, params, config)
-        }
-
-        return promise
-      }
-    }
-  }
-}
+    this.addSub('apm:elasticsearch:query:end', () => {
+      this.exit()
+    })
 
-function wrapCallback (tracer, span, params, config, done) {
-  return tracer.scope().bind(function (err) {
-    finish(span, params, config, err)
-    done.apply(null, arguments)
-  })
-}
+    this.addSub('apm:elasticsearch:query:error', err => {
+      const span = storage.getStore().span
+      span.setTag('error', err)
+    })
 
-function finish (span, params, config, err) {
-  if (err) {
-    span.addTags({
-      'error.type': err.name,
-      'error.msg': err.message,
-      'error.stack': err.stack
+    this.addSub('apm:elasticsearch:query:async-end', ({ params }) => {
+      const span = storage.getStore().span
+      this.config.hooks.query(span, params)
+      span.finish()
     })
   }
-
-  config.hooks.query(span, params)
-
-  span.finish()
-}
-
-function quantizePath (path) {
-  return path && path.replace(/[0-9]+/g, '?')
-}
-
-function getBody (body) {
-  return body && JSON.stringify(body)
 }
 
 function normalizeConfig (config) {
@@ -94,27 +68,12 @@ function getHooks (config) {
   return { query }
 }
 
-module.exports = [
-  {
-    name: 'elasticsearch',
-    file: 'src/lib/transport.js',
-    versions: ['>=10'],
-    patch (Transport, tracer, config) {
-      this.wrap(Transport.prototype, 'request', createWrapRequest(tracer, config))
-    },
-    unpatch (Transport) {
-      this.unwrap(Transport.prototype, 'request')
-    }
-  },
-  {
-    name: '@elastic/elasticsearch',
-    file: 'lib/Transport.js',
-    versions: ['>=5.6.16'], // initial version of this module
-    patch (Transport, tracer, config) {
-      this.wrap(Transport.prototype, 'request', createWrapRequest(tracer, config))
-    },
-    unpatch (Transport) {
-      this.unwrap(Transport.prototype, 'request')
-    }
-  }
-]
+function getBody (body) {
+  return body && JSON.stringify(body)
+}
+
+function quantizePath (path) {
+  return path && path.replace(/[0-9]+/g, '?')
+}
+
+module.exports = ElasticsearchPlugin

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

@@ -165,7 +165,28 @@ function getRes (reply) {
 module.exports = [
   {
     name: 'fastify',
-    versions: ['>=1'],
+    versions: ['>=3'],
+    patch (fastify, tracer, config) {
+      // `fastify` is a function so we return a wrapper that will replace its export.
+      const wrapped = this.wrapExport(fastify, createWrapFastify(tracer, config)(fastify))
+
+      wrapped.fastify = wrapped
+      wrapped.default = wrapped
+
+      return wrapped
+    },
+    unpatch (fastify) {
+      const unwrapped = this.unwrapExport(fastify)
+
+      unwrapped.fastify = unwrapped
+      unwrapped.default = unwrapped
+
+      return unwrapped
+    }
+  },
+  {
+    name: 'fastify',
+    versions: ['1 - 2'],
     patch (fastify, tracer, config) {
       // `fastify` is a function so we return a wrapper that will replace its export.
       return this.wrapExport(fastify, createWrapFastify(tracer, config)(fastify))

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

@@ -12,7 +12,7 @@ class MySQLPlugin extends Plugin {
   constructor (...args) {
     super(...args)
 
-    this.addSub('apm:mysql:query:start', ([sql, conf]) => {
+    this.addSub(`apm:${this.constructor.name}:query:start`, ({ sql, conf }) => {
       const store = storage.getStore()
       const childOf = store ? store.span : store
       const span = this.tracer.startSpan('mysql.query', {
@@ -37,18 +37,18 @@ class MySQLPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub('apm:mysql:query:end', () => {
+    this.addSub(`apm:${this.constructor.name}:query:end`, () => {
       this.exit()
     })
 
-    this.addSub('apm:mysql:query:error', err => {
+    this.addSub(`apm:${this.constructor.name}:query:error`, err => {
       if (err) {
         const span = storage.getStore().span
         span.setTag('error', err)
       }
     })
 
-    this.addSub('apm:mysql:query:async-end', () => {
+    this.addSub(`apm:${this.constructor.name}:query:async-end`, () => {
       const span = storage.getStore().span
       span.finish()
     })

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

@@ -1,94 +1,11 @@
 'use strict'
 
-const Tags = require('opentracing').Tags
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
+const MySQLPlugin = require('../../datadog-plugin-mysql/src')
 
-function createWrapAddCommand (tracer, config) {
-  return function wrapAddCommand (addCommand) {
-    return function addCommandWithTrace (cmd) {
-      const name = cmd && cmd.constructor && cmd.constructor.name
-      const isCommand = typeof cmd.execute === 'function'
-      const isSupported = name === 'Execute' || name === 'Query'
-
-      if (isCommand && isSupported) {
-        cmd.execute = wrapExecute(tracer, config, cmd.execute)
-      }
-
-      return addCommand.apply(this, arguments)
-    }
+class MySQL2Plugin extends MySQLPlugin {
+  static get name () {
+    return 'mysql2'
   }
 }
 
-function wrapExecute (tracer, config, execute) {
-  const scope = tracer.scope()
-  const childOf = scope.active()
-
-  return function executeWithTrace (packet, connection) {
-    const connectionConfig = (connection && connection.config) || {}
-    const sql = this.statement ? this.statement.query : this.sql
-    const span = tracer.startSpan('mysql.query', {
-      childOf,
-      tags: {
-        [Tags.SPAN_KIND]: Tags.SPAN_KIND_RPC_CLIENT,
-        'service.name': config.service || `${tracer._service}-mysql`,
-        'resource.name': sql,
-        'span.type': 'sql',
-        'span.kind': 'client',
-        'db.type': 'mysql',
-        'db.user': connectionConfig.user,
-        'db.name': connectionConfig.database,
-        'out.host': connectionConfig.host,
-        'out.port': connectionConfig.port
-      }
-    })
-
-    analyticsSampler.sample(span, config.measured)
-
-    if (typeof this.onResult === 'function') {
-      this.onResult = wrapCallback(tracer, span, childOf, this.onResult)
-    } else {
-      this.on('error', error => span.addTags({ error }))
-      this.on('end', () => span.finish())
-    }
-
-    this.execute = execute
-
-    return scope.bind(execute, span).apply(this, arguments)
-  }
-}
-
-function wrapCallback (tracer, span, parent, done) {
-  return tracer.scope().bind((...args) => {
-    const [ error ] = args
-    span.addTags({ error })
-
-    span.finish()
-
-    done(...args)
-  }, parent)
-}
-
-module.exports = [
-  {
-    name: 'mysql2',
-    file: 'lib/connection.js',
-    versions: ['>=1'],
-    patch (Connection, tracer, config) {
-      this.wrap(Connection.prototype, 'addCommand', createWrapAddCommand(tracer, config))
-    },
-    unpatch (Connection) {
-      this.unwrap(Connection.prototype, 'addCommand')
-    }
-  },
-  {
-    name: 'mysql2',
-    file: 'lib/commands/command.js',
-    versions: ['>=1'],
-    patch (Command, tracer, config) {
-      tracer.scope().bind(Command.prototype)
-    },
-    unpatch (Command, tracer) {
-      tracer.scope().unbind(Command.prototype)
-    }
-  }
-]
+module.exports = MySQL2Plugin

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

@@ -115,10 +115,10 @@ function trace (tracer, config, req, res, handler) {
   // TODO: Use CLS when it will be available in core.
   span._nextReq = req
 
-  promise.then(() => finish(span, config, req, res), err => {
-    span.setTag('error', err)
-    finish(span, config, req, res)
-  })
+  promise.then(
+    () => finish(span, config, req, res),
+    err => finish(span, config, req, res, err)
+  )
 
   return promise
 }
@@ -132,7 +132,8 @@ function addPage (req, page) {
   })
 }
 
-function finish (span, config, req, res) {
+function finish (span, config, req, res, err) {
+  span.setTag('error', err || !config.validateStatus(res.statusCode))
   span.addTags({
     'http.status_code': res.statusCode
   })
@@ -142,8 +143,11 @@ function finish (span, config, req, res) {
 
 function normalizeConfig (config) {
   const hooks = getHooks(config)
+  const validateStatus = typeof config.validateStatus === 'function'
+    ? config.validateStatus
+    : code => code < 500
 
-  return Object.assign({}, config, { hooks })
+  return Object.assign({}, config, { hooks, validateStatus })
 }
 
 function getHooks (config) {

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

@@ -2,18 +2,40 @@
 
 const { LOG } = require('../../../ext/formats')
 
+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()
 
-      tracer.inject(span, LOG, chunk)
+      const holder = {}
+      tracer.inject(span, LOG, holder)
+      arguments[0] = chunkProxy(chunk, holder)
 
-      const result = write.apply(this, arguments)
-
-      delete chunk.dd
-
-      return result
+      return write.apply(this, arguments)
     }
   }
 }
@@ -42,15 +64,14 @@ function createWrapLog (tracer, config) {
     return function logWithTrace (level, msg, meta, callback) {
       const span = tracer.scope().active()
 
-      meta = arguments[2] = meta || {}
+      meta = meta || {}
 
-      tracer.inject(span, LOG, meta)
+      const holder = {}
+      tracer.inject(span, LOG, holder)
 
-      const result = log.apply(this, arguments)
+      arguments[2] = chunkProxy(meta, holder)
 
-      delete meta.dd
-
-      return result
+      return log.apply(this, arguments)
     }
   }
 }

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

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

package/packages/dd-trace/src/appsec/index.js

@@ -76,6 +76,10 @@ function incomingHttpEndTranslator (data) {
   }
 
   // TODO: temporary express instrumentation, will use express plugin later
+  if (data.req.body !== undefined && data.req.body !== null) {
+    payload[addresses.HTTP_INCOMING_BODY] = data.req.body
+  }
+
   if (data.req.query && typeof data.req.query === 'object') {
     payload[addresses.HTTP_INCOMING_QUERY] = data.req.query
   }