dd-trace 2.1.1 → 2.3.0

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
@@ -406,6 +400,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.1",
+  "version": "2.3.0",
   "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,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/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/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

@@ -0,0 +1,84 @@
+'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 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 = parentResource.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') {
+          const onResolve = asyncResource.bind(() => finish(params))
+          const onReject = asyncResource.bind(e => finish(params, e))
+
+          promise.then(onResolve, onReject)
+        } 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,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
+})