dd-trace 2.2.0 → 2.2.1

package/LICENSE-3rdparty.csv

@@ -22,8 +22,6 @@ require,path-to-regexp,MIT,Copyright 2014 Blake Embrey
 require,performance-now,MIT,Copyright 2013 Braveg1rl
 require,retry,MIT,Copyright 2011 Tim Koschützki Felix Geisendörfer
 require,semver,ISC,Copyright Isaac Z. Schlueter and Contributors
-require,source-map,BSD-3-Clause,Copyright 2009-2011 Mozilla Foundation and contributors
-require,source-map-resolve,MIT,Copyright 2014-2020 Simon Lydell 2019 Jinxiang
 dev,autocannon,MIT,Copyright 2016 Matteo Collina
 dev,axios,MIT,Copyright 2014-present Matt Zabriskie
 dev,benchmark,MIT,Copyright 2010-2016 Mathias Bynens Robert Kieffer John-David Dalton

package/index.d.ts

@@ -186,18 +186,6 @@ export declare interface SamplingRule {
  * List of options available to the tracer.
  */
 export declare interface TracerOptions {
-  /**
-   * Whether to enable the tracer.
-   * @default true
-   */
-  enabled?: boolean;
-
-  /**
-   * Enable debug logging in the tracer.
-   * @default false
-   */
-  debug?: boolean;
-
   /**
    * Whether to enable trace ID injection in log records to be able to correlate
    * traces with logs.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -69,7 +69,7 @@
     "crypto-randomuuid": "^1.0.0",
     "diagnostics_channel": "^1.1.0",
     "form-data": "^3.0.0",
-    "import-in-the-middle": "^1.1.2",
+    "import-in-the-middle": "^1.2.1",
     "koalas": "^1.0.2",
     "limiter": "^1.1.4",
     "lodash.kebabcase": "^4.1.1",
@@ -83,9 +83,7 @@
     "path-to-regexp": "^0.1.2",
     "performance-now": "^2.1.0",
     "retry": "^0.10.1",
-    "semver": "^5.5.0",
-    "source-map": "^0.7.3",
-    "source-map-resolve": "^0.6.0"
+    "semver": "^5.5.0"
   },
   "devDependencies": {
     "autocannon": "^4.5.2",

package/packages/datadog-instrumentations/index.js

@@ -1,13 +1,21 @@
 'use strict'
 
 require('./src/bluebird')
+require('./src/bunyan')
 require('./src/couchbase')
 require('./src/dns')
 require('./src/elasticsearch')
+require('./src/generic-pool')
+require('./src/ioredis')
 require('./src/memcached')
+require('./src/mongoose')
 require('./src/mysql')
 require('./src/mysql2')
+require('./src/pino')
 require('./src/promise')
 require('./src/promise-js')
 require('./src/q')
+require('./src/redis')
+require('./src/sharedb')
 require('./src/when')
+require('./src/winston')

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

@@ -0,0 +1,22 @@
+'use strict'
+
+const {
+  channel,
+  addHook
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+addHook({ name: 'bunyan', versions: ['>=1'] }, Logger => {
+  const logCh = channel('apm:bunyan:log')
+  shimmer.wrap(Logger.prototype, '_emit', emit => {
+    return function wrappedEmit (rec) {
+      if (logCh.hasSubscribers) {
+        const payload = { message: rec }
+        logCh.publish(payload)
+        arguments[0] = payload.message
+      }
+      return emit.apply(this, arguments)
+    }
+  })
+  return Logger
+})

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

@@ -12,7 +12,12 @@ const asyncEndCh = channel('apm:elasticsearch:query:async-end')
 const endCh = channel('apm:elasticsearch:query:end')
 const errorCh = channel('apm:elasticsearch:query:error')
 
-addHook({ name: '@elastic/elasticsearch', file: 'lib/Transport.js', versions: ['>=5.6.16'] }, Transport => {
+addHook({ name: '@elastic/transport', file: 'lib/Transport.js', versions: ['>=8'] }, (exports) => {
+  shimmer.wrap(exports.default.prototype, 'request', wrapRequest)
+  return exports
+})
+
+addHook({ name: '@elastic/elasticsearch', file: 'lib/Transport.js', versions: ['>=5.6.16 <8', '>=8'] }, Transport => {
   shimmer.wrap(Transport.prototype, 'request', wrapRequest)
   return Transport
 })

package/packages/datadog-instrumentations/src/generic-pool.js

@@ -0,0 +1,48 @@
+'use strict'
+
+const { addHook, AsyncResource } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+function createWrapAcquire () {
+  return function wrapAcquire (acquire) {
+    return function acquireWithTrace (callback, priority) {
+      if (typeof callback === 'function') {
+        arguments[0] = AsyncResource.bind(callback)
+      }
+
+      return acquire.apply(this, arguments)
+    }
+  }
+}
+
+function createWrapPool () {
+  return function wrapPool (Pool) {
+    if (typeof Pool !== 'function') return Pool
+
+    return function PoolWithTrace (factory) {
+      const pool = Pool.apply(this, arguments)
+
+      if (pool && typeof pool.acquire === 'function') {
+        shimmer.wrap(pool, 'acquire', createWrapAcquire())
+      }
+
+      return pool
+    }
+  }
+}
+
+addHook({
+  name: 'generic-pool',
+  versions: ['^2.4']
+}, genericPool => {
+  shimmer.wrap(genericPool.Pool.prototype, 'acquire', createWrapAcquire())
+  return genericPool
+})
+
+addHook({
+  name: 'generic-pool',
+  versions: ['2 - 2.3']
+}, genericPool => {
+  shimmer.wrap(genericPool, 'Pool', createWrapPool())
+  return genericPool
+})

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

@@ -0,0 +1,49 @@
+'use strict'
+
+const {
+  channel,
+  addHook
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const startCh = channel('apm:ioredis:command:start')
+const asyncEndCh = channel('apm:ioredis:command:async-end')
+const endCh = channel('apm:ioredis:command:end')
+const errorCh = channel('apm:ioredis:command:error')
+
+addHook({ name: 'ioredis', versions: ['>=2'] }, Redis => {
+  shimmer.wrap(Redis.prototype, 'sendCommand', sendCommand => function (command, stream) {
+    if (!startCh.hasSubscribers) return sendCommand.apply(this, arguments)
+
+    if (!command || !command.promise) return sendCommand.apply(this, arguments)
+
+    const options = this.options || {}
+    const connectionName = options.connectionName
+    const db = options.db
+    const connectionOptions = { host: options.host, port: options.port }
+    startCh.publish({ db, command: command.name, args: command.args, connectionOptions, connectionName })
+
+    command.promise.then(
+      () => finish(asyncEndCh, errorCh),
+      err => finish(asyncEndCh, errorCh, err)
+    )
+
+    try {
+      return sendCommand.apply(this, arguments)
+    } catch (err) {
+      errorCh.publish(err)
+
+      throw err
+    } finally {
+      endCh.publish(undefined)
+    }
+  })
+  return Redis
+})
+
+function finish (asyncEndCh, errorCh, error) {
+  if (error) {
+    errorCh.publish(error)
+  }
+  asyncEndCh.publish(undefined)
+}

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

@@ -0,0 +1,30 @@
+'use strict'
+
+const { addHook } = require('./helpers/instrument')
+const { wrapThen } = require('./helpers/promise')
+const { AsyncResource } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+function wrapAddQueue (addQueue) {
+  return function addQueueWithTrace (name) {
+    if (typeof name === 'function') {
+      arguments[0] = AsyncResource.bind(name)
+    } else if (typeof this[name] === 'function') {
+      arguments[0] = AsyncResource.bind((...args) => this[name](...args))
+    }
+
+    return addQueue.apply(this, arguments)
+  }
+}
+
+addHook({
+  name: 'mongoose',
+  versions: ['>=4.6.4']
+}, mongoose => {
+  if (mongoose.Promise !== global.Promise) {
+    shimmer.wrap(mongoose.Promise.prototype, 'then', wrapThen)
+  }
+
+  shimmer.wrap(mongoose.Collection.prototype, 'addQueue', wrapAddQueue)
+  return mongoose
+})

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

@@ -0,0 +1,105 @@
+'use strict'
+
+const {
+  channel,
+  addHook
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+function wrapPino (symbol, wrapper, pino) {
+  return function pinoWithTrace () {
+    const instance = pino.apply(this, arguments)
+
+    Object.defineProperty(instance, symbol, {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: wrapper(instance[symbol])
+    })
+
+    return instance
+  }
+}
+
+function wrapAsJson (asJson) {
+  const ch = channel('apm:pino:log')
+  return function asJsonWithTrace (obj, msg, num, time) {
+    obj = arguments[0] = obj || {}
+
+    const payload = { message: obj }
+    ch.publish(payload)
+    arguments[0] = payload.message
+
+    return asJson.apply(this, arguments)
+  }
+}
+
+function wrapMixin (mixin) {
+  const ch = channel('apm:pino:log')
+  return function mixinWithTrace () {
+    let obj = {}
+
+    if (mixin) {
+      obj = mixin.apply(this, arguments)
+    }
+
+    const payload = { message: obj }
+    ch.publish(payload)
+
+    return payload.message
+  }
+}
+
+function wrapPrettifyObject (prettifyObject) {
+  const ch = channel('apm:pino:log')
+  return function prettifyObjectWithTrace (input) {
+    const payload = { message: input.input }
+    ch.publish(payload)
+    input.input = payload.message
+    return prettifyObject.apply(this, arguments)
+  }
+}
+
+function wrapPrettyFactory (prettyFactory) {
+  const ch = channel('apm:pino:log')
+  return function prettyFactoryWithTrace () {
+    const pretty = prettyFactory.apply(this, arguments)
+    return function prettyWithTrace (obj) {
+      const payload = { message: obj }
+      ch.publish(payload)
+      arguments[0] = payload.message
+      return pretty.apply(this, arguments)
+    }
+  }
+}
+
+addHook({ name: 'pino', versions: ['2 - 3', '4', '>=5 <5.14.0'] }, pino => {
+  const asJsonSym = (pino.symbols && pino.symbols.asJsonSym) || 'asJson'
+
+  return shimmer.wrap(pino, wrapPino(asJsonSym, wrapAsJson, pino))
+})
+
+addHook({ name: 'pino', versions: ['>=5.14.0 <6.8.0'] }, pino => {
+  const mixinSym = pino.symbols.mixinSym
+
+  return shimmer.wrap(pino, wrapPino(mixinSym, wrapMixin, pino))
+})
+
+addHook({ name: 'pino', versions: ['>=6.8.0'] }, pino => {
+  const mixinSym = pino.symbols.mixinSym
+
+  const wrapped = shimmer.wrap(pino, wrapPino(mixinSym, wrapMixin, pino))
+  wrapped.pino = wrapped
+  wrapped.default = wrapped
+
+  return wrapped
+})
+
+addHook({ name: 'pino-pretty', file: 'lib/utils.js', versions: ['>=3'] }, utils => {
+  shimmer.wrap(utils, 'prettifyObject', wrapPrettifyObject)
+  return utils
+})
+
+addHook({ name: 'pino-pretty', versions: ['1 - 2'] }, prettyFactory => {
+  return shimmer.wrap(prettyFactory, wrapPrettyFactory(prettyFactory))
+})

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-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-fastify/src/find-my-way.js

@@ -10,7 +10,6 @@ function createWrapOn () {
       const wrapper = function (req) {
         web.patch(req)
         web.enterRoute(req, path)
-        req._datadog.routeEntered = true
 
         return handler.apply(this, arguments)
       }