dd-trace 2.3.0 → 2.4.1

package/ci/init.js

@@ -1,12 +1,36 @@
+const path = require('path')
 const tracer = require('../packages/dd-trace')
 const { ORIGIN_KEY } = require('../packages/dd-trace/src/constants')
+const { mochaHook } = require('../packages/datadog-instrumentations/src/mocha')
+const { pickleHook, testCaseHook } = require('../packages/datadog-instrumentations/src/cucumber')
 
-tracer.init({
+const options = {
   startupLogs: false,
   tags: {
     [ORIGIN_KEY]: 'ciapp-test'
   }
-})
+}
+
+// TODO: remove this in a later major version since we now recommend using
+// `NODE_OPTIONS='-r dd-trace/ci/init'`.
+try {
+  for (const filename in require.cache) {
+    const cache = require.cache[filename]
+    const id = filename.split(path.sep).join('/')
+
+    if (id.includes('/node_modules/mocha/lib/runner.js')) {
+      cache.exports = mochaHook(cache.exports)
+    } else if (id.includes('/node_modules/@cucumber/cucumber/lib/runtime/pickle_runner.js')) {
+      cache.exports = pickleHook(cache.exports)
+    } else if (id.includes('/node_modules/@cucumber/cucumber/lib/runtime/test_case_runner.js')) {
+      cache.exports = testCaseHook(cache.exports)
+    }
+  }
+} catch (e) {
+  // ignore error and let the tracer initialize anyway
+}
+
+tracer.init(options)
 
 tracer.use('fs', false)
 

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 {
@@ -311,6 +318,7 @@ export declare interface TracerOptions {
    */
   experimental?: boolean | {
     b3?: boolean
+    traceparent?: boolean
 
     /**
      * Whether to add an auto-generated `runtime-id` tag to metrics.
@@ -424,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.3.0",
+  "version": "2.4.1",
   "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.3",
     "@datadog/native-metrics": "^1.1.0",
     "@datadog/pprof": "^0.3.0",
     "@datadog/sketches-js": "^1.0.4",

package/packages/datadog-instrumentations/index.js

@@ -1,22 +1,32 @@
 '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/http')
 require('./src/ioredis')
 require('./src/memcached')
+require('./src/mongodb-core')
 require('./src/mongoose')
 require('./src/mysql')
 require('./src/mysql2')
+require('./src/mocha')
+require('./src/net')
 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

@@ -10,6 +10,9 @@ const runStepStartCh = channel('ci:cucumber:run-step:start')
 const runStepEndCh = channel('ci:cucumber:run-step:end')
 const errorCh = channel('ci:cucumber:error')
 
+// TODO: remove in a later major version
+const patched = new WeakSet()
+
 function getStatusFromResult (result) {
   if (result.status === 1) {
     return { status: 'pass' }
@@ -37,6 +40,10 @@ function getStatusFromResultLatest (result) {
 }
 
 function wrapRun (pl, isLatestVersion) {
+  if (patched.has(pl)) return
+
+  patched.add(pl)
+
   shimmer.wrap(pl.prototype, 'run', run => function () {
     if (!runStartCh.hasSubscribers) {
       return run.apply(this, arguments)
@@ -55,6 +62,7 @@ function wrapRun (pl, isLatestVersion) {
       return promise
     } catch (err) {
       errorCh.publish(err)
+      throw err
     } finally {
       runEndCh.publish(undefined)
     }
@@ -85,32 +93,39 @@ function wrapRun (pl, isLatestVersion) {
       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) => {
+function pickleHook (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) => {
+function testCaseHook (TestCaseRunner) {
   const pl = TestCaseRunner.default
 
   wrapRun(pl, true)
 
   return TestCaseRunner
-})
+}
+
+addHook({
+  name: '@cucumber/cucumber',
+  versions: ['7.0.0 - 7.2.1'],
+  file: 'lib/runtime/pickle_runner.js'
+}, pickleHook)
+
+addHook({
+  name: '@cucumber/cucumber',
+  versions: ['>=7.3.0'],
+  file: 'lib/runtime/test_case_runner.js'
+}, testCaseHook)
+
+module.exports = { pickleHook, testCaseHook }

package/packages/datadog-instrumentations/src/helpers/hook.js

@@ -0,0 +1,44 @@
+'use strict'
+
+const path = require('path')
+const iitm = require('../../../dd-trace/src/iitm')
+const ritm = require('../../../dd-trace/src/ritm')
+
+function Hook (modules, onrequire) {
+  if (!(this instanceof Hook)) return new Hook(modules, onrequire)
+
+  this._patched = Object.create(null)
+
+  const safeHook = (moduleExports, moduleName, moduleBaseDir) => {
+    const parts = [moduleBaseDir, moduleName].filter(v => v)
+    const filename = path.join(...parts)
+
+    if (this._patched[filename]) return moduleExports
+
+    this._patched[filename] = true
+
+    return onrequire(moduleExports, moduleName, moduleBaseDir)
+  }
+
+  this._ritmHook = ritm(modules, {}, safeHook)
+  this._iitmHook = iitm(modules, {}, (moduleExports, moduleName, moduleBaseDir) => {
+    // TODO: Move this logic to import-in-the-middle and only do it for CommonJS
+    // modules and not ESM. In the meantime, all the modules we instrument are
+    // CommonJS modules for which the default export is always moved to
+    // `default` anyway.
+    if (moduleExports && moduleExports.default) {
+      moduleExports.default = safeHook(moduleExports.default, moduleName, moduleBaseDir)
+      return moduleExports
+    } else {
+      return safeHook(moduleExports, moduleName, moduleBaseDir)
+    }
+  })
+}
+
+Hook.prototype.unhook = function () {
+  this._ritmHook.unhook()
+  this._iitmHook.unhook()
+  this._patched = Object.create(null)
+}
+
+module.exports = Hook