dd-trace 3.3.1 → 3.12.1

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

@@ -7,76 +7,80 @@ const {
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
-const startCh = channel('apm:elasticsearch:query:start')
-const finishCh = channel('apm:elasticsearch:query:finish')
-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)
+  shimmer.wrap(exports.default.prototype, 'request', createWrapRequest('elasticsearch'))
   return exports
 })
 
 addHook({ name: '@elastic/elasticsearch', file: 'lib/Transport.js', versions: ['>=5.6.16 <8', '>=8'] }, Transport => {
-  shimmer.wrap(Transport.prototype, 'request', wrapRequest)
+  shimmer.wrap(Transport.prototype, 'request', createWrapRequest('elasticsearch'))
   return Transport
 })
 
 addHook({ name: 'elasticsearch', file: 'src/lib/transport.js', versions: ['>=10'] }, Transport => {
-  shimmer.wrap(Transport.prototype, 'request', wrapRequest)
+  shimmer.wrap(Transport.prototype, 'request', createWrapRequest('elasticsearch'))
   return Transport
 })
 
-function wrapRequest (request) {
-  return function (params, options, cb) {
-    if (!startCh.hasSubscribers) {
-      return request.apply(this, arguments)
-    }
+function createWrapRequest (name) {
+  const startCh = channel(`apm:${name}:query:start`)
+  const finishCh = channel(`apm:${name}:query:finish`)
+  const errorCh = channel(`apm:${name}:query:error`)
 
-    if (!params) return request.apply(this, arguments)
+  return function wrapRequest (request) {
+    return function (params, options, cb) {
+      if (!startCh.hasSubscribers) {
+        return request.apply(this, arguments)
+      }
 
-    const parentResource = new AsyncResource('bound-anonymous-fn')
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
+      if (!params) return request.apply(this, arguments)
 
-    return asyncResource.runInAsyncScope(() => {
-      startCh.publish({ params })
+      const parentResource = new AsyncResource('bound-anonymous-fn')
+      const asyncResource = new AsyncResource('bound-anonymous-fn')
 
-      try {
-        const lastIndex = arguments.length - 1
-        cb = arguments[lastIndex]
+      return asyncResource.runInAsyncScope(() => {
+        startCh.publish({ params })
 
-        if (typeof cb === 'function') {
-          cb = parentResource.bind(cb)
+        try {
+          const lastIndex = arguments.length - 1
+          cb = arguments[lastIndex]
 
-          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))
+          if (typeof cb === 'function') {
+            cb = parentResource.bind(cb)
 
-            promise.then(onResolve, onReject)
+            arguments[lastIndex] = asyncResource.bind(function (error) {
+              finish(params, error)
+              return cb.apply(null, arguments)
+            })
+            return request.apply(this, arguments)
           } else {
-            finish(params)
+            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
           }
-          return promise
-        }
-      } catch (err) {
-        err.stack // trigger getting the stack at the original throwing point
-        errorCh.publish(err)
+        } catch (err) {
+          err.stack // trigger getting the stack at the original throwing point
+          errorCh.publish(err)
 
-        throw err
-      }
-    })
+          throw err
+        }
+      })
+    }
   }
-}
 
-function finish (params, error) {
-  if (error) {
-    errorCh.publish(error)
+  function finish (params, error) {
+    if (error) {
+      errorCh.publish(error)
+    }
+    finishCh.publish({ params })
   }
-  finishCh.publish({ params })
 }
+
+module.exports = { createWrapRequest }

package/packages/datadog-instrumentations/src/google-cloud-pubsub.js

@@ -65,7 +65,7 @@ addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'] }, (obj) => {
       try {
         return emit.apply(this, arguments)
       } catch (err) {
-        receiveErrorCh.publish({ err, message })
+        receiveErrorCh.publish(err)
         throw err
       }
     })

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

@@ -8,14 +8,20 @@ module.exports = {
   '@grpc/grpc-js': () => require('../grpc'),
   '@hapi/hapi': () => require('../hapi'),
   '@jest/core': () => require('../jest'),
+  '@jest/reporters': () => require('../jest'),
   '@koa/router': () => require('../koa'),
   '@node-redis/client': () => require('../redis'),
+  '@opensearch-project/opensearch': () => require('../opensearch'),
+  '@redis/client': () => require('../redis'),
   'amqp10': () => require('../amqp10'),
   'amqplib': () => require('../amqplib'),
   'aws-sdk': () => require('../aws-sdk'),
   'bluebird': () => require('../bluebird'),
+  'body-parser': () => require('../body-parser'),
   'bunyan': () => require('../bunyan'),
   'cassandra-driver': () => require('../cassandra-driver'),
+  'child_process': () => require('../child-process'),
+  'node:child_process': () => require('../child-process'),
   'connect': () => require('../connect'),
   'couchbase': () => require('../couchbase'),
   'crypto': () => require('../crypto'),
@@ -40,7 +46,9 @@ module.exports = {
   'koa': () => require('../koa'),
   'koa-router': () => require('../koa'),
   'kafkajs': () => require('../kafkajs'),
+  'ldapjs': () => require('../ldapjs'),
   'limitd-client': () => require('../limitd-client'),
+  'mariadb': () => require('../mariadb'),
   'memcached': () => require('../memcached'),
   'microgateway-core': () => require('../microgateway-core'),
   'mocha': () => require('../mocha'),
@@ -61,6 +69,7 @@ module.exports = {
   'promise-js': () => require('../promise-js'),
   'promise': () => require('../promise'),
   'q': () => require('../q'),
+  'qs': () => require('../qs'),
   'redis': () => require('../redis'),
   'restify': () => require('../restify'),
   'rhea': () => require('../rhea'),

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

@@ -57,3 +57,8 @@ function getVersion (moduleBaseDir) {
 function filename (name, file) {
   return [name, file].filter(val => val).join('/')
 }
+
+module.exports = {
+  filename,
+  pathSepExpr
+}

package/packages/datadog-instrumentations/src/http/server.js

@@ -1,16 +1,19 @@
 'use strict'
 
+const { AbortController } = require('node-abort-controller') // AbortController is not available in node <15
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 
 const startServerCh = channel('apm:http:server:request:start')
+const exitServerCh = channel('apm:http:server:request:exit')
 const errorServerCh = channel('apm:http:server:request:error')
 const finishServerCh = channel('apm:http:server:request:finish')
 
+const requestFinishedSet = new WeakSet()
+
 addHook({ name: 'https' }, http => {
   // http.ServerResponse not present on https
   shimmer.wrap(http.Server.prototype, 'emit', wrapEmit)
@@ -29,8 +32,9 @@ function wrapResponseEmit (emit) {
       return emit.apply(this, arguments)
     }
 
-    if (eventName === 'close') {
+    if (['finish', 'close'].includes(eventName) && !requestFinishedSet.has(this)) {
       finishServerCh.publish({ req: this.req })
+      requestFinishedSet.add(this)
     }
 
     return emit.apply(this, arguments)
@@ -45,18 +49,22 @@ function wrapEmit (emit) {
     if (eventName === 'request') {
       res.req = req
 
-      const asyncResource = new AsyncResource('bound-anonymous-fn')
-      return asyncResource.runInAsyncScope(() => {
-        startServerCh.publish({ req, res })
+      const abortController = new AbortController()
 
-        try {
-          return emit.apply(this, arguments)
-        } catch (err) {
-          errorServerCh.publish(err)
+      startServerCh.publish({ req, res, abortController })
 
-          throw err
+      try {
+        if (abortController.signal.aborted) {
+          return res.end()
         }
-      })
+        return emit.apply(this, arguments)
+      } catch (err) {
+        errorServerCh.publish(err)
+
+        throw err
+      } finally {
+        exitServerCh.publish({ req })
+      }
     }
     return emit.apply(this, arguments)
   }

package/packages/datadog-instrumentations/src/http2/server.js

@@ -1,3 +1,69 @@
 'use strict'
 
-// Instrumentation temporarily disabled. See https://github.com/DataDog/dd-trace-js/issues/312
+// Old instrumentation temporarily replaced with compatibility mode only instrumentation.
+// See https://github.com/DataDog/dd-trace-js/issues/312
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('../helpers/instrument')
+const shimmer = require('../../../datadog-shimmer')
+
+const startServerCh = channel('apm:http2:server:request:start')
+const errorServerCh = channel('apm:http2:server:request:error')
+const finishServerCh = channel('apm:http2:server:request:finish')
+
+addHook({ name: 'http2' }, http2 => {
+  shimmer.wrap(http2, 'createSecureServer', wrapCreateServer)
+  shimmer.wrap(http2, 'createServer', wrapCreateServer)
+  return http2
+})
+
+function wrapCreateServer (createServer) {
+  return function (...args) {
+    const server = createServer.apply(this, args)
+    shimmer.wrap(server, 'emit', wrapEmit)
+    return server
+  }
+}
+
+function wrapResponseEmit (emit) {
+  const asyncResource = new AsyncResource('bound-anonymous-fn')
+  return function (eventName, event) {
+    return asyncResource.runInAsyncScope(() => {
+      if (eventName === 'close' && finishServerCh.hasSubscribers) {
+        finishServerCh.publish({ req: this.req })
+      }
+
+      return emit.apply(this, arguments)
+    })
+  }
+}
+function wrapEmit (emit) {
+  return function (eventName, req, res) {
+    if (!startServerCh.hasSubscribers) {
+      return emit.apply(this, arguments)
+    }
+
+    if (eventName === 'request') {
+      res.req = req
+
+      const asyncResource = new AsyncResource('bound-anonymous-fn')
+      return asyncResource.runInAsyncScope(() => {
+        startServerCh.publish({ req, res })
+
+        shimmer.wrap(res, 'emit', wrapResponseEmit)
+
+        try {
+          return emit.apply(this, arguments)
+        } catch (err) {
+          errorServerCh.publish(err)
+
+          throw err
+        }
+      })
+    }
+    return emit.apply(this, arguments)
+  }
+}

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

@@ -1,7 +1,8 @@
 'use strict'
-const istanbul = 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 } = require('../../dd-trace/src/plugins/util/test')
 
 const testSessionStartCh = channel('ci:jest:session:start')
 const testSessionFinishCh = channel('ci:jest:session:finish')
@@ -17,6 +18,13 @@ const testSkippedCh = channel('ci:jest:test:skip')
 const testRunFinishCh = channel('ci:jest:test:finish')
 const testErrCh = channel('ci:jest:test:err')
 
+const skippableSuitesCh = channel('ci:jest:test-suite:skippable')
+const jestItrConfigurationCh = channel('ci:jest:itr-configuration')
+
+let skippableSuites = []
+let isCodeCoverageEnabled = false
+let isSuitesSkippingEnabled = false
+
 const {
   getTestSuitePath,
   getTestParametersString
@@ -26,21 +34,6 @@ const { getFormattedJestTestParameters, getJestTestName } = require('../../datad
 
 const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 
-function extractCoverageInformation (coverage, rootDir) {
-  const coverageMap = istanbul.createCoverageMap(coverage)
-
-  return coverageMap
-    .files()
-    .filter(filename => {
-      const fileCoverage = coverageMap.fileCoverageFor(filename)
-      const lineCoverage = fileCoverage.getLineCoverage()
-      const isAnyLineExecuted = Object.entries(lineCoverage).some(([, numExecutions]) => !!numExecutions)
-
-      return isAnyLineExecuted
-    })
-    .map(filename => filename.replace(`${rootDir}/`, ''))
-}
-
 const specStatusToTestStatus = {
   'pending': 'skip',
   'disabled': 'skip',
@@ -179,17 +172,80 @@ addHook({
 
 function cliWrapper (cli) {
   const wrapped = shimmer.wrap(cli, 'runCLI', runCLI => async function () {
+    let onDone
+    const configurationPromise = new Promise((resolve) => {
+      onDone = resolve
+    })
+    if (!jestItrConfigurationCh.hasSubscribers) {
+      return runCLI.apply(this, arguments)
+    }
+
+    sessionAsyncResource.runInAsyncScope(() => {
+      jestItrConfigurationCh.publish({ onDone })
+    })
+
+    try {
+      const { err, itrConfig } = await configurationPromise
+      if (err) {
+        log.error(err)
+      }
+      isCodeCoverageEnabled = itrConfig.isCodeCoverageEnabled
+      isSuitesSkippingEnabled = itrConfig.isSuitesSkippingEnabled
+    } catch (e) {
+      log.error(e)
+    }
+
+    if (isSuitesSkippingEnabled) {
+      const skippableSuitesPromise = new Promise((resolve) => {
+        onDone = resolve
+      })
+
+      sessionAsyncResource.runInAsyncScope(() => {
+        skippableSuitesCh.publish({ onDone })
+      })
+
+      try {
+        const { err, skippableSuites: receivedSkippableSuites } = await skippableSuitesPromise
+        if (err) {
+          log.error(err)
+        } else {
+          skippableSuites = receivedSkippableSuites
+        }
+      } catch (e) {
+        log.error(e)
+      }
+    }
+
+    const isSuitesSkipped = !!skippableSuites.length
+
     const processArgv = process.argv.slice(2).join(' ')
     sessionAsyncResource.runInAsyncScope(() => {
       testSessionStartCh.publish(`jest ${processArgv}`)
     })
-    return runCLI.apply(this, arguments).then(result => {
-      const { results: { success } } = result
-      sessionAsyncResource.runInAsyncScope(() => {
-        testSessionFinishCh.publish(success ? 'pass' : 'fail')
+
+    const result = await runCLI.apply(this, arguments)
+
+    const { results: { success, coverageMap } } = result
+
+    let testCodeCoverageLinesTotal
+    try {
+      const { pct, total } = coverageMap.getCoverageSummary().lines
+      testCodeCoverageLinesTotal = total !== 0 ? pct : 0
+    } catch (e) {
+      // ignore errors
+    }
+
+    sessionAsyncResource.runInAsyncScope(() => {
+      testSessionFinishCh.publish({
+        status: success ? 'pass' : 'fail',
+        isSuitesSkipped,
+        isSuitesSkippingEnabled,
+        isCodeCoverageEnabled,
+        testCodeCoverageLinesTotal
       })
-      return result
     })
+
+    return result
   })
 
   cli.runCLI = wrapped.runCLI
@@ -197,6 +253,35 @@ function cliWrapper (cli) {
   return cli
 }
 
+function coverageReporterWrapper (coverageReporter) {
+  const CoverageReporter = coverageReporter.default ? coverageReporter.default : coverageReporter
+
+  /**
+   * If ITR is active, we're running fewer tests, so of course the total code coverage is reduced.
+   * This calculation adds no value, so we'll skip it.
+   */
+  shimmer.wrap(CoverageReporter.prototype, '_addUntestedFiles', addUntestedFiles => async function () {
+    if (isSuitesSkippingEnabled) {
+      return Promise.resolve()
+    }
+    return addUntestedFiles.apply(this, arguments)
+  })
+
+  return coverageReporter
+}
+
+addHook({
+  name: '@jest/reporters',
+  file: 'build/coverage_reporter.js',
+  versions: ['>=24.8.0 <26.6.2']
+}, coverageReporterWrapper)
+
+addHook({
+  name: '@jest/reporters',
+  file: 'build/CoverageReporter.js',
+  versions: ['>=26.6.2']
+}, coverageReporterWrapper)
+
 addHook({
   name: '@jest/core',
   file: 'build/cli/index.js',
@@ -207,6 +292,9 @@ function jestAdapterWrapper (jestAdapter) {
   const adapter = jestAdapter.default ? jestAdapter.default : jestAdapter
   const newAdapter = shimmer.wrap(adapter, function () {
     const environment = arguments[2]
+    if (!environment) {
+      return adapter.apply(this, arguments)
+    }
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     return asyncResource.runInAsyncScope(() => {
       testSuiteStartCh.publish({
@@ -222,11 +310,21 @@ function jestAdapterWrapper (jestAdapter) {
           status = 'fail'
         }
         testSuiteFinishCh.publish({ status, errorMessage })
-        if (environment.global.__coverage__) {
-          const coverageFiles = extractCoverageInformation(environment.global.__coverage__, environment.rootDir)
-          if (coverageFiles.length) {
+
+        const coverageFiles = getCoveredFilenamesFromCoverage(environment.global.__coverage__)
+          .map(filename => getTestSuitePath(filename, environment.rootDir))
+
+        /**
+         * Child processes do not each request ITR configuration, so the jest's parent process
+         * needs to pass them the configuration. This is done via _ddTestCodeCoverageEnabled, which
+         * controls whether coverage is reported.
+         */
+        if (coverageFiles &&
+          environment.testEnvironmentOptions &&
+          environment.testEnvironmentOptions._ddTestCodeCoverageEnabled) {
+          asyncResource.runInAsyncScope(() => {
             testSuiteCodeCoverageCh.publish([...coverageFiles, environment.testSuite])
-          }
+          })
         }
         return suiteResults
       })
@@ -252,6 +350,32 @@ function configureTestEnvironment (readConfigsResult) {
   sessionAsyncResource.runInAsyncScope(() => {
     testSessionConfigurationCh.publish(configs.map(config => config.testEnvironmentOptions))
   })
+  // We can't directly use isCodeCoverageEnabled when reporting coverage in `jestAdapterWrapper`
+  // because `jestAdapterWrapper` runs in a different process. We have to go through `testEnvironmentOptions`
+  configs.forEach(config => {
+    config.testEnvironmentOptions._ddTestCodeCoverageEnabled = isCodeCoverageEnabled
+  })
+
+  if (isCodeCoverageEnabled) {
+    const globalConfig = {
+      ...readConfigsResult.globalConfig,
+      collectCoverage: true
+    }
+    readConfigsResult.globalConfig = globalConfig
+  }
+  if (isSuitesSkippingEnabled) {
+    // If suite skipping is enabled, the code coverage results are not going to be relevant,
+    // so we do not show them.
+    // Also, we might skip every test, so we need to pass `passWithNoTests`
+    const globalConfig = {
+      ...readConfigsResult.globalConfig,
+      coverageReporters: ['none'],
+      passWithNoTests: true
+    }
+    readConfigsResult.globalConfig = globalConfig
+  }
+
+  return readConfigsResult
 }
 
 function jestConfigAsyncWrapper (jestConfig) {
@@ -272,6 +396,39 @@ function jestConfigSyncWrapper (jestConfig) {
   return jestConfig
 }
 
+/**
+ * Hook to remove the test paths (test suite) that are part of `skippableSuites`
+ */
+addHook({
+  name: '@jest/core',
+  versions: ['>=24.8.0'],
+  file: 'build/SearchSource.js'
+}, searchSourcePackage => {
+  const SearchSource = searchSourcePackage.default ? searchSourcePackage.default : searchSourcePackage
+
+  shimmer.wrap(SearchSource.prototype, 'getTestPaths', getTestPaths => async function () {
+    if (!skippableSuites.length) {
+      return getTestPaths.apply(this, arguments)
+    }
+
+    const [{ rootDir }] = arguments
+
+    const testPaths = await getTestPaths.apply(this, arguments)
+    const { tests } = testPaths
+
+    const filteredTests = tests.filter(({ path: testPath }) => {
+      const relativePath = testPath.replace(`${rootDir}/`, '')
+      return !skippableSuites.includes(relativePath)
+    })
+
+    skippableSuites = []
+
+    return { ...testPaths, tests: filteredTests }
+  })
+
+  return searchSourcePackage
+})
+
 // from 25.1.0 on, readConfigs becomes async
 addHook({
   name: 'jest-config',