dd-trace 2.3.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 {
@@ -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.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,7 +1,10 @@
 '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')
@@ -9,14 +12,19 @@ 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

@@ -55,6 +55,7 @@ function wrapRun (pl, isLatestVersion) {
       return promise
     } catch (err) {
       errorCh.publish(err)
+      throw err
     } finally {
       runEndCh.publish(undefined)
     }
@@ -85,6 +86,7 @@ function wrapRun (pl, isLatestVersion) {
       return promise
     } catch (err) {
       errorCh.publish(err)
+      throw err
     } finally {
       runStepEndCh.publish(undefined)
     }

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/mocha.js

@@ -0,0 +1,122 @@
+const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const testStartCh = channel('ci:mocha:test:start')
+const errorCh = channel('ci:mocha:test:error')
+const skipCh = channel('ci:mocha:test:skip')
+const testEndCh = channel('ci:mocha:test:end')
+const testAsyncEndCh = channel('ci:mocha:test:async-end')
+const suiteEndCh = channel('ci:mocha:suite:end')
+const hookErrorCh = channel('ci:mocha:hook:error')
+const parameterizedTestCh = channel('ci:mocha:test:parameterize')
+const testRunEndCh = channel('ci:mocha:run:end')
+
+function isRetry (test) {
+  return test._currentRetry !== undefined && test._currentRetry !== 0
+}
+
+function getAllTestsInSuite (root) {
+  const tests = []
+  function getTests (suiteOrTest) {
+    suiteOrTest.tests.forEach(test => {
+      tests.push(test)
+    })
+    suiteOrTest.suites.forEach(suite => {
+      getTests(suite)
+    })
+  }
+  getTests(root)
+  return tests
+}
+
+addHook({
+  name: 'mocha',
+  versions: ['>=5.2.0'],
+  file: 'lib/runner.js'
+}, (Runner) => {
+  shimmer.wrap(Runner.prototype, 'runTest', runTest => function () {
+    if (!testStartCh.hasSubscribers) {
+      return runTest.apply(this, arguments)
+    }
+
+    if (!isRetry(this.test)) {
+      testStartCh.publish(this.test)
+    }
+
+    this.once('test end', AsyncResource.bind(() => {
+      let status
+
+      if (this.test.pending) {
+        status = 'skipped'
+      } else if (this.test.state !== 'failed' && !this.test.timedOut) {
+        status = 'pass'
+      } else {
+        status = 'fail'
+      }
+
+      testAsyncEndCh.publish(status)
+    }))
+
+    this.once('fail', AsyncResource.bind((test, err) => {
+      errorCh.publish(err)
+    }))
+
+    this.once('pending', AsyncResource.bind((test) => {
+      skipCh.publish(test)
+    }))
+
+    try {
+      return runTest.apply(this, arguments)
+    } catch (err) {
+      errorCh.publish(err)
+      throw err
+    } finally {
+      testEndCh.publish(undefined)
+    }
+  })
+
+  shimmer.wrap(Runner.prototype, 'runTests', runTests => function () {
+    if (!suiteEndCh.hasSubscribers) {
+      return runTests.apply(this, arguments)
+    }
+    this.once('end', AsyncResource.bind(() => {
+      testRunEndCh.publish(undefined)
+    }))
+    runTests.apply(this, arguments)
+    const suite = arguments[0]
+    // We call `getAllTestsInSuite` with the root suite so every skipped test
+    // should already have an associated test span.
+    const tests = getAllTestsInSuite(suite)
+    suiteEndCh.publish(tests)
+  })
+
+  shimmer.wrap(Runner.prototype, 'fail', fail => function (hook, error) {
+    if (!hookErrorCh.hasSubscribers) {
+      return fail.apply(this, arguments)
+    }
+    if (error && hook.ctx && hook.ctx.currentTest) {
+      error.message = `${hook.title}: ${error.message}`
+      hookErrorCh.publish({ test: hook.ctx.currentTest, error })
+    }
+    return fail.apply(this, arguments)
+  })
+
+  return Runner
+})
+
+addHook({
+  name: 'mocha-each',
+  versions: ['>=2.0.1']
+}, (mochaEach) => {
+  return shimmer.wrap(mochaEach, function () {
+    const [params] = arguments
+    const { it, ...rest } = mochaEach.apply(this, arguments)
+    return {
+      it: function (name) {
+        parameterizedTestCh.publish({ name, params })
+        it.apply(this, arguments)
+      },
+      ...rest
+    }
+  })
+})