dd-trace 5.53.0 → 5.55.0

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

@@ -1,10 +1,11 @@
 'use strict'
 
 const { createCoverageMap } = require('istanbul-lib-coverage')
-const { addHook, channel, AsyncResource } = require('../helpers/instrument')
+const { addHook, channel } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 const { isMarkedAsUnskippable } = require('../../../datadog-plugin-jest/src/util')
 const log = require('../../../dd-trace/src/log')
+const { getEnvironmentVariable } = require('../../../dd-trace/src/config-helper')
 const {
   getTestSuitePath,
   MOCHA_WORKER_TRACE_PAYLOAD_CODE,
@@ -37,7 +38,6 @@ const {
 
 require('./common')
 
-const testSessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 const patched = new WeakSet()
 
 const unskippableSuites = []
@@ -65,7 +65,10 @@ const testSuiteCodeCoverageCh = channel('ci:mocha:test-suite:code-coverage')
 const libraryConfigurationCh = channel('ci:mocha:library-configuration')
 const knownTestsCh = channel('ci:mocha:known-tests')
 const skippableSuitesCh = channel('ci:mocha:test-suite:skippable')
+const mochaGlobalRunCh = channel('ci:mocha:global:run')
+
 const testManagementTestsCh = channel('ci:mocha:test-management-tests')
+const impactedTestsCh = channel('ci:mocha:modified-tests')
 const workerReportTraceCh = channel('ci:mocha:worker-report:trace')
 const testSessionStartCh = channel('ci:mocha:session:start')
 const testSessionFinishCh = channel('ci:mocha:session:finish')
@@ -99,18 +102,18 @@ function getFilteredSuites (originalSuites) {
 }
 
 function getOnStartHandler (isParallel, frameworkVersion) {
-  return testSessionAsyncResource.bind(function () {
+  return function () {
     const processArgv = process.argv.slice(2).join(' ')
     const command = `mocha ${processArgv}`
     testSessionStartCh.publish({ command, frameworkVersion })
     if (!isParallel && skippedSuites.length) {
       itrSkippedSuitesCh.publish({ skippedSuites, frameworkVersion })
     }
-  })
+  }
 }
 
 function getOnEndHandler (isParallel) {
-  return testSessionAsyncResource.bind(function () {
+  return function () {
     let status = 'pass'
     let error
     if (this.stats) {
@@ -175,7 +178,7 @@ function getOnEndHandler (isParallel) {
           originalCoverageMap.merge(fromCoverageMapToCoverage(untestedCoverage))
         }
         testCodeCoverageLinesTotal = originalCoverageMap.getCoverageSummary().lines.pct
-      } catch (e) {
+      } catch {
         // ignore errors
       }
       // restore the original coverage
@@ -195,27 +198,12 @@ function getOnEndHandler (isParallel) {
       isTestManagementEnabled: config.isTestManagementTestsEnabled,
       isParallel
     })
-  })
+  }
 }
 
 function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
-  const mochaRunAsyncResource = new AsyncResource('bound-anonymous-fn')
-
-  const onReceivedTestManagementTests = ({ err, testManagementTests: receivedTestManagementTests }) => {
-    if (err) {
-      config.testManagementTests = {}
-      config.isTestManagementTestsEnabled = false
-      config.testManagementAttemptToFixRetries = 0
-    } else {
-      config.testManagementTests = receivedTestManagementTests
-    }
-    if (config.isSuitesSkippingEnabled) {
-      skippableSuitesCh.publish({
-        onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
-      })
-    } else {
-      onFinishRequest()
-    }
+  const ctx = {
+    isParallel
   }
 
   const onReceivedSkippableSuites = ({ err, skippableSuites, itrCorrelationId: responseItrCorrelationId }) => {
@@ -237,9 +225,49 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
 
     runner.suite.suites = suitesToRun
 
-    skippedSuites = Array.from(filteredSuites.skippedSuites)
+    skippedSuites = [...filteredSuites.skippedSuites]
+
+    mochaGlobalRunCh.runStores(ctx, () => {
+      onFinishRequest()
+    })
+  }
 
-    onFinishRequest()
+  const onReceivedImpactedTests = ({ err, modifiedTests: receivedModifiedTests }) => {
+    if (err) {
+      config.modifiedTests = []
+      config.isImpactedTestsEnabled = false
+    } else {
+      config.modifiedTests = receivedModifiedTests
+    }
+    if (config.isSuitesSkippingEnabled) {
+      ctx.onDone = onReceivedSkippableSuites
+      skippableSuitesCh.runStores(ctx, () => {})
+    } else {
+      mochaGlobalRunCh.runStores(ctx, () => {
+        onFinishRequest()
+      })
+    }
+  }
+
+  const onReceivedTestManagementTests = ({ err, testManagementTests: receivedTestManagementTests }) => {
+    if (err) {
+      config.testManagementTests = {}
+      config.isTestManagementTestsEnabled = false
+      config.testManagementAttemptToFixRetries = 0
+    } else {
+      config.testManagementTests = receivedTestManagementTests
+    }
+    if (config.isImpactedTestsEnabled) {
+      ctx.onDone = onReceivedImpactedTests
+      impactedTestsCh.runStores(ctx, () => {})
+    } else if (config.isSuitesSkippingEnabled) {
+      ctx.onDone = onReceivedSkippableSuites
+      skippableSuitesCh.runStores(ctx, () => {})
+    } else {
+      mochaGlobalRunCh.runStores(ctx, () => {
+        onFinishRequest()
+      })
+    }
   }
 
   const onReceivedKnownTests = ({ err, knownTests }) => {
@@ -251,55 +279,61 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
       config.knownTests = knownTests
     }
     if (config.isTestManagementTestsEnabled) {
-      testManagementTestsCh.publish({
-        onDone: mochaRunAsyncResource.bind(onReceivedTestManagementTests)
-      })
+      ctx.onDone = onReceivedTestManagementTests
+      testManagementTestsCh.runStores(ctx, () => {})
+    } if (config.isImpactedTestsEnabled) {
+      ctx.onDone = onReceivedImpactedTests
+      impactedTestsCh.runStores(ctx, () => {})
     } else if (config.isSuitesSkippingEnabled) {
-      skippableSuitesCh.publish({
-        onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
-      })
+      ctx.onDone = onReceivedSkippableSuites
+      skippableSuitesCh.runStores(ctx, () => {})
     } else {
-      onFinishRequest()
+      mochaGlobalRunCh.runStores(ctx, () => {
+        onFinishRequest()
+      })
     }
   }
 
   const onReceivedConfiguration = ({ err, libraryConfig }) => {
     if (err || !skippableSuitesCh.hasSubscribers || !knownTestsCh.hasSubscribers) {
-      return onFinishRequest()
+      return mochaGlobalRunCh.runStores(ctx, () => {
+        onFinishRequest()
+      })
     }
-
     config.isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
     config.earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
     config.earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
     config.isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
     config.isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
     config.testManagementAttemptToFixRetries = libraryConfig.testManagementAttemptToFixRetries
+    config.isImpactedTestsEnabled = libraryConfig.isImpactedTestsEnabled
     // ITR and auto test retries are not supported in parallel mode yet
     config.isSuitesSkippingEnabled = !isParallel && libraryConfig.isSuitesSkippingEnabled
     config.isFlakyTestRetriesEnabled = !isParallel && libraryConfig.isFlakyTestRetriesEnabled
     config.flakyTestRetriesCount = !isParallel && libraryConfig.flakyTestRetriesCount
 
     if (config.isKnownTestsEnabled) {
-      knownTestsCh.publish({
-        onDone: mochaRunAsyncResource.bind(onReceivedKnownTests)
-      })
+      ctx.onDone = onReceivedKnownTests
+      knownTestsCh.runStores(ctx, () => {})
     } else if (config.isTestManagementTestsEnabled) {
-      testManagementTestsCh.publish({
-        onDone: mochaRunAsyncResource.bind(onReceivedTestManagementTests)
-      })
+      ctx.onDone = onReceivedTestManagementTests
+      testManagementTestsCh.runStores(ctx, () => {})
+    } else if (config.isImpactedTestsEnabled) {
+      ctx.onDone = onReceivedImpactedTests
+      impactedTestsCh.runStores(ctx, () => {})
     } else if (config.isSuitesSkippingEnabled) {
-      skippableSuitesCh.publish({
-        onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
-      })
+      ctx.onDone = onReceivedSkippableSuites
+      skippableSuitesCh.runStores(ctx, () => {})
     } else {
-      onFinishRequest()
+      mochaGlobalRunCh.runStores(ctx, () => {
+        onFinishRequest()
+      })
     }
   }
 
-  libraryConfigurationCh.publish({
-    onDone: mochaRunAsyncResource.bind(onReceivedConfiguration),
-    isParallel
-  })
+  ctx.onDone = onReceivedConfiguration
+
+  libraryConfigurationCh.runStores(ctx, () => {})
 }
 
 // In this hook we delay the execution with options.delay to grab library configuration,
@@ -312,7 +346,7 @@ addHook({
 }, (Mocha) => {
   shimmer.wrap(Mocha.prototype, 'run', run => function () {
     // Workers do not need to request any data, just run the tests
-    if (!testFinishCh.hasSubscribers || process.env.MOCHA_WORKER_ID || this.options.parallel) {
+    if (!testFinishCh.hasSubscribers || getEnvironmentVariable('MOCHA_WORKER_ID') || this.options.parallel) {
       return run.apply(this, arguments)
     }
 
@@ -441,7 +475,7 @@ addHook({
           itrCorrelationId
         }
         testFileToSuiteCtx.set(suite.file, ctx)
-        testSuiteStartCh.runStores(ctx, () => { })
+        testSuiteStartCh.runStores(ctx, () => {})
       }
     })
 
@@ -485,9 +519,9 @@ addHook({
 
       const ctx = testFileToSuiteCtx.get(suite.file)
       if (ctx) {
-        testSuiteFinishCh.publish({ status, ...ctx.currentStore }, () => { })
+        testSuiteFinishCh.publish({ status, ...ctx.currentStore }, () => {})
       } else {
-        log.warn(() => `No AsyncResource found for suite ${suite.file}`)
+        log.warn(() => `No ctx found for suite ${suite.file}`)
       }
     })
 
@@ -505,6 +539,15 @@ addHook({
   file: 'lib/runnable.js'
 }, (runnablePackage) => runnableWrapper(runnablePackage, config))
 
+function onMessage (message) {
+  if (Array.isArray(message)) {
+    const [messageCode, payload] = message
+    if (messageCode === MOCHA_WORKER_TRACE_PAYLOAD_CODE) {
+      workerReportTraceCh.publish(payload)
+    }
+  }
+}
+
 // Only used in parallel mode (--parallel flag is passed)
 // Used to generate suite events and receive test payloads from workers
 addHook({
@@ -523,42 +566,33 @@ addHook({
       return exec.apply(this, arguments)
     }
     const [testSuiteAbsolutePath] = path
-    const testSuiteContext = { }
-
-    function onMessage (message) {
-      if (Array.isArray(message)) {
-        const [messageCode, payload] = message
-        if (messageCode === MOCHA_WORKER_TRACE_PAYLOAD_CODE) {
-          workerReportTraceCh.publish(payload)
-        }
-      }
-    }
+    const testSuiteContext = {}
 
     this.worker.on('message', onMessage)
 
     testSuiteContext.testSuiteAbsolutePath = testSuiteAbsolutePath
-    testSuiteStartCh.runStores(testSuiteContext, () => { })
+    testSuiteStartCh.runStores(testSuiteContext, () => {})
 
     try {
       const promise = exec.apply(this, arguments)
       promise.then(
         (result) => {
           const status = result.failureCount === 0 ? 'pass' : 'fail'
-          testSuiteFinishCh.publish({ status, ...testSuiteContext.currentStore }, () => { })
+          testSuiteFinishCh.publish({ status, ...testSuiteContext.currentStore }, () => {})
           this.worker.off('message', onMessage)
         },
         (err) => {
           testSuiteContext.error = err
-          testSuiteErrorCh.runStores(testSuiteContext, () => { })
-          testSuiteFinishCh.publish({ status: 'fail', ...testSuiteContext.currentStore }, () => { })
+          testSuiteErrorCh.runStores(testSuiteContext, () => {})
+          testSuiteFinishCh.publish({ status: 'fail', ...testSuiteContext.currentStore }, () => {})
           this.worker.off('message', onMessage)
         }
       )
       return promise
     } catch (err) {
       testSuiteContext.error = err
-      testSuiteErrorCh.runStores(testSuiteContext, () => { })
-      testSuiteFinishCh.publish({ status: 'fail', ...testSuiteContext.currentStore }, () => { })
+      testSuiteErrorCh.runStores(testSuiteContext, () => {})
+      testSuiteFinishCh.publish({ status: 'fail', ...testSuiteContext.currentStore }, () => {})
       this.worker.off('message', onMessage)
       throw err
     }
@@ -616,7 +650,10 @@ addHook({
   const { BufferedWorkerPool } = BufferedWorkerPoolPackage
 
   shimmer.wrap(BufferedWorkerPool.prototype, 'run', run => async function (testSuiteAbsolutePath, workerArgs) {
-    if (!testFinishCh.hasSubscribers || (!config.isKnownTestsEnabled && !config.isTestManagementTestsEnabled)) {
+    if (!testFinishCh.hasSubscribers ||
+        (!config.isKnownTestsEnabled &&
+         !config.isTestManagementTestsEnabled &&
+         !config.isImpactedTestsEnabled)) {
       return run.apply(this, arguments)
     }
 
@@ -649,6 +686,12 @@ addHook({
       }
     }
 
+    if (config.isImpactedTestsEnabled) {
+      const testSuiteImpactedTests = config.modifiedTests || {}
+      newWorkerArgs._ddIsImpactedTestsEnabled = true
+      newWorkerArgs._ddModifiedTests = testSuiteImpactedTests
+    }
+
     // We pass the known tests for the test file to the worker
     const testFileResult = await run.apply(
       this,
@@ -669,10 +712,10 @@ addHook({
         const testFullName = getTestFullName(test)
         const tests = newTests[testFullName]
 
-        if (!tests) {
-          newTests[testFullName] = [test]
-        } else {
+        if (tests) {
           tests.push(test)
+        } else {
+          newTests[testFullName] = [test]
         }
       }
       // `testsQuarantined` is filled in the worker process, so we need to use the test results to fill it here too.

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

@@ -18,7 +18,7 @@ const testRetryCh = channel('ci:mocha:test:retry')
 const errorCh = channel('ci:mocha:test:error')
 const skipCh = channel('ci:mocha:test:skip')
 const testFnCh = channel('ci:mocha:test:fn')
-
+const isModifiedCh = channel('ci:mocha:test:is-modified')
 // suite channels
 const testSuiteErrorCh = channel('ci:mocha:test-suite:error')
 
@@ -209,7 +209,8 @@ function getOnTestHandler (isMain) {
       _ddIsEfdRetry: isEfdRetry,
       _ddIsAttemptToFix: isAttemptToFix,
       _ddIsDisabled: isDisabled,
-      _ddIsQuarantined: isQuarantined
+      _ddIsQuarantined: isQuarantined,
+      _ddIsModified: isModified
     } = test
 
     const testName = removeEfdStringFromTestName(removeAttemptToFixStringFromTestName(test.fullTitle()))
@@ -230,6 +231,7 @@ function getOnTestHandler (isMain) {
     testInfo.isAttemptToFix = isAttemptToFix
     testInfo.isDisabled = isDisabled
     testInfo.isQuarantined = isQuarantined
+    testInfo.isModified = isModified
     // We want to store the result of the new tests
     if (isNew) {
       const testFullName = getTestFullName(test)
@@ -246,7 +248,7 @@ function getOnTestHandler (isMain) {
 
     const ctx = testInfo
     testToContext.set(test.fn, ctx)
-    testStartCh.runStores(ctx, () => { })
+    testStartCh.runStores(ctx, () => {})
   }
 }
 
@@ -271,17 +273,17 @@ function getOnTestEndHandler (config) {
 
     const testName = getTestFullName(test)
 
-    if (!testsStatuses.get(testName)) {
-      testsStatuses.set(testName, [status])
-    } else {
+    if (testsStatuses.get(testName)) {
       testsStatuses.get(testName).push(status)
+    } else {
+      testsStatuses.set(testName, [status])
     }
     const testStatuses = testsStatuses.get(testName)
 
     const isLastAttempt = testStatuses.length === config.testManagementAttemptToFixRetries + 1
 
     if (test._ddIsAttemptToFix && isLastAttempt) {
-      if (testStatuses.some(status => status === 'fail')) {
+      if (testStatuses.includes('fail')) {
         attemptToFixFailed = true
       }
       if (testStatuses.every(status => status === 'fail')) {
@@ -351,12 +353,12 @@ function getOnFailHandler (isMain) {
       if (isHook) {
         err.message = `${testOrHook.fullTitle()}: ${err.message}`
         testContext.err = err
-        errorCh.runStores(testContext, () => { })
+        errorCh.runStores(testContext, () => {})
         // if it's a hook and it has failed, 'test end' will not be called
         testFinishCh.publish({ status: 'fail', hasBeenRetried: isMochaRetry(test), ...testContext.currentStore })
       } else {
         testContext.err = err
-        errorCh.runStores(testContext, () => { })
+        errorCh.runStores(testContext, () => {})
       }
     }
 
@@ -370,7 +372,7 @@ function getOnFailHandler (isMain) {
         )
         testSuiteError.stack = err.stack
         testSuiteContext.error = testSuiteError
-        testSuiteErrorCh.runStores(testSuiteContext, () => { })
+        testSuiteErrorCh.runStores(testSuiteContext, () => {})
       }
     }
   }
@@ -420,7 +422,7 @@ function getOnPendingHandler () {
       } else {
         testToContext.set(test, testCtx)
       }
-      skipCh.runStores(testCtx, () => { })
+      skipCh.runStores(testCtx, () => {})
     }
   }
 }
@@ -452,12 +454,34 @@ function getRunTestsWrapper (runTests, config) {
       })
     }
 
+    if (config.isImpactedTestsEnabled) {
+      suite.tests.forEach((test) => {
+        isModifiedCh.publish({
+          modifiedTests: config.modifiedTests,
+          file: suite.file,
+          onDone: (isModified) => {
+            if (isModified) {
+              test._ddIsModified = true
+              if (!test.isPending() && !test._ddIsAttemptToFix && config.isEarlyFlakeDetectionEnabled) {
+                retryTest(
+                  test,
+                  config.earlyFlakeDetectionNumRetries,
+                  addEfdStringToTestName,
+                  ['_ddIsModified', '_ddIsEfdRetry']
+                )
+              }
+            }
+          }
+        })
+      })
+    }
+
     if (config.isKnownTestsEnabled) {
       // by the time we reach `this.on('test')`, it is too late. We need to add retries here
       suite.tests.forEach(test => {
         if (!test.isPending() && isNewTest(test, config.knownTests)) {
           test._ddIsNew = true
-          if (config.isEarlyFlakeDetectionEnabled) {
+          if (config.isEarlyFlakeDetectionEnabled && !test._ddIsAttemptToFix && !test._ddIsModified) {
             retryTest(
               test,
               config.earlyFlakeDetectionNumRetries,

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

@@ -34,6 +34,12 @@ addHook({
       delete this.options._ddEfdNumRetries
       delete this.options._ddIsKnownTestsEnabled
     }
+    if (this.options._ddIsImpactedTestsEnabled) {
+      config.isImpactedTestsEnabled = true
+      config.modifiedTests = this.options._ddModifiedTests
+      delete this.options._ddIsImpactedTestsEnabled
+      delete this.options._ddModifiedTests
+    }
     if (this.options._ddIsTestManagementTestsEnabled) {
       config.isTestManagementTestsEnabled = true
       // TODO: attempt to fix does not work in parallel mode yet

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

@@ -1,4 +1,6 @@
-if (process.env.MOCHA_WORKER_ID) {
+const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
+
+if (getEnvironmentVariable('MOCHA_WORKER_ID')) {
   require('./mocha/worker')
 } else {
   require('./mocha/main')

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

@@ -204,7 +204,7 @@ function instrumentPromise (operation, command, ctx, args, server, ns, ops, opti
       errorCh.publish(err)
       finishCh.publish()
 
-      return Promise.reject(err)
+      throw err
     })
   })
 }

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

@@ -1,10 +1,6 @@
 'use strict'
 
-const {
-  channel,
-  addHook,
-  AsyncResource
-} = require('./helpers/instrument')
+const { channel, addHook } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
 addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connection => {
@@ -19,43 +15,38 @@ addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connect
 
     const sql = arguments[0].sql || arguments[0]
     const conf = this.config
-    const payload = { sql, conf }
-
-    const callbackResource = new AsyncResource('bound-anonymous-fn')
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
-    return asyncResource.runInAsyncScope(() => {
-      startCh.publish(payload)
+    const ctx = { sql, conf }
 
+    return startCh.runStores(ctx, () => {
       if (arguments[0].sql) {
-        arguments[0].sql = payload.sql
+        arguments[0].sql = ctx.sql
       } else {
-        arguments[0] = payload.sql
+        arguments[0] = ctx.sql
       }
+
       try {
         const res = query.apply(this, arguments)
 
         if (res._callback) {
-          const cb = callbackResource.bind(res._callback)
-          res._callback = shimmer.wrapFunction(cb, cb => asyncResource.bind(function (error, result) {
+          const cb = res._callback
+          res._callback = shimmer.wrapFunction(cb, cb => function (error, result) {
             if (error) {
-              errorCh.publish(error)
+              ctx.error = error
+              errorCh.publish(ctx)
             }
-            finishCh.publish(result)
+            ctx.result = result
 
-            return cb.apply(this, arguments)
-          }))
-        } else {
-          const cb = asyncResource.bind(function () {
-            finishCh.publish(undefined)
+            return finishCh.runStores(ctx, cb, this, error, result)
           })
-          res.on('end', cb)
+        } else {
+          res.on('end', () => finishCh.publish(ctx))
         }
 
         return res
       } catch (err) {
         err.stack // trigger getting the stack at the original throwing point
-        errorCh.publish(err)
+        ctx.error = err
+        errorCh.publish(ctx)
 
         throw err
       }
@@ -66,11 +57,20 @@ addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connect
 })
 
 addHook({ name: 'mysql', file: 'lib/Pool.js', versions: ['>=2'] }, Pool => {
+  const connectionStartCh = channel('apm:mysql:connection:start')
+  const connectionFinishCh = channel('apm:mysql:connection:finish')
   const startPoolQueryCh = channel('datadog:mysql:pool:query:start')
   const finishPoolQueryCh = channel('datadog:mysql:pool:query:finish')
 
   shimmer.wrap(Pool.prototype, 'getConnection', getConnection => function (cb) {
-    arguments[0] = AsyncResource.bind(cb)
+    arguments[0] = function () {
+      return connectionFinishCh.runStores(ctx, cb, this, ...arguments)
+    }
+
+    const ctx = {}
+
+    connectionStartCh.publish(ctx)
+
     return getConnection.apply(this, arguments)
   })
 
@@ -79,22 +79,15 @@ addHook({ name: 'mysql', file: 'lib/Pool.js', versions: ['>=2'] }, Pool => {
       return query.apply(this, arguments)
     }
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
     const sql = arguments[0].sql || arguments[0]
+    const ctx = { sql }
+    const finish = () => finishPoolQueryCh.publish(ctx)
 
-    return asyncResource.runInAsyncScope(() => {
-      startPoolQueryCh.publish({ sql })
-
-      const finish = asyncResource.bind(function () {
-        finishPoolQueryCh.publish()
-      })
-
+    return startPoolQueryCh.runStores(ctx, () => {
       const cb = arguments[arguments.length - 1]
       if (typeof cb === 'function') {
         arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => function () {
-          finish()
-          return cb.apply(this, arguments)
+          return finishPoolQueryCh.runStores(ctx, cb, this, ...arguments)
         })
       }