dd-trace 5.0.0-pre-8a512a2 → 5.0.0-pre-0a30f33

package/CONTRIBUTING.md

@@ -4,4 +4,70 @@ Please reach out before starting work on any major code changes.
 This will ensure we avoid duplicating work, or that your code can't be merged due to a rapidly changing
 base. If you would like support for a module that is not listed, [contact support][1] to share a request.
 
+## Keep changes small and incremental
+
+Changes should be incremental and understandable. As much as possible, large-scale efforts should be broken up into many PRs over time for better reviewability. If a feature would require more changes to be "complete" it's fine to land partial changes if they are not wired up to anything yet, so long as tests are included which at least prove those parts work in isolation.
+
+There are great benefits to taking a measured and iterative approach to improvement. When working on code in fewer places there is far less risk of running into merge conflicts or incompatibilities with other systems. Keeping contributions small makes them easy to review which makes that much quicker to land. Additionally, keeping things small and iterative makes it easier for other teams to review and understand what the code does.
+
+## Be descriptive
+
+Sometimes code can be self-documenting, but often it can't. That is especially true to someone reviewing code they haven't worked on. Be conscious of writing code in a self-describing way and leave comments anywhere that self-description fails. This goes a long way towards making even complex code coherent to one not already familiar with it.
+
+Try to write code in a way the describes the intent when read. For example, verbs can be used for function and method names to communicate that they are used to do some specific action. In doing so it becomes clear when referenced by name elsewhere that it is a function and what the function is meant to do. If a function can not be described with a simple verb it's probably too complex or does too many things.
+
+## Give your code space
+
+Very dense code is hard to read. It helps to make use of empty lines to separate logical groupings of statements. Long lines should be split up into multiple lines to make them more readable. Complex objects or arrays should generally be split over several lines. Sometimes it's a good idea to assign a variable only to immediately use it in a call as it can be more descriptive than just using the expression in place. It's not always clear what an argument is for if it doesn't visibly have a name somehow. Remember, lines are free, our time is not.
+
+## Avoid large refactors
+
+Large refactors should generally be avoided in favour of iterative approaches. For example, rather than rewriting how every plugin works, one might make a special-case plugin that works a bit different for their particular use-case. If several dozen files need to change to add a feature we've probably done something wrong.
+
+Sometimes new patterns or new ideas emerge which would be a substantial improvement over the existing state. It can be tempting to want to go all-in on a new way to do something, but the code churn can be hard to manage. It's best to introduce such new things incrementally and advocate for their adoption gradually through the rest of the codebase. As old systems are gradually phased out, the infrastructure which supports them can be deleted or relegated to lazy-loading only if and when that specific part of the system needs to be used.
+
+## Test everything
+
+It's very difficult to know if a change is valid unless there are tests to prove it. As an extension of that, it's also difficult to know the _use_ of that code is valid if the way it is integrated is not propertly tested. For this reason we generally favour integration tests over unit tests. If an API is expected to be used in different places or in different ways then it should generally include unit tests too for each unique scenario, however great care should be taken to ensure unit tests are actually testing the _logic_ and not just testing the _mocks_. It's a very common mistake to write a unit test that abstracts away the actual use of the interface so much that it doesn't actually test how that interface works in real-world scenarios. Remember to test how it handles failures, how it operates under heavy load, and how it impacts usability of what its purpose is.
+
+## Don't forget benchmarks
+
+Observability products tend to have quite a bit of their behaviour running in app code hot paths. It's important we extensively benchmark anything we expect to have heavy use to ensure it performs well and we don't cause any significant regressions through future changes. Measuring once at the time of writing is insufficient--a graph with just one data point is not going to tell you much of anything.
+
+## Always consider backportability
+
+To reduce delta between release lines and make it easier for us to support older versions we try as much as possible to backport every change we can. We should be diligent about keeping breaking changes to a minimum and ensuring we don't use language or runtime features which are too new. This way we can generally be confident that a change can be backported.
+
+To reduce the surface area of a breaking change, the breaking aspects could be placed behind a flag which is disabled by default or isolated to a function. In the next major the change would then be just to change the default of the flag or to start or stop calling the isolated function. By isolating the breaking logic it also becomes easier to delete later when it's no longer relevant on any release line.
+
+Currently we do not have CI to test PRs for mergeability to past release lines, but we intend to expand our CI to include that in the future. For the time being, it's recommended when developing locally to try to cherry-pick your changes onto the previous vN.x branches to see if the tests pass there too.
+
+## Respect semantic versioning
+
+This library follows the semantic versioning standard, but there are some subtleties left under-specified so this section is meant to clarify exactly how we interpret the meaning of semver. Additionally, it exists to communicate that we also use semver labels on all PRs to indicate which type of release the change should land in. Outside contributions should be evaluated and a semver label selected by the relevant team.
+
+### semver-patch
+
+If the change is a bug or security fix, it should be labelled as semver-patch. These changes should generally not alter existing behaviour in any way other than to correct the specific issue.
+
+### semver-minor
+
+Any addition of new functionality should be labelled as semver-minor and should not change any existing behaviour either in how any existing API works or in changing the contents or value of any existing data being reported except in purely additive cases where all existing data retains its prior state. Such changes may include new configuration options which when used will change behaviour, or may include the addition of new data being captured such as a new instrumentation, but should not impact the current operating design of any existing features.
+
+### semver-major
+
+In the event that some existing functionality _does_ need to change, as much as possible the non-breaking aspects of that change should be made in a semver-minor PR and the actually breaking aspects should be done via a follow-up PR with only the specific aspects which are breaking. Remember to [always consider backportability](#always-consider-backportability).
+
+## Indicate intended release targets
+
+When writing major changes we use a series of labels in the form of `dont-land-on-vN.x` where N is the major release line which a PR should not land in. Every PR marked as semver-major should include these tags. These tags allow our [branch-diff](https://github.com/bengl/branch-diff) tooling to work smoothly as we can exclude PRs not intended for the release line we're preparing a release proposal for. The `semver-major` labels on their own are not sufficient as they don't encode any indication of from _which_ releases they are a major change.
+
+For outside contributions we will have the relevant team add these labels when they review and determine when they plan to release it.
+
+## Ensure all tests are green
+
+We follow an all-green policy which means that for any PR to be merged _all_ tests must be passing. If a test is flaky or failing consistently the owner of that test should make it a priority to fix that test and unblock other teams from landing changes. For outside contributors there are currently several tests which will always fail as full CI permission is required. For these PRs our current process is for the relevant team to copy the PR and resubmit it to run tests as a user with full CI permission.
+
+Eventually we plan to look into putting these permission-required tests behind a label which team members can add to their PRs at creation to run the full CI and can add to outside contributor PRs to trigger the CI from their own user credentials. If the label is not present there will be another action which checks the label is present. Rather than showing a bunch of confusing failures to new contributors it would just show a single job failure which indicates an additional label is required, and we can name it in a way that makes it clear that it's not the responsibility of the outside contributor to add it. Something like `approve-full-ci` is one possible choice there.
+
 [1]: https://docs.datadoghq.com/help

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.0.0-pre-8a512a2",
+  "version": "5.0.0-pre-0a30f33",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -37,6 +37,7 @@
     "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:integration:serverless": "mocha --colors --timeout 30000 \"integration-tests/serverless/*.spec.js\"",
+    "test:integration:plugins": "mocha --colors --timeout 30000 \"packages/datadog-plugin-*/test/integration-test/*.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'",
@@ -77,7 +78,7 @@
     "crypto-randomuuid": "^1.0.0",
     "diagnostics_channel": "^1.1.0",
     "ignore": "^5.2.4",
-    "import-in-the-middle": "^1.4.1",
+    "import-in-the-middle": "^1.4.2",
     "int64-buffer": "^0.1.9",
     "ipaddr.js": "^2.1.0",
     "istanbul-lib-coverage": "3.2.0",

package/packages/datadog-esbuild/index.js

@@ -50,12 +50,18 @@ for (const pkg of INSTRUMENTED) {
 module.exports.name = 'datadog-esbuild'
 
 module.exports.setup = function (build) {
+  const externalModules = new Set(build.initialOptions.external || [])
   build.onResolve({ filter: /.*/ }, args => {
+    if (externalModules.has(args.path)) {
+      if (DEBUG) console.log(`EXTERNAL: ${args.path}`)
+      return
+    }
+
     let fullPathToModule
     try {
       fullPathToModule = dotFriendlyResolve(args.path, args.resolveDir)
     } catch (err) {
-      console.warn(`Unable to find "${args.path}". Is the package dead code?`)
+      console.warn(`MISSING: Unable to find "${args.path}". Is the package dead code?`)
       return
     }
     const extracted = extractPackageAndModulePath(fullPathToModule)
@@ -74,7 +80,7 @@ module.exports.setup = function (build) {
       } catch (err) {
         if (err.code === 'MODULE_NOT_FOUND') {
           if (!internal) {
-            console.warn(`Unable to find "${extracted.pkg}/package.json". Is the package dead code?`)
+            console.warn(`MISSING: Unable to find "${extracted.pkg}/package.json". Is the package dead code?`)
           }
           return
         } else {
@@ -84,7 +90,7 @@ module.exports.setup = function (build) {
 
       const packageJson = require(pathToPackageJson)
 
-      if (DEBUG) console.log(`RESOLVE ${packageName}@${packageJson.version}`)
+      if (DEBUG) console.log(`RESOLVE: ${packageName}@${packageJson.version}`)
 
       // https://esbuild.github.io/plugins/#on-resolve-arguments
       return {
@@ -114,7 +120,7 @@ module.exports.setup = function (build) {
   build.onLoad({ filter: /.*/, namespace: NAMESPACE }, args => {
     const data = args.pluginData
 
-    if (DEBUG) console.log(`LOAD ${data.pkg}@${data.version}, pkg "${data.path}"`)
+    if (DEBUG) console.log(`LOAD: ${data.pkg}@${data.version}, pkg "${data.path}"`)
 
     const path = data.raw !== data.pkg
       ? `${data.pkg}/${data.path}`

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

@@ -74,7 +74,7 @@ function wrap (prefix, fn) {
     return asyncResource.runInAsyncScope(() => {
       const cb = callbackResource.bind(arguments[callbackIndex])
 
-      startCh.publish({ bucket: { name: this.name || this._name } })
+      startCh.publish({ bucket: { name: this.name || this._name }, seedNodes: this._dd_hosts })
 
       arguments[callbackIndex] = asyncResource.bind(function (error, result) {
         if (error) {
@@ -146,7 +146,8 @@ function wrapWithName (name) {
     return function () { // no arguments used by us
       return wrapCBandPromise(operation, name, {
         collection: { name: this._name || '_default' },
-        bucket: { name: this._scope._bucket._name }
+        bucket: { name: this._scope._bucket._name },
+        seedNodes: this._dd_connStr
       }, this, arguments)
     }
   }
@@ -155,7 +156,7 @@ function wrapWithName (name) {
 function wrapV3Query (query) {
   return function (q) {
     const resource = getQueryResource(q)
-    return wrapCBandPromise(query, 'query', { resource }, this, arguments)
+    return wrapCBandPromise(query, 'query', { resource, seedNodes: this._connStr }, this, arguments)
   }
 }
 
@@ -179,7 +180,7 @@ addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^2.6.12'] }, Buc
 
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     return asyncResource.runInAsyncScope(() => {
-      startCh.publish({ resource: n1qlQuery, bucket: { name: this.name || this._name } })
+      startCh.publish({ resource: n1qlQuery, bucket: { name: this.name || this._name }, seedNodes: this._dd_hosts })
 
       emitter.once('rows', asyncResource.bind(() => {
         finishCh.publish(undefined)
@@ -212,11 +213,32 @@ addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^2.6.12'] }, Cl
   Cluster.prototype._maybeInvoke = wrapMaybeInvoke(Cluster.prototype._maybeInvoke)
   Cluster.prototype.query = wrapQuery(Cluster.prototype.query)
 
+  shimmer.wrap(Cluster.prototype, 'openBucket', openBucket => {
+    return function () {
+      const bucket = openBucket.apply(this, arguments)
+      const hosts = this.dsnObj.hosts
+      bucket._dd_hosts = hosts.map(hostAndPort => hostAndPort.join(':')).join(',')
+      return bucket
+    }
+  })
   return Cluster
 })
 
 // semver >=3 <3.2.0
 
+addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^3.0.7', '^3.1.3'] }, Bucket => {
+  shimmer.wrap(Bucket.prototype, 'collection', getCollection => {
+    return function () {
+      const collection = getCollection.apply(this, arguments)
+      const connStr = this._cluster._connStr
+      collection._dd_connStr = connStr
+      return collection
+    }
+  })
+
+  return Bucket
+})
+
 addHook({ name: 'couchbase', file: 'lib/collection.js', versions: ['^3.0.7', '^3.1.3'] }, Collection => {
   wrapAllNames(['upsert', 'insert', 'replace'], name => {
     shimmer.wrap(Collection.prototype, name, wrapWithName(name))
@@ -242,7 +264,21 @@ addHook({ name: 'couchbase', file: 'dist/collection.js', versions: ['>=3.2.0'] }
   return collection
 })
 
-addHook({ name: 'couchbase', file: 'dist/cluster.js', versions: ['3.2.0 - 3.2.1', '>=3.2.2'] }, cluster => {
+addHook({ name: 'couchbase', file: 'dist/bucket.js', versions: ['>=3.2.0'] }, bucket => {
+  const Bucket = bucket.Bucket
+  shimmer.wrap(Bucket.prototype, 'collection', getCollection => {
+    return function () {
+      const collection = getCollection.apply(this, arguments)
+      const connStr = this._cluster._connStr
+      collection._dd_connStr = connStr
+      return collection
+    }
+  })
+
+  return bucket
+})
+
+addHook({ name: 'couchbase', file: 'dist/cluster.js', versions: ['3.2.0 - 3.2.1', '>=3.2.2'] }, (cluster) => {
   const Cluster = cluster.Cluster
 
   shimmer.wrap(Cluster.prototype, 'query', wrapV3Query)

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

@@ -21,6 +21,8 @@ const skippableSuitesCh = channel('ci:cucumber:test-suite:skippable')
 const sessionStartCh = channel('ci:cucumber:session:start')
 const sessionFinishCh = channel('ci:cucumber:session:finish')
 
+const itrSkippedSuitesCh = channel('ci:cucumber:itr:skipped-suites')
+
 const {
   getCoveredFilenamesFromCoverage,
   resetCoverage,
@@ -37,7 +39,6 @@ const patched = new WeakSet()
 
 let pickleByFile = {}
 const pickleResultByFile = {}
-let isSuitesSkipped = false
 
 function getSuiteStatusFromTestStatuses (testStatuses) {
   if (testStatuses.some(status => status === 'fail')) {
@@ -216,11 +217,18 @@ addHook({
   file: 'lib/runtime/test_case_runner.js'
 }, testCaseHook)
 
-function getPicklesToRun (runtime, suitesToSkip) {
-  return runtime.pickleIds.filter((pickleId) => {
+function getFilteredPickles (runtime, suitesToSkip) {
+  return runtime.pickleIds.reduce((acc, pickleId) => {
     const test = runtime.eventDataCollector.getPickle(pickleId)
-    return !suitesToSkip.includes(getTestSuitePath(test.uri, process.cwd()))
-  }, {})
+    const testSuitePath = getTestSuitePath(test.uri, process.cwd())
+    const isSkipped = suitesToSkip.includes(testSuitePath)
+    if (isSkipped) {
+      acc.skippedSuites.add(testSuitePath)
+    } else {
+      acc.picklesToRun.push(pickleId)
+    }
+    return acc
+  }, { skippedSuites: new Set(), picklesToRun: [] })
 }
 
 function getPickleByFile (runtime) {
@@ -239,7 +247,7 @@ addHook({
   name: '@cucumber/cucumber',
   versions: ['>=7.0.0'],
   file: 'lib/runtime/index.js'
-}, (runtimePackage, cucumberVersion) => {
+}, (runtimePackage, frameworkVersion) => {
   shimmer.wrap(runtimePackage.default.prototype, 'start', start => async function () {
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     let onDone
@@ -263,11 +271,16 @@ addHook({
     })
 
     const { err, skippableSuites } = await skippableSuitesPromise
+    let skippedSuites = []
+    let isSuitesSkipped = false
 
     if (!err) {
-      const newPickleIds = getPicklesToRun(this, skippableSuites)
-      isSuitesSkipped = newPickleIds.length !== this.pickleIds.length
-      this.pickleIds = newPickleIds
+      const filteredPickles = getFilteredPickles(this, skippableSuites)
+      const { picklesToRun } = filteredPickles
+      isSuitesSkipped = picklesToRun.length !== this.pickleIds.length
+      this.pickleIds = picklesToRun
+
+      skippedSuites = Array.from(filteredPickles.skippedSuites)
     }
 
     pickleByFile = getPickleByFile(this)
@@ -276,8 +289,13 @@ addHook({
     const command = process.env.npm_lifecycle_script || `cucumber-js ${processArgv}`
 
     asyncResource.runInAsyncScope(() => {
-      sessionStartCh.publish({ command, frameworkVersion: cucumberVersion })
+      sessionStartCh.publish({ command, frameworkVersion })
     })
+
+    if (!err && skippedSuites.length) {
+      itrSkippedSuitesCh.publish({ skippedSuites, frameworkVersion })
+    }
+
     const success = await start.apply(this, arguments)
 
     let testCodeCoverageLinesTotal
@@ -296,7 +314,8 @@ addHook({
       sessionFinishCh.publish({
         status: success ? 'pass' : 'fail',
         isSuitesSkipped,
-        testCodeCoverageLinesTotal
+        testCodeCoverageLinesTotal,
+        numSkippedSuites: skippedSuites.length
       })
     })
     return success

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

@@ -30,6 +30,8 @@ function createWrapEmit (ctx) {
 function createWrapRequest (authority, options) {
   return function wrapRequest (request) {
     return function (headers) {
+      if (!startChannel.hasSubscribers) return request.apply(this, arguments)
+
       const ctx = { headers, authority, options }
 
       return startChannel.runStores(ctx, () => {

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

@@ -39,10 +39,13 @@ const testErrCh = channel('ci:jest:test:err')
 const skippableSuitesCh = channel('ci:jest:test-suite:skippable')
 const jestItrConfigurationCh = channel('ci:jest:itr-configuration')
 
+const itrSkippedSuitesCh = channel('ci:jest:itr:skipped-suites')
+
 let skippableSuites = []
 let isCodeCoverageEnabled = false
 let isSuitesSkippingEnabled = false
 let isSuitesSkipped = false
+let numSkippedSuites = 0
 
 const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 
@@ -191,7 +194,7 @@ addHook({
 addHook({
   name: '@jest/test-sequencer',
   versions: ['>=24.8.0']
-}, sequencerPackage => {
+}, (sequencerPackage, frameworkVersion) => {
   shimmer.wrap(sequencerPackage.default.prototype, 'shard', shard => function () {
     const shardedTests = shard.apply(this, arguments)
 
@@ -202,13 +205,15 @@ addHook({
     const [test] = shardedTests
     const rootDir = test && test.context && test.context.config && test.context.config.rootDir
 
-    const filteredTests = getJestSuitesToRun(skippableSuites, shardedTests, rootDir || process.cwd())
+    const { skippedSuites, suitesToRun } = getJestSuitesToRun(skippableSuites, shardedTests, rootDir || process.cwd())
 
-    isSuitesSkipped = filteredTests.length !== shardedTests.length
+    isSuitesSkipped = suitesToRun.length !== shardedTests.length
+    numSkippedSuites = skippedSuites.length
 
-    skippableSuites = []
+    itrSkippedSuitesCh.publish({ skippedSuites, frameworkVersion })
 
-    return filteredTests
+    skippableSuites = []
+    return suitesToRun
   })
   return sequencerPackage
 })
@@ -279,10 +284,13 @@ function cliWrapper (cli, jestVersion) {
         isSuitesSkipped,
         isSuitesSkippingEnabled,
         isCodeCoverageEnabled,
-        testCodeCoverageLinesTotal
+        testCodeCoverageLinesTotal,
+        numSkippedSuites
       })
     })
 
+    numSkippedSuites = 0
+
     return result
   })
 
@@ -468,7 +476,7 @@ addHook({
   name: '@jest/core',
   versions: ['>=24.8.0'],
   file: 'build/SearchSource.js'
-}, searchSourcePackage => {
+}, (searchSourcePackage, frameworkVersion) => {
   const SearchSource = searchSourcePackage.default ? searchSourcePackage.default : searchSourcePackage
 
   shimmer.wrap(SearchSource.prototype, 'getTestPaths', getTestPaths => async function () {
@@ -492,13 +500,16 @@ addHook({
     const testPaths = await getTestPaths.apply(this, arguments)
     const { tests } = testPaths
 
-    const filteredTests = getJestSuitesToRun(skippableSuites, tests, rootDir)
+    const { skippedSuites, suitesToRun } = getJestSuitesToRun(skippableSuites, tests, rootDir)
+
+    isSuitesSkipped = suitesToRun.length !== tests.length
+    numSkippedSuites = skippedSuites.length
 
-    isSuitesSkipped = filteredTests.length !== tests.length
+    itrSkippedSuitesCh.publish({ skippedSuites, frameworkVersion })
 
     skippableSuites = []
 
-    return { ...testPaths, tests: filteredTests }
+    return { ...testPaths, tests: suitesToRun }
   })
 
   return searchSourcePackage

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

@@ -30,6 +30,8 @@ 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')
 
+const itrSkippedSuitesCh = channel('ci:mocha:itr:skipped-suites')
+
 // TODO: remove when root hooks and fixtures are implemented
 const patched = new WeakSet()
 
@@ -47,6 +49,7 @@ const originalCoverageMap = createCoverageMap()
 let suitesToSkip = []
 let frameworkVersion
 let isSuitesSkipped = false
+let skippedSuites = []
 
 function getSuitesByTestFile (root) {
   const suitesByTestFile = {}
@@ -97,10 +100,17 @@ function getTestAsyncResource (test) {
   return testToAr.get(originalFn)
 }
 
-function getSuitesToRun (originalSuites) {
-  return originalSuites.filter(suite =>
-    !suitesToSkip.includes(getTestSuitePath(suite.file, process.cwd()))
-  )
+function getFilteredSuites (originalSuites) {
+  return originalSuites.reduce((acc, suite) => {
+    const testPath = getTestSuitePath(suite.file, process.cwd())
+    const shouldSkip = suitesToSkip.includes(testPath)
+    if (shouldSkip) {
+      acc.skippedSuites.add(testPath)
+    } else {
+      acc.suitesToRun.push(suite)
+    }
+    return acc
+  }, { suitesToRun: [], skippedSuites: new Set() })
 }
 
 function mochaHook (Runner) {
@@ -137,13 +147,21 @@ function mochaHook (Runner) {
         global.__coverage__ = fromCoverageMapToCoverage(originalCoverageMap)
       }
 
-      testSessionFinishCh.publish({ status, isSuitesSkipped, testCodeCoverageLinesTotal })
+      testSessionFinishCh.publish({
+        status,
+        isSuitesSkipped,
+        testCodeCoverageLinesTotal,
+        numSkippedSuites: skippedSuites.length
+      })
     }))
 
     this.once('start', testRunAsyncResource.bind(function () {
       const processArgv = process.argv.slice(2).join(' ')
       const command = `mocha ${processArgv}`
       testSessionStartCh.publish({ command, frameworkVersion })
+      if (skippedSuites.length) {
+        itrSkippedSuitesCh.publish({ skippedSuites, frameworkVersion })
+      }
     }))
 
     this.on('suite', function (suite) {
@@ -359,9 +377,13 @@ addHook({
         suitesToSkip = skippableSuites
       }
       // We remove the suites that we skip through ITR
-      const newSuites = getSuitesToRun(runner.suite.suites)
-      isSuitesSkipped = newSuites.length !== runner.suite.suites.length
-      runner.suite.suites = newSuites
+      const filteredSuites = getFilteredSuites(runner.suite.suites)
+      const { suitesToRun } = filteredSuites
+
+      isSuitesSkipped = suitesToRun.length !== runner.suite.suites.length
+      runner.suite.suites = suitesToRun
+
+      skippedSuites = Array.from(filteredSuites.skippedSuites)
 
       global.run()
     }

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

@@ -2,7 +2,7 @@
 
 // TODO: either instrument all or none of the render functions
 
-const { channel, addHook, AsyncResource } = require('./helpers/instrument')
+const { channel, addHook } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 const { DD_MAJOR } = require('../../../version')
 
@@ -11,7 +11,7 @@ const finishChannel = channel('apm:next:request:finish')
 const errorChannel = channel('apm:next:request:error')
 const pageLoadChannel = channel('apm:next:page:load')
 
-const requestResources = new WeakMap()
+const requests = new WeakSet()
 
 function wrapHandleRequest (handleRequest) {
   return function (req, res, pathname, query) {
@@ -105,38 +105,40 @@ function getPageFromPath (page, dynamicRoutes = []) {
 }
 
 function instrument (req, res, handler) {
-  if (requestResources.has(req)) return handler()
+  req = req.originalRequest || req
+  res = res.originalResponse || res
 
-  const requestResource = new AsyncResource('bound-anonymous-fn')
+  if (requests.has(req)) return handler()
 
-  requestResources.set(req, requestResource)
+  requests.add(req)
 
-  return requestResource.runInAsyncScope(() => {
-    startChannel.publish({ req, res })
+  const ctx = { req, res }
 
+  return startChannel.runStores(ctx, () => {
     try {
-      const promise = handler()
+      const promise = handler(ctx)
 
       // 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)
+        result => finish(ctx, result),
+        err => finish(ctx, null, err)
       )
     } catch (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)
+      return finish(ctx, null, e)
     }
   })
 }
 
-function finish (req, res, result, err) {
+function finish (ctx, result, err) {
   if (err) {
-    errorChannel.publish(err)
+    ctx.error = err
+    errorChannel.publish(ctx)
   }
 
-  finishChannel.publish({ req, res })
+  finishChannel.publish(ctx)
 
   if (err) {
     throw err

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

@@ -11,8 +11,12 @@ const startCh = channel('apm:pg:query:start')
 const finishCh = channel('apm:pg:query:finish')
 const errorCh = channel('apm:pg:query:error')
 
+const startPoolQueryCh = channel('datadog:pg:pool:query:start')
+const finishPoolQueryCh = channel('datadog:pg:pool:query:finish')
+
 addHook({ name: 'pg', versions: ['>=8.0.3'] }, pg => {
   shimmer.wrap(pg.Client.prototype, 'query', query => wrapQuery(query))
+  shimmer.wrap(pg.Pool.prototype, 'query', query => wrapPoolQuery(query))
   return pg
 })
 
@@ -97,3 +101,45 @@ function wrapQuery (query) {
     })
   }
 }
+
+function wrapPoolQuery (query) {
+  return function () {
+    if (!startPoolQueryCh.hasSubscribers) {
+      return query.apply(this, arguments)
+    }
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+    const pgQuery = arguments[0] && typeof arguments[0] === 'object' ? arguments[0] : { text: arguments[0] }
+
+    return asyncResource.runInAsyncScope(() => {
+      startPoolQueryCh.publish({
+        query: pgQuery
+      })
+
+      const finish = asyncResource.bind(function () {
+        finishPoolQueryCh.publish()
+      })
+
+      const cb = arguments[arguments.length - 1]
+      if (typeof cb === 'function') {
+        arguments[arguments.length - 1] = shimmer.wrap(cb, function () {
+          finish()
+          return cb.apply(this, arguments)
+        })
+      }
+
+      const retval = query.apply(this, arguments)
+
+      if (retval && retval.then) {
+        retval.then(() => {
+          finish()
+        }).catch(() => {
+          finish()
+        })
+      }
+
+      return retval
+    })
+  }
+}