dd-trace 2.1.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.
@@ -406,6 +394,28 @@ export declare interface TracerOptions {
    * @default true
    */
   orphanable?: boolean
+
+  /**
+   * Configuration of the AppSec protection. Can be a boolean as an alias to `appsec.enabled`.
+   */
+  appsec?: boolean | {
+    /**
+     * Whether to enable AppSec.
+     * @default false
+     */
+    enabled?: boolean,
+
+    /**
+     * Specifies a path to a custom rules file.
+     */
+    rules?: string,
+
+    /**
+     * Controls the maximum amount of traces sampled by AppSec attacks, per second.
+     * @default 100
+     */
+    rateLimit?: number
+  };
 }
 
 /** @hidden */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "2.1.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,11 +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/bluebird')
-require('./src/when')
+require('./src/pino')
 require('./src/promise')
-require('./src/q')
 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/couchbase.js

@@ -0,0 +1,143 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^2.6.5'] }, Bucket => {
+  const startCh = channel('apm:couchbase:query:start')
+  const asyncEndCh = channel('apm:couchbase:query:async-end')
+  const endCh = channel('apm:couchbase:query:end')
+  const errorCh = channel('apm:couchbase:query:error')
+
+  Bucket.prototype._maybeInvoke = wrapMaybeInvoke(Bucket.prototype._maybeInvoke)
+  Bucket.prototype.query = wrapQuery(Bucket.prototype.query)
+
+  shimmer.wrap(Bucket.prototype, '_n1qlReq', _n1qlReq => function (host, q, adhoc, emitter) {
+    if (!startCh.hasSubscribers) {
+      return _n1qlReq.apply(this, arguments)
+    }
+
+    if (!emitter || !emitter.once) return _n1qlReq.apply(this, arguments)
+
+    const n1qlQuery = q && q.statement
+
+    startCh.publish({ resource: n1qlQuery, bucket: this })
+
+    emitter.once('rows', AsyncResource.bind(() => {
+      asyncEndCh.publish(undefined)
+    }))
+
+    emitter.once('error', AsyncResource.bind((error) => {
+      errorCh.publish(error)
+      asyncEndCh.publish(undefined)
+    }))
+
+    try {
+      return _n1qlReq.apply(this, arguments)
+    } catch (err) {
+      err.stack // trigger getting the stack at the original throwing point
+      errorCh.publish(err)
+
+      throw err
+    } finally {
+      endCh.publish(undefined)
+    }
+  })
+
+  Bucket.prototype.upsert = wrap('apm:couchbase:upsert', Bucket.prototype.upsert)
+  Bucket.prototype.insert = wrap('apm:couchbase:insert', Bucket.prototype.insert)
+  Bucket.prototype.replace = wrap('apm:couchbase:replace', Bucket.prototype.replace)
+  Bucket.prototype.append = wrap('apm:couchbase:append', Bucket.prototype.append)
+  Bucket.prototype.prepend = wrap('apm:couchbase:prepend', Bucket.prototype.prepend)
+
+  return Bucket
+})
+
+addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^2.6.5'] }, Cluster => {
+  Cluster.prototype._maybeInvoke = wrapMaybeInvoke(Cluster.prototype._maybeInvoke)
+  Cluster.prototype.query = wrapQuery(Cluster.prototype.query)
+
+  return Cluster
+})
+
+function findCallbackIndex (args) {
+  for (let i = args.length - 1; i >= 2; i--) {
+    if (typeof args[i] === 'function') return i
+  }
+  return -1
+}
+
+function wrapMaybeInvoke (_maybeInvoke) {
+  const wrapped = function (fn, args) {
+    if (!Array.isArray(args)) return _maybeInvoke.apply(this, arguments)
+
+    const callbackIndex = args.length - 1
+    const callback = args[callbackIndex]
+
+    if (callback instanceof Function) {
+      args[callbackIndex] = AsyncResource.bind(callback)
+    }
+
+    return _maybeInvoke.apply(this, arguments)
+  }
+  return shimmer.wrap(_maybeInvoke, wrapped)
+}
+
+function wrapQuery (query) {
+  const wrapped = function (q, params, callback) {
+    callback = AsyncResource.bind(arguments[arguments.length - 1])
+
+    if (typeof callback === 'function') {
+      arguments[arguments.length - 1] = callback
+    }
+
+    const res = query.apply(this, arguments)
+    return res
+  }
+  return shimmer.wrap(query, wrapped)
+}
+
+function wrap (prefix, fn) {
+  const startCh = channel(prefix + ':start')
+  const endCh = channel(prefix + ':end')
+  const asyncEndCh = channel(prefix + ':async-end')
+  const errorCh = channel(prefix + ':error')
+
+  const wrapped = function (key, value, options, callback) {
+    if (!startCh.hasSubscribers) {
+      return fn.apply(this, arguments)
+    }
+
+    const callbackIndex = findCallbackIndex(arguments)
+
+    if (callbackIndex < 0) return fn.apply(this, arguments)
+
+    const cb = arguments[callbackIndex]
+
+    startCh.publish({ bucket: this })
+
+    arguments[callbackIndex] = function (error, result) {
+      if (error) {
+        errorCh.publish(error)
+      }
+      asyncEndCh.publish(result)
+      return cb.apply(this, arguments)
+    }
+
+    try {
+      return fn.apply(this, arguments)
+    } catch (error) {
+      error.stack // trigger getting the stack at the original throwing point
+      errorCh.publish(error)
+
+      throw error
+    } finally {
+      endCh.publish(undefined)
+    }
+  }
+  return shimmer.wrap(fn, wrapped)
+}

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

@@ -0,0 +1,79 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const startCh = channel('apm:elasticsearch:query:start')
+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/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
+})
+
+addHook({ name: 'elasticsearch', file: 'src/lib/transport.js', versions: ['>=10'] }, Transport => {
+  shimmer.wrap(Transport.prototype, 'request', wrapRequest)
+  return Transport
+})
+
+function wrapRequest (request) {
+  return function (params, options, cb) {
+    if (!startCh.hasSubscribers) {
+      return request.apply(this, arguments)
+    }
+
+    if (!params) return request.apply(this, arguments)
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+    startCh.publish({ params })
+
+    try {
+      const lastIndex = arguments.length - 1
+      cb = arguments[lastIndex]
+
+      if (typeof cb === 'function') {
+        cb = asyncResource.bind(cb)
+
+        arguments[lastIndex] = AsyncResource.bind(function (error) {
+          finish(params, error)
+          return cb.apply(null, arguments)
+        })
+        return request.apply(this, arguments)
+      } else {
+        const promise = request.apply(this, arguments)
+        if (promise && typeof promise.then === 'function') {
+          promise.then(() => finish(params), e => finish(params, e))
+        } else {
+          finish(params)
+        }
+        return promise
+      }
+    } catch (err) {
+      err.stack // trigger getting the stack at the original throwing point
+      errorCh.publish(err)
+
+      throw err
+    } finally {
+      endCh.publish(undefined)
+    }
+  }
+}
+
+function finish (params, error) {
+  if (error) {
+    errorCh.publish(error)
+  }
+  asyncEndCh.publish({ 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,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/mysql.js

@@ -20,9 +20,9 @@ addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connect
     }
 
     const sql = arguments[0].sql ? arguments[0].sql : arguments[0]
-    const startArgs = [sql, this.config]
+    const conf = this.config
 
-    startCh.publish(startArgs)
+    startCh.publish({ sql, conf })
 
     try {
       const res = query.apply(this, arguments)

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

@@ -8,10 +8,10 @@ const {
 const shimmer = require('../../datadog-shimmer')
 
 addHook({ name: 'mysql2', file: 'lib/connection.js', versions: ['>=1'] }, Connection => {
-  const startCh = channel('apm:mysql:query:start')
-  const asyncEndCh = channel('apm:mysql:query:async-end')
-  const endCh = channel('apm:mysql:query:end')
-  const errorCh = channel('apm:mysql:query:error')
+  const startCh = channel('apm:mysql2:query:start')
+  const asyncEndCh = channel('apm:mysql2:query:async-end')
+  const endCh = channel('apm:mysql2:query:end')
+  const errorCh = channel('apm:mysql2:query:error')
 
   shimmer.wrap(Connection.prototype, 'addCommand', addCommand => function (cmd) {
     if (!startCh.hasSubscribers) return addCommand.apply(this, arguments)
@@ -45,7 +45,7 @@ addHook({ name: 'mysql2', file: 'lib/connection.js', versions: ['>=1'] }, Connec
     return asyncResource.bind(function executeWithTrace (packet, connection) {
       const sql = cmd.statement ? cmd.statement.query : cmd.sql
 
-      startCh.publish([sql, config])
+      startCh.publish({ sql, conf: config })
 
       if (this.onResult) {
         const onResult = asyncResource.bind(this.onResult)

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))
+})