dd-trace 5.4.0 → 5.5.0

package/CONTRIBUTING.md

@@ -70,4 +70,102 @@ We follow an all-green policy which means that for any PR to be merged _all_ tes
 
 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.
 
+## Development Requirements
+
+Since this project supports multiple Node versions, using a version
+manager such as [nvm](https://github.com/creationix/nvm) is recommended.
+
+We use [yarn](https://yarnpkg.com/) for its workspace functionality, so make sure to install that as well.
+
+To install dependencies once you have Node and yarn installed, run:
+
+```sh
+$ yarn
+```
+
+
+## Testing
+
+Before running _plugin_ tests, the data stores need to be running.
+The easiest way to start all of them is to use the provided
+docker-compose configuration:
+
+```sh
+$ 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
+
+There are several types of unit tests, for various types of components. The
+following commands may be useful:
+
+```sh
+# Tracer core tests (i.e. testing `packages/dd-trace`)
+$ yarn test:trace:core
+# "Core" library tests (i.e. testing `packages/datadog-core`
+$ yarn test:core
+# Instrumentations tests (i.e. testing `packages/datadog-instrumentations`
+$ yarn test:instrumentations
+```
+
+Several other components have test commands as well. See `package.json` for
+details.
+
+To test _plugins_ (i.e. components in `packages/datadog-plugin-XXXX`
+directories, set the `PLUGINS` environment variable to the plugin you're
+interested in, and use `yarn test:plugins`. If you need to test multiple
+plugins you may separate then with a pipe (`|`) delimiter. Here's an
+example testing the `express` and `bluebird` plugins:
+
+```sh
+PLUGINS="express|bluebird" yarn test:plugins
+```
+
+
+### Memory Leaks
+
+To run the memory leak tests, use:
+
+```sh
+$ yarn leak:core
+
+# or
+
+$ yarn leak:plugins
+```
+
+
+### Linting
+
+We use [ESLint](https://eslint.org) to make sure that new code
+conforms to our coding standards.
+
+To run the linter, use:
+
+```sh
+$ yarn lint
+```
+
+
+### Benchmarks
+
+Our microbenchmarks live in `benchmark/sirun`. Each directory in there
+corresponds to a specific benchmark test and its variants, which are used to
+track regressions and improvements over time.
+
+In addition to those, when two or more approaches must be compared, please write
+a benchmark in the `benchmark/index.js` module so that we can keep track of the
+most efficient algorithm. To run your benchmark, use:
+
+```sh
+$ yarn bench
+```
+
+
 [1]: https://docs.datadoghq.com/help

package/README.md

@@ -62,95 +62,12 @@ For more information about library versioning and compatibility, see the [NodeJS
 Changes associated with each individual release are documented on the [GitHub Releases](https://github.com/DataDog/dd-trace-js/releases) screen.
 
 
-## Development
+## Development and Contribution
 
-Before contributing to this open source project, read our [CONTRIBUTING.md](https://github.com/DataDog/dd-trace-js/blob/master/CONTRIBUTING.md).
+Please read the [CONTRIBUTING.md](https://github.com/DataDog/dd-trace-js/blob/master/CONTRIBUTING.md) document before contributing to this open source project.
 
 
-## Requirements
-
-Since this project supports multiple Node versions, using a version
-manager such as [nvm](https://github.com/creationix/nvm) is recommended.
-
-We use [yarn](https://yarnpkg.com/) for its workspace functionality, so make sure to install that as well.
-
-To install dependencies once you have Node and yarn installed, run:
-
-```sh
-$ yarn
-```
-
-
-## Testing
-
-Before running _plugin_ tests, the data stores need to be running.
-The easiest way to start all of them is to use the provided
-docker-compose configuration:
-
-```sh
-$ 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
-
-There are several types of unit tests, for various types of components. The
-following commands may be useful:
-
-```sh
-# Tracer core tests (i.e. testing `packages/dd-trace`)
-$ yarn test:trace:core
-# "Core" library tests (i.e. testing `packages/datadog-core`
-$ yarn test:core
-# Instrumentations tests (i.e. testing `packages/datadog-instrumentations`
-$ yarn test:instrumentations
-```
-
-Several other components have test commands as well. See `package.json` for
-details.
-
-To test _plugins_ (i.e. components in `packages/datadog-plugin-XXXX`
-directories, set the `PLUGINS` environment variable to the plugin you're
-interested in, and use `yarn test:plugins`. If you need to test multiple
-plugins you may separate then with a pipe (`|`) delimiter. Here's an
-example testing the `express` and `bluebird` plugins:
-
-```sh
-PLUGINS="express|bluebird" yarn test:plugins
-```
-
-
-### Memory Leaks
-
-To run the memory leak tests, use:
-
-```sh
-$ yarn leak:core
-
-# or
-
-$ yarn leak:plugins
-```
-
-
-### Linting
-
-We use [ESLint](https://eslint.org) to make sure that new code
-conforms to our coding standards.
-
-To run the linter, use:
-
-```sh
-$ yarn lint
-```
-
-
-### Experimental ESM Support
+## Experimental ESM Support
 
 > **Warning**
 > 
@@ -168,21 +85,6 @@ node --loader dd-trace/loader-hook.mjs entrypoint.js
 ```
 
 
-### Benchmarks
-
-Our microbenchmarks live in `benchmark/sirun`. Each directory in there
-corresponds to a specific benchmark test and its variants, which are used to
-track regressions and improvements over time.
-
-In addition to those, when two or more approaches must be compared, please write
-a benchmark in the `benchmark/index.js` module so that we can keep track of the
-most efficient algorithm. To run your benchmark, use:
-
-```sh
-$ yarn bench
-```
-
-
 ## Serverless / Lambda
 
 Note that there is a separate Lambda project, [datadog-lambda-js](https://github.com/DataDog/datadog-lambda-js), that is responsible for enabling metrics and distributed tracing when your application runs on Lambda.
@@ -199,4 +101,4 @@ If you would like to trace your bundled application then please read this page o
 
 ## Security Vulnerabilities
 
-If you have found a security issue, please contact the security team directly at [security@datadoghq.com](mailto:security@datadoghq.com).
+Please refer to the [SECURITY.md](https://github.com/DataDog/dd-trace-js/blob/master/SECURITY.md) document if you have found a security issue.

package/ci/cypress/after-run.js

@@ -0,0 +1 @@
+module.exports = require('../../packages/datadog-plugin-cypress/src/after-run')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.4.0",
+  "version": "5.5.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",

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

@@ -17,6 +17,7 @@ const testSuiteFinishCh = channel('ci:cucumber:test-suite:finish')
 const testSuiteCodeCoverageCh = channel('ci:cucumber:test-suite:code-coverage')
 
 const libraryConfigurationCh = channel('ci:cucumber:library-configuration')
+const knownTestsCh = channel('ci:cucumber:known-tests')
 const skippableSuitesCh = channel('ci:cucumber:test-suite:skippable')
 const sessionStartCh = channel('ci:cucumber:session:start')
 const sessionFinishCh = channel('ci:cucumber:session:finish')
@@ -41,12 +42,18 @@ const originalCoverageMap = createCoverageMap()
 // TODO: remove in a later major version
 const patched = new WeakSet()
 
+const lastStatusByPickleId = new Map()
+const numRetriesByPickleId = new Map()
+
 let pickleByFile = {}
 const pickleResultByFile = {}
 let skippableSuites = []
 let itrCorrelationId = ''
 let isForcedToRun = false
 let isUnskippable = false
+let isEarlyFlakeDetectionEnabled = false
+let earlyFlakeDetectionNumRetries = 0
+let knownTests = []
 
 function getSuiteStatusFromTestStatuses (testStatuses) {
   if (testStatuses.some(status => status === 'fail')) {
@@ -84,6 +91,20 @@ function getStatusFromResultLatest (result) {
   return { status: 'fail', errorMessage: result.message }
 }
 
+function isNewTest (testSuite, testName) {
+  return !knownTests.includes(`cucumber.${testSuite}.${testName}`)
+}
+
+function getTestStatusFromRetries (testStatuses) {
+  if (testStatuses.every(status => status === 'fail')) {
+    return 'fail'
+  }
+  if (testStatuses.some(status => status === 'pass')) {
+    return 'pass'
+  }
+  return 'pass'
+}
+
 function wrapRun (pl, isLatestVersion) {
   if (patched.has(pl)) return
 
@@ -98,18 +119,7 @@ function wrapRun (pl, isLatestVersion) {
     return asyncResource.runInAsyncScope(() => {
       const testFileAbsolutePath = this.pickle.uri
 
-      if (!pickleResultByFile[testFileAbsolutePath]) { // first test in suite
-        isUnskippable = isMarkedAsUnskippable(this.pickle)
-        const testSuitePath = getTestSuitePath(testFileAbsolutePath, process.cwd())
-        isForcedToRun = isUnskippable && skippableSuites.includes(testSuitePath)
-
-        testSuiteStartCh.publish({ testSuitePath, isUnskippable, isForcedToRun, itrCorrelationId })
-      }
-
-      const testSourceLine = this.gherkinDocument &&
-        this.gherkinDocument.feature &&
-        this.gherkinDocument.feature.location &&
-        this.gherkinDocument.feature.location.line
+      const testSourceLine = this.gherkinDocument?.feature?.location?.line
 
       testStartCh.publish({
         testName: this.pickle.name,
@@ -123,30 +133,20 @@ function wrapRun (pl, isLatestVersion) {
           const { status, skipReason, errorMessage } = isLatestVersion
             ? getStatusFromResultLatest(result) : getStatusFromResult(result)
 
-          if (!pickleResultByFile[testFileAbsolutePath]) {
-            pickleResultByFile[testFileAbsolutePath] = [status]
+          if (lastStatusByPickleId.has(this.pickle.id)) {
+            lastStatusByPickleId.get(this.pickle.id).push(status)
           } else {
-            pickleResultByFile[testFileAbsolutePath].push(status)
+            lastStatusByPickleId.set(this.pickle.id, [status])
           }
-          testFinishCh.publish({ status, skipReason, errorMessage })
-          // last test in suite
-          if (pickleResultByFile[testFileAbsolutePath].length === pickleByFile[testFileAbsolutePath].length) {
-            const testSuiteStatus = getSuiteStatusFromTestStatuses(pickleResultByFile[testFileAbsolutePath])
-            if (global.__coverage__) {
-              const coverageFiles = getCoveredFilenamesFromCoverage(global.__coverage__)
-
-              testSuiteCodeCoverageCh.publish({
-                coverageFiles,
-                suiteFile: testFileAbsolutePath
-              })
-              // 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)
+          let isNew = false
+          let isEfdRetry = false
+          if (isEarlyFlakeDetectionEnabled && status !== 'skip') {
+            const numRetries = numRetriesByPickleId.get(this.pickle.id)
+
+            isNew = numRetries !== undefined
+            isEfdRetry = numRetries > 0
           }
+          testFinishCh.publish({ status, skipReason, errorMessage, isNew, isEfdRetry })
         })
         return promise
       } catch (err) {
@@ -258,12 +258,11 @@ function getPickleByFile (runtime) {
   }, {})
 }
 
-addHook({
-  name: '@cucumber/cucumber',
-  versions: ['>=7.0.0'],
-  file: 'lib/runtime/index.js'
-}, (runtimePackage, frameworkVersion) => {
-  shimmer.wrap(runtimePackage.default.prototype, 'start', start => async function () {
+function getWrappedStart (start, frameworkVersion) {
+  return async function () {
+    if (!libraryConfigurationCh.hasSubscribers) {
+      return start.apply(this, arguments)
+    }
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     let onDone
 
@@ -275,7 +274,23 @@ addHook({
       libraryConfigurationCh.publish({ onDone })
     })
 
-    await configPromise
+    const configurationResponse = await configPromise
+
+    isEarlyFlakeDetectionEnabled = configurationResponse.libraryConfig?.isEarlyFlakeDetectionEnabled
+    earlyFlakeDetectionNumRetries = configurationResponse.libraryConfig?.earlyFlakeDetectionNumRetries
+
+    if (isEarlyFlakeDetectionEnabled) {
+      const knownTestsPromise = new Promise(resolve => {
+        onDone = resolve
+      })
+      asyncResource.runInAsyncScope(() => {
+        knownTestsCh.publish({ onDone })
+      })
+      const knownTestsResponse = await knownTestsPromise
+      if (!knownTestsResponse.err) {
+        knownTests = knownTestsResponse.knownTests
+      }
+    }
 
     const skippableSuitesPromise = new Promise(resolve => {
       onDone = resolve
@@ -342,11 +357,110 @@ addHook({
         testCodeCoverageLinesTotal,
         numSkippedSuites: skippedSuites.length,
         hasUnskippableSuites: isUnskippable,
-        hasForcedToRunSuites: isForcedToRun
+        hasForcedToRunSuites: isForcedToRun,
+        isEarlyFlakeDetectionEnabled
       })
     })
     return success
-  })
+  }
+}
+
+function getWrappedRunTest (runTestFunction) {
+  return async function (pickleId) {
+    const test = this.eventDataCollector.getPickle(pickleId)
+
+    const testFileAbsolutePath = test.uri
+    const testSuitePath = getTestSuitePath(testFileAbsolutePath, process.cwd())
+
+    if (!pickleResultByFile[testFileAbsolutePath]) { // first test in suite
+      isUnskippable = isMarkedAsUnskippable(test)
+      isForcedToRun = isUnskippable && skippableSuites.includes(testSuitePath)
+
+      testSuiteStartCh.publish({ testSuitePath, isUnskippable, isForcedToRun, itrCorrelationId })
+    }
+
+    let isNew = false
+
+    if (isEarlyFlakeDetectionEnabled) {
+      isNew = isNewTest(testSuitePath, test.name)
+      if (isNew) {
+        numRetriesByPickleId.set(pickleId, 0)
+      }
+    }
+    const runTestCaseResult = await runTestFunction.apply(this, arguments)
+
+    const testStatuses = lastStatusByPickleId.get(pickleId)
+    const lastTestStatus = testStatuses[testStatuses.length - 1]
+    // If it's a new test and it hasn't been skipped, we run it again
+    if (isEarlyFlakeDetectionEnabled && lastTestStatus !== 'skip' && isNew) {
+      for (let retryIndex = 0; retryIndex < earlyFlakeDetectionNumRetries; retryIndex++) {
+        numRetriesByPickleId.set(pickleId, retryIndex + 1)
+        await runTestFunction.apply(this, arguments)
+      }
+    }
+    let testStatus = lastTestStatus
+    if (isEarlyFlakeDetectionEnabled) {
+      /**
+       * If Early Flake Detection (EFD) is enabled the logic is as follows:
+       * - If all attempts for a test are failing, the test has failed and we will let the test process fail.
+       * - If just a single attempt passes, we will prevent the test process from failing.
+       * The rationale behind is the following: you may still be able to block your CI pipeline by gating
+       * on flakiness (the test will be considered flaky), but you may choose to unblock the pipeline too.
+       */
+      testStatus = getTestStatusFromRetries(testStatuses)
+      if (testStatus === 'pass') {
+        this.success = true
+      }
+    }
+
+    if (!pickleResultByFile[testFileAbsolutePath]) {
+      pickleResultByFile[testFileAbsolutePath] = [testStatus]
+    } else {
+      pickleResultByFile[testFileAbsolutePath].push(testStatus)
+    }
+
+    // last test in suite
+    if (pickleResultByFile[testFileAbsolutePath].length === pickleByFile[testFileAbsolutePath].length) {
+      const testSuiteStatus = getSuiteStatusFromTestStatuses(pickleResultByFile[testFileAbsolutePath])
+      if (global.__coverage__) {
+        const coverageFiles = getCoveredFilenamesFromCoverage(global.__coverage__)
+
+        testSuiteCodeCoverageCh.publish({
+          coverageFiles,
+          suiteFile: testFileAbsolutePath
+        })
+        // 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)
+    }
+
+    return runTestCaseResult
+  }
+}
+
+// From 7.3.0 onwards, runPickle becomes runTestCase
+addHook({
+  name: '@cucumber/cucumber',
+  versions: ['>=7.3.0'],
+  file: 'lib/runtime/index.js'
+}, (runtimePackage, frameworkVersion) => {
+  shimmer.wrap(runtimePackage.default.prototype, 'runTestCase', runTestCase => getWrappedRunTest(runTestCase))
+  shimmer.wrap(runtimePackage.default.prototype, 'start', start => getWrappedStart(start, frameworkVersion))
+
+  return runtimePackage
+})
+
+addHook({
+  name: '@cucumber/cucumber',
+  versions: ['>=7.0.0 <7.3.0'],
+  file: 'lib/runtime/index.js'
+}, (runtimePackage, frameworkVersion) => {
+  shimmer.wrap(runtimePackage.default.prototype, 'runPickle', runPickle => getWrappedRunTest(runPickle))
+  shimmer.wrap(runtimePackage.default.prototype, 'start', start => getWrappedStart(start, frameworkVersion))
 
   return runtimePackage
 })

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

@@ -58,6 +58,7 @@ let hasUnskippableSuites = false
 let hasForcedToRunSuites = false
 let isEarlyFlakeDetectionEnabled = false
 let earlyFlakeDetectionNumRetries = 0
+let hasFilteredSkippableSuites = false
 
 const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 
@@ -270,6 +271,23 @@ function getTestEnvironment (pkg, jestVersion) {
   return getWrappedEnvironment(pkg, jestVersion)
 }
 
+function applySuiteSkipping (originalTests, rootDir, frameworkVersion) {
+  const jestSuitesToRun = getJestSuitesToRun(skippableSuites, originalTests, rootDir || process.cwd())
+  hasFilteredSkippableSuites = true
+  log.debug(
+    () => `${jestSuitesToRun.suitesToRun.length} out of ${originalTests.length} suites are going to run.`
+  )
+  hasUnskippableSuites = jestSuitesToRun.hasUnskippableSuites
+  hasForcedToRunSuites = jestSuitesToRun.hasForcedToRunSuites
+
+  isSuitesSkipped = jestSuitesToRun.suitesToRun.length !== originalTests.length
+  numSkippedSuites = jestSuitesToRun.skippedSuites.length
+
+  itrSkippedSuitesCh.publish({ skippedSuites: jestSuitesToRun.skippedSuites, frameworkVersion })
+  skippableSuites = []
+  return jestSuitesToRun.suitesToRun
+}
+
 addHook({
   name: 'jest-environment-node',
   versions: ['>=24.8.0']
@@ -280,6 +298,51 @@ addHook({
   versions: ['>=24.8.0']
 }, getTestEnvironment)
 
+function getWrappedScheduleTests (scheduleTests, frameworkVersion) {
+  return async function (tests) {
+    if (!isSuitesSkippingEnabled || hasFilteredSkippableSuites) {
+      return scheduleTests.apply(this, arguments)
+    }
+    const [test] = tests
+    const rootDir = test?.context?.config?.rootDir
+
+    arguments[0] = applySuiteSkipping(tests, rootDir, frameworkVersion)
+
+    return scheduleTests.apply(this, arguments)
+  }
+}
+
+addHook({
+  name: '@jest/core',
+  file: 'build/TestScheduler.js',
+  versions: ['>=27.0.0']
+}, (testSchedulerPackage, frameworkVersion) => {
+  const oldCreateTestScheduler = testSchedulerPackage.createTestScheduler
+  const newCreateTestScheduler = async function () {
+    if (!isSuitesSkippingEnabled || hasFilteredSkippableSuites) {
+      return oldCreateTestScheduler.apply(this, arguments)
+    }
+    // If suite skipping is enabled and has not filtered skippable suites yet, we'll attempt to do it
+    const scheduler = await oldCreateTestScheduler.apply(this, arguments)
+    shimmer.wrap(scheduler, 'scheduleTests', scheduleTests => getWrappedScheduleTests(scheduleTests, frameworkVersion))
+    return scheduler
+  }
+  testSchedulerPackage.createTestScheduler = newCreateTestScheduler
+  return testSchedulerPackage
+})
+
+addHook({
+  name: '@jest/core',
+  file: 'build/TestScheduler.js',
+  versions: ['>=24.8.0 <27.0.0']
+}, (testSchedulerPackage, frameworkVersion) => {
+  shimmer.wrap(
+    testSchedulerPackage.default.prototype,
+    'scheduleTests', scheduleTests => getWrappedScheduleTests(scheduleTests, frameworkVersion)
+  )
+  return testSchedulerPackage
+})
+
 addHook({
   name: '@jest/test-sequencer',
   versions: ['>=24.8.0']
@@ -287,29 +350,13 @@ addHook({
   shimmer.wrap(sequencerPackage.default.prototype, 'shard', shard => function () {
     const shardedTests = shard.apply(this, arguments)
 
-    if (!shardedTests.length) {
+    if (!shardedTests.length || !isSuitesSkippingEnabled || !skippableSuites.length) {
       return shardedTests
     }
-    // TODO: could we get the rootDir from each test?
     const [test] = shardedTests
     const rootDir = test?.context?.config?.rootDir
 
-    const jestSuitesToRun = getJestSuitesToRun(skippableSuites, shardedTests, rootDir || process.cwd())
-
-    log.debug(
-      () => `${jestSuitesToRun.suitesToRun.length} out of ${shardedTests.length} suites are going to run.`
-    )
-
-    hasUnskippableSuites = jestSuitesToRun.hasUnskippableSuites
-    hasForcedToRunSuites = jestSuitesToRun.hasForcedToRunSuites
-
-    isSuitesSkipped = jestSuitesToRun.suitesToRun.length !== shardedTests.length
-    numSkippedSuites = jestSuitesToRun.skippedSuites.length
-
-    itrSkippedSuitesCh.publish({ skippedSuites: jestSuitesToRun.skippedSuites, frameworkVersion })
-
-    skippableSuites = []
-    return jestSuitesToRun.suitesToRun
+    return applySuiteSkipping(shardedTests, rootDir, frameworkVersion)
   })
   return sequencerPackage
 })
@@ -660,13 +707,13 @@ addHook({
   const SearchSource = searchSourcePackage.default ? searchSourcePackage.default : searchSourcePackage
 
   shimmer.wrap(SearchSource.prototype, 'getTestPaths', getTestPaths => async function () {
-    if (!skippableSuites.length) {
+    if (!isSuitesSkippingEnabled || !skippableSuites.length) {
       return getTestPaths.apply(this, arguments)
     }
 
     const [{ rootDir, shard }] = arguments
 
-    if (shard && shard.shardIndex) {
+    if (shard?.shardCount > 1) {
       // If the user is using jest sharding, we want to apply the filtering of tests in the shard process.
       // The reason for this is the following:
       // The tests for different shards are likely being run in different CI jobs so
@@ -680,21 +727,8 @@ addHook({
     const testPaths = await getTestPaths.apply(this, arguments)
     const { tests } = testPaths
 
-    const jestSuitesToRun = getJestSuitesToRun(skippableSuites, tests, rootDir)
-
-    log.debug(() => `${jestSuitesToRun.suitesToRun.length} out of ${tests.length} suites are going to run.`)
-
-    hasUnskippableSuites = jestSuitesToRun.hasUnskippableSuites
-    hasForcedToRunSuites = jestSuitesToRun.hasForcedToRunSuites
-
-    isSuitesSkipped = jestSuitesToRun.suitesToRun.length !== tests.length
-    numSkippedSuites = jestSuitesToRun.skippedSuites.length
-
-    itrSkippedSuitesCh.publish({ skippedSuites: jestSuitesToRun.skippedSuites, frameworkVersion })
-
-    skippableSuites = []
-
-    return { ...testPaths, tests: jestSuitesToRun.suitesToRun }
+    const suitesToRun = applySuiteSkipping(tests, rootDir, frameworkVersion)
+    return { ...testPaths, tests: suitesToRun }
   })
 
   return searchSourcePackage

package/packages/datadog-plugin-amqplib/src/consumer.js

@@ -28,9 +28,12 @@ class AmqplibConsumerPlugin extends ConsumerPlugin {
       }
     })
 
-    if (this.config.dsmEnabled && message) {
+    if (
+      this.config.dsmEnabled &&
+      message?.properties?.headers?.[CONTEXT_PROPAGATION_KEY]
+    ) {
       const payloadSize = getAmqpMessageSize({ headers: message.properties.headers, content: message.content })
-      const queue = fields.queue ?? fields.routingKey
+      const queue = fields.queue ? fields.queue : fields.routingKey
       this.tracer.decodeDataStreamsContext(message.properties.headers[CONTEXT_PROPAGATION_KEY])
       this.tracer
         .setCheckpoint(['direction:in', `topic:${queue}`, 'type:rabbitmq'], span, payloadSize)