dd-trace 3.3.1 → 3.12.1

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

@@ -1,12 +1,13 @@
 'use strict'
 
 const shimmer = require('../../datadog-shimmer')
-const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+const { addHook, channel } = require('./helpers/instrument')
 
 const enterChannel = channel('apm:koa:middleware:enter')
 const exitChannel = channel('apm:koa:middleware:exit')
 const errorChannel = channel('apm:koa:middleware:error')
 const nextChannel = channel('apm:koa:middleware:next')
+const finishChannel = channel('apm:koa:middleware:finish')
 const handleChannel = channel('apm:koa:request:handle')
 const routeChannel = channel('apm:koa:request:route')
 
@@ -86,42 +87,41 @@ function wrapMiddleware (fn, layer) {
   return function (ctx, next) {
     if (!ctx || !enterChannel.hasSubscribers) return fn.apply(this, arguments)
 
-    const middlewareResource = new AsyncResource('bound-anonymous-fn')
     const req = ctx.req
 
-    return middlewareResource.runInAsyncScope(() => {
-      const path = layer && layer.path
-      const route = typeof path === 'string' && !path.endsWith('(.*)') && !path.endsWith('([^/]*)') && path
+    const path = layer && layer.path
+    const route = typeof path === 'string' && !path.endsWith('(.*)') && !path.endsWith('([^/]*)') && path
 
-      enterChannel.publish({ req, name, route })
+    enterChannel.publish({ req, name, route })
 
-      if (typeof next === 'function') {
-        arguments[1] = wrapNext(req, next)
-      }
+    if (typeof next === 'function') {
+      arguments[1] = wrapNext(req, next)
+    }
 
-      try {
-        const result = fn.apply(this, arguments)
-
-        if (result && typeof result.then === 'function') {
-          return result.then(
-            result => {
-              fulfill(ctx)
-              return result
-            },
-            err => {
-              fulfill(ctx, err)
-              throw err
-            }
-          )
-        } else {
-          fulfill(ctx)
-          return result
-        }
-      } catch (e) {
-        fulfill(ctx, e)
-        throw e
+    try {
+      const result = fn.apply(this, arguments)
+
+      if (result && typeof result.then === 'function') {
+        return result.then(
+          result => {
+            fulfill(ctx)
+            return result
+          },
+          err => {
+            fulfill(ctx, err)
+            throw err
+          }
+        )
+      } else {
+        fulfill(ctx)
+        return result
       }
-    })
+    } catch (e) {
+      fulfill(ctx, e)
+      throw e
+    } finally {
+      exitChannel.publish({ req })
+    }
   }
 }
 
@@ -138,7 +138,7 @@ function fulfill (ctx, error) {
     routeChannel.publish({ req, route })
   }
 
-  exitChannel.publish({ req })
+  finishChannel.publish({ req })
 }
 
 function wrapNext (req, next) {

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

@@ -0,0 +1,91 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+function isString (value) {
+  return typeof value === 'string' || value instanceof String
+}
+
+function getCallbackArgIndex (args) {
+  let callbackIndex = -1
+  for (let i = args.length - 1; i >= 0; i--) {
+    if (typeof args[i] === 'function') {
+      callbackIndex = i
+      break
+    }
+  }
+  return callbackIndex
+}
+
+function wrapEmitter (corkedEmitter) {
+  const callbackMap = new WeakMap()
+
+  const addListener = on => function (name, fn) {
+    if (typeof fn === 'function') {
+      let bindedFn = callbackMap.get(fn)
+      if (!bindedFn) {
+        const callbackResource = new AsyncResource('bound-anonymous-fn')
+        bindedFn = callbackResource.bind(fn)
+        callbackMap.set(fn, bindedFn)
+      }
+      arguments[1] = bindedFn
+    }
+    on.apply(this, arguments)
+  }
+  shimmer.wrap(corkedEmitter, 'on', addListener)
+  shimmer.wrap(corkedEmitter, 'addListener', addListener)
+
+  const removeListener = off => function (name, fn) {
+    if (typeof fn === 'function') {
+      const emitterOn = callbackMap.get(fn)
+      if (emitterOn) {
+        arguments[1] = emitterOn
+      }
+    }
+    off.apply(this, arguments)
+  }
+  shimmer.wrap(corkedEmitter, 'off', removeListener)
+  shimmer.wrap(corkedEmitter, 'removeListener', removeListener)
+}
+
+addHook({ name: 'ldapjs', versions: ['>=2'] }, ldapjs => {
+  const ldapSearchCh = channel('datadog:ldapjs:client:search')
+
+  shimmer.wrap(ldapjs.Client.prototype, 'search', search => function (base, options) {
+    if (ldapSearchCh.hasSubscribers) {
+      let filter
+      if (isString(options)) {
+        filter = options
+      } else if (typeof options === 'object' && options.filter) {
+        if (isString(options.filter)) {
+          filter = options.filter
+        }
+      }
+      ldapSearchCh.publish({ base, filter })
+    }
+
+    return search.apply(this, arguments)
+  })
+
+  shimmer.wrap(ldapjs.Client.prototype, '_send', _send => function () {
+    const callbackIndex = getCallbackArgIndex(arguments)
+    if (callbackIndex > -1) {
+      const callback = arguments[callbackIndex]
+      arguments[callbackIndex] = shimmer.wrap(callback, function (err, corkedEmitter) {
+        if (typeof corkedEmitter === 'object' && typeof corkedEmitter['on'] === 'function') {
+          wrapEmitter(corkedEmitter)
+        }
+        callback.apply(this, arguments)
+      })
+    }
+
+    return _send.apply(this, arguments)
+  })
+
+  return ldapjs
+})

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

@@ -0,0 +1,63 @@
+'use strict'
+
+const { channel, addHook, AsyncResource } = require('./helpers/instrument')
+
+const shimmer = require('../../datadog-shimmer')
+
+const startCh = channel('apm:mariadb:query:start')
+const finishCh = channel('apm:mariadb:query:finish')
+const errorCh = channel('apm:mariadb:query:error')
+
+function wrapCommandStart (start) {
+  return function () {
+    if (!startCh.hasSubscribers) return start.apply(this, arguments)
+
+    const callbackResource = new AsyncResource('bound-anonymous-fn')
+
+    const resolve = callbackResource.bind(this.resolve)
+    const reject = callbackResource.bind(this.reject)
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+    shimmer.wrap(this, 'resolve', function wrapResolve () {
+      return function () {
+        asyncResource.runInAsyncScope(() => {
+          finishCh.publish()
+        })
+
+        return resolve.apply(this, arguments)
+      }
+    })
+
+    shimmer.wrap(this, 'reject', function wrapReject () {
+      return function (error) {
+        asyncResource.runInAsyncScope(() => {
+          errorCh.publish(error)
+          finishCh.publish()
+        })
+
+        return reject.apply(this, arguments)
+      }
+    })
+
+    return asyncResource.runInAsyncScope(() => {
+      startCh.publish({ sql: this.sql, conf: this.opts })
+      return start.apply(this, arguments)
+    })
+  }
+}
+
+const name = 'mariadb'
+const versions = ['>=2.0.3']
+
+addHook({ name, file: 'lib/cmd/query.js', versions }, (Query) => {
+  shimmer.wrap(Query.prototype, 'start', wrapCommandStart)
+
+  return Query
+})
+
+addHook({ name, file: 'lib/cmd/execute.js', versions }, (Query) => {
+  shimmer.wrap(Query.prototype, 'start', wrapCommandStart)
+
+  return Query
+})

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

@@ -9,7 +9,6 @@ const shimmer = require('../../datadog-shimmer')
 
 addHook({ name: 'memcached', versions: ['>=2.2'] }, Memcached => {
   const startCh = channel('apm:memcached:command:start')
-  const startWithArgsCh = channel('apm:memcached:command:start:with-args')
   const finishCh = channel('apm:memcached:command:finish')
   const errorCh = channel('apm:memcached:command:error')
 
@@ -35,14 +34,12 @@ addHook({ name: 'memcached', versions: ['>=2.2'] }, Memcached => {
 
         return callback.apply(this, arguments)
       })
-      startWithArgsCh.publish({ client, server, query })
+      startCh.publish({ client, server, query })
 
       return query
     })
 
     return asyncResource.runInAsyncScope(() => {
-      startCh.publish()
-
       arguments[0] = wrappedQueryCompiler
 
       const result = command.apply(this, arguments)

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

@@ -1,5 +1,15 @@
+const { createCoverageMap } = require('istanbul-lib-coverage')
+
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
+const log = require('../../dd-trace/src/log')
+const {
+  getCoveredFilenamesFromCoverage,
+  resetCoverage,
+  mergeCoverage,
+  getTestSuitePath,
+  fromCoverageMapToCoverage
+} = require('../../dd-trace/src/plugins/util/test')
 
 const testStartCh = channel('ci:mocha:test:start')
 const errorCh = channel('ci:mocha:test:error')
@@ -7,12 +17,16 @@ const skipCh = channel('ci:mocha:test:skip')
 const testFinishCh = channel('ci:mocha:test:finish')
 const parameterizedTestCh = channel('ci:mocha:test:parameterize')
 
-const testRunStartCh = channel('ci:mocha:run:start')
-const testRunFinishCh = channel('ci:mocha:run:finish')
+const itrConfigurationCh = channel('ci:mocha:itr-configuration')
+const skippableSuitesCh = channel('ci:mocha:test-suite:skippable')
+
+const testSessionStartCh = channel('ci:mocha:session:start')
+const testSessionFinishCh = channel('ci:mocha:session:finish')
 
 const testSuiteStartCh = channel('ci:mocha:test-suite:start')
 const testSuiteFinishCh = channel('ci:mocha:test-suite:finish')
 const testSuiteErrorCh = channel('ci:mocha:test-suite:error')
+const testSuiteCodeCoverageCh = channel('ci:mocha:test-suite:code-coverage')
 
 // TODO: remove when root hooks and fixtures are implemented
 const patched = new WeakSet()
@@ -21,6 +35,11 @@ const testToAr = new WeakMap()
 const originalFns = new WeakMap()
 const testFileToSuiteAr = new Map()
 
+// We'll preserve the original coverage here
+const originalCoverageMap = createCoverageMap()
+
+let suitesToSkip = []
+
 function getSuitesByTestFile (root) {
   const suitesByTestFile = {}
   function getSuites (suite) {
@@ -46,13 +65,13 @@ function getSuitesByTestFile (root) {
 }
 
 function getTestStatus (test) {
-  if (test.pending) {
+  if (test.isPending()) {
     return 'skip'
   }
-  if (test.state !== 'failed' && !test.timedOut) {
-    return 'pass'
+  if (test.isFailed() || test.timedOut) {
+    return 'fail'
   }
-  return 'fail'
+  return 'pass'
 }
 
 function isRetry (test) {
@@ -70,6 +89,12 @@ function getTestAsyncResource (test) {
   return testToAr.get(originalFn)
 }
 
+function getSuitesToRun (originalSuites) {
+  return originalSuites.filter(suite =>
+    !suitesToSkip.includes(getTestSuitePath(suite.file, process.cwd()))
+  )
+}
+
 function mochaHook (Runner) {
   if (patched.has(Runner)) return Runner
 
@@ -92,13 +117,18 @@ function mochaHook (Runner) {
         status = 'fail'
       }
       testFileToSuiteAr.clear()
-      testRunFinishCh.publish(status)
+
+      const isSuitesSkipped = !!suitesToSkip.length
+
+      testSessionFinishCh.publish({ status, isSuitesSkipped })
+      // restore the original coverage
+      global.__coverage__ = fromCoverageMapToCoverage(originalCoverageMap)
     }))
 
     this.once('start', testRunAsyncResource.bind(function () {
       const processArgv = process.argv.slice(2).join(' ')
       const command = `mocha ${processArgv}`
-      testRunStartCh.publish(command)
+      testSessionStartCh.publish(command)
     }))
 
     this.on('suite', function (suite) {
@@ -140,9 +170,21 @@ function mochaHook (Runner) {
         })
       }
 
+      if (global.__coverage__) {
+        const coverageFiles = getCoveredFilenamesFromCoverage(global.__coverage__)
+
+        testSuiteCodeCoverageCh.publish({
+          coverageFiles,
+          suiteFile: suite.file
+        })
+        // We need to reset coverage to get a code coverage per suite
+        // Before that, we preserve the original coverage
+        mergeCoverage(global.__coverage__, originalCoverageMap)
+        resetCoverage(global.__coverage__)
+      }
+
       const asyncResource = testFileToSuiteAr.get(suite.file)
       asyncResource.runInAsyncScope(() => {
-        // get suite status
         testSuiteFinishCh.publish(status)
       })
     })
@@ -229,7 +271,8 @@ function mochaHook (Runner) {
           skipCh.publish(test)
         })
       } else {
-        // if there is no async resource, the test has been skipped through `test.skip``
+        // if there is no async resource, the test has been skipped through `test.skip`
+        // or the parent suite is skipped
         const skippedTestAsyncResource = new AsyncResource('bound-anonymous-fn')
         if (test.fn) {
           testToAr.set(test.fn, skippedTestAsyncResource)
@@ -245,13 +288,6 @@ function mochaHook (Runner) {
     return run.apply(this, arguments)
   })
 
-  shimmer.wrap(Runner.prototype, 'runTests', runTests => function () {
-    if (!testRunFinishCh.hasSubscribers) {
-      return runTests.apply(this, arguments)
-    }
-    return runTests.apply(this, arguments)
-  })
-
   return Runner
 }
 
@@ -273,18 +309,93 @@ function mochaEachHook (mochaEach) {
   })
 }
 
+addHook({
+  name: 'mocha',
+  versions: ['>=5.2.0'],
+  file: 'lib/mocha.js'
+}, (Mocha) => {
+  const mochaRunAsyncResource = new AsyncResource('bound-anonymous-fn')
+
+  /**
+   * Get ITR configuration and skippable suites
+   * If ITR is disabled, `onDone` is called immediately on the subscriber
+   */
+  shimmer.wrap(Mocha.prototype, 'run', run => function () {
+    if (!itrConfigurationCh.hasSubscribers) {
+      return run.apply(this, arguments)
+    }
+    this.options.delay = true
+
+    const runner = run.apply(this, arguments)
+
+    const onReceivedSkippableSuites = ({ err, skippableSuites }) => {
+      if (err) {
+        log.error(err)
+        suitesToSkip = []
+      } else {
+        suitesToSkip = skippableSuites
+      }
+      // We remove the suites that we skip through ITR
+      runner.suite.suites = getSuitesToRun(runner.suite.suites)
+      global.run()
+    }
+
+    const onReceivedConfiguration = ({ err }) => {
+      if (err) {
+        log.error(err)
+        return global.run()
+      }
+      if (!skippableSuitesCh.hasSubscribers) {
+        return global.run()
+      }
+
+      skippableSuitesCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
+      })
+    }
+
+    mochaRunAsyncResource.runInAsyncScope(() => {
+      itrConfigurationCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedConfiguration)
+      })
+    })
+    return runner
+  })
+  return Mocha
+})
+
 addHook({
   name: 'mocha',
   versions: ['>=5.2.0'],
   file: 'lib/runner.js'
 }, mochaHook)
 
+addHook({
+  name: 'mocha',
+  versions: ['>=5.2.0'],
+  file: 'lib/cli/run-helpers.js'
+}, (run) => {
+  shimmer.wrap(run, 'runMocha', runMocha => async function () {
+    const mocha = arguments[0]
+    /**
+     * This attaches `run` to the global context, which we'll call after
+     * our configuration and skippable suites requests
+     */
+    mocha.options.delay = true
+    return runMocha.apply(this, arguments)
+  })
+  return run
+})
+
 addHook({
   name: 'mocha',
   versions: ['>=5.2.0'],
   file: 'lib/runnable.js'
 }, (Runnable) => {
   shimmer.wrap(Runnable.prototype, 'run', run => function () {
+    if (!testStartCh.hasSubscribers) {
+      return run.apply(this, arguments)
+    }
     const isBeforeEach = this.parent._beforeEach.includes(this)
     const isAfterEach = this.parent._afterEach.includes(this)
 
@@ -300,13 +411,15 @@ addHook({
       const test = isTestHook ? this.ctx.currentTest : this
       const asyncResource = getTestAsyncResource(test)
 
-      // we bind the test fn to the correct async resource
-      const newFn = asyncResource.bind(this.fn)
+      if (asyncResource) {
+        // we bind the test fn to the correct async resource
+        const newFn = asyncResource.bind(this.fn)
 
-      // we store the original function, not to lose it
-      originalFns.set(newFn, this.fn)
+        // we store the original function, not to lose it
+        originalFns.set(newFn, this.fn)
 
-      this.fn = newFn
+        this.fn = newFn
+      }
     }
 
     return run.apply(this, arguments)
@@ -318,5 +431,3 @@ addHook({
   name: 'mocha-each',
   versions: ['>=2.0.1']
 }, mochaEachHook)
-
-module.exports = { mochaHook, mochaEachHook }

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

@@ -99,12 +99,16 @@ function instrument (req, res, handler) {
     try {
       const promise = handler()
 
+      // promise should only reject when propagateError is true:
+      // https://github.com/vercel/next.js/blob/cee656238a/packages/next/server/api-utils/node.ts#L547
       return promise.then(
         result => finish(req, res, result),
         err => finish(req, res, null, err)
       )
     } catch (e) {
-      finish(req, res, null, e)
+      // this will probably never happen as the handler caller is an async function:
+      // https://github.com/vercel/next.js/blob/cee656238a/packages/next/server/api-utils/node.ts#L420
+      return finish(req, res, null, e)
     }
   })
 }
@@ -116,7 +120,11 @@ function finish (req, res, result, err) {
 
   finishChannel.publish({ req, res })
 
-  return result || err
+  if (err) {
+    throw err
+  }
+
+  return result
 }
 
 addHook({ name: 'next', versions: ['>=11.1'], file: 'dist/server/next-server.js' }, nextServer => {

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

@@ -0,0 +1,10 @@
+'use strict'
+
+const { addHook } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+const { createWrapRequest } = require('./elasticsearch')
+
+addHook({ name: '@opensearch-project/opensearch', file: 'lib/Transport.js', versions: ['>=1'] }, Transport => {
+  shimmer.wrap(Transport.prototype, 'request', createWrapRequest('opensearch'))
+  return Transport
+})

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

@@ -10,21 +10,21 @@ const shimmer = require('../../datadog-shimmer')
 const connectionAttributes = new WeakMap()
 const poolAttributes = new WeakMap()
 
-const executeStartChannel = channel('apm:oracledb:execute:start')
-const executeErrorChannel = channel('apm:oracledb:execute:error')
-const executeFinishChannel = channel('apm:oracledb:execute:finish')
+const startChannel = channel('apm:oracledb:query:start')
+const errorChannel = channel('apm:oracledb:query:error')
+const finishChannel = channel('apm:oracledb:query:finish')
 
 function finish (err) {
   if (err) {
-    executeErrorChannel.publish(err)
+    errorChannel.publish(err)
   }
-  executeFinishChannel.publish(undefined)
+  finishChannel.publish(undefined)
 }
 
 addHook({ name: 'oracledb', versions: ['5'] }, oracledb => {
   shimmer.wrap(oracledb.Connection.prototype, 'execute', execute => {
     return function wrappedExecute (dbQuery, ...args) {
-      if (!executeStartChannel.hasSubscribers) {
+      if (!startChannel.hasSubscribers) {
         return execute.apply(this, arguments)
       }
 
@@ -39,7 +39,7 @@ addHook({ name: 'oracledb', versions: ['5'] }, oracledb => {
 
       return new AsyncResource('apm:oracledb:inner-scope').runInAsyncScope(() => {
         const connAttrs = connectionAttributes.get(this)
-        executeStartChannel.publish({ query: dbQuery, connAttrs })
+        startChannel.publish({ query: dbQuery, connAttrs })
         try {
           let result = execute.apply(this, arguments)
 
@@ -58,7 +58,7 @@ addHook({ name: 'oracledb', versions: ['5'] }, oracledb => {
 
           return result
         } catch (err) {
-          executeErrorChannel.publish(err)
+          errorChannel.publish(err)
           throw err
         }
       })

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

@@ -37,12 +37,16 @@ function wrapQuery (query) {
       return retval
     }
 
-    const statement = pgQuery.text
     const callbackResource = new AsyncResource('bound-anonymous-fn')
     const asyncResource = new AsyncResource('bound-anonymous-fn')
-
+    const processId = this.processID
     return asyncResource.runInAsyncScope(() => {
-      startCh.publish({ params: this.connectionParameters, statement })
+      startCh.publish({
+        params: this.connectionParameters,
+        originalQuery: pgQuery.text,
+        query: pgQuery,
+        processId
+      })
 
       const finish = asyncResource.bind(function (error) {
         if (error) {

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

@@ -0,0 +1,24 @@
+'use strict'
+
+const { addHook, channel } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const qsParseCh = channel('datadog:qs:parse:finish')
+
+function wrapParse (originalParse) {
+  return function () {
+    const qsParsedObj = originalParse.apply(this, arguments)
+    if (qsParseCh.hasSubscribers && qsParsedObj) {
+      qsParseCh.publish({ qs: qsParsedObj })
+    }
+    return qsParsedObj
+  }
+}
+
+addHook({
+  name: 'qs',
+  versions: ['>=1']
+}, qs => {
+  shimmer.wrap(qs, 'parse', wrapParse)
+  return qs
+})