dd-trace 5.53.0 → 5.55.0

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

@@ -1,9 +1,10 @@
 '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 log = require('../../dd-trace/src/log')
+const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
 
 const testStartCh = channel('ci:cucumber:test:start')
 const testRetryCh = channel('ci:cucumber:test:retry')
@@ -24,6 +25,8 @@ const skippableSuitesCh = channel('ci:cucumber:test-suite:skippable')
 const sessionStartCh = channel('ci:cucumber:session:start')
 const sessionFinishCh = channel('ci:cucumber:session:finish')
 const testManagementTestsCh = channel('ci:cucumber:test-management-tests')
+const impactedTestsCh = channel('ci:cucumber:modified-tests')
+const isModifiedCh = channel('ci:cucumber:is-modified-test')
 
 const workerReportTraceCh = channel('ci:cucumber:worker-report:trace')
 
@@ -42,7 +45,7 @@ const {
 } = require('../../dd-trace/src/plugins/util/test')
 
 const isMarkedAsUnskippable = (pickle) => {
-  return !!pickle.tags.find(tag => tag.name === '@datadog:unskippable')
+  return pickle.tags.some(tag => tag.name === '@datadog:unskippable')
 }
 
 // We'll preserve the original coverage here
@@ -55,13 +58,12 @@ const lastStatusByPickleId = new Map()
 const numRetriesByPickleId = new Map()
 const numAttemptToCtx = new Map()
 const newTestsByTestFullname = new Map()
+const modifiedTestsByPickleId = new Map()
 
 let eventDataCollector = null
 let pickleByFile = {}
 const pickleResultByFile = {}
 
-const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
-
 let skippableSuites = []
 let itrCorrelationId = ''
 let isForcedToRun = false
@@ -74,15 +76,17 @@ let isEarlyFlakeDetectionFaulty = false
 let isFlakyTestRetriesEnabled = false
 let isKnownTestsEnabled = false
 let isTestManagementTestsEnabled = false
+let isImpactedTestsEnabled = false
 let testManagementAttemptToFixRetries = 0
 let testManagementTests = {}
+let modifiedTests = {}
 let numTestRetries = 0
 let knownTests = []
 let skippedSuites = []
 let isSuitesSkipped = false
 
 function getSuiteStatusFromTestStatuses (testStatuses) {
-  if (testStatuses.some(status => status === 'fail')) {
+  if (testStatuses.includes('fail')) {
     return 'fail'
   }
   if (testStatuses.every(status => status === 'skip')) {
@@ -133,7 +137,7 @@ function getTestStatusFromRetries (testStatuses) {
   if (testStatuses.every(status => status === 'fail')) {
     return 'fail'
   }
-  if (testStatuses.some(status => status === 'pass')) {
+  if (testStatuses.includes('pass')) {
     return 'pass'
   }
   return 'pass'
@@ -155,9 +159,7 @@ function getErrorFromCucumberResult (cucumberResult) {
 
 function getChannelPromise (channelToPublishTo, isParallel = false) {
   return new Promise(resolve => {
-    sessionAsyncResource.runInAsyncScope(() => {
-      channelToPublishTo.publish({ onDone: resolve, isParallel })
-    })
+    channelToPublishTo.publish({ onDone: resolve, isParallel })
   })
 }
 
@@ -242,11 +244,11 @@ function wrapRun (pl, isLatestVersion) {
       testName: this.pickle.name,
       testFileAbsolutePath,
       testSourceLine,
-      isParallel: !!process.env.CUCUMBER_WORKER_ID
+      isParallel: !!getEnvironmentVariable('CUCUMBER_WORKER_ID')
     }
     const ctx = testStartPayload
     numAttemptToCtx.set(numAttempt, ctx)
-    testStartCh.runStores(ctx, () => { })
+    testStartCh.runStores(ctx, () => {})
     const promises = {}
     try {
       this.eventBroadcaster.on('envelope', shimmer.wrapFunction(null, () => async (testCase) => {
@@ -258,7 +260,7 @@ function wrapRun (pl, isLatestVersion) {
             try {
               const cucumberResult = this.getWorstStepResult()
               error = getErrorFromCucumberResult(cucumberResult)
-            } catch (e) {
+            } catch {
               // ignore error
             }
 
@@ -276,7 +278,7 @@ function wrapRun (pl, isLatestVersion) {
             const newCtx = { ...testStartPayload, promises }
             numAttemptToCtx.set(numAttempt, newCtx)
 
-            testStartCh.runStores(newCtx, () => { })
+            testStartCh.runStores(newCtx, () => {})
           }
         }
       }))
@@ -305,6 +307,7 @@ function wrapRun (pl, isLatestVersion) {
         let hasFailedAttemptToFix = false
         let isDisabled = false
         let isQuarantined = false
+        let isModified = false
 
         if (isTestManagementTestsEnabled) {
           const testSuitePath = getTestSuitePath(testFileAbsolutePath, process.cwd())
@@ -329,10 +332,17 @@ function wrapRun (pl, isLatestVersion) {
           }
         }
 
-        if (isKnownTestsEnabled && status !== 'skip' && !isAttemptToFix) {
-          const numRetries = numRetriesByPickleId.get(this.pickle.id)
+        const numRetries = numRetriesByPickleId.get(this.pickle.id)
 
+        if (isImpactedTestsEnabled) {
+          isModified = modifiedTestsByPickleId.get(this.pickle.id)
+        }
+
+        if (isKnownTestsEnabled && status !== 'skip') {
           isNew = numRetries !== undefined
+        }
+
+        if (isNew || isModified) {
           isEfdRetry = numRetries > 0
         }
 
@@ -357,6 +367,7 @@ function wrapRun (pl, isLatestVersion) {
           hasFailedAttemptToFix,
           isDisabled,
           isQuarantined,
+          isModified,
           ...attemptCtx.currentStore
         })
       })
@@ -451,14 +462,15 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
     isKnownTestsEnabled = configurationResponse.libraryConfig?.isKnownTestsEnabled
     isTestManagementTestsEnabled = configurationResponse.libraryConfig?.isTestManagementEnabled
     testManagementAttemptToFixRetries = configurationResponse.libraryConfig?.testManagementAttemptToFixRetries
+    isImpactedTestsEnabled = configurationResponse.libraryConfig?.isImpactedTestsEnabled
 
     if (isKnownTestsEnabled) {
       const knownTestsResponse = await getChannelPromise(knownTestsCh)
-      if (!knownTestsResponse.err) {
-        knownTests = knownTestsResponse.knownTests
-      } else {
+      if (knownTestsResponse.err) {
         isEarlyFlakeDetectionEnabled = false
         isKnownTestsEnabled = false
+      } else {
+        knownTests = knownTestsResponse.knownTests
       }
     }
 
@@ -488,7 +500,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
           this.pickleIds = picklesToRun
         }
 
-        skippedSuites = Array.from(filteredPickles.skippedSuites)
+        skippedSuites = [...filteredPickles.skippedSuites]
         itrCorrelationId = skippableResponse.itrCorrelationId
       }
     }
@@ -510,23 +522,28 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
 
     if (isTestManagementTestsEnabled) {
       const testManagementTestsResponse = await getChannelPromise(testManagementTestsCh)
-      if (!testManagementTestsResponse.err) {
-        testManagementTests = testManagementTestsResponse.testManagementTests
-      } else {
+      if (testManagementTestsResponse.err) {
         isTestManagementTestsEnabled = false
+      } else {
+        testManagementTests = testManagementTestsResponse.testManagementTests
+      }
+    }
+
+    if (isImpactedTestsEnabled) {
+      const impactedTestsResponse = await getChannelPromise(impactedTestsCh)
+      if (!impactedTestsResponse.err) {
+        modifiedTests = impactedTestsResponse.modifiedTests
       }
     }
 
     const processArgv = process.argv.slice(2).join(' ')
-    const command = process.env.npm_lifecycle_script || `cucumber-js ${processArgv}`
+    const command = getEnvironmentVariable('npm_lifecycle_script') || `cucumber-js ${processArgv}`
 
     if (isFlakyTestRetriesEnabled && !options.retry && numTestRetries > 0) {
       options.retry = numTestRetries
     }
 
-    sessionAsyncResource.runInAsyncScope(() => {
-      sessionStartCh.publish({ command, frameworkVersion })
-    })
+    sessionStartCh.publish({ command, frameworkVersion })
 
     if (!errorSkippableRequest && skippedSuites.length) {
       itrSkippedSuitesCh.publish({ skippedSuites, frameworkVersion })
@@ -547,26 +564,24 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
           originalCoverageMap.merge(fromCoverageMapToCoverage(untestedCoverage))
         }
         testCodeCoverageLinesTotal = originalCoverageMap.getCoverageSummary().lines.pct
-      } catch (e) {
+      } catch {
         // ignore errors
       }
       // restore the original coverage
       global.__coverage__ = fromCoverageMapToCoverage(originalCoverageMap)
     }
 
-    sessionAsyncResource.runInAsyncScope(() => {
-      sessionFinishCh.publish({
-        status: success ? 'pass' : 'fail',
-        isSuitesSkipped,
-        testCodeCoverageLinesTotal,
-        numSkippedSuites: skippedSuites.length,
-        hasUnskippableSuites: isUnskippable,
-        hasForcedToRunSuites: isForcedToRun,
-        isEarlyFlakeDetectionEnabled,
-        isEarlyFlakeDetectionFaulty,
-        isTestManagementTestsEnabled,
-        isParallel
-      })
+    sessionFinishCh.publish({
+      status: success ? 'pass' : 'fail',
+      isSuitesSkipped,
+      testCodeCoverageLinesTotal,
+      numSkippedSuites: skippedSuites.length,
+      hasUnskippableSuites: isUnskippable,
+      hasForcedToRunSuites: isForcedToRun,
+      isEarlyFlakeDetectionEnabled,
+      isEarlyFlakeDetectionFaulty,
+      isTestManagementTestsEnabled,
+      isParallel
     })
     eventDataCollector = null
     return success
@@ -577,12 +592,15 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
 // Handles EFD in both the main process and the worker process.
 function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = false, isWorker = false) {
   return async function () {
-    let pickle
-    if (isNewerCucumberVersion) {
-      pickle = arguments[0].pickle
-    } else {
-      pickle = this.eventDataCollector.getPickle(arguments[0])
-    }
+    const pickle = isNewerCucumberVersion
+      ? arguments[0].pickle
+      : this.eventDataCollector.getPickle(arguments[0])
+    const testCase = isNewerCucumberVersion
+      ? arguments[0].testCase
+      : arguments[1]
+    const gherkinDocument = isNewerCucumberVersion
+      ? arguments[0].gherkinDocument
+      : this.eventDataCollector.getGherkinDocument(pickle.uri)
 
     const testFileAbsolutePath = pickle.uri
     const testSuitePath = getTestSuitePath(testFileAbsolutePath, process.cwd())
@@ -604,6 +622,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     let isAttemptToFix = false
     let isDisabled = false
     let isQuarantined = false
+    let isModified = false
 
     if (isTestManagementTestsEnabled) {
       const testProperties = getTestProperties(testSuitePath, pickle.name)
@@ -616,6 +635,24 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       }
     }
 
+    if (isImpactedTestsEnabled) {
+      const setIsModified = (receivedIsModified) => { isModified = receivedIsModified }
+      const scenarios = gherkinDocument.feature?.children?.filter(
+        children => pickle.astNodeIds.includes(children.scenario.id)
+      ).map(scenario => scenario.scenario)
+      const stepIds = testCase?.testSteps?.flatMap(testStep => testStep.stepDefinitionIds)
+
+      isModifiedCh.publish({
+        scenarios,
+        testFileAbsolutePath: gherkinDocument.uri,
+        modifiedTests,
+        stepIds,
+        stepDefinitions: this.supportCodeLibrary.stepDefinitions,
+        setIsModified
+      })
+      modifiedTestsByPickleId.set(pickle.id, isModified)
+    }
+
     if (isKnownTestsEnabled && !isAttemptToFix) {
       isNew = isNewTest(testSuitePath, pickle.name)
       if (isNew) {
@@ -626,27 +663,29 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     let runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
 
     const testStatuses = lastStatusByPickleId.get(pickle.id)
-    const lastTestStatus = testStatuses[testStatuses.length - 1]
+    const lastTestStatus = testStatuses.at(-1)
 
     // New tests should not be marked as attempt to fix, so EFD + Attempt to fix should not be enabled at the same time
     if (isAttemptToFix && lastTestStatus !== 'skip') {
       for (let retryIndex = 0; retryIndex < testManagementAttemptToFixRetries; retryIndex++) {
         numRetriesByPickleId.set(pickle.id, retryIndex + 1)
+        // eslint-disable-next-line no-await-in-loop
         runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
       }
     }
 
     // If it's a new test and it hasn't been skipped, we run it again
-    if (isEarlyFlakeDetectionEnabled && lastTestStatus !== 'skip' && isNew) {
+    if (isEarlyFlakeDetectionEnabled && lastTestStatus !== 'skip' && (isNew || isModified)) {
       for (let retryIndex = 0; retryIndex < earlyFlakeDetectionNumRetries; retryIndex++) {
         numRetriesByPickleId.set(pickle.id, retryIndex + 1)
+        // eslint-disable-next-line no-await-in-loop
         runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
       }
     }
     let testStatus = lastTestStatus
     let shouldBePassedByEFD = false
     let shouldBePassedByTestManagement = false
-    if (isNew && isEarlyFlakeDetectionEnabled) {
+    if ((isNew || isModified) && 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.
@@ -667,10 +706,10 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       shouldBePassedByTestManagement = true
     }
 
-    if (!pickleResultByFile[testFileAbsolutePath]) {
-      pickleResultByFile[testFileAbsolutePath] = [testStatus]
-    } else {
+    if (pickleResultByFile[testFileAbsolutePath]) {
       pickleResultByFile[testFileAbsolutePath].push(testStatus)
+    } else {
+      pickleResultByFile[testFileAbsolutePath] = [testStatus]
     }
 
     // If it's a worker, suite events are handled in `getWrappedParseWorkerMessage`
@@ -694,7 +733,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       testSuiteFinishCh.publish({ status: testSuiteStatus, testSuitePath })
     }
 
-    if (isNewerCucumberVersion && isEarlyFlakeDetectionEnabled && isNew) {
+    if (isNewerCucumberVersion && isEarlyFlakeDetectionEnabled && (isNew || isModified)) {
       return shouldBePassedByEFD
     }
 
@@ -714,20 +753,12 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
     if (Array.isArray(message)) {
       const [messageCode, payload] = message
       if (messageCode === CUCUMBER_WORKER_TRACE_PAYLOAD_CODE) {
-        sessionAsyncResource.runInAsyncScope(() => {
-          workerReportTraceCh.publish(payload)
-        })
+        workerReportTraceCh.publish(payload)
         return
       }
     }
 
-    let envelope
-
-    if (isNewVersion) {
-      envelope = message.envelope
-    } else {
-      envelope = message.jsonEnvelope
-    }
+    const envelope = isNewVersion ? message.envelope : message.jsonEnvelope
 
     if (!envelope) {
       return parseWorkerMessageFunction.apply(this, arguments)
@@ -737,7 +768,7 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
     if (typeof parsed === 'string') {
       try {
         parsed = JSON.parse(envelope)
-      } catch (e) {
+      } catch {
         // ignore errors and continue
         return parseWorkerMessageFunction.apply(this, arguments)
       }
@@ -790,11 +821,11 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
       if (isEarlyFlakeDetectionEnabled && isNew) {
         const testFullname = `${pickle.uri}:${pickle.name}`
         let testStatuses = newTestsByTestFullname.get(testFullname)
-        if (!testStatuses) {
+        if (testStatuses) {
+          testStatuses.push(status)
+        } else {
           testStatuses = [status]
           newTestsByTestFullname.set(testFullname, testStatuses)
-        } else {
-          testStatuses.push(status)
         }
         // We have finished all retries
         if (testStatuses.length === earlyFlakeDetectionNumRetries + 1) {
@@ -894,7 +925,7 @@ addHook({
   shimmer.wrap(
     workerPackage.Worker.prototype,
     'runTestCase',
-    runTestCase => getWrappedRunTestCase(runTestCase, true, !!process.env.CUCUMBER_WORKER_ID)
+    runTestCase => getWrappedRunTestCase(runTestCase, true, !!getEnvironmentVariable('CUCUMBER_WORKER_ID'))
   )
   return workerPackage
 })
@@ -947,6 +978,11 @@ addHook({
       this.options.worldParameters._ddEarlyFlakeDetectionNumRetries = earlyFlakeDetectionNumRetries
     }
 
+    if (isImpactedTestsEnabled) {
+      this.options.worldParameters._ddImpactedTestsEnabled = isImpactedTestsEnabled
+      this.options.worldParameters._ddModifiedTests = modifiedTests
+    }
+
     return startWorker.apply(this, arguments)
   })
   return adapterPackage
@@ -973,6 +1009,10 @@ addHook({
       if (isEarlyFlakeDetectionEnabled) {
         earlyFlakeDetectionNumRetries = this.options.worldParameters._ddEarlyFlakeDetectionNumRetries
       }
+      isImpactedTestsEnabled = !!this.options.worldParameters._ddImpactedTestsEnabled
+      if (isImpactedTestsEnabled) {
+        modifiedTests = this.options.worldParameters._ddModifiedTests
+      }
     }
   )
   return workerPackage

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

@@ -1,8 +1,9 @@
 const { addHook } = require('./helpers/instrument')
+const { DD_MAJOR } = require('../../../version')
 
 // No handler because this is only useful for testing.
 // Cypress plugin does not patch any library.
 addHook({
   name: 'cypress',
-  versions: ['>=6.7.0']
+  versions: DD_MAJOR >= 6 ? ['>=10.2.0'] : ['>=6.7.0']
 }, lib => lib)

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

@@ -39,12 +39,12 @@ addHook({ name: names }, dns => {
 })
 
 function patchResolveShorthands (prototype) {
-  Object.keys(rrtypes)
-    .filter(method => !!prototype[method])
-    .forEach(method => {
+  for (const method of Object.keys(rrtypes)) {
+    if (prototype[method]) {
       rrtypeMap.set(prototype[method], rrtypes[method])
       shimmer.wrap(prototype, method, fn => wrap('apm:dns:resolve', fn, 2, rrtypes[method]))
-    })
+    }
+  }
 }
 
 function wrap (prefix, fn, expectedArgs, rrtype) {
@@ -62,7 +62,7 @@ function wrap (prefix, fn, expectedArgs, rrtype) {
       return fn.apply(this, arguments)
     }
 
-    const args = Array.from(arguments)
+    const args = [...arguments]
     args.pop() // gets rid of the callback
     if (rrtype) {
       args.push(rrtype)

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

@@ -91,18 +91,17 @@ function createWrapRequest (name) {
               return cb.apply(null, arguments)
             }))
             return request.apply(this, arguments)
+          }
+          const promise = request.apply(this, arguments)
+          if (promise && typeof promise.then === 'function') {
+            const onResolve = asyncResource.bind(() => finish(params))
+            const onReject = asyncResource.bind(e => finish(params, e))
+
+            promise.then(onResolve, onReject)
           } else {
-            const promise = request.apply(this, arguments)
-            if (promise && typeof promise.then === 'function') {
-              const onResolve = asyncResource.bind(() => finish(params))
-              const onReject = asyncResource.bind(e => finish(params, e))
-
-              promise.then(onResolve, onReject)
-            } else {
-              finish(params)
-            }
-            return promise
+            finish(params)
           }
+          return promise
         } catch (err) {
           err.stack // trigger getting the stack at the original throwing point
           errorCh.publish(err)

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

@@ -59,21 +59,19 @@ function wrapAddHook (addHook) {
               return parsingResource.runInAsyncScope(() => {
                 return done.apply(this, arguments)
               })
-            } else {
-              return done.apply(this, arguments)
             }
+            return done.apply(this, arguments)
           }
 
           return fn.apply(this, arguments)
-        } else {
-          const promise = fn.apply(this, arguments)
-
-          if (promise && typeof promise.catch === 'function') {
-            return promise.catch(err => publishError(err, req))
-          }
+        }
+        const promise = fn.apply(this, arguments)
 
-          return promise
+        if (promise && typeof promise.catch === 'function') {
+          return promise.catch(err => publishError(err, req))
         }
+
+        return promise
       } catch (e) {
         throw publishError(e, req)
       }

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

@@ -366,7 +366,7 @@ function massWrap (target, methods, wrapper) {
 function wrap (target, method, wrapper) {
   try {
     shimmer.wrap(target, method, wrapper)
-  } catch (e) {
+  } catch {
     // skip unavailable method
   }
 }

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

@@ -2,8 +2,7 @@
 
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -65,42 +64,35 @@ function wrapMethod (method) {
   return function (request) {
     if (!requestStartCh.hasSubscribers) return method.apply(this, arguments)
 
-    const innerAsyncResource = new AsyncResource('bound-anonymous-fn')
-
-    return innerAsyncResource.runInAsyncScope(() => {
-      const projectId = this.auth._cachedProjectId
+    const ctx = { request, api, projectId: this.auth._cachedProjectId }
+    return requestStartCh.runStores(ctx, () => {
       const cb = arguments[arguments.length - 1]
 
-      requestStartCh.publish({ request, api, projectId })
-
       if (typeof cb === 'function') {
-        const outerAsyncResource = new AsyncResource('bound-anonymous-fn')
-
-        arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => innerAsyncResource.bind(function (error) {
+        arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => function (error) {
           if (error) {
-            requestErrorCh.publish(error)
+            ctx.error = error
+            requestErrorCh.publish(ctx)
           }
 
-          requestFinishCh.publish()
+          return requestFinishCh.runStores(ctx, cb, this, ...arguments)
+        })
 
-          return outerAsyncResource.runInAsyncScope(() => cb.apply(this, arguments))
-        }))
-
-        return method.apply(this, arguments)
-      } else {
         return method.apply(this, arguments)
-          .then(
-            response => {
-              requestFinishCh.publish()
-              return response
-            },
-            error => {
-              requestErrorCh.publish(error)
-              requestFinishCh.publish()
-              throw error
-            }
-          )
       }
+      return method.apply(this, arguments)
+        .then(
+          response => {
+            requestFinishCh.publish(ctx)
+            return response
+          },
+          error => {
+            ctx.error = error
+            requestErrorCh.publish(ctx)
+            requestFinishCh.publish(ctx)
+            throw error
+          }
+        )
     })
   }
 }
@@ -119,16 +111,14 @@ addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'] }, (obj) => {
   shimmer.wrap(Subscription.prototype, 'emit', emit => function (eventName, message) {
     if (eventName !== 'message' || !message) return emit.apply(this, arguments)
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
-    return asyncResource.runInAsyncScope(() => {
-      try {
-        return emit.apply(this, arguments)
-      } catch (err) {
-        receiveErrorCh.publish(err)
-        throw err
-      }
-    })
+    const ctx = {}
+    try {
+      return emit.apply(this, arguments)
+    } catch (err) {
+      ctx.error = err
+      receiveErrorCh.publish(ctx)
+      throw err
+    }
   })
 
   return obj
@@ -136,22 +126,24 @@ addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'] }, (obj) => {
 
 addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'], file: 'build/src/lease-manager.js' }, (obj) => {
   const LeaseManager = obj.LeaseManager
+  const ctx = {}
 
   shimmer.wrap(LeaseManager.prototype, '_dispense', dispense => function (message) {
     if (receiveStartCh.hasSubscribers) {
-      receiveStartCh.publish({ message })
+      ctx.message = message
+      return receiveStartCh.runStores(ctx, dispense, this, ...arguments)
     }
     return dispense.apply(this, arguments)
   })
 
   shimmer.wrap(LeaseManager.prototype, 'remove', remove => function (message) {
-    receiveFinishCh.publish({ message })
-    return remove.apply(this, arguments)
+    return receiveFinishCh.runStores(ctx, remove, this, ...arguments)
   })
 
   shimmer.wrap(LeaseManager.prototype, 'clear', clear => function () {
     for (const message of this._messages) {
-      receiveFinishCh.publish({ message })
+      ctx.message = message
+      receiveFinishCh.publish(ctx)
     }
     return clear.apply(this, arguments)
   })