dd-trace 2.1.0 → 2.2.1

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

@@ -0,0 +1,118 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const startCh = channel('apm:redis:command:start')
+const asyncEndCh = channel('apm:redis:command:async-end')
+const endCh = channel('apm:redis:command:end')
+const errorCh = channel('apm:redis:command:error')
+
+addHook({ name: '@node-redis/client', file: 'dist/lib/client/commands-queue.js', versions: ['>=1'] }, redis => {
+  shimmer.wrap(redis.default.prototype, 'addCommand', addCommand => function (command) {
+    if (!startCh.hasSubscribers) {
+      return addCommand.apply(this, arguments)
+    }
+
+    const name = command[0]
+    const args = command.slice(1)
+
+    startSpan(this, name, args)
+
+    const res = addCommand.apply(this, arguments)
+
+    res.then(
+      () => finish(asyncEndCh, errorCh),
+      err => finish(asyncEndCh, errorCh, err)
+    )
+    endCh.publish(undefined)
+    return res
+  })
+  return redis
+})
+
+addHook({ name: 'redis', versions: ['>=2.6 <4'] }, redis => {
+  shimmer.wrap(redis.RedisClient.prototype, 'internal_send_command', internalSendCommand => function (options) {
+    if (!startCh.hasSubscribers) return internalSendCommand.apply(this, arguments)
+
+    if (!options.callback) return internalSendCommand.apply(this, arguments)
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+    const cb = asyncResource.bind(options.callback)
+
+    startSpan(this, options.command, options.args)
+
+    options.callback = AsyncResource.bind(wrapCallback(asyncEndCh, errorCh, cb))
+
+    try {
+      return internalSendCommand.apply(this, arguments)
+    } catch (err) {
+      errorCh.publish(err)
+
+      throw err
+    } finally {
+      endCh.publish(undefined)
+    }
+  })
+  return redis
+})
+
+addHook({ name: 'redis', versions: ['>=0.12 <2.6'] }, redis => {
+  shimmer.wrap(redis.RedisClient.prototype, 'send_command', sendCommand => function (command, args, callback) {
+    if (!startCh.hasSubscribers) {
+      return sendCommand.apply(this, arguments)
+    }
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+    startSpan(this, command, args)
+
+    if (typeof callback === 'function') {
+      const cb = asyncResource.bind(callback)
+      arguments[2] = AsyncResource.bind(wrapCallback(asyncEndCh, errorCh, cb))
+    } else if (Array.isArray(args) && typeof args[args.length - 1] === 'function') {
+      const cb = asyncResource.bind(args[args.length - 1])
+      args[args.length - 1] = AsyncResource.bind(wrapCallback(asyncEndCh, errorCh, cb))
+    } else {
+      arguments[2] = AsyncResource.bind(wrapCallback(asyncEndCh, errorCh))
+    }
+
+    try {
+      return sendCommand.apply(this, arguments)
+    } catch (err) {
+      errorCh.publish(err)
+
+      throw err
+    } finally {
+      endCh.publish(undefined)
+    }
+  })
+  return redis
+})
+
+function startSpan (client, command, args) {
+  const db = client.selected_db
+  const connectionOptions = client.connection_options || client.connection_option || client.connectionOption || {}
+  startCh.publish({ db, command, args, connectionOptions })
+}
+
+function wrapCallback (asyncEndCh, errorCh, callback) {
+  return function (err) {
+    finish(asyncEndCh, errorCh, err)
+    if (callback) {
+      return callback.apply(this, arguments)
+    }
+  }
+}
+
+function finish (asyncEndCh, errorCh, error) {
+  if (error) {
+    errorCh.publish(error)
+  }
+  asyncEndCh.publish(undefined)
+}

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

@@ -0,0 +1,78 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+/**
+ * @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'
+}
+
+addHook({ name: 'sharedb', versions: ['>=1'], file: 'lib/agent.js' }, Agent => {
+  const startCh = channel('apm:sharedb:request:start')
+  const asyncEndCh = channel('apm:sharedb:request:async-end')
+  const endCh = channel('apm:sharedb:request:end')
+  const errorCh = channel('apm:sharedb:request:error')
+
+  shimmer.wrap(Agent.prototype, '_handleMessage', origHandleMessageFn => function (request, callback) {
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    const action = request.a
+
+    const actionName = getReadableActionName(action)
+
+    startCh.publish({ actionName, request })
+
+    callback = asyncResource.bind(callback)
+
+    arguments[1] = AsyncResource.bind(function (error, res) {
+      if (error) {
+        errorCh.publish(error)
+      }
+      asyncEndCh.publish({ request, res })
+
+      return callback.apply(this, arguments)
+    })
+
+    try {
+      return origHandleMessageFn.apply(this, arguments)
+    } catch (error) {
+      errorCh.publish(error)
+
+      throw error
+    } finally {
+      endCh.publish(undefined)
+    }
+  })
+  return Agent
+})
+
+function getReadableActionName (action) {
+  const actionName = READABLE_ACTION_NAMES[action]
+  if (actionName === undefined) {
+    return action
+  }
+  return actionName
+}

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

@@ -0,0 +1,57 @@
+'use strict'
+
+const {
+  channel,
+  addHook
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const patched = new WeakSet()
+
+addHook({ name: 'winston', file: 'lib/winston/logger.js', versions: ['>=3'] }, Logger => {
+  const logCh = channel('apm:winston:log')
+  shimmer.wrap(Logger.prototype, 'write', write => {
+    return function wrappedWrite (chunk, enc, cb) {
+      if (logCh.hasSubscribers) {
+        const payload = { message: chunk }
+        logCh.publish(payload)
+        arguments[0] = payload.message
+      }
+      return write.apply(this, arguments)
+    }
+  })
+  return Logger
+})
+
+addHook({ name: 'winston', file: 'lib/winston/logger.js', versions: ['1', '2'] }, logger => {
+  const logCh = channel('apm:winston:log')
+  if (logger.Logger.prototype.configure) {
+    shimmer.wrap(logger.Logger.prototype, 'configure', configure => wrapMethod(configure, logCh))
+  }
+  shimmer.wrap(logger.Logger.prototype, 'add', configure => wrapMethod(configure, logCh))
+  return logger
+})
+
+function wrapMethod (method, logCh) {
+  return function methodWithTrace () {
+    const result = method.apply(this, arguments)
+
+    if (logCh.hasSubscribers) {
+      for (const name in this.transports) {
+        const transport = this.transports[name]
+
+        if (patched.has(transport) || typeof transport.log !== 'function') continue
+
+        const log = transport.log
+        transport.log = function wrappedLog (level, msg, meta, callback) {
+          const payload = { message: meta || {} }
+          logCh.publish(payload)
+          arguments[2] = payload.message
+          log.apply(this, arguments)
+        }
+        patched.add(transport)
+      }
+    }
+    return result
+  }
+}

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

@@ -80,7 +80,7 @@ const helpers = {
     if (!span) return
 
     const service = services[serviceName] && services[serviceName]
-    if (service.requestInject) service.requestInject(span, request, tracer)
+    if (service && service.requestInject) service.requestInject(span, request, tracer)
   },
 
   wrapCb (cb, serviceName, tags, request, tracer, childOf) {

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

@@ -1,27 +1,10 @@
 'use strict'
 
-const { LOG } = require('../../../ext/formats')
+const LogPlugin = require('../../dd-trace/src/plugins/log_plugin')
 
-function createWrapEmit (tracer, config) {
-  return function wrapEmit (emit) {
-    return function emitWithTrace (rec, noemit) {
-      const span = tracer.scope().active()
-
-      tracer.inject(span, LOG, rec)
-
-      return emit.apply(this, arguments)
-    }
-  }
-}
-
-module.exports = {
-  name: 'bunyan',
-  versions: ['>=1'],
-  patch (Logger, tracer, config) {
-    if (!tracer._logInjection) return
-    this.wrap(Logger.prototype, '_emit', createWrapEmit(tracer, config))
-  },
-  unpatch (Logger) {
-    this.unwrap(Logger.prototype, '_emit')
+class BunyanPlugin extends LogPlugin {
+  static get name () {
+    return 'bunyan'
   }
 }
+module.exports = BunyanPlugin

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