dd-trace 3.15.0 → 3.17.0

package/LICENSE-3rdparty.csv

@@ -36,6 +36,7 @@ dev,chalk,MIT,Copyright Sindre Sorhus
 dev,checksum,MIT,Copyright Daniel D. Shaw
 dev,cli-table3,MIT,Copyright 2014 James Talmage
 dev,dotenv,BSD-2-Clause,Copyright 2015 Scott Motte
+dev,esbuild,MIT,Copyright (c) 2020 Evan Wallace
 dev,eslint,MIT,Copyright JS Foundation and other contributors https://js.foundation
 dev,eslint-config-standard,MIT,Copyright Feross Aboukhadijeh
 dev,eslint-plugin-import,MIT,Copyright 2015 Ben Mosher
@@ -51,8 +52,6 @@ dev,int64-buffer,MIT,Copyright 2015-2016 Yusuke Kawasaki
 dev,jszip,MIT,Copyright 2015-2016 Stuart Knightley and contributors
 dev,mkdirp,MIT,Copyright 2010 James Halliday
 dev,mocha,MIT,Copyright 2011-2018 JS Foundation and contributors https://js.foundation
-dev,mocha-junit-reporter,MIT,Copyright (c) 2015 Michael Allen
-dev,mocha-multi-reporters,MIT,Copyright 2019 Yousaf Nabi and 2015 Stanley Ng
 dev,multer,MIT,Copyright 2014 Hage Yaapa
 dev,msgpack-lite,MIT,Copyright 2015 Yusuke Kawasaki
 dev,nock,MIT,Copyright 2017 Pedro Teixeira and other contributors
@@ -62,6 +61,7 @@ dev,proxyquire,MIT,Copyright 2013 Thorsten Lorenz
 dev,rimraf,ISC,Copyright Isaac Z. Schlueter and Contributors
 dev,sinon,BSD-3-Clause,Copyright 2010-2017 Christian Johansen
 dev,sinon-chai,WTFPL and BSD-2-Clause,Copyright 2004 Sam Hocevar 2012–2017 Domenic Denicola
+dev,tap,ISC,Copyright 2011-2022 Isaac Z. Schlueter and Contributors
 dev,tape,MIT,Copyright James Halliday
 dev,wait-on,MIT,Copyright 2015 Jeff Barczewski
 file,aws-lambda-nodejs-runtime-interface-client,Apache 2.0,Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.

package/README.md

@@ -93,6 +93,10 @@ $ docker-compose up -d -V --remove-orphans --force-recreate
 $ yarn services
 ```
 
+> **Note**
+> The `couchbase`, `grpc` and `oracledb` instrumentations rely on native modules
+> that do not compile on ARM64 devices (for example M1/M2 Mac) - their tests
+> cannot be run locally on these devices.
 
 ### Unit Tests
 
@@ -147,6 +151,19 @@ $ yarn lint
 ```
 
 
+### Experimental ESM Support
+
+ESM support is currently in the experimental stages, while CJS has been supported
+since inception. This means that code loaded using `require()` should work fine
+but code loaded using `import` might not always work.
+
+Use the following command to enable experimental ESM support with your application:
+
+```sh
+node --loader dd-trace/loader-hook.mjs entrypoint.js
+```
+
+
 ### Benchmarks
 
 Our microbenchmarks live in `benchmark/sirun`. Each directory in there
@@ -171,6 +188,42 @@ That said, even if your application runs on Lambda, any core instrumentation iss
 Regardless of where you open the issue, someone at Datadog will try to help.
 
 
+## Bundling
+
+Generally, `dd-trace` works by intercepting `require()` calls that a Node.js application makes when loading modules. This includes modules that are built-in to Node.js, like the `fs` module for accessing the filesystem, as well as modules installed from the npm registry, like the `pg` database module.
+
+Also generally, bundlers work by crawling all of the `require()` calls that an application makes to files on disk, replacing the `require()` calls with custom code, and then concatenating all of the resulting JavaScript into one "bundled" file. When a built-in module is loaded, like `require('fs')`, that call can then remain the same in the resulting bundle.
+
+Fundamentally APM tools like `dd-trace` stop working at this point. Perhaps they continue to intercept the calls for built-in modules but don't intercept calls to third party libraries. This means that by default when you bundle a `dd-trace` app with a bundler it is likely to capture information about disk access (via `fs`) and outbound HTTP requests (via `http`), but will otherwise omit calls to third party libraries (like extracting incoming request route information for the `express` framework or showing which query is run for the `mysql` database client).
+
+To get around this, one can treat all third party modules, or at least third party modules that the APM needs to instrument, as being "external" to the bundler. With this setting the instrumented modules remain on disk and continue to be loaded via `require()` while the non-instrumented modules are bundled. Sadly this results in a build with many extraneous files and starts to defeat the purpose of bundling. 
+
+For these reasons it's necessary to have custom-built bundler plugins. Such plugins are able to instruct the bundler on how to behave, injecting intermediary code and otherwise intercepting the "translated" `require()` calls. The result is that many more packages are then included in the bundled JavaScript file. Some applications can have 100% of modules bundled, however native modules still need to remain external to the bundle.
+
+### Esbuild Support
+
+This library provides experimental esbuild support in the form of an esbuild plugin, and currently requires at least Node.js v16.17 or v18.7. To use the plugin, make sure you have `dd-trace@3+` installed, and then require the `dd-trace/esbuild` module when building your bundle.
+
+Here's an example of how one might use `dd-trace` with esbuild:
+
+```javascript
+const ddPlugin = require('dd-trace/esbuild')
+const esbuild = require('esbuild')
+
+esbuild.build({
+  entryPoints: ['app.js'], 
+  bundle: true,
+  outfile: 'out.js',
+  plugins: [ddPlugin],
+  platform: 'node', // allows built-in modules to be required
+  target: ['node16']
+}).catch((err) => {
+  console.error(err)
+  process.exit(1)
+})
+```
+
+
 ## Security Vulnerabilities
 
 If you have found a security issue, please contact the security team directly at [security@datadoghq.com](mailto:security@datadoghq.com).

package/ci/init.js

@@ -3,13 +3,15 @@ const tracer = require('../packages/dd-trace')
 const { ORIGIN_KEY } = require('../packages/dd-trace/src/constants')
 const { isTrue } = require('../packages/dd-trace/src/util')
 
+const isJestWorker = !!process.env.JEST_WORKER_ID
+
 const options = {
   startupLogs: false,
   tags: {
     [ORIGIN_KEY]: 'ciapp-test'
   },
   isCiVisibility: true,
-  flushInterval: 5000
+  flushInterval: isJestWorker ? 0 : 5000
 }
 
 let shouldInit = true
@@ -33,6 +35,12 @@ so dd-trace will not be initialized.`)
   }
 }
 
+if (isJestWorker) {
+  options.experimental = {
+    exporter: 'jest_worker'
+  }
+}
+
 if (shouldInit) {
   tracer.init(options)
   tracer.use('fs', false)

package/ext/exporters.d.ts

@@ -2,7 +2,8 @@ declare const exporters: {
   LOG: 'log',
   AGENT: 'agent',
   DATADOG: 'datadog',
-  AGENT_PROXY: 'agent_proxy'
+  AGENT_PROXY: 'agent_proxy',
+  JEST_WORKER: 'jest_worker'
 }
 
 export = exporters

package/ext/exporters.js

@@ -3,5 +3,6 @@ module.exports = {
   LOG: 'log',
   AGENT: 'agent',
   DATADOG: 'datadog',
-  AGENT_PROXY: 'agent_proxy'
+  AGENT_PROXY: 'agent_proxy',
+  JEST_WORKER: 'jest_worker'
 }

package/index.d.ts

@@ -98,7 +98,7 @@ export declare interface Tracer extends opentracing.Tracer {
    * * The function doesn't accept a callback and doesn't return a promise, in
    * which case the span will finish at the end of the function execution.
    */
-  wrap<T = (...args: any[]) => any> (name: string, fn: T, requiresParent?: boolean): T;
+  wrap<T = (...args: any[]) => any> (name: string, fn: T): T;
   wrap<T = (...args: any[]) => any> (name: string, options: TraceOptions & SpanOptions, fn: T): T;
   wrap<T = (...args: any[]) => any> (name: string, options: (...args: any[]) => TraceOptions & SpanOptions, fn: T): T;
 
@@ -438,7 +438,11 @@ export declare interface TracerOptions {
        * Controls how many code vulnerabilities can be detected in the same request
        * @default 2
        */
-      maxContextOperations?: number
+      maxContextOperations?: number,
+      /**
+       * Whether to enable vulnerability deduplication
+       */
+      deduplicationEnabled?: boolean
     }
   };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "3.15.0",
+  "version": "3.17.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -14,27 +14,32 @@
     "type:test": "cd docs && yarn && yarn test",
     "lint": "node scripts/check_licenses.js && eslint . && yarn audit --groups dependencies",
     "services": "node ./scripts/install_plugin_modules && node packages/dd-trace/test/setup/services",
-    "tdd": "node scripts/tdd.js",
     "test": "SERVICES=* yarn services && mocha --colors --exit --expose-gc 'packages/dd-trace/test/setup/node.js' 'packages/*/test/**/*.spec.js'",
-    "test:trace:core": "mocha --colors --exit --expose-gc --file packages/dd-trace/test/setup/core.js --exclude \"packages/dd-trace/test/lambda/**/*.spec.js\" --exclude \"packages/dd-trace/test/profiling/**/*.spec.js\" --exclude \"packages/dd-trace/test/appsec/iast/**/*.plugin.spec.js\" \"packages/dd-trace/test/**/*.spec.js\"",
-    "test:trace:core:ci": "nyc --no-clean --include \"packages/dd-trace/src/**/*.js\" --exclude \"packages/dd-trace/src/lambda/**/*.spec.js\" --exclude \"packages/dd-trace/src/profiling/**/*.js\" --exclude \"packages/dd-trace/test/appsec/iast/**/*.plugin.spec.js\" -- npm run test:trace:core -- --reporter mocha-multi-reporters --reporter-options configFile=mocha-reporter.json",
-    "test:instrumentations": "mocha --colors --file 'packages/dd-trace/test/setup/core.js' 'packages/datadog-instrumentations/test/**/*.spec.js'",
+    "test:appsec": "mocha --colors --exit -r \"packages/dd-trace/test/setup/mocha.js\" --exclude \"packages/dd-trace/test/appsec/iast/**/*.plugin.spec.js\" \"packages/dd-trace/test/appsec/**/*.spec.js\"",
+    "test:appsec:ci": "nyc --no-clean --include \"packages/dd-trace/src/appsec/**/*.js\" --exclude \"packages/dd-trace/test/appsec/iast/**/*.plugin.spec.js\" -- npm run test:appsec",
+    "test:appsec:plugins": "mocha --colors --exit -r \"packages/dd-trace/test/setup/mocha.js\" \"packages/dd-trace/test/appsec/iast/**/*.@($(echo $PLUGINS)).plugin.spec.js\"",
+    "test:appsec:plugins:ci": "yarn services && nyc --no-clean --include \"packages/dd-trace/test/appsec/iast/**/*.@($(echo $PLUGINS)).plugin.spec.js\" -- npm run test:appsec:plugins",
+    "test:trace:core": "tap packages/dd-trace/test/*.spec.js \"packages/dd-trace/test/{ci-visibility,encode,exporters,opentracing,plugins,telemetry}/**/*.spec.js\"",
+    "test:trace:core:ci": "npm run test:trace:core -- --coverage --nyc-arg=--include=\"packages/dd-trace/src/**/*.js\"",
+    "test:instrumentations": "mocha --colors -r 'packages/dd-trace/test/setup/mocha.js' 'packages/datadog-instrumentations/test/**/*.spec.js'",
     "test:instrumentations:ci": "nyc --no-clean --include 'packages/datadog-instrumentations/src/**/*.js' -- npm run test:instrumentations",
-    "test:core": "mocha --colors --file packages/datadog-core/test/setup.js 'packages/datadog-core/test/**/*.spec.js'",
-    "test:core:ci": "nyc --no-clean --include 'packages/datadog-core/src/**/*.js' -- npm run test:core",
-    "test:lambda": "mocha --colors --exit --file \"packages/dd-trace/test/setup/core.js\" \"packages/dd-trace/test/lambda/**/*.spec.js\"",
+    "test:core": "tap \"packages/datadog-core/test/**/*.spec.js\"",
+    "test:core:ci": "npm run test:core -- --coverage --nyc-arg=--include=\"packages/datadog-core/src/**/*.js\"",
+    "test:lambda": "mocha --colors --exit -r \"packages/dd-trace/test/setup/mocha.js\" \"packages/dd-trace/test/lambda/**/*.spec.js\"",
     "test:lambda:ci": "nyc --no-clean --include \"packages/dd-trace/src/lambda/**/*.js\" -- npm run test:lambda",
-    "test:plugins": "mocha --colors --exit --file \"packages/dd-trace/test/setup/core.js\" \"packages/datadog-instrumentations/test/@($(echo $PLUGINS)).spec.js\" \"packages/datadog-plugin-@($(echo $PLUGINS))/test/**/*.spec.js\" \"packages/dd-trace/test/appsec/iast/**/*.@($(echo $PLUGINS)).plugin.spec.js\"",
-    "test:plugins:ci": "yarn services && nyc --no-clean --include \"packages/datadog-instrumentations/src/@($(echo $PLUGINS)).js\" --include \"packages/datadog-instrumentations/src/@($(echo $PLUGINS))/**/*.js\" --include \"packages/datadog-plugin-@($(echo $PLUGINS))/src/**/*.js\" --include \"packages/dd-trace/test/appsec/iast/**/*.@($(echo $PLUGINS)).plugin.spec.js\" -- npm run test:plugins",
+    "test:plugins": "mocha --colors --exit -r \"packages/dd-trace/test/setup/mocha.js\" \"packages/datadog-instrumentations/test/@($(echo $PLUGINS)).spec.js\" \"packages/datadog-plugin-@($(echo $PLUGINS))/test/**/*.spec.js\"",
+    "test:plugins:ci": "yarn services && nyc --no-clean --include \"packages/datadog-instrumentations/src/@($(echo $PLUGINS)).js\" --include \"packages/datadog-instrumentations/src/@($(echo $PLUGINS))/**/*.js\" --include \"packages/datadog-plugin-@($(echo $PLUGINS))/src/**/*.js\" -- npm run test:plugins",
     "test:plugins:upstream": "node ./packages/dd-trace/test/plugins/suite.js",
-    "test:profiler": "mocha --colors --exit --file \"packages/dd-trace/test/setup/core.js\" \"packages/dd-trace/test/profiling/**/*.spec.js\"",
-    "test:profiler:ci": "nyc --no-clean --include \"packages/dd-trace/src/profiling/**/*.js\" -- npm run test:profiler",
-    "test:integration": "mocha --colors --timeout 30000 \"integration-tests/**/*.spec.js\"",
+    "test:profiler": "tap \"packages/dd-trace/test/profiling/**/*.spec.js\"",
+    "test:profiler:ci": "npm run test:profiler -- --coverage --nyc-arg=--include=\"packages/dd-trace/src/profiling/**/*.js\"",
+    "test:integration": "mocha --colors --timeout 30000 \"integration-tests/*.spec.js\"",
+    "test:integration:cucumber": "mocha --colors --timeout 30000 \"integration-tests/cucumber/*.spec.js\"",
+    "test:integration:cypress": "mocha --colors --timeout 30000 \"integration-tests/cypress/*.spec.js\"",
+    "test:integration:playwright": "mocha --colors --timeout 30000 \"integration-tests/playwright/*.spec.js\"",
     "test:shimmer": "mocha --colors 'packages/datadog-shimmer/test/**/*.spec.js'",
     "test:shimmer:ci": "nyc --no-clean --include 'packages/datadog-shimmer/src/**/*.js' -- npm run test:shimmer",
     "leak:core": "node ./scripts/install_plugin_modules && (cd packages/memwatch && yarn) && NODE_PATH=./packages/memwatch/node_modules node --no-warnings ./node_modules/.bin/tape 'packages/dd-trace/test/leak/**/*.js'",
-    "leak:plugins": "yarn services && (cd packages/memwatch && yarn) && NODE_PATH=./packages/memwatch/node_modules node --no-warnings ./node_modules/.bin/tape \"packages/datadog-plugin-@($(echo $PLUGINS))/test/leak.js\"",
-    "junit:upload": "node ./scripts/junit_report.js"
+    "leak:plugins": "yarn services && (cd packages/memwatch && yarn) && NODE_PATH=./packages/memwatch/node_modules node --no-warnings ./node_modules/.bin/tape \"packages/datadog-plugin-@($(echo $PLUGINS))/test/leak.js\""
   },
   "repository": {
     "type": "git",
@@ -62,9 +67,9 @@
   "dependencies": {
     "@datadog/native-appsec": "2.0.0",
     "@datadog/native-iast-rewriter": "2.0.1",
-    "@datadog/native-iast-taint-tracking": "1.1.1",
+    "@datadog/native-iast-taint-tracking": "1.3.1",
     "@datadog/native-metrics": "^1.5.0",
-    "@datadog/pprof": "^2.0.0",
+    "@datadog/pprof": "^2.1.0",
     "@datadog/sketches-js": "^2.1.0",
     "crypto-randomuuid": "^1.0.0",
     "diagnostics_channel": "^1.1.0",
@@ -99,6 +104,7 @@
     "checksum": "^0.1.1",
     "cli-table3": "^0.5.1",
     "dotenv": "8.2.0",
+    "esbuild": "0.16.12",
     "eslint": "^8.23.0",
     "eslint-config-standard": "^11.0.0-beta.0",
     "eslint-plugin-import": "^2.8.0",
@@ -114,8 +120,6 @@
     "jszip": "^3.5.0",
     "mkdirp": "^0.5.1",
     "mocha": "8",
-    "mocha-junit-reporter": "^2.1.0",
-    "mocha-multi-reporters": "^1.5.1",
     "msgpack-lite": "^0.1.26",
     "multer": "^1.4.5-lts.1",
     "nock": "^11.3.3",
@@ -125,6 +129,7 @@
     "rimraf": "^3.0.0",
     "sinon": "^11.1.2",
     "sinon-chai": "^3.7.0",
+    "tap": "^16.3.4",
     "tape": "^4.9.1",
     "wait-on": "^5.0.0"
   }

package/packages/datadog-esbuild/index.js

@@ -0,0 +1,104 @@
+'use strict'
+
+/* eslint-disable no-console */
+
+const NAMESPACE = 'datadog'
+
+const instrumented = Object.keys(require('../datadog-instrumentations/src/helpers/hooks.js'))
+const rawBuiltins = require('module').builtinModules
+
+warnIfUnsupported()
+
+const builtins = new Set()
+
+for (const builtin of rawBuiltins) {
+  builtins.add(builtin)
+  builtins.add(`node:${builtin}`)
+}
+
+const packagesOfInterest = new Set()
+
+const DEBUG = !!process.env.DD_TRACE_DEBUG
+
+// We don't want to handle any built-in packages via DCITM
+// Those packages will still be handled via RITM
+// Attempting to instrument them would fail as they have no package.json file
+for (const pkg of instrumented) {
+  if (builtins.has(pkg)) continue
+  if (pkg.startsWith('node:')) continue
+  packagesOfInterest.add(pkg)
+}
+
+const DC_CHANNEL = 'dd-trace:bundledModuleLoadStart'
+
+module.exports.name = 'datadog-esbuild'
+
+module.exports.setup = function (build) {
+  build.onResolve({ filter: /.*/ }, args => {
+    const packageName = args.path
+
+    if (args.namespace === 'file' && packagesOfInterest.has(packageName)) {
+      // The file namespace is used when requiring files from disk in userland
+      const pathToPackageJson = require.resolve(`${packageName}/package.json`, { paths: [ args.resolveDir ] })
+      const pkg = require(pathToPackageJson)
+
+      if (DEBUG) {
+        console.log(`resolve ${packageName}@${pkg.version}`)
+      }
+
+      // https://esbuild.github.io/plugins/#on-resolve-arguments
+      return {
+        path: packageName,
+        namespace: NAMESPACE,
+        pluginData: {
+          version: pkg.version
+        }
+      }
+    } else if (args.namespace === 'datadog') {
+      // The datadog namespace is used when requiring files that are injected during the onLoad stage
+      // see note in onLoad
+
+      if (builtins.has(packageName)) return
+
+      return {
+        path: require.resolve(packageName, { paths: [ args.resolveDir ] }),
+        namespace: 'file'
+      }
+    }
+  })
+
+  build.onLoad({ filter: /.*/, namespace: NAMESPACE }, args => {
+    if (DEBUG) {
+      console.log(`load ${args.path}@${args.pluginData.version}`)
+    }
+
+    // JSON.stringify adds double quotes. For perf gain could simply add in quotes when we know it's safe.
+    const contents = `
+      const dc = require('diagnostics_channel');
+      const ch = dc.channel(${JSON.stringify(DC_CHANNEL + ':' + args.path)});
+      const mod = require(${JSON.stringify(args.path)});
+      const payload = {
+        module: mod,
+        path: ${JSON.stringify(args.path)},
+        version: ${JSON.stringify(args.pluginData.version)}
+      };
+      ch.publish(payload);
+      module.exports = payload.module;
+    `
+    // https://esbuild.github.io/plugins/#on-load-results
+    return {
+      contents,
+      loader: 'js'
+    }
+  })
+}
+
+function warnIfUnsupported () {
+  const [major, minor] = process.versions.node.split('.').map(Number)
+  if (major < 14 || (major === 14 && minor < 17)) {
+    console.error('WARNING: Esbuild support isn\'t available for older versions of Node.js.')
+    console.error(`Expected: Node.js >= v14.17. Actual: Node.js = ${process.version}.`)
+    console.error('This application may build properly with this version of Node.js, but unless a')
+    console.error('more recent version is used at runtime, third party packages won\'t be instrumented.')
+  }
+}

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

@@ -1,4 +1,5 @@
 'use strict'
+const { createCoverageMap } = require('istanbul-lib-coverage')
 
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
@@ -12,10 +13,24 @@ const errorCh = channel('ci:cucumber:error')
 
 const testSuiteStartCh = channel('ci:cucumber:test-suite:start')
 const testSuiteFinishCh = channel('ci:cucumber:test-suite:finish')
+const testSuiteCodeCoverageCh = channel('ci:cucumber:test-suite:code-coverage')
 
+const itrConfigurationCh = channel('ci:cucumber:itr-configuration')
+const skippableSuitesCh = channel('ci:cucumber:test-suite:skippable')
 const sessionStartCh = channel('ci:cucumber:session:start')
 const sessionFinishCh = channel('ci:cucumber:session:finish')
 
+const {
+  getCoveredFilenamesFromCoverage,
+  resetCoverage,
+  mergeCoverage,
+  fromCoverageMapToCoverage,
+  getTestSuitePath
+} = require('../../dd-trace/src/plugins/util/test')
+
+// We'll preserve the original coverage here
+const originalCoverageMap = createCoverageMap()
+
 // TODO: remove in a later major version
 const patched = new WeakSet()
 
@@ -88,12 +103,25 @@ function wrapRun (pl, isLatestVersion) {
           } else {
             pickleResultByFile[testSuiteFullPath].push(status)
           }
+          testFinishCh.publish({ status, skipReason, errorMessage })
           // last test in suite
           if (pickleResultByFile[testSuiteFullPath].length === pickleByFile[testSuiteFullPath].length) {
             const testSuiteStatus = getSuiteStatusFromTestStatuses(pickleResultByFile[testSuiteFullPath])
+            if (global.__coverage__) {
+              const coverageFiles = getCoveredFilenamesFromCoverage(global.__coverage__)
+
+              testSuiteCodeCoverageCh.publish({
+                coverageFiles,
+                suiteFile: testSuiteFullPath
+              })
+              // 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__)
+            }
+
             testSuiteFinishCh.publish(testSuiteStatus)
           }
-          testFinishCh.publish({ status, skipReason, errorMessage })
         })
         return promise
       } catch (err) {
@@ -164,6 +192,13 @@ addHook({
   file: 'lib/runtime/test_case_runner.js'
 }, testCaseHook)
 
+function getPicklesToRun (runtime, suitesToSkip) {
+  return runtime.pickleIds.filter((pickleId) => {
+    const test = runtime.eventDataCollector.getPickle(pickleId)
+    return !suitesToSkip.includes(getTestSuitePath(test.uri, process.cwd()))
+  }, {})
+}
+
 function getPickleByFile (runtime) {
   return runtime.pickleIds.reduce((acc, pickleId) => {
     const test = runtime.eventDataCollector.getPickle(pickleId)
@@ -182,19 +217,61 @@ addHook({
   file: 'lib/runtime/index.js'
 }, (runtimePackage, cucumberVersion) => {
   shimmer.wrap(runtimePackage.default.prototype, 'start', start => async function () {
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    let onDone
+
+    const configPromise = new Promise(resolve => {
+      onDone = resolve
+    })
+
+    asyncResource.runInAsyncScope(() => {
+      itrConfigurationCh.publish({ onDone })
+    })
+
+    await configPromise
+
+    const skippableSuitesPromise = new Promise(resolve => {
+      onDone = resolve
+    })
+
+    asyncResource.runInAsyncScope(() => {
+      skippableSuitesCh.publish({ onDone })
+    })
+
+    const { err, skippableSuites } = await skippableSuitesPromise
+
+    if (!err) {
+      this.pickleIds = getPicklesToRun(this, skippableSuites)
+    }
+
     pickleByFile = getPickleByFile(this)
 
     const processArgv = process.argv.slice(2).join(' ')
     const command = process.env.npm_lifecycle_script || `cucumber-js ${processArgv}`
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
     asyncResource.runInAsyncScope(() => {
       sessionStartCh.publish({ command, frameworkVersion: cucumberVersion })
     })
     const success = await start.apply(this, arguments)
 
+    let testCodeCoverageLinesTotal
+
+    if (global.__coverage__) {
+      try {
+        testCodeCoverageLinesTotal = originalCoverageMap.getCoverageSummary().lines.pct
+      } catch (e) {
+        // ignore errors
+      }
+      // restore the original coverage
+      global.__coverage__ = fromCoverageMapToCoverage(originalCoverageMap)
+    }
+
     asyncResource.runInAsyncScope(() => {
-      sessionFinishCh.publish(success ? 'pass' : 'fail')
+      sessionFinishCh.publish({
+        status: success ? 'pass' : 'fail',
+        isSuitesSkipped: skippableSuites ? !!skippableSuites.length : false,
+        testCodeCoverageLinesTotal
+      })
     })
     return success
   })

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

@@ -15,46 +15,106 @@ const receiveStartCh = channel(`apm:google-cloud-pubsub:receive:start`)
 const receiveFinishCh = channel('apm:google-cloud-pubsub:receive:finish')
 const receiveErrorCh = channel('apm:google-cloud-pubsub:receive:error')
 
-addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'] }, (obj) => {
-  const PubSub = obj.PubSub
-  const Subscription = obj.Subscription
-
-  shimmer.wrap(PubSub.prototype, 'request', request => function (cfg = { reqOpts: {} }, cb) {
-    if (!requestStartCh.hasSubscribers) {
-      return request.apply(this, arguments)
-    }
+const publisherMethods = [
+  'createTopic',
+  'updateTopic',
+  'publish',
+  'getTopic',
+  'listTopics',
+  'listTopicSubscriptions',
+  'listTopicSnapshots',
+  'deleteTopic',
+  'detachSubscription'
+]
+
+const schemaServiceMethods = [
+  'createSchema',
+  'getSchema',
+  'listSchemas',
+  'listSchemaRevisions',
+  'commitSchema',
+  'rollbackSchema',
+  'deleteSchemaRevision',
+  'deleteSchema',
+  'validateSchema',
+  'validateMessage'
+]
+
+const subscriberMethods = [
+  'createSubscription',
+  'getSubscription',
+  'updateSubscription',
+  'listSubscriptions',
+  'deleteSubscription',
+  'modifyAckDeadline',
+  'acknowledge',
+  'pull',
+  'streamingPull',
+  'modifyPushConfig',
+  'getSnapshot',
+  'listSnapshots',
+  'createSnapshot',
+  'updateSnapshot',
+  'deleteSnapshot',
+  'seek'
+]
+
+function wrapMethod (method) {
+  const api = method.name
+
+  return function (request) {
+    if (!requestStartCh.hasSubscribers) return method.apply(this, arguments)
 
     const innerAsyncResource = new AsyncResource('bound-anonymous-fn')
-    const outerAsyncResource = new AsyncResource('bound-anonymous-fn')
 
     return innerAsyncResource.runInAsyncScope(() => {
-      let messages = []
-      if (cfg.reqOpts && cfg.method === 'publish') {
-        messages = cfg.reqOpts.messages
-      }
+      const projectId = this.auth._cachedProjectId
+      const cb = arguments[arguments.length - 1]
+
+      requestStartCh.publish({ request, api, projectId })
 
-      requestStartCh.publish({ cfg, projectId: this.projectId, messages })
-      cb = outerAsyncResource.bind(cb)
+      if (typeof cb === 'function') {
+        const outerAsyncResource = new AsyncResource('bound-anonymous-fn')
 
-      const fn = () => {
-        arguments[1] = innerAsyncResource.bind(function (error) {
+        arguments[arguments.length - 1] = innerAsyncResource.bind(function (error) {
           if (error) {
             requestErrorCh.publish(error)
           }
-          requestFinishCh.publish(undefined)
-          return cb.apply(this, arguments)
+
+          requestFinishCh.publish()
+
+          return outerAsyncResource.runInAsyncScope(() => cb.apply(this, arguments))
         })
-        return request.apply(this, arguments)
-      }
 
-      try {
-        return fn.apply(this, arguments)
-      } catch (e) {
-        requestErrorCh.publish(e)
-        throw e
+        return method.apply(this, arguments)
+      } else {
+        return method.apply(this, arguments)
+          .then(
+            response => {
+              requestFinishCh.publish()
+              return response
+            },
+            error => {
+              requestErrorCh.publish(error)
+              requestFinishCh.publish()
+              throw error
+            }
+          )
       }
     })
-  })
+  }
+}
+
+function massWrap (obj, methods, wrapper) {
+  for (const method of methods) {
+    if (typeof obj[method] === 'function') {
+      shimmer.wrap(obj, method, wrapper)
+    }
+  }
+}
+
+addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'] }, (obj) => {
+  const Subscription = obj.Subscription
 
   shimmer.wrap(Subscription.prototype, 'emit', emit => function (eventName, message) {
     if (eventName !== 'message' || !message) return emit.apply(this, arguments)
@@ -98,3 +158,16 @@ addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'], file: 'build/src/le
 
   return obj
 })
+
+addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'] }, (obj) => {
+  const { PublisherClient, SchemaServiceClient, SubscriberClient } = obj.v1
+
+  massWrap(PublisherClient.prototype, publisherMethods, wrapMethod)
+  massWrap(SubscriberClient.prototype, subscriberMethods, wrapMethod)
+
+  if (SchemaServiceClient) {
+    massWrap(SchemaServiceClient.prototype, schemaServiceMethods, wrapMethod)
+  }
+
+  return obj
+})