dd-trace 5.56.0 → 5.57.0

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

@@ -6,8 +6,14 @@ const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const errorChannel = channel('apm:fastify:middleware:error')
 const handleChannel = channel('apm:fastify:request:handle')
 const routeAddedChannel = channel('apm:fastify:route:added')
+const bodyParserReadCh = channel('datadog:fastify:body-parser:finish')
+const queryParamsReadCh = channel('datadog:fastify:query-params:finish')
+const cookieParserReadCh = channel('datadog:fastify-cookie:read:finish')
+const responsePayloadReadCh = channel('datadog:fastify:response:finish')
+const pathParamsReadCh = channel('datadog:fastify:path-params:finish')
 
 const parsingResources = new WeakMap()
+const cookiesPublished = new WeakSet()
 
 function wrapFastify (fastify, hasParsingEvents) {
   if (typeof fastify !== 'function') return fastify
@@ -45,26 +51,46 @@ function wrapAddHook (addHook) {
       const req = getReq(request)
 
       try {
-        if (typeof done === 'function') {
-          done = arguments[arguments.length - 1]
+        // done callback is always the last argument
+        const doneCallback = arguments[arguments.length - 1]
 
+        if (typeof doneCallback === 'function') {
           arguments[arguments.length - 1] = function (err) {
             publishError(err, req)
 
+            const hasCookies = request.cookies && Object.keys(request.cookies).length > 0
+
+            if (cookieParserReadCh.hasSubscribers && hasCookies && !cookiesPublished.has(req)) {
+              const res = getRes(reply)
+              const abortController = new AbortController()
+
+              cookieParserReadCh.publish({
+                req,
+                res,
+                abortController,
+                cookies: request.cookies
+              })
+
+              cookiesPublished.add(req)
+
+              if (abortController.signal.aborted) return
+            }
+
             if (name === 'onRequest' || name === 'preParsing') {
               const parsingResource = new AsyncResource('bound-anonymous-fn')
 
               parsingResources.set(req, parsingResource)
 
               return parsingResource.runInAsyncScope(() => {
-                return done.apply(this, arguments)
+                return doneCallback.apply(this, arguments)
               })
             }
-            return done.apply(this, arguments)
+            return doneCallback.apply(this, arguments)
           }
 
           return fn.apply(this, arguments)
         }
+
         const promise = fn.apply(this, arguments)
 
         if (promise && typeof promise.catch === 'function') {
@@ -106,11 +132,52 @@ function preHandler (request, reply, done) {
 
 function preValidation (request, reply, done) {
   const req = getReq(request)
+  const res = getRes(reply)
   const parsingResource = parsingResources.get(req)
 
-  if (!parsingResource) return done()
+  const processInContext = () => {
+    let abortController
 
-  parsingResource.runInAsyncScope(() => done())
+    if (queryParamsReadCh.hasSubscribers && request.query) {
+      abortController ??= new AbortController()
+
+      queryParamsReadCh.publish({
+        req,
+        res,
+        abortController,
+        query: request.query
+      })
+
+      if (abortController.signal.aborted) return
+    }
+
+    if (bodyParserReadCh.hasSubscribers && request.body) {
+      abortController ??= new AbortController()
+
+      bodyParserReadCh.publish({ req, res, body: request.body, abortController })
+
+      if (abortController.signal.aborted) return
+    }
+
+    if (pathParamsReadCh.hasSubscribers && request.params) {
+      abortController ??= new AbortController()
+
+      pathParamsReadCh.publish({
+        req,
+        res,
+        abortController,
+        params: request.params
+      })
+
+      if (abortController.signal.aborted) return
+    }
+
+    done()
+  }
+
+  if (!parsingResource) return processInContext()
+
+  parsingResource.runInAsyncScope(processInContext)
 }
 
 function preParsing (request, reply, payload, done) {
@@ -126,9 +193,12 @@ function preParsing (request, reply, payload, done) {
 }
 
 function wrapSend (send, req) {
-  return function sendWithTrace (error) {
-    if (error instanceof Error) {
-      errorChannel.publish({ req, error })
+  return function sendWithTrace (payload) {
+    if (payload instanceof Error) {
+      errorChannel.publish({ req, error: payload })
+    } else if (canPublishResponsePayload(payload)) {
+      const res = getRes(this)
+      responsePayloadReadCh.publish({ req, res, body: payload })
     }
 
     return send.apply(this, arguments)
@@ -159,6 +229,18 @@ function onRoute (routeOptions) {
   routeAddedChannel.publish({ routeOptions, onRoute })
 }
 
+// send() payload types: https://fastify.dev/docs/latest/Reference/Reply/#senddata
+function canPublishResponsePayload (payload) {
+  return responsePayloadReadCh.hasSubscribers &&
+    payload &&
+    typeof payload === 'object' &&
+    typeof payload.pipe !== 'function' && // Node streams
+    typeof payload.body?.pipe !== 'function' && // Response with body stream
+    !Buffer.isBuffer(payload) && // Buffer
+    !(payload instanceof ArrayBuffer) && // ArrayBuffer
+    !ArrayBuffer.isView(payload) // TypedArray
+}
+
 addHook({ name: 'fastify', versions: ['>=3'] }, fastify => {
   const wrapped = shimmer.wrapFunction(fastify, fastify => wrapFastify(fastify, true))
 

package/packages/datadog-instrumentations/src/helpers/bundler-register.js

@@ -26,14 +26,29 @@ if (!dc.unsubscribe) {
   }
 }
 
-dc.subscribe(CHANNEL, (payload) => {
-  try {
-    hooks[payload.package]()
-  } catch (err) {
+function doHook (payload) {
+  const hook = hooks[payload.package]
+  if (!hook) {
     log.error('esbuild-wrapped %s missing in list of hooks', payload.package)
-    throw err
+    return
+  }
+
+  const hookFn = hook.fn ?? hook
+  if (typeof hookFn !== 'function') {
+    log.error('esbuild-wrapped hook %s is not a function', payload.package)
+    return
   }
 
+  try {
+    hookFn()
+  } catch {
+    log.error('esbuild-wrapped %s hook failed', payload.package)
+  }
+}
+
+dc.subscribe(CHANNEL, (payload) => {
+  doHook(payload)
+
   if (!instrumentations[payload.package]) {
     log.error('esbuild-wrapped %s missing in list of instrumentations', payload.package)
     return

package/packages/datadog-instrumentations/src/helpers/check-require-cache.js

@@ -55,7 +55,7 @@ module.exports.checkForRequiredModules = function () {
     if (naughties.has(pkg)) continue
     if (!(pkg in packages)) continue
 
-    warnings.push(`Warning: Package '${pkg}' was loaded before dd-trace! This may break instrumentation.`)
+    warnings.push(() => `Warning: Package '${pkg}' was loaded before dd-trace! This may break instrumentation.`)
 
     naughties.add(pkg)
     didWarn = true
@@ -87,7 +87,7 @@ module.exports.checkForPotentialConflicts = function () {
     if (naughties.has(pkg)) continue
     if (!potentialConflicts.has(pkg)) continue
 
-    warnings.push(`Warning: Package '${pkg}' may cause conflicts with dd-trace.`)
+    warnings.push(() => `Warning: Package '${pkg}' may cause conflicts with dd-trace.`)
 
     naughties.add(pkg)
     didWarn = true

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -24,6 +24,7 @@ module.exports = {
   '@node-redis/client': () => require('../redis'),
   '@opensearch-project/opensearch': () => require('../opensearch'),
   '@opentelemetry/sdk-trace-node': () => require('../otel-sdk-trace'),
+  '@prisma/client': () => require('../prisma'),
   '@redis/client': () => require('../redis'),
   '@smithy/smithy-client': () => require('../aws-sdk'),
   '@vitest/runner': { esmFirst: true, fn: () => require('../vitest') },

package/packages/datadog-instrumentations/src/helpers/register.js

@@ -9,6 +9,7 @@ const log = require('../../../dd-trace/src/log')
 const checkRequireCache = require('./check-require-cache')
 const telemetry = require('../../../dd-trace/src/guardrails/telemetry')
 const { isInServerlessEnvironment } = require('../../../dd-trace/src/serverless')
+const { isFalse, isTrue, normalizePluginEnvName } = require('../../../dd-trace/src/util')
 const { getEnvironmentVariables } = require('../../../dd-trace/src/config-helper')
 
 const envs = getEnvironmentVariables()
@@ -22,16 +23,22 @@ const hooks = require('./hooks')
 const instrumentations = require('./instrumentations')
 const names = Object.keys(hooks)
 const pathSepExpr = new RegExp(`\\${path.sep}`, 'g')
+
 const disabledInstrumentations = new Set(
-  DD_TRACE_DISABLED_INSTRUMENTATIONS ? DD_TRACE_DISABLED_INSTRUMENTATIONS.split(',') : []
+  DD_TRACE_DISABLED_INSTRUMENTATIONS?.split(',').map(name => normalizePluginEnvName(name, true)) ?? []
 )
+const reenabledInstrumentations = new Set()
 
 // Check for DD_TRACE_<INTEGRATION>_ENABLED environment variables
 for (const [key, value] of Object.entries(envs)) {
   const match = key.match(/^DD_TRACE_(.+)_ENABLED$/)
-  if (match && (value?.toLowerCase() === 'false' || value === '0')) {
-    const integration = match[1].toLowerCase()
-    disabledInstrumentations.add(integration)
+  if (match && value) {
+    const integration = normalizePluginEnvName(match[1], true)
+    if (isFalse(value)) {
+      disabledInstrumentations.add(integration)
+    } else if (isTrue(value)) {
+      reenabledInstrumentations.add(integration)
+    }
   }
 }
 
@@ -58,7 +65,8 @@ const allInstrumentations = {}
 
 // TODO: make this more efficient
 for (const packageName of names) {
-  if (disabledInstrumentations.has(packageName)) continue
+  const normalizedPackageName = normalizePluginEnvName(packageName, true)
+  if (disabledInstrumentations.has(normalizedPackageName)) continue
 
   const hookOptions = {}
 
@@ -67,6 +75,10 @@ for (const packageName of names) {
   if (typeof hook === 'object') {
     if (hook.serverless === false && isInServerlessEnvironment()) continue
 
+    // some integrations are disabled by default, but can be enabled by setting
+    // the DD_TRACE_<INTEGRATION>_ENABLED environment variable to true
+    if (hook.disabled && !reenabledInstrumentations.has(normalizedPackageName)) continue
+
     hookOptions.internals = hook.esmFirst
     hook = hook.fn
   }

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

@@ -2,8 +2,7 @@
 
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -22,14 +21,9 @@ addHook({ name: 'ioredis', versions: ['>=2'] }, Redis => {
     const db = options.db
     const connectionOptions = { host: options.host, port: options.port }
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-    return asyncResource.runInAsyncScope(() => {
-      startCh.publish({ db, command: command.name, args: command.args, connectionOptions, connectionName })
-
-      const onResolve = asyncResource.bind(() => finish(finishCh, errorCh))
-      const onReject = asyncResource.bind(err => finish(finishCh, errorCh, err))
-
-      command.promise.then(onResolve, onReject)
+    const ctx = { db, command: command.name, args: command.args, connectionOptions, connectionName }
+    return startCh.runStores(ctx, () => {
+      command.promise.then(() => finish(finishCh, errorCh, ctx), err => finish(finishCh, errorCh, ctx, err))
 
       try {
         return sendCommand.apply(this, arguments)
@@ -43,9 +37,10 @@ addHook({ name: 'ioredis', versions: ['>=2'] }, Redis => {
   return Redis
 })
 
-function finish (finishCh, errorCh, error) {
+function finish (finishCh, errorCh, ctx, error) {
   if (error) {
-    errorCh.publish(error)
+    ctx.error = error
+    errorCh.publish(ctx)
   }
-  finishCh.publish()
+  finishCh.publish(ctx)
 }

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

@@ -2,8 +2,7 @@
 
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -22,19 +21,15 @@ addHook({ name: 'iovalkey', versions: ['>=0.0.1'] }, Valkey => {
     const db = options.db
     const connectionOptions = { host: options.host, port: options.port }
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-    return asyncResource.runInAsyncScope(() => {
-      startCh.publish({ db, command: command.name, args: command.args, connectionOptions, connectionName })
-
-      const onResolve = asyncResource.bind(() => finishCh.publish())
-      const onReject = asyncResource.bind(err => finish(finishCh, errorCh, err))
-
-      command.promise.then(onResolve, onReject)
+    const ctx = { db, command: command.name, args: command.args, connectionOptions, connectionName }
+    return startCh.runStores(ctx, () => {
+      command.promise.then(() => finish(finishCh, errorCh, ctx), err => finish(finishCh, errorCh, ctx, err))
 
       try {
         return sendCommand.apply(this, arguments)
       } catch (err) {
-        errorCh.publish(err)
+        ctx.error = err
+        errorCh.publish(ctx)
 
         throw err
       }
@@ -43,9 +38,10 @@ addHook({ name: 'iovalkey', versions: ['>=0.0.1'] }, Valkey => {
   return Valkey
 })
 
-function finish (finishCh, errorCh, error) {
+function finish (finishCh, errorCh, ctx, error) {
   if (error) {
-    errorCh.publish(error)
+    ctx.error = error
+    errorCh.publish(ctx)
   }
-  finishCh.publish()
+  finishCh.publish(ctx)
 }

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

@@ -3,6 +3,7 @@
 const { addHook, channel } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 const log = require('../../dd-trace/src/log')
+const path = require('path')
 const {
   getCoveredFilenamesFromCoverage,
   JEST_WORKER_TRACE_PAYLOAD_CODE,
@@ -90,6 +91,7 @@ const retriedTestsToNumAttempts = new Map()
 const newTestsTestStatuses = new Map()
 const attemptToFixRetriedTestsStatuses = new Map()
 const wrappedWorkers = new WeakSet()
+const testSuiteMockedFiles = new Map()
 
 const BREAKPOINT_HIT_GRACE_PERIOD_MS = 200
 
@@ -137,6 +139,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       this.nameToParams = {}
       this.global._ddtrace = global._ddtrace
       this.hasSnapshotTests = undefined
+      this.testSuiteAbsolutePath = context.testPath
 
       this.displayName = config.projectConfig?.displayName?.name
       this.testEnvironmentOptions = getTestEnvironmentOptions(config)
@@ -291,7 +294,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       // We'll still detect new tests, but we won't retry them.
       // TODO: do not bail out of retrying tests for the whole test suite
       if (this.getHasSnapshotTests()) {
-        log.warn(`${retryType} is disabled for suites with snapshots`)
+        log.warn('%s is disabled for suites with snapshots', retryType)
         return
       }
 
@@ -299,7 +302,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         if (this.global.test) {
           this.global.test(addRetryStringToTestName(testName, retryIndex), event.fn, event.timeout)
         } else {
-          log.error(`${retryType} could not retry test because global.test is undefined`)
+          log.error('%s could not retry test because global.test is undefined', retryType)
         }
       }
     }
@@ -726,7 +729,7 @@ function getCliWrapper (isNewJestVersion) {
         return runCLI.apply(this, arguments)
       }
 
-      libraryConfigurationCh.publish({ onDone })
+      libraryConfigurationCh.publish({ onDone, frameworkVersion: jestVersion })
 
       try {
         const { err, libraryConfig } = await configurationPromise
@@ -1095,10 +1098,12 @@ function jestAdapterWrapper (jestAdapter, jestVersion) {
       if (environment.testEnvironmentOptions?._ddTestCodeCoverageEnabled) {
         const root = environment.repositoryRoot || environment.rootDir
 
-        const coverageFiles = getCoveredFilenamesFromCoverage(environment.global.__coverage__)
-          .map(filename => getTestSuitePath(filename, root))
+        const getFilesWithPath = (files) => files.map(file => getTestSuitePath(file, root))
 
-        testSuiteCodeCoverageCh.publish({ coverageFiles, testSuite: environment.testSourceFile })
+        const coverageFiles = getFilesWithPath(getCoveredFilenamesFromCoverage(environment.global.__coverage__))
+        const mockedFiles = getFilesWithPath(testSuiteMockedFiles.get(environment.testSuiteAbsolutePath) || [])
+
+        testSuiteCodeCoverageCh.publish({ coverageFiles, testSuite: environment.testSourceFile, mockedFiles })
       }
       testSuiteFinishCh.publish({ status, errorMessage })
       return suiteResults
@@ -1267,6 +1272,23 @@ addHook({
 }, (runtimePackage) => {
   const Runtime = runtimePackage.default ?? runtimePackage
 
+  shimmer.wrap(Runtime.prototype, '_createJestObjectFor', _createJestObjectFor => function (from) {
+    const result = _createJestObjectFor.apply(this, arguments)
+    const suiteFilePath = this._testPath
+
+    shimmer.wrap(result, 'mock', mock => function (moduleName) {
+      if (suiteFilePath) {
+        const existingMockedFiles = testSuiteMockedFiles.get(suiteFilePath) || []
+        const suiteDir = path.dirname(suiteFilePath)
+        const mockPath = path.resolve(suiteDir, moduleName)
+        existingMockedFiles.push(mockPath)
+        testSuiteMockedFiles.set(suiteFilePath, existingMockedFiles)
+      }
+      return mock.apply(this, arguments)
+    })
+    return result
+  })
+
   shimmer.wrap(Runtime.prototype, 'requireModuleOrMock', requireModuleOrMock => function (from, moduleName) {
     // TODO: do this for every library that we instrument
     if (shouldBypassJestRequireEngine(moduleName)) {

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

@@ -2,8 +2,7 @@
 
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -17,35 +16,29 @@ addHook({ name: 'memcached', versions: ['>=2.2'] }, Memcached => {
       return command.apply(this, arguments)
     }
 
-    const callbackResource = new AsyncResource('bound-anonymous-fn')
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
     const client = this
 
-    const wrappedQueryCompiler = asyncResource.bind(function () {
+    const wrappedQueryCompiler = function () {
       const query = queryCompiler.apply(this, arguments)
-      const callback = callbackResource.bind(query.callback)
-
-      query.callback = shimmer.wrapFunction(callback, callback => asyncResource.bind(function (err) {
-        if (err) {
-          errorCh.publish(err)
-        }
-        finishCh.publish()
-
-        return callback.apply(this, arguments)
-      }))
-      startCh.publish({ client, server, query })
 
+      const ctx = { client, server, query }
+      startCh.runStores(ctx, () => {
+        query.callback = shimmer.wrapFunction(query.callback, callback => function (err) {
+          if (err) {
+            ctx.error = err
+            errorCh.publish(ctx)
+          }
+          finishCh.publish(ctx)
+
+          return finishCh.runStores(ctx, callback, this, ...arguments)
+        })
+      })
       return query
-    })
-
-    return asyncResource.runInAsyncScope(() => {
-      arguments[0] = wrappedQueryCompiler
+    }
 
-      const result = command.apply(this, arguments)
+    arguments[0] = wrappedQueryCompiler
 
-      return result
-    })
+    return command.apply(this, arguments)
   })
 
   return Memcached

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

@@ -201,9 +201,10 @@ function getOnEndHandler (isParallel) {
   }
 }
 
-function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
+function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFinishRequest) {
   const ctx = {
-    isParallel
+    isParallel,
+    frameworkVersion
   }
 
   const onReceivedSkippableSuites = ({ err, skippableSuites, itrCorrelationId: responseItrCorrelationId }) => {
@@ -343,7 +344,7 @@ addHook({
   name: 'mocha',
   versions: ['>=5.2.0'],
   file: 'lib/mocha.js'
-}, (Mocha) => {
+}, (Mocha, frameworkVersion) => {
   shimmer.wrap(Mocha.prototype, 'run', run => function () {
     // Workers do not need to request any data, just run the tests
     if (!testFinishCh.hasSubscribers || getEnvironmentVariable('MOCHA_WORKER_ID') || this.options.parallel) {
@@ -363,7 +364,7 @@ addHook({
       }
     })
 
-    getExecutionConfiguration(runner, false, () => {
+    getExecutionConfiguration(runner, false, frameworkVersion, () => {
       if (config.isKnownTestsEnabled) {
         const testSuites = this.files.map(file => getTestSuitePath(file, process.cwd()))
         const isFaulty = getIsFaultyEarlyFlakeDetection(
@@ -521,7 +522,7 @@ addHook({
       if (ctx) {
         testSuiteFinishCh.publish({ status, ...ctx.currentStore }, () => {})
       } else {
-        log.warn(() => `No ctx found for suite ${suite.file}`)
+        log.warn('No ctx found for suite', suite.file)
       }
     })
 
@@ -616,7 +617,7 @@ addHook({
     this.once('start', getOnStartHandler(true, frameworkVersion))
     this.once('end', getOnEndHandler(true))
 
-    getExecutionConfiguration(this, true, () => {
+    getExecutionConfiguration(this, true, frameworkVersion, () => {
       if (config.isKnownTestsEnabled) {
         const testSuites = files.map(file => getTestSuitePath(file, process.cwd()))
         const isFaulty = getIsFaultyEarlyFlakeDetection(

package/packages/datadog-instrumentations/src/moleculer/client.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { channel, addHook, AsyncResource } = require('../helpers/instrument')
+const { channel, addHook } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 
 const startChannel = channel('apm:moleculer:call:start')
@@ -9,29 +9,28 @@ const errorChannel = channel('apm:moleculer:call:error')
 
 function wrapCall (call) {
   return function (actionName, params, opts) {
-    const callResource = new AsyncResource('bound-anonymous-fn')
-
     opts = arguments[2] = opts || {}
     opts.meta = opts.meta || {}
 
     arguments.length = Math.max(3, arguments.length)
 
-    return callResource.runInAsyncScope(() => {
-      startChannel.publish({ actionName, params, opts })
-
+    const ctx = { actionName, params, opts }
+    return startChannel.runStores(ctx, () => {
       const promise = call.apply(this, arguments)
       const broker = this
-      const ctx = promise.ctx
+      ctx.promiseCtx = promise.ctx
+      ctx.broker = broker
 
       return promise
         .then(
           result => {
-            finishChannel.publish({ broker, ctx })
+            finishChannel.publish(ctx)
             return result
           },
           error => {
-            errorChannel.publish(error)
-            finishChannel.publish({ broker, ctx })
+            ctx.error = error
+            errorChannel.publish(ctx)
+            finishChannel.publish(ctx)
             throw error
           }
         )

package/packages/datadog-instrumentations/src/moleculer/server.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { channel, addHook, AsyncResource } = require('../helpers/instrument')
+const { channel, addHook } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 
 const startChannel = channel('apm:moleculer:action:start')
@@ -24,27 +24,26 @@ function createMiddleware () {
     localAction (next, action) {
       const broker = this
 
-      return shimmer.wrapFunction(next, next => function datadogMiddleware (ctx) {
-        const actionResource = new AsyncResource('bound-anonymous-fn')
-
-        return actionResource.runInAsyncScope(() => {
-          startChannel.publish({ action, ctx, broker })
-
+      return shimmer.wrapFunction(next, next => function datadogMiddleware (middlewareCtx) {
+        const ctx = { action, middlewareCtx, broker }
+        return startChannel.runStores(ctx, () => {
           try {
-            return next(ctx).then(
+            return next(middlewareCtx).then(
               result => {
-                finishChannel.publish()
+                finishChannel.publish(ctx)
                 return result
               },
               error => {
-                errorChannel.publish(error)
-                finishChannel.publish()
+                ctx.error = error
+                errorChannel.publish(ctx)
+                finishChannel.publish(ctx)
                 throw error
               }
             )
           } catch (e) {
-            errorChannel.publish(e)
-            finishChannel.publish()
+            ctx.error = e
+            errorChannel.publish(ctx)
+            finishChannel.publish(ctx)
           }
         })
       })