dd-trace 2.2.1 → 2.4.0

package/index.d.ts

@@ -108,6 +108,13 @@ export declare interface Tracer extends opentracing.Tracer {
    * should not be cached.
    */
   getRumData(): string;
+
+  /**
+   * Links an authenticated user to the current trace.
+   * @param {User} user Properties of the authenticated user. Accepts custom fields.
+   * @returns {Tracer} The Tracer instance for chaining.
+   */
+  setUser(user: User): Tracer;
 }
 
 export declare interface TraceOptions extends Analyzable {
@@ -266,6 +273,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
@@ -305,6 +318,7 @@ export declare interface TracerOptions {
    */
   experimental?: boolean | {
     b3?: boolean
+    traceparent?: boolean
 
     /**
      * Whether to add an auto-generated `runtime-id` tag to metrics.
@@ -418,6 +432,49 @@ export declare interface TracerOptions {
   };
 }
 
+/**
+ * User object that can be passed to `tracer.setUser()`.
+ */
+ export declare interface User {
+  /**
+   * Unique identifier of the user.
+   * Mandatory.
+   */
+  id: string,
+
+  /**
+   * Email of the user.
+   */
+  email?: string,
+
+  /**
+   * User-friendly name of the user.
+   */
+  name?: string,
+
+  /**
+   * Session ID of the user.
+   */
+  session_id?: string,
+
+  /**
+   * Role the user is making the request under.
+   */
+  role?: string,
+
+  /**
+   * Scopes or granted authorizations the user currently possesses.
+   * The value could come from the scope associated with an OAuth2
+   * Access Token or an attribute value in a SAML 2 Assertion.
+   */
+  scope?: string,
+
+  /**
+   * Custom fields to attach to the user (RBAC, Oauth, etc…).
+   */
+  [key: string]: string | undefined
+}
+
 /** @hidden */
 interface EventEmitter {
   emit(eventName: string | symbol, ...args: any[]): any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "2.2.1",
+  "version": "2.4.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -61,7 +61,7 @@
     "node": ">=12"
   },
   "dependencies": {
-    "@datadog/native-appsec": "^0.8.1",
+    "@datadog/native-appsec": "^0.8.2",
     "@datadog/native-metrics": "^1.1.0",
     "@datadog/pprof": "^0.3.0",
     "@datadog/sketches-js": "^1.0.4",

package/packages/datadog-instrumentations/index.js

@@ -1,21 +1,30 @@
 'use strict'
 
+require('./src/amqplib')
+require('./src/amqp10')
 require('./src/bluebird')
 require('./src/bunyan')
+require('./src/cassandra-driver')
 require('./src/couchbase')
+require('./src/cucumber')
 require('./src/dns')
 require('./src/elasticsearch')
 require('./src/generic-pool')
 require('./src/ioredis')
 require('./src/memcached')
+require('./src/mongodb-core')
 require('./src/mongoose')
 require('./src/mysql')
 require('./src/mysql2')
+require('./src/mocha')
 require('./src/pino')
+require('./src/pg')
 require('./src/promise')
 require('./src/promise-js')
 require('./src/q')
 require('./src/redis')
+require('./src/rhea')
 require('./src/sharedb')
+require('./src/tedious')
 require('./src/when')
 require('./src/winston')

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

@@ -0,0 +1,70 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+addHook({ name: 'amqp10', file: 'lib/sender_link.js', versions: ['>=3'] }, SenderLink => {
+  const startCh = channel('apm:amqp10:send:start')
+  const asyncEndCh = channel('apm:amqp10:send:async-end')
+  const endCh = channel('apm:amqp10:send:end')
+  const errorCh = channel('apm:amqp10:send:error')
+  shimmer.wrap(SenderLink.prototype, 'send', send => function (msg, options) {
+    if (!startCh.hasSubscribers) {
+      return send.apply(this, arguments)
+    }
+    startCh.publish({ link: this })
+    try {
+      const promise = send.apply(this, arguments)
+
+      if (!promise) {
+        finish(asyncEndCh, errorCh)
+        return promise
+      }
+
+      const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+      promise.then(asyncResource.bind(() => finish(asyncEndCh, errorCh)),
+        asyncResource.bind(e => finish(asyncEndCh, errorCh, e)))
+
+      return promise
+    } catch (err) {
+      finish(asyncEndCh, errorCh, err)
+      throw err
+    } finally {
+      endCh.publish(undefined)
+    }
+  })
+  return SenderLink
+})
+
+addHook({ name: 'amqp10', file: 'lib/receiver_link.js', versions: ['>=3'] }, ReceiverLink => {
+  const startCh = channel('apm:amqp10:receive:start')
+  const endCh = channel('apm:amqp10:receive:end')
+  const errorCh = channel('apm:amqp10:receive:error')
+  shimmer.wrap(ReceiverLink.prototype, '_messageReceived', messageReceived => function (transferFrame) {
+    if (!transferFrame || transferFrame.aborted || transferFrame.more) {
+      return messageReceived.apply(this, arguments)
+    }
+    startCh.publish({ link: this })
+    try {
+      return messageReceived.apply(this, arguments)
+    } catch (err) {
+      errorCh.publish(err)
+      throw err
+    } finally {
+      endCh.publish(undefined)
+    }
+  })
+  return ReceiverLink
+})
+
+function finish (asyncEndCh, errorCh, error) {
+  if (error) {
+    errorCh.publish(error)
+  }
+  asyncEndCh.publish(undefined)
+}

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

@@ -0,0 +1,58 @@
+'use strict'
+
+const {
+  channel,
+  addHook
+} = require('./helpers/instrument')
+const kebabCase = require('lodash.kebabcase')
+const shimmer = require('../../datadog-shimmer')
+
+const startCh = channel('apm:amqplib:command:start')
+const endCh = channel('apm:amqplib:command:end')
+const errorCh = channel('apm:amqplib:command:error')
+
+let methods = {}
+
+addHook({ name: 'amqplib', file: 'lib/defs.js', versions: ['>=0.5'] }, defs => {
+  methods = Object.keys(defs)
+    .filter(key => Number.isInteger(defs[key]))
+    .filter(key => isCamelCase(key))
+    .reduce((acc, key) => Object.assign(acc, { [defs[key]]: kebabCase(key).replace('-', '.') }), {})
+  return defs
+})
+
+addHook({ name: 'amqplib', file: 'lib/channel.js', versions: ['>=0.5'] }, channel => {
+  shimmer.wrap(channel.Channel.prototype, 'sendImmediately', sendImmediately => function (method, fields) {
+    return instrument(sendImmediately, this, arguments, methods[method], fields)
+  })
+
+  shimmer.wrap(channel.Channel.prototype, 'sendMessage', sendMessage => function (fields) {
+    return instrument(sendMessage, this, arguments, 'basic.publish', fields)
+  })
+
+  shimmer.wrap(channel.BaseChannel.prototype, 'dispatchMessage', dispatchMessage => function (fields, message) {
+    return instrument(dispatchMessage, this, arguments, 'basic.deliver', fields, message)
+  })
+  return channel
+})
+
+function instrument (send, channel, args, method, fields, message) {
+  if (!startCh.hasSubscribers) {
+    return send.apply(this, arguments)
+  }
+  startCh.publish({ channel, method, fields, message })
+
+  try {
+    return send.apply(channel, args)
+  } catch (err) {
+    errorCh.publish(err)
+
+    throw err
+  } finally {
+    endCh.publish(undefined)
+  }
+}
+
+function isCamelCase (str) {
+  return /([A-Z][a-z0-9]+)+/.test(str)
+}

package/packages/datadog-instrumentations/src/cassandra-driver.js

@@ -0,0 +1,191 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const startCh = channel('apm:cassandra:query:start')
+const asyncEndCh = channel('apm:cassandra:query:async-end')
+const endCh = channel('apm:cassandra:query:end')
+const errorCh = channel('apm:cassandra:query:error')
+const addConnectionCh = channel(`apm:cassandra:query:addConnection`)
+
+addHook({ name: 'cassandra-driver', versions: ['>=3.0.0'] }, cassandra => {
+  shimmer.wrap(cassandra.Client.prototype, 'batch', batch => function (queries, options, callback) {
+    if (!startCh.hasSubscribers) {
+      return batch.apply(this, arguments)
+    }
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    startCh.publish({ keyspace: this.keyspace, query: queries })
+
+    const lastIndex = arguments.length - 1
+    let cb = arguments[lastIndex]
+
+    if (typeof cb === 'function') {
+      cb = asyncResource.bind(cb)
+      arguments[lastIndex] = wrapCallback(asyncEndCh, errorCh, cb)
+    }
+
+    try {
+      const res = batch.apply(this, arguments)
+      if (typeof res === 'function' || !res) {
+        return wrapCallback(asyncEndCh, errorCh, res)
+      } else {
+        const promiseAsyncResource = new AsyncResource('bound-anonymous-fn')
+        return res.then(
+          promiseAsyncResource.bind(() => finish(asyncEndCh, errorCh)),
+          promiseAsyncResource.bind(err => finish(asyncEndCh, errorCh, err))
+        )
+      }
+    } catch (e) {
+      finish(asyncEndCh, errorCh, e)
+      throw e
+    } finally {
+      endCh.publish(undefined)
+    }
+  })
+  return cassandra
+})
+
+addHook({ name: 'cassandra-driver', versions: ['>=4.4'] }, cassandra => {
+  shimmer.wrap(cassandra.Client.prototype, '_execute', _execute => function (query, params, execOptions, callback) {
+    if (!startCh.hasSubscribers) {
+      return _execute.apply(this, arguments)
+    }
+    startCh.publish({ keyspace: this.keyspace, query })
+    const promise = _execute.apply(this, arguments)
+
+    const promiseAsyncResource = new AsyncResource('bound-anonymous-fn')
+
+    promise.then(
+      promiseAsyncResource.bind(() => finish(asyncEndCh, errorCh)),
+      promiseAsyncResource.bind(err => finish(asyncEndCh, errorCh, err))
+    )
+    endCh.publish(undefined)
+    return promise
+  })
+  return cassandra
+})
+
+addHook({ name: 'cassandra-driver', versions: ['3 - 4.3'] }, cassandra => {
+  shimmer.wrap(cassandra.Client.prototype, '_innerExecute', _innerExecute =>
+    function (query, params, execOptions, callback) {
+      if (!startCh.hasSubscribers) {
+        return _innerExecute.apply(this, arguments)
+      }
+      const asyncResource = new AsyncResource('bound-anonymous-fn')
+      const isValid = (args) => {
+        return args.length === 4 || typeof args[3] === 'function'
+      }
+
+      if (!isValid(arguments)) {
+        return _innerExecute.apply(this, arguments)
+      }
+
+      startCh.publish({ keyspace: this.keyspace, query })
+
+      const lastIndex = arguments.length - 1
+      let cb = arguments[lastIndex]
+
+      if (typeof cb === 'function') {
+        cb = asyncResource.bind(cb)
+        arguments[lastIndex] = wrapCallback(asyncEndCh, errorCh, cb)
+      }
+
+      try {
+        return _innerExecute.apply(this, arguments)
+      } catch (e) {
+        finish(asyncEndCh, errorCh, e)
+        throw e
+      } finally {
+        endCh.publish(undefined)
+      }
+    }
+  )
+  return cassandra
+})
+
+addHook({ name: 'cassandra-driver', versions: ['>=3.3'], file: 'lib/request-execution.js' }, RequestExecution => {
+  shimmer.wrap(RequestExecution.prototype, '_sendOnConnection', _sendOnConnection => function () {
+    if (!startCh.hasSubscribers) {
+      return _sendOnConnection.apply(this, arguments)
+    }
+    addConnectionCh.publish({ address: this._connection.address, port: this._connection.port })
+    return _sendOnConnection.apply(this, arguments)
+  })
+  return RequestExecution
+})
+
+addHook({ name: 'cassandra-driver', versions: ['3.3 - 4.3'], file: 'lib/request-execution.js' }, RequestExecution => {
+  shimmer.wrap(RequestExecution.prototype, 'start', start => function (getHostCallback) {
+    if (!startCh.hasSubscribers) {
+      return getHostCallback.apply(this, arguments)
+    }
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    const execution = this
+
+    if (!isRequestValid(this, arguments, 1)) {
+      return start.apply(this, arguments)
+    }
+
+    getHostCallback = asyncResource.bind(getHostCallback)
+
+    arguments[0] = AsyncResource.bind(function () {
+      addConnectionCh.publish({ address: execution._connection.address, port: execution._connection.port })
+      return getHostCallback.apply(this, arguments)
+    })
+
+    return start.apply(this, arguments)
+  })
+  return RequestExecution
+})
+
+addHook({ name: 'cassandra-driver', versions: ['3 - 3.2'], file: 'lib/request-handler.js' }, RequestHandler => {
+  shimmer.wrap(RequestHandler.prototype, 'send', send => function (request, options, callback) {
+    if (!startCh.hasSubscribers) {
+      return send.apply(this, arguments)
+    }
+    const handler = this
+
+    if (!isRequestValid(this, arguments, 3)) {
+      return send.apply(this, arguments)
+    }
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+    callback = asyncResource.bind(callback)
+
+    arguments[2] = AsyncResource.bind(function () {
+      addConnectionCh.publish({ address: handler.connection.address, port: handler.connection.port })
+      return callback.apply(this, arguments)
+    })
+
+    return send.apply(this, arguments)
+  })
+  return RequestHandler
+})
+
+function finish (asyncEndCh, errorCh, error) {
+  if (error) {
+    errorCh.publish(error)
+  }
+  asyncEndCh.publish(undefined)
+}
+
+function wrapCallback (asyncEndCh, errorCh, callback) {
+  return AsyncResource.bind(function (err) {
+    finish(asyncEndCh, errorCh, err)
+    if (callback) {
+      return callback.apply(this, arguments)
+    }
+  })
+}
+
+function isRequestValid (exec, args, length) {
+  if (!exec) return false
+  if (args.length !== length || typeof args[length - 1] !== 'function') return false
+
+  return true
+}

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

@@ -0,0 +1,118 @@
+'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)
+      throw 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)
+      throw 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

@@ -35,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)
         })
@@ -54,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/helpers/instrument.js

@@ -20,11 +20,11 @@ exports.channel = function channel (name) {
 }
 
 exports.addHook = function addHook ({ name, versions, file }, hook) {
-  file = filename(name, file)
+  const fullFilename = filename(name, file)
   const loaderHook = (moduleExports, moduleName, moduleBaseDir) => {
     moduleName = moduleName.replace(pathSepExpr, '/')
     const moduleVersion = getVersion(moduleBaseDir)
-    if (moduleName !== file || !matchVersion(moduleVersion, versions)) {
+    if (moduleName !== fullFilename || !matchVersion(moduleVersion, versions)) {
       return moduleExports
     }
     return hook(moduleExports)
@@ -65,7 +65,7 @@ function cjsPostLoad (instrumentation, hook) {
     if (!id.includes(`/node_modules/${instrumentation.name}/`)) continue
 
     if (instrumentation.file) {
-      if (!id.endsWith(`/node_modules/${filename(instrumentation)}`)) continue
+      if (!id.endsWith(`/node_modules/${filename(instrumentation.name, instrumentation.file)}`)) continue
 
       const basedir = getBasedir(ids[i])
 

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

@@ -2,7 +2,8 @@
 
 const {
   channel,
-  addHook
+  addHook,
+  AsyncResource
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -21,12 +22,14 @@ addHook({ name: 'ioredis', versions: ['>=2'] }, Redis => {
     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)
-    )
+    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)