dd-trace 2.21.0 → 2.22.0

package/LICENSE-3rdparty.csv

@@ -1,6 +1,8 @@
 Component,Origin,License,Copyright
 require,@datadog/native-appsec,Apache license 2.0,Copyright 2018 Datadog Inc.
 require,@datadog/native-metrics,Apache license 2.0,Copyright 2018 Datadog Inc.
+require,@datadog/native-iast-rewriter,Apache license 2.0,Copyright 2018 Datadog Inc.
+require,@datadog/native-iast-taint-tracking,Apache license 2.0,Copyright 2018 Datadog Inc.
 require,@datadog/pprof,Apache license 2.0,Copyright 2019 Google Inc.
 require,@datadog/sketches-js,Apache license 2.0,Copyright 2020 Datadog Inc.
 require,@types/node,MIT,Copyright Authors

package/index.d.ts

@@ -167,6 +167,11 @@ export declare interface SpanContext extends opentracing.SpanContext {
    * Returns the string representation of the internal span ID.
    */
   toSpanId(): string;
+
+  /**
+   * Returns the string representation used for DBM integration.
+   */
+  toTraceparent(): string;
 }
 
 /**
@@ -463,6 +468,12 @@ export declare interface TracerOptions {
    */
   orphanable?: boolean
 
+  /**
+   * Enables DBM to APM link using tag injection.
+   * @default 'disabled'
+   */
+  dbmPropagationMode?: 'disabled' | 'service' | 'full'
+
   /**
    * Configuration of the AppSec protection. Can be a boolean as an alias to `appsec.enabled`.
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "2.21.0",
+  "version": "2.22.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -58,7 +58,9 @@
     "node": ">=12"
   },
   "dependencies": {
-    "@datadog/native-appsec": "1.3.0",
+    "@datadog/native-appsec": "2.0.0",
+    "@datadog/native-iast-rewriter": "1.0.0",
+    "@datadog/native-iast-taint-tracking": "1.0.0",
     "@datadog/native-metrics": "^1.5.0",
     "@datadog/pprof": "^1.1.1",
     "@datadog/sketches-js": "^2.1.0",

package/packages/datadog-instrumentations/src/body-parser.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const { channel, addHook, AsyncResource } = require('./helpers/instrument')
+
+const bodyParserReadCh = channel('datadog:body-parser:read:finish')
+
+function publishRequestBodyAndNext (request, next) {
+  return function () {
+    if (bodyParserReadCh.hasSubscribers && request) {
+      bodyParserReadCh.publish({ request })
+    }
+    next.apply(this, arguments)
+  }
+}
+
+addHook({
+  name: 'body-parser',
+  file: 'lib/read.js',
+  versions: ['>=1']
+}, read => {
+  return function (req, res, next) {
+    const nextResource = new AsyncResource('bound-anonymous-fn')
+    arguments[2] = nextResource.bind(publishRequestBodyAndNext(req, next))
+    read.apply(this, arguments)
+  }
+})

package/packages/datadog-instrumentations/src/child-process.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const {
+  channel,
+  addHook
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const childProcessChannel = channel('datadog:child_process:execution:start')
+const execMethods = ['exec', 'execFile', 'fork', 'spawn', 'execFileSync', 'execSync', 'spawnSync']
+const names = ['child_process', 'node:child_process']
+names.forEach(name => {
+  addHook({ name }, childProcess => {
+    shimmer.massWrap(childProcess, execMethods, wrapChildProcessMethod())
+    return childProcess
+  })
+})
+
+function wrapChildProcessMethod () {
+  function wrapMethod (childProcessMethod) {
+    return function () {
+      if (childProcessChannel.hasSubscribers && arguments.length > 0) {
+        const command = arguments[0]
+        childProcessChannel.publish({ command })
+      }
+      return childProcessMethod.apply(this, arguments)
+    }
+  }
+  return wrapMethod
+}

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

@@ -50,7 +50,7 @@ function wrapRun (pl, isLatestVersion) {
 
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     return asyncResource.runInAsyncScope(() => {
-      runStartCh.publish({ pickleName: this.pickle.name, pickleUri: this.pickle.uri })
+      runStartCh.publish({ testName: this.pickle.name, fullTestSuite: this.pickle.uri })
       try {
         const promise = run.apply(this, arguments)
         promise.finally(() => {

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

@@ -142,19 +142,19 @@ function reply (request, h) {
   }
 }
 
-addHook({ name: '@hapi/hapi', versions: ['>=17.9'] }, hapi => {
+addHook({ name: '@hapi/hapi', versions: ['>=17.9 <=20.2.1'] }, hapi => {
   shimmer.massWrap(hapi, ['server', 'Server'], wrapServer)
 
   return hapi
 })
 
-addHook({ name: '@hapi/hapi', versions: ['>=17.9'], file: 'lib/core.js' }, Core => {
+addHook({ name: '@hapi/hapi', versions: ['>=17.9 <=20.2.1'], file: 'lib/core.js' }, Core => {
   shimmer.wrap(Core.prototype, '_dispatch', wrapDispatch)
 
   return Core
 })
 
-addHook({ name: '@hapi/hapi', versions: ['>=17.9'], file: 'lib/route.js' }, Route => {
+addHook({ name: '@hapi/hapi', versions: ['>=17.9 <=20.2.1'], file: 'lib/route.js' }, Route => {
   shimmer.wrap(Route.prototype, 'rebuild', wrapRebuild)
 
   return Route

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

@@ -8,6 +8,7 @@ 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'),
@@ -16,8 +17,11 @@ module.exports = {
   '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'),
@@ -65,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/jest.js

@@ -1,8 +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')
@@ -23,6 +23,7 @@ const jestConfigurationCh = channel('ci:jest:configuration')
 
 let skippableSuites = []
 let isCodeCoverageEnabled = false
+let isSuitesSkippingEnabled = false
 
 const {
   getTestSuitePath,
@@ -33,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',
@@ -186,38 +172,42 @@ addHook({
 
 function cliWrapper (cli) {
   const wrapped = shimmer.wrap(cli, 'runCLI', runCLI => async function () {
-    let onResponse, onError
-    const configurationPromise = new Promise((resolve, reject) => {
-      onResponse = resolve
-      onError = reject
+    let onDone
+    const configurationPromise = new Promise((resolve) => {
+      onDone = resolve
     })
 
     sessionAsyncResource.runInAsyncScope(() => {
-      jestConfigurationCh.publish({ onResponse, onError })
+      jestConfigurationCh.publish({ onDone })
     })
 
-    let isSuitesSkippingEnabled = false
-
     try {
-      const config = await configurationPromise
+      const { err, config } = await configurationPromise
+      if (err) {
+        log.error(err)
+      }
       isCodeCoverageEnabled = config.isCodeCoverageEnabled
       isSuitesSkippingEnabled = config.isSuitesSkippingEnabled
     } catch (e) {
-      // ignore error
+      log.error(e)
     }
 
     if (isSuitesSkippingEnabled) {
-      const skippableSuitesPromise = new Promise((resolve, reject) => {
-        onResponse = resolve
-        onError = reject
+      const skippableSuitesPromise = new Promise((resolve) => {
+        onDone = resolve
       })
 
       sessionAsyncResource.runInAsyncScope(() => {
-        skippableSuitesCh.publish({ onResponse, onError })
+        skippableSuitesCh.publish({ onDone })
       })
 
       try {
-        skippableSuites = await skippableSuitesPromise
+        const { err, skippableSuites: receivedSkippableSuites } = await skippableSuitesPromise
+        if (err) {
+          log.error(err)
+        } else {
+          skippableSuites = receivedSkippableSuites
+        }
       } catch (e) {
         log.error(e)
       }
@@ -253,6 +243,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',
@@ -281,13 +300,16 @@ function jestAdapterWrapper (jestAdapter) {
           status = 'fail'
         }
         testSuiteFinishCh.publish({ status, errorMessage })
-        if (environment.global.__coverage__) {
-          const coverageFiles = extractCoverageInformation(environment.global.__coverage__, environment.rootDir)
-          if (coverageFiles.length &&
-            environment.testEnvironmentOptions &&
-            environment.testEnvironmentOptions._ddTestCodeCoverageEnabled) {
+
+        const coverageFiles = getCoveredFilenamesFromCoverage(environment.global.__coverage__)
+          .map(filename => getTestSuitePath(filename, environment.rootDir))
+
+        if (coverageFiles &&
+          environment.testEnvironmentOptions &&
+          environment.testEnvironmentOptions._ddTestCodeCoverageEnabled) {
+          asyncResource.runInAsyncScope(() => {
             testSuiteCodeCoverageCh.publish([...coverageFiles, environment.testSuite])
-          }
+          })
         }
         return suiteResults
       })
@@ -310,12 +332,6 @@ addHook({
 
 function configureTestEnvironment (readConfigsResult) {
   const { configs } = readConfigsResult
-  configs.forEach(config => {
-    skippableSuites.forEach((suite) => {
-      config.testMatch.push(`!**/${suite}`)
-    })
-    skippableSuites = []
-  })
   sessionAsyncResource.runInAsyncScope(() => {
     testSessionConfigurationCh.publish(configs.map(config => config.testEnvironmentOptions))
   })
@@ -324,6 +340,7 @@ function configureTestEnvironment (readConfigsResult) {
   configs.forEach(config => {
     config.testEnvironmentOptions._ddTestCodeCoverageEnabled = isCodeCoverageEnabled
   })
+
   if (isCodeCoverageEnabled) {
     const globalConfig = {
       ...readConfigsResult.globalConfig,
@@ -331,6 +348,16 @@ function configureTestEnvironment (readConfigsResult) {
     }
     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.
+    const globalConfig = {
+      ...readConfigsResult.globalConfig,
+      coverageReporters: ['none']
+    }
+    readConfigsResult.globalConfig = globalConfig
+  }
+
   return readConfigsResult
 }
 
@@ -352,6 +379,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',

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 configurationCh = channel('ci:mocha: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) {
@@ -93,6 +112,8 @@ function mochaHook (Runner) {
       }
       testFileToSuiteAr.clear()
       testSessionFinishCh.publish(status)
+      // restore the original coverage
+      global.__coverage__ = fromCoverageMapToCoverage(originalCoverageMap)
     }))
 
     this.once('start', testRunAsyncResource.bind(function () {
@@ -140,9 +161,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 +262,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)
@@ -242,6 +276,11 @@ function mochaHook (Runner) {
       }
     })
 
+    // We remove the suites that we skip through ITR
+    this.suite.suites = this.suite.suites.filter(suite =>
+      !suitesToSkip.includes(getTestSuitePath(suite.file, process.cwd()))
+    )
+
     return run.apply(this, arguments)
   })
 
@@ -266,6 +305,48 @@ 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 () {
+    const onReceivedSkippableSuites = ({ err, skippableSuites }) => {
+      if (err) {
+        log.error(err)
+        suitesToSkip = []
+      } else {
+        suitesToSkip = skippableSuites
+      }
+      run.apply(this, arguments)
+    }
+
+    const onReceivedConfiguration = ({ err }) => {
+      if (err) {
+        log.error(err)
+        return run.apply(this, arguments)
+      }
+
+      skippableSuitesCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
+      })
+    }
+
+    mochaRunAsyncResource.runInAsyncScope(() => {
+      configurationCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedConfiguration)
+      })
+    })
+  })
+  return Mocha
+})
+
 addHook({
   name: 'mocha',
   versions: ['>=5.2.0'],

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

@@ -37,13 +37,12 @@ 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, processId })
+      startCh.publish({ params: this.connectionParameters, 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
+})

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

@@ -68,7 +68,7 @@ function wrapNext (req, next) {
   }
 }
 
-addHook({ name: 'restify', versions: ['>=3'], file: 'lib/server.js' }, Server => {
+addHook({ name: 'restify', versions: ['>=3 <=8.6.1'], file: 'lib/server.js' }, Server => {
   shimmer.wrap(Server.prototype, '_setupRequest', wrapSetupRequest)
   shimmer.massWrap(Server.prototype, handlers, wrapHandler)
   shimmer.massWrap(Server.prototype, methods, wrapMethod)