dd-trace 4.28.0 → 4.30.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "4.28.0",
+  "version": "4.30.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -69,11 +69,11 @@
     "node": ">=16"
   },
   "dependencies": {
-    "@datadog/native-appsec": "7.0.0",
+    "@datadog/native-appsec": "7.1.0",
     "@datadog/native-iast-rewriter": "2.2.3",
     "@datadog/native-iast-taint-tracking": "1.7.0",
     "@datadog/native-metrics": "^2.0.0",
-    "@datadog/pprof": "5.0.0",
+    "@datadog/pprof": "5.1.0",
     "@datadog/sketches-js": "^2.1.0",
     "@opentelemetry/api": "^1.0.0",
     "@opentelemetry/core": "^1.14.0",

package/packages/datadog-core/src/utils/src/get.js

@@ -0,0 +1,11 @@
+'use strict'
+
+module.exports = (object, path) => {
+  const pathArr = path.split('.')
+  let val = object
+  for (const p of pathArr) {
+    if (val === undefined) return val
+    val = val[p]
+  }
+  return val
+}

package/packages/datadog-core/src/utils/src/has.js

@@ -0,0 +1,14 @@
+'use strict'
+
+module.exports = (object, path) => {
+  const pathArr = path.split('.')
+  let property = object
+  for (const n of pathArr) {
+    if (property.hasOwnProperty(n)) {
+      property = property[n]
+    } else {
+      return false
+    }
+  }
+  return true
+}

package/packages/datadog-core/src/utils/src/set.js

@@ -0,0 +1,16 @@
+'use strict'
+
+module.exports = (object, path, value) => {
+  const pathArr = path.split('.')
+  let property = object
+  let i
+  for (i = 0; i < pathArr.length - 1; i++) {
+    const n = pathArr[i]
+    if (property.hasOwnProperty(n)) {
+      property = property[n]
+    } else {
+      property[n] = property = {}
+    }
+  }
+  property[pathArr[i]] = value
+}

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

@@ -5,7 +5,7 @@ const {
   addHook,
   AsyncResource
 } = require('./helpers/instrument')
-const kebabCase = require('../../utils/src/kebabcase')
+const kebabCase = require('../../datadog-core/src/utils/src/kebabcase')
 const shimmer = require('../../datadog-shimmer')
 
 const startCh = channel('apm:amqplib:command:start')

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,21 @@ function getStatusFromResultLatest (result) {
   return { status: 'fail', errorMessage: result.message }
 }
 
+function isNewTest (testSuite, testName) {
+  const testsForSuite = knownTests.cucumber?.[testSuite] || []
+  return !testsForSuite.includes(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 +120,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 +134,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 +259,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 +275,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 +358,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/grpc/server.js

@@ -92,7 +92,9 @@ function createWrapEmit (call, ctx, onCancel) {
           finishChannel.publish(ctx)
           call.removeListener('cancelled', onCancel)
           break
-        case 'finish':
+        // Streams are always cancelled before `finish` since 1.10.0 so we have
+        // to use `prefinish` instead to avoid cancellation false positives.
+        case 'prefinish':
           if (call.status) {
             updateChannel.publish(call.status)
           }

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')
 
@@ -114,6 +115,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       this.nameToParams = {}
       this.global._ddtrace = global._ddtrace
 
+      this.displayName = config.projectConfig?.displayName?.name
       this.testEnvironmentOptions = getTestEnvironmentOptions(config)
 
       const repositoryRoot = this.testEnvironmentOptions._ddRepositoryRoot
@@ -138,14 +140,16 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
     // Function that receives a list of known tests for a test service and
     // returns the ones that belong to the current suite
     getKnownTestsForSuite (knownTests) {
+      if (this.knownTestsForThisSuite) {
+        return this.knownTestsForThisSuite
+      }
       let knownTestsForSuite = knownTests
-      // If jest runs in band, the known tests are not serialized, so they're an array.
-      if (!Array.isArray(knownTests)) {
+      // If jest is using workers, known tests are serialized to json.
+      // If jest runs in band, they are not.
+      if (typeof knownTestsForSuite === 'string') {
         knownTestsForSuite = JSON.parse(knownTestsForSuite)
       }
-      return knownTestsForSuite
-        .filter(test => test.includes(this.testSuite))
-        .map(test => test.replace(`jest.${this.testSuite}.`, '').trim())
+      return knownTestsForSuite.jest?.[this.testSuite] || []
     }
 
     // Add the `add_test` event we don't have the test object yet, so
@@ -200,6 +204,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             suite: this.testSuite,
             testSourceFile: this.testSourceFile,
             runner: 'jest-circus',
+            displayName: this.displayName,
             testParameters,
             frameworkVersion: jestVersion,
             isNew: isNewTest,
@@ -251,6 +256,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             suite: this.testSuite,
             testSourceFile: this.testSourceFile,
             runner: 'jest-circus',
+            displayName: this.displayName,
             frameworkVersion: jestVersion,
             testStartLine: getTestLineStart(event.test.asyncError, this.testSuite)
           })
@@ -270,6 +276,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 +303,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 +355,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
 })
@@ -512,6 +564,7 @@ function jestAdapterWrapper (jestAdapter, jestVersion) {
       testSuiteStartCh.publish({
         testSuite: environment.testSuite,
         testEnvironmentOptions: environment.testEnvironmentOptions,
+        displayName: environment.displayName,
         frameworkVersion: jestVersion
       })
       return adapter.apply(this, arguments).then(suiteResults => {
@@ -660,13 +713,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 +733,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-instrumentations/src/mocha.js

@@ -106,7 +106,10 @@ function getTestFullName (test) {
 }
 
 function isNewTest (test) {
-  return !knownTests.includes(getTestFullName(test))
+  const testSuite = getTestSuitePath(test.file, process.cwd())
+  const testName = removeEfdStringFromTestName(test.fullTitle())
+  const testsForSuite = knownTests.mocha?.[testSuite] || []
+  return !testsForSuite.includes(testName)
 }
 
 function retryTest (test) {

package/packages/datadog-instrumentations/src/mongodb-core.js

@@ -32,12 +32,18 @@ addHook({ name: 'mongodb', versions: ['>=4 <4.6.0'], file: 'lib/cmap/connection.
   return Connection
 })
 
-addHook({ name: 'mongodb', versions: ['>=4.6.0'], file: 'lib/cmap/connection.js' }, Connection => {
+addHook({ name: 'mongodb', versions: ['>=4.6.0 <6.4.0'], file: 'lib/cmap/connection.js' }, Connection => {
   const proto = Connection.Connection.prototype
   shimmer.wrap(proto, 'command', command => wrapConnectionCommand(command, 'command'))
   return Connection
 })
 
+addHook({ name: 'mongodb', versions: ['>=6.4.0'], file: 'lib/cmap/connection.js' }, Connection => {
+  const proto = Connection.Connection.prototype
+  shimmer.wrap(proto, 'command', command => wrapConnectionCommand(command, 'command', undefined, instrumentPromise))
+  return Connection
+})
+
 addHook({ name: 'mongodb', versions: ['>=3.3 <4'], file: 'lib/core/wireprotocol/index.js' }, wp => wrapWp(wp))
 
 addHook({ name: 'mongodb-core', versions: ['>=3.2'], file: 'lib/wireprotocol/index.js' }, wp => wrapWp(wp))
@@ -89,7 +95,7 @@ function wrapUnifiedCommand (command, operation, name) {
   return shimmer.wrap(command, wrapped)
 }
 
-function wrapConnectionCommand (command, operation, name) {
+function wrapConnectionCommand (command, operation, name, instrumentFn = instrument) {
   const wrapped = function (ns, ops) {
     if (!startCh.hasSubscribers) {
       return command.apply(this, arguments)
@@ -101,7 +107,7 @@ function wrapConnectionCommand (command, operation, name) {
     const topology = { s: { options } }
 
     ns = `${ns.db}.${ns.collection}`
-    return instrument(operation, command, this, arguments, topology, ns, ops, { name })
+    return instrumentFn(operation, command, this, arguments, topology, ns, ops, { name })
   }
   return shimmer.wrap(command, wrapped)
 }
@@ -179,3 +185,28 @@ function instrument (operation, command, ctx, args, server, ns, ops, options = {
     }
   })
 }
+
+function instrumentPromise (operation, command, ctx, args, server, ns, ops, options = {}) {
+  const name = options.name || (ops && Object.keys(ops)[0])
+
+  const serverInfo = server && server.s && server.s.options
+  const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+  return asyncResource.runInAsyncScope(() => {
+    startCh.publish({ ns, ops, options: serverInfo, name })
+
+    const promise = command.apply(ctx, args)
+
+    promise.then(function (res) {
+      finishCh.publish()
+      return res
+    }, function (err) {
+      errorCh.publish(err)
+      finishCh.publish()
+
+      return Promise.reject(err)
+    })
+
+    return promise
+  })
+}