dd-trace 2.2.0 → 2.3.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.
@@ -278,6 +266,12 @@ export declare interface TracerOptions {
    */
   flushInterval?: number;
 
+  /**
+   *  Number of spans before partially exporting a trace. This prevents keeping all the spans in memory for very large traces.
+   * @default 1000
+   */
+   flushMinSpans?: number;
+
   /**
    * Whether to enable runtime metrics.
    * @default false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "2.2.0",
+  "version": "2.3.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,22 @@
 'use strict'
 
 require('./src/bluebird')
+require('./src/bunyan')
 require('./src/couchbase')
+require('./src/cucumber')
 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/cucumber.js

@@ -0,0 +1,116 @@
+'use strict'
+
+const { addHook, channel } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const runStartCh = channel('ci:cucumber:run:start')
+const runEndCh = channel('ci:cucumber:run:end')
+const runAsyncEndCh = channel('ci:cucumber:run:async-end')
+const runStepStartCh = channel('ci:cucumber:run-step:start')
+const runStepEndCh = channel('ci:cucumber:run-step:end')
+const errorCh = channel('ci:cucumber:error')
+
+function getStatusFromResult (result) {
+  if (result.status === 1) {
+    return { status: 'pass' }
+  }
+  if (result.status === 2) {
+    return { status: 'skip' }
+  }
+  if (result.status === 4) {
+    return { status: 'skip', skipReason: 'not implemented' }
+  }
+  return { status: 'fail', errorMessage: result.message }
+}
+
+function getStatusFromResultLatest (result) {
+  if (result.status === 'PASSED') {
+    return { status: 'pass' }
+  }
+  if (result.status === 'SKIPPED' || result.status === 'PENDING') {
+    return { status: 'skip' }
+  }
+  if (result.status === 'UNDEFINED') {
+    return { status: 'skip', skipReason: 'not implemented' }
+  }
+  return { status: 'fail', errorMessage: result.message }
+}
+
+function wrapRun (pl, isLatestVersion) {
+  shimmer.wrap(pl.prototype, 'run', run => function () {
+    if (!runStartCh.hasSubscribers) {
+      return run.apply(this, arguments)
+    }
+
+    runStartCh.publish({ pickleName: this.pickle.name, pickleUri: this.pickle.uri })
+    try {
+      const promise = run.apply(this, arguments)
+      promise.finally(() => {
+        const result = this.getWorstStepResult()
+        const { status, skipReason, errorMessage } = isLatestVersion
+          ? getStatusFromResultLatest(result) : getStatusFromResult(result)
+
+        runAsyncEndCh.publish({ status, skipReason, errorMessage })
+      })
+      return promise
+    } catch (err) {
+      errorCh.publish(err)
+    } finally {
+      runEndCh.publish(undefined)
+    }
+  })
+  shimmer.wrap(pl.prototype, 'runStep', runStep => function () {
+    if (!runStepStartCh.hasSubscribers) {
+      return runStep.apply(this, arguments)
+    }
+    const testStep = arguments[0]
+    let resource
+
+    if (isLatestVersion) {
+      resource = testStep.text
+    } else {
+      resource = testStep.isHook ? 'hook' : testStep.pickleStep.text
+    }
+
+    runStepStartCh.publish({ resource })
+    try {
+      const promise = runStep.apply(this, arguments)
+
+      promise.then((result) => {
+        const { status, skipReason, errorMessage } = isLatestVersion
+          ? getStatusFromResultLatest(result) : getStatusFromResult(result)
+
+        runAsyncEndCh.publish({ isStep: true, status, skipReason, errorMessage })
+      })
+      return promise
+    } catch (err) {
+      errorCh.publish(err)
+    } finally {
+      runStepEndCh.publish(undefined)
+    }
+  })
+}
+
+addHook({
+  name: '@cucumber/cucumber',
+  versions: ['7.0.0 - 7.2.1'],
+  file: 'lib/runtime/pickle_runner.js'
+}, (PickleRunner) => {
+  const pl = PickleRunner.default
+
+  wrapRun(pl, false)
+
+  return PickleRunner
+})
+
+addHook({
+  name: '@cucumber/cucumber',
+  versions: ['>=7.3.0'],
+  file: 'lib/runtime/test_case_runner.js'
+}, (TestCaseRunner) => {
+  const pl = TestCaseRunner.default
+
+  wrapRun(pl, true)
+
+  return TestCaseRunner
+})

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
 })
@@ -30,18 +35,20 @@ function wrapRequest (request) {
 
     if (!params) return request.apply(this, arguments)
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    const parentResource = new AsyncResource('bound-anonymous-fn')
 
     startCh.publish({ params })
 
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+
     try {
       const lastIndex = arguments.length - 1
       cb = arguments[lastIndex]
 
       if (typeof cb === 'function') {
-        cb = asyncResource.bind(cb)
+        cb = parentResource.bind(cb)
 
-        arguments[lastIndex] = AsyncResource.bind(function (error) {
+        arguments[lastIndex] = asyncResource.bind(function (error) {
           finish(params, error)
           return cb.apply(null, arguments)
         })
@@ -49,7 +56,10 @@ function wrapRequest (request) {
       } else {
         const promise = request.apply(this, arguments)
         if (promise && typeof promise.then === 'function') {
-          promise.then(() => finish(params), e => finish(params, e))
+          const onResolve = asyncResource.bind(() => finish(params))
+          const onReject = asyncResource.bind(e => finish(params, e))
+
+          promise.then(onResolve, onReject)
         } else {
           finish(params)
         }

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,52 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = 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 })
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    const onResolve = asyncResource.bind(() => finish(asyncEndCh, errorCh))
+    const onReject = asyncResource.bind(err => finish(asyncEndCh, errorCh, err))
+
+    command.promise.then(onResolve, onReject)
+
+    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)
+
+    start(this, name, args)
+
+    const res = addCommand.apply(this, arguments)
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    const onResolve = asyncResource.bind(() => finish(asyncEndCh, errorCh))
+    const onReject = asyncResource.bind(err => finish(asyncEndCh, errorCh, err))
+
+    res.then(onResolve, onReject)
+    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)
+
+    start(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')
+
+    start(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 start (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)
+}