dd-trace 5.52.0 → 5.54.0

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

@@ -8,6 +8,7 @@ const log = require('../../dd-trace/src/log')
 const testStartCh = channel('ci:cucumber:test:start')
 const testRetryCh = channel('ci:cucumber:test:retry')
 const testFinishCh = channel('ci:cucumber:test:finish') // used for test steps too
+const testFnCh = channel('ci:cucumber:test:fn')
 
 const testStepStartCh = channel('ci:cucumber:test-step:start')
 
@@ -23,6 +24,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')
 
@@ -41,7 +44,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
@@ -52,8 +55,9 @@ const patched = new WeakSet()
 
 const lastStatusByPickleId = new Map()
 const numRetriesByPickleId = new Map()
-const numAttemptToAsyncResource = new Map()
+const numAttemptToCtx = new Map()
 const newTestsByTestFullname = new Map()
+const modifiedTestsByPickleId = new Map()
 
 let eventDataCollector = null
 let pickleByFile = {}
@@ -73,15 +77,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')) {
@@ -132,7 +138,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'
@@ -227,16 +233,12 @@ function wrapRun (pl, isLatestVersion) {
   patched.add(pl)
 
   shimmer.wrap(pl.prototype, 'run', run => function () {
-    if (!testStartCh.hasSubscribers) {
+    if (!testFinishCh.hasSubscribers) {
       return run.apply(this, arguments)
     }
 
     let numAttempt = 0
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
-    numAttemptToAsyncResource.set(numAttempt, asyncResource)
-
     const testFileAbsolutePath = this.pickle.uri
 
     const testSourceLine = this.gherkinDocument?.feature?.location?.line
@@ -247,9 +249,9 @@ function wrapRun (pl, isLatestVersion) {
       testSourceLine,
       isParallel: !!process.env.CUCUMBER_WORKER_ID
     }
-    asyncResource.runInAsyncScope(() => {
-      testStartCh.publish(testStartPayload)
-    })
+    const ctx = testStartPayload
+    numAttemptToCtx.set(numAttempt, ctx)
+    testStartCh.runStores(ctx, () => {})
     const promises = {}
     try {
       this.eventBroadcaster.on('envelope', shimmer.wrapFunction(null, () => async (testCase) => {
@@ -261,11 +263,11 @@ function wrapRun (pl, isLatestVersion) {
             try {
               const cucumberResult = this.getWorstStepResult()
               error = getErrorFromCucumberResult(cucumberResult)
-            } catch (e) {
+            } catch {
               // ignore error
             }
 
-            const failedAttemptAsyncResource = numAttemptToAsyncResource.get(numAttempt)
+            const failedAttemptCtx = numAttemptToCtx.get(numAttempt)
             const isFirstAttempt = numAttempt++ === 0
             const isAtrRetry = !isFirstAttempt && isFlakyTestRetriesEnabled
 
@@ -273,23 +275,19 @@ function wrapRun (pl, isLatestVersion) {
               await promises.hitBreakpointPromise
             }
 
-            failedAttemptAsyncResource.runInAsyncScope(() => {
-              // the current span will be finished and a new one will be created
-              testRetryCh.publish({ isFirstAttempt, error, isAtrRetry })
-            })
+            // the current span will be finished and a new one will be created
+            testRetryCh.publish({ isFirstAttempt, error, isAtrRetry, ...failedAttemptCtx.currentStore })
 
-            const newAsyncResource = new AsyncResource('bound-anonymous-fn')
-            numAttemptToAsyncResource.set(numAttempt, newAsyncResource)
+            const newCtx = { ...testStartPayload, promises }
+            numAttemptToCtx.set(numAttempt, newCtx)
 
-            newAsyncResource.runInAsyncScope(() => {
-              testStartCh.publish({ ...testStartPayload, promises }) // a new span will be created
-            })
+            testStartCh.runStores(newCtx, () => {})
           }
         }
       }))
       let promise
 
-      asyncResource.runInAsyncScope(() => {
+      testFnCh.runStores(ctx, () => {
         promise = run.apply(this, arguments)
       })
       promise.finally(async () => {
@@ -312,6 +310,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())
@@ -336,46 +335,55 @@ 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
         }
 
-        const attemptAsyncResource = numAttemptToAsyncResource.get(numAttempt)
+        const attemptCtx = numAttemptToCtx.get(numAttempt)
 
         const error = getErrorFromCucumberResult(result)
 
         if (promises.hitBreakpointPromise) {
           await promises.hitBreakpointPromise
         }
-        attemptAsyncResource.runInAsyncScope(() => {
-          testFinishCh.publish({
-            status,
-            skipReason,
-            error,
-            isNew,
-            isEfdRetry,
-            isFlakyRetry: numAttempt > 0,
-            isAttemptToFix,
-            isAttemptToFixRetry,
-            hasFailedAllRetries,
-            hasPassedAllRetries,
-            hasFailedAttemptToFix,
-            isDisabled,
-            isQuarantined
-          })
+        testFinishCh.publish({
+          status,
+          skipReason,
+          error,
+          isNew,
+          isEfdRetry,
+          isFlakyRetry: numAttempt > 0,
+          isAttemptToFix,
+          isAttemptToFixRetry,
+          hasFailedAllRetries,
+          hasPassedAllRetries,
+          hasFailedAttemptToFix,
+          isDisabled,
+          isQuarantined,
+          isModified,
+          ...attemptCtx.currentStore
         })
       })
       return promise
     } catch (err) {
-      errorCh.publish(err)
-      throw err
+      ctx.err = err
+      errorCh.runStores(ctx, () => {
+        throw err
+      })
     }
   })
   shimmer.wrap(pl.prototype, 'runStep', runStep => function () {
-    if (!testStepStartCh.hasSubscribers) {
+    if (!testFinishCh.hasSubscribers) {
       return runStep.apply(this, arguments)
     }
     const testStep = arguments[0]
@@ -387,9 +395,8 @@ function wrapRun (pl, isLatestVersion) {
       resource = testStep.isHook ? 'hook' : testStep.pickleStep.text
     }
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-    return asyncResource.runInAsyncScope(() => {
-      testStepStartCh.publish({ resource })
+    const ctx = { resource }
+    return testStepStartCh.runStores(ctx, () => {
       try {
         const promise = runStep.apply(this, arguments)
 
@@ -398,12 +405,14 @@ function wrapRun (pl, isLatestVersion) {
             ? getStatusFromResultLatest(result)
             : getStatusFromResult(result)
 
-          testFinishCh.publish({ isStep: true, status, skipReason, errorMessage })
+          testFinishCh.publish({ isStep: true, status, skipReason, errorMessage, ...ctx.currentStore })
         })
         return promise
       } catch (err) {
-        errorCh.publish(err)
-        throw err
+        ctx.err = err
+        errorCh.runStores(ctx, () => {
+          throw err
+        })
       }
     })
   })
@@ -456,14 +465,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
       }
     }
 
@@ -493,7 +503,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
           this.pickleIds = picklesToRun
         }
 
-        skippedSuites = Array.from(filteredPickles.skippedSuites)
+        skippedSuites = [...filteredPickles.skippedSuites]
         itrCorrelationId = skippableResponse.itrCorrelationId
       }
     }
@@ -515,10 +525,17 @@ 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
       }
     }
 
@@ -552,7 +569,7 @@ 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
@@ -582,12 +599,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())
@@ -609,6 +629,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)
@@ -621,6 +642,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) {
@@ -631,7 +670,7 @@ 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') {
@@ -642,7 +681,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     }
 
     // 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)
         runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
@@ -651,7 +690,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     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.
@@ -672,10 +711,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`
@@ -699,7 +738,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       testSuiteFinishCh.publish({ status: testSuiteStatus, testSuitePath })
     }
 
-    if (isNewerCucumberVersion && isEarlyFlakeDetectionEnabled && isNew) {
+    if (isNewerCucumberVersion && isEarlyFlakeDetectionEnabled && (isNew || isModified)) {
       return shouldBePassedByEFD
     }
 
@@ -726,13 +765,7 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
       }
     }
 
-    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)
@@ -742,7 +775,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)
       }
@@ -795,11 +828,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) {
@@ -952,6 +985,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
@@ -978,6 +1016,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

@@ -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/express.js

@@ -149,11 +149,9 @@ addHook({ name: 'express', versions: ['>=4.3.0 <5.0.0'] }, express => {
 const queryReadCh = channel('datadog:express:query:finish')
 
 addHook({ name: 'express', file: ['lib/request.js'], versions: ['>=5.0.0'] }, request => {
-  const requestDescriptor = Object.getOwnPropertyDescriptor(request, 'query')
-
-  shimmer.wrap(requestDescriptor, 'get', function (originalGet) {
+  shimmer.wrap(request, 'query', function (originalGet) {
     return function wrappedGet () {
-      const query = originalGet.apply(this, arguments)
+      const query = originalGet.call(this)
 
       if (queryReadCh.hasSubscribers && query) {
         queryReadCh.publish({ query })
@@ -163,7 +161,5 @@ addHook({ name: 'express', file: ['lib/request.js'], versions: ['>=5.0.0'] }, re
     }
   })
 
-  Object.defineProperty(request, 'query', requestDescriptor)
-
   return request
 })

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

@@ -1,5 +1,6 @@
 'use strict'
 
+const { errorMonitor } = require('events')
 const { channel, addHook } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -199,16 +200,16 @@ function wrapCreateStream (original) {
         }
         const onFinish = () => {
           finishChannel.runStores(ctx, () => {})
-          stream.off('close', onFinish)
-          stream.off('end', onFinish)
-          stream.off('finish', onFinish)
-          stream.off('error', onError)
+          stream.removeListener('close', onFinish)
+          stream.removeListener('end', onFinish)
+          stream.removeListener('finish', onFinish)
+          stream.removeListener(errorMonitor, onError)
         }
 
         stream.once('close', onFinish)
         stream.once('end', onFinish)
         stream.once('finish', onFinish)
-        stream.once('error', onError)
+        stream.once(errorMonitor, onError)
 
         return stream
       } catch (error) {
@@ -365,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,38 +64,32 @@ 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 outerAsyncResource.runInAsyncScope(() => cb.apply(this, arguments))
-        }))
+          return requestFinishCh.runStores(ctx, cb, this, ...arguments)
+        })
 
         return method.apply(this, arguments)
       } else {
         return method.apply(this, arguments)
           .then(
             response => {
-              requestFinishCh.publish()
+              requestFinishCh.publish(ctx)
               return response
             },
             error => {
-              requestErrorCh.publish(error)
-              requestFinishCh.publish()
+              ctx.error = error
+              requestErrorCh.publish(ctx)
+              requestFinishCh.publish(ctx)
               throw error
             }
           )
@@ -119,16 +112,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 +127,25 @@ 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)
+    } else {
+      return dispense.apply(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)
   })