dd-trace 2.7.1 → 2.8.0

package/LICENSE-3rdparty.csv

@@ -17,7 +17,6 @@ require,lodash.sortby,MIT,Copyright JS Foundation and other contributors
 require,lodash.uniq,MIT,Copyright JS Foundation and other contributors
 require,methods,MIT,Copyright 2013-2014 TJ Holowaychuk
 require,module-details-from-path,MIT,Copyright 2016 Thomas Watson Steen
-require,multer,MIT,Copyright 2014 Hage Yaapa
 require,opentracing,MIT,Copyright 2016 Resonance Labs Inc
 require,path-to-regexp,MIT,Copyright 2014 Blake Embrey
 require,performance-now,MIT,Copyright 2013 Braveg1rl
@@ -31,7 +30,6 @@ dev,chai,MIT,Copyright 2017 Chai.js Assertion Library
 dev,chalk,MIT,Copyright Sindre Sorhus
 dev,checksum,MIT,Copyright Daniel D. Shaw
 dev,cli-table3,MIT,Copyright 2014 James Talmage
-dev,codecov,MIT,Copyright 2014 Gregg Caines
 dev,dotenv,BSD-2-Clause,Copyright 2015 Scott Motte
 dev,eslint,MIT,Copyright JS Foundation and other contributors https://js.foundation
 dev,eslint-config-standard,MIT,Copyright Feross Aboukhadijeh
@@ -47,6 +45,7 @@ dev,int64-buffer,MIT,Copyright 2015-2016 Yusuke Kawasaki
 dev,jszip,MIT,Copyright 2015-2016 Stuart Knightley and contributors
 dev,mkdirp,MIT,Copyright 2010 James Halliday
 dev,mocha,MIT,Copyright 2011-2018 JS Foundation and contributors https://js.foundation
+dev,multer,MIT,Copyright 2014 Hage Yaapa
 dev,msgpack-lite,MIT,Copyright 2015 Yusuke Kawasaki
 dev,nock,MIT,Copyright 2017 Pedro Teixeira and other contributors
 dev,nyc,ISC,Copyright 2015 Contributors

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "2.7.1",
+  "version": "2.8.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -32,7 +32,6 @@
     "test:shimmer:ci": "nyc --no-clean --include 'packages/datadog-shimmer/src/**/*.js' -- npm run test:shimmer",
     "leak:core": "node ./scripts/install_plugin_modules && (cd packages/memwatch && yarn) && NODE_PATH=./packages/memwatch/node_modules node --no-warnings ./node_modules/.bin/tape 'packages/dd-trace/test/leak/**/*.js'",
     "leak:plugins": "yarn services && (cd packages/memwatch && yarn) && NODE_PATH=./packages/memwatch/node_modules node --no-warnings ./node_modules/.bin/tape \"packages/datadog-plugin-@($(echo $PLUGINS))/test/leak.js\"",
-    "codecov": "codecov",
     "junit:upload": "node ./scripts/junit_report.js"
   },
   "repository": {
@@ -59,7 +58,7 @@
     "node": ">=12"
   },
   "dependencies": {
-    "@datadog/native-appsec": "^1.1.1",
+    "@datadog/native-appsec": "^1.2.0",
     "@datadog/native-metrics": "^1.2.0",
     "@datadog/pprof": "^0.4.0",
     "@datadog/sketches-js": "^1.0.4",
@@ -77,7 +76,6 @@
     "lodash.uniq": "^4.5.0",
     "methods": "^1.1.2",
     "module-details-from-path": "^1.0.3",
-    "multer": "^1.4.2",
     "opentracing": ">=0.12.1",
     "path-to-regexp": "^0.1.2",
     "performance-now": "^2.1.0",
@@ -93,7 +91,6 @@
     "chalk": "^3.0.0",
     "checksum": "^0.1.1",
     "cli-table3": "^0.5.1",
-    "codecov": "3.8.1",
     "dotenv": "8.2.0",
     "eslint": "^7.32.0",
     "eslint-config-standard": "^11.0.0-beta.0",
@@ -109,6 +106,7 @@
     "jszip": "^3.5.0",
     "mkdirp": "^0.5.1",
     "mocha": "8",
+    "multer": "^1.4.2",
     "msgpack-lite": "^0.1.26",
     "nock": "^11.3.3",
     "nyc": "^15.1.0",

package/packages/datadog-instrumentations/index.js

@@ -16,6 +16,7 @@ require('./src/fastify')
 require('./src/find-my-way')
 require('./src/generic-pool')
 require('./src/google-cloud-pubsub')
+require('./src/hapi')
 require('./src/http')
 require('./src/ioredis')
 require('./src/jest')
@@ -23,6 +24,7 @@ require('./src/kafkajs')
 require('./src/knex')
 require('./src/koa')
 require('./src/memcached')
+require('./src/moleculer')
 require('./src/mongodb-core')
 require('./src/mongoose')
 require('./src/mysql')

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

@@ -9,62 +9,63 @@ const shimmer = require('../../datadog-shimmer')
 
 addHook({ name: 'amqp10', file: 'lib/sender_link.js', versions: ['>=3'] }, SenderLink => {
   const startCh = channel('apm:amqp10:send:start')
-  const asyncEndCh = channel('apm:amqp10:send:async-end')
-  const endCh = channel('apm:amqp10:send:end')
+  const finishCh = channel('apm:amqp10:send:finish')
   const errorCh = channel('apm:amqp10:send:error')
   shimmer.wrap(SenderLink.prototype, 'send', send => function (msg, options) {
     if (!startCh.hasSubscribers) {
       return send.apply(this, arguments)
     }
-    startCh.publish({ link: this })
-    try {
-      const promise = send.apply(this, arguments)
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    return asyncResource.runInAsyncScope(() => {
+      startCh.publish({ link: this })
+      try {
+        const promise = send.apply(this, arguments)
 
-      if (!promise) {
-        finish(asyncEndCh, errorCh)
-        return promise
-      }
-
-      const asyncResource = new AsyncResource('bound-anonymous-fn')
+        if (!promise) {
+          finish(finishCh, errorCh)
+          return promise
+        }
 
-      promise.then(asyncResource.bind(() => finish(asyncEndCh, errorCh)),
-        asyncResource.bind(e => finish(asyncEndCh, errorCh, e)))
+        promise.then(asyncResource.bind(() => finish(finishCh, errorCh)),
+          asyncResource.bind(e => finish(finishCh, errorCh, e)))
 
-      return promise
-    } catch (err) {
-      finish(asyncEndCh, errorCh, err)
-      throw err
-    } finally {
-      endCh.publish(undefined)
-    }
+        return promise
+      } catch (err) {
+        finish(finishCh, errorCh, err)
+        throw err
+      }
+    })
   })
   return SenderLink
 })
 
 addHook({ name: 'amqp10', file: 'lib/receiver_link.js', versions: ['>=3'] }, ReceiverLink => {
   const startCh = channel('apm:amqp10:receive:start')
-  const endCh = channel('apm:amqp10:receive:end')
+  const finishCh = channel('apm:amqp10:receive:finish')
   const errorCh = channel('apm:amqp10:receive:error')
   shimmer.wrap(ReceiverLink.prototype, '_messageReceived', messageReceived => function (transferFrame) {
     if (!transferFrame || transferFrame.aborted || transferFrame.more) {
       return messageReceived.apply(this, arguments)
     }
-    startCh.publish({ link: this })
-    try {
-      return messageReceived.apply(this, arguments)
-    } catch (err) {
-      errorCh.publish(err)
-      throw err
-    } finally {
-      endCh.publish(undefined)
-    }
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    return asyncResource.runInAsyncScope(() => {
+      startCh.publish({ link: this })
+      try {
+        return messageReceived.apply(this, arguments)
+      } catch (err) {
+        errorCh.publish(err)
+        throw err
+      } finally {
+        finishCh.publish()
+      }
+    })
   })
   return ReceiverLink
 })
 
-function finish (asyncEndCh, errorCh, error) {
+function finish (finishCh, errorCh, error) {
   if (error) {
     errorCh.publish(error)
   }
-  asyncEndCh.publish(undefined)
+  finishCh.publish()
 }

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

@@ -2,13 +2,14 @@
 
 const {
   channel,
-  addHook
+  addHook,
+  AsyncResource
 } = require('./helpers/instrument')
 const kebabCase = require('lodash.kebabcase')
 const shimmer = require('../../datadog-shimmer')
 
 const startCh = channel('apm:amqplib:command:start')
-const endCh = channel('apm:amqplib:command:end')
+const finishCh = channel('apm:amqplib:command:finish')
 const errorCh = channel('apm:amqplib:command:error')
 
 let methods = {}
@@ -40,17 +41,21 @@ function instrument (send, channel, args, method, fields, message) {
   if (!startCh.hasSubscribers) {
     return send.apply(channel, args)
   }
-  startCh.publish({ channel, method, fields, message })
 
-  try {
-    return send.apply(channel, args)
-  } catch (err) {
-    errorCh.publish(err)
+  const asyncResource = new AsyncResource('bound-anonymous-fn')
+  return asyncResource.runInAsyncScope(() => {
+    startCh.publish({ channel, method, fields, message })
 
-    throw err
-  } finally {
-    endCh.publish(undefined)
-  }
+    try {
+      return send.apply(channel, args)
+    } catch (err) {
+      errorCh.publish(err)
+
+      throw err
+    } finally {
+      finishCh.publish()
+    }
+  })
 }
 
 function isCamelCase (str) {

package/packages/datadog-instrumentations/src/cassandra-driver.js

@@ -8,8 +8,7 @@ const {
 const shimmer = require('../../datadog-shimmer')
 
 const startCh = channel('apm:cassandra:query:start')
-const asyncEndCh = channel('apm:cassandra:query:async-end')
-const endCh = channel('apm:cassandra:query:end')
+const finishCh = channel('apm:cassandra:query:finish')
 const errorCh = channel('apm:cassandra:query:error')
 const addConnectionCh = channel(`apm:cassandra:query:addConnection`)
 
@@ -18,34 +17,34 @@ addHook({ name: 'cassandra-driver', versions: ['>=3.0.0'] }, cassandra => {
     if (!startCh.hasSubscribers) {
       return batch.apply(this, arguments)
     }
+    const callbackResource = new AsyncResource('bound-anonymous-fn')
     const asyncResource = new AsyncResource('bound-anonymous-fn')
-    startCh.publish({ keyspace: this.keyspace, query: queries })
-
     const lastIndex = arguments.length - 1
     let cb = arguments[lastIndex]
 
     if (typeof cb === 'function') {
-      cb = asyncResource.bind(cb)
-      arguments[lastIndex] = wrapCallback(asyncEndCh, errorCh, cb)
+      cb = callbackResource.bind(cb)
+      arguments[lastIndex] = wrapCallback(finishCh, errorCh, asyncResource, cb)
     }
 
-    try {
-      const res = batch.apply(this, arguments)
-      if (typeof res === 'function' || !res) {
-        return wrapCallback(asyncEndCh, errorCh, res)
-      } else {
-        const promiseAsyncResource = new AsyncResource('bound-anonymous-fn')
-        return res.then(
-          promiseAsyncResource.bind(() => finish(asyncEndCh, errorCh)),
-          promiseAsyncResource.bind(err => finish(asyncEndCh, errorCh, err))
-        )
+    return asyncResource.runInAsyncScope(() => {
+      startCh.publish({ keyspace: this.keyspace, query: queries })
+      try {
+        const res = batch.apply(this, arguments)
+        if (typeof res === 'function' || !res) {
+          return wrapCallback(finishCh, errorCh, asyncResource, res)
+        } else {
+          const promiseAsyncResource = new AsyncResource('bound-anonymous-fn')
+          return res.then(
+            promiseAsyncResource.bind(() => finish(finishCh, errorCh)),
+            promiseAsyncResource.bind(err => finish(finishCh, errorCh, err))
+          )
+        }
+      } catch (e) {
+        finish(finishCh, errorCh, e)
+        throw e
       }
-    } catch (e) {
-      finish(asyncEndCh, errorCh, e)
-      throw e
-    } finally {
-      endCh.publish(undefined)
-    }
+    })
   })
   return cassandra
 })
@@ -55,17 +54,19 @@ addHook({ name: 'cassandra-driver', versions: ['>=4.4'] }, cassandra => {
     if (!startCh.hasSubscribers) {
       return _execute.apply(this, arguments)
     }
-    startCh.publish({ keyspace: this.keyspace, query })
-    const promise = _execute.apply(this, arguments)
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    return asyncResource.runInAsyncScope(() => {
+      startCh.publish({ keyspace: this.keyspace, query })
+      const promise = _execute.apply(this, arguments)
 
-    const promiseAsyncResource = new AsyncResource('bound-anonymous-fn')
+      const promiseAsyncResource = new AsyncResource('bound-anonymous-fn')
 
-    promise.then(
-      promiseAsyncResource.bind(() => finish(asyncEndCh, errorCh)),
-      promiseAsyncResource.bind(err => finish(asyncEndCh, errorCh, err))
-    )
-    endCh.publish(undefined)
-    return promise
+      promise.then(
+        promiseAsyncResource.bind(() => finish(finishCh, errorCh)),
+        promiseAsyncResource.bind(err => finish(finishCh, errorCh, err))
+      )
+      return promise
+    })
   })
   return cassandra
 })
@@ -76,6 +77,7 @@ addHook({ name: 'cassandra-driver', versions: ['3 - 4.3'] }, cassandra => {
       if (!startCh.hasSubscribers) {
         return _innerExecute.apply(this, arguments)
       }
+      const callbackResource = new AsyncResource('bound-anonymous-fn')
       const asyncResource = new AsyncResource('bound-anonymous-fn')
       const isValid = (args) => {
         return args.length === 4 || typeof args[3] === 'function'
@@ -85,24 +87,24 @@ addHook({ name: 'cassandra-driver', versions: ['3 - 4.3'] }, cassandra => {
         return _innerExecute.apply(this, arguments)
       }
 
-      startCh.publish({ keyspace: this.keyspace, query })
+      return asyncResource.runInAsyncScope(() => {
+        startCh.publish({ keyspace: this.keyspace, query })
 
-      const lastIndex = arguments.length - 1
-      let cb = arguments[lastIndex]
+        const lastIndex = arguments.length - 1
+        let cb = arguments[lastIndex]
 
-      if (typeof cb === 'function') {
-        cb = asyncResource.bind(cb)
-        arguments[lastIndex] = wrapCallback(asyncEndCh, errorCh, cb)
-      }
+        if (typeof cb === 'function') {
+          cb = callbackResource.bind(cb)
+          arguments[lastIndex] = wrapCallback(finishCh, errorCh, asyncResource, cb)
+        }
 
-      try {
-        return _innerExecute.apply(this, arguments)
-      } catch (e) {
-        finish(asyncEndCh, errorCh, e)
-        throw e
-      } finally {
-        endCh.publish(undefined)
-      }
+        try {
+          return _innerExecute.apply(this, arguments)
+        } catch (e) {
+          finish(finishCh, errorCh, e)
+          throw e
+        }
+      })
     }
   )
   return cassandra
@@ -167,16 +169,16 @@ addHook({ name: 'cassandra-driver', versions: ['3 - 3.2'], file: 'lib/request-ha
   return RequestHandler
 })
 
-function finish (asyncEndCh, errorCh, error) {
+function finish (finishCh, errorCh, error) {
   if (error) {
     errorCh.publish(error)
   }
-  asyncEndCh.publish(undefined)
+  finishCh.publish(undefined)
 }
 
-function wrapCallback (asyncEndCh, errorCh, callback) {
-  return AsyncResource.bind(function (err) {
-    finish(asyncEndCh, errorCh, err)
+function wrapCallback (finishCh, errorCh, asyncResource, callback) {
+  return asyncResource.bind(function (err) {
+    finish(finishCh, errorCh, err)
     if (callback) {
       return callback.apply(this, arguments)
     }

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

@@ -5,7 +5,7 @@ const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 
 const enterChannel = channel('apm:connect:middleware:enter')
 const errorChannel = channel('apm:connect:middleware:error')
-const exitChannel = channel('apm:connect:middleware:exit')
+const nextChannel = channel('apm:connect:middleware:next')
 const handleChannel = channel('apm:connect:request:handle')
 
 function wrapConnect (connect) {
@@ -64,10 +64,10 @@ function wrapLayerHandle (layer) {
     const lastIndex = arguments.length - 1
     const name = original._name || original.name
     const req = arguments[arguments.length > 3 ? 1 : 0]
-    const next = AsyncResource.bind(arguments[lastIndex])
+    const next = arguments[lastIndex]
 
     if (typeof next === 'function') {
-      arguments[lastIndex] = wrapNext(req, middlewareResource.bind(next))
+      arguments[lastIndex] = wrapNext(req, next)
     }
 
     return middlewareResource.runInAsyncScope(() => {
@@ -79,7 +79,7 @@ function wrapLayerHandle (layer) {
         return original.apply(this, arguments)
       } catch (e) {
         errorChannel.publish(e)
-        exitChannel.publish({ req })
+        nextChannel.publish({ req })
 
         throw e
       }
@@ -93,7 +93,7 @@ function wrapNext (req, next) {
       errorChannel.publish(error)
     }
 
-    exitChannel.publish({ req })
+    nextChannel.publish({ req })
 
     next.apply(null, arguments)
   }

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

@@ -9,8 +9,7 @@ const shimmer = require('../../datadog-shimmer')
 
 addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^2.6.5'] }, Bucket => {
   const startCh = channel('apm:couchbase:query:start')
-  const asyncEndCh = channel('apm:couchbase:query:async-end')
-  const endCh = channel('apm:couchbase:query:end')
+  const finishCh = channel('apm:couchbase:query:finish')
   const errorCh = channel('apm:couchbase:query:error')
 
   Bucket.prototype._maybeInvoke = wrapMaybeInvoke(Bucket.prototype._maybeInvoke)
@@ -25,27 +24,28 @@ addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^2.6.5'] }, Buck
 
     const n1qlQuery = q && q.statement
 
-    startCh.publish({ resource: n1qlQuery, bucket: this })
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    return asyncResource.runInAsyncScope(() => {
+      startCh.publish({ resource: n1qlQuery, bucket: this })
 
-    emitter.once('rows', AsyncResource.bind(() => {
-      asyncEndCh.publish(undefined)
-    }))
+      emitter.once('rows', asyncResource.bind(() => {
+        finishCh.publish(undefined)
+      }))
 
-    emitter.once('error', AsyncResource.bind((error) => {
-      errorCh.publish(error)
-      asyncEndCh.publish(undefined)
-    }))
+      emitter.once('error', asyncResource.bind((error) => {
+        errorCh.publish(error)
+        finishCh.publish(undefined)
+      }))
 
-    try {
-      return _n1qlReq.apply(this, arguments)
-    } catch (err) {
-      err.stack // trigger getting the stack at the original throwing point
-      errorCh.publish(err)
+      try {
+        return _n1qlReq.apply(this, arguments)
+      } catch (err) {
+        err.stack // trigger getting the stack at the original throwing point
+        errorCh.publish(err)
 
-      throw err
-    } finally {
-      endCh.publish(undefined)
-    }
+        throw err
+      }
+    })
   })
 
   Bucket.prototype.upsert = wrap('apm:couchbase:upsert', Bucket.prototype.upsert)
@@ -103,8 +103,7 @@ function wrapQuery (query) {
 
 function wrap (prefix, fn) {
   const startCh = channel(prefix + ':start')
-  const endCh = channel(prefix + ':end')
-  const asyncEndCh = channel(prefix + ':async-end')
+  const finishCh = channel(prefix + ':finish')
   const errorCh = channel(prefix + ':error')
 
   const wrapped = function (key, value, options, callback) {
@@ -116,28 +115,31 @@ function wrap (prefix, fn) {
 
     if (callbackIndex < 0) return fn.apply(this, arguments)
 
-    const cb = arguments[callbackIndex]
+    const callbackResource = new AsyncResource('bound-anonymous-fn')
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
 
-    startCh.publish({ bucket: this })
+    return asyncResource.runInAsyncScope(() => {
+      const cb = callbackResource.bind(arguments[callbackIndex])
 
-    arguments[callbackIndex] = function (error, result) {
-      if (error) {
-        errorCh.publish(error)
-      }
-      asyncEndCh.publish(result)
-      return cb.apply(this, arguments)
-    }
+      startCh.publish({ bucket: this })
 
-    try {
-      return fn.apply(this, arguments)
-    } catch (error) {
-      error.stack // trigger getting the stack at the original throwing point
-      errorCh.publish(error)
+      arguments[callbackIndex] = asyncResource.bind(function (error, result) {
+        if (error) {
+          errorCh.publish(error)
+        }
+        finishCh.publish(result)
+        return cb.apply(this, arguments)
+      })
 
-      throw error
-    } finally {
-      endCh.publish(undefined)
-    }
+      try {
+        return fn.apply(this, arguments)
+      } catch (error) {
+        error.stack // trigger getting the stack at the original throwing point
+        errorCh.publish(error)
+
+        throw error
+      }
+    })
   }
   return shimmer.wrap(fn, wrapped)
 }

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

@@ -1,13 +1,11 @@
 'use strict'
 
-const { addHook, channel } = require('./helpers/instrument')
+const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
 const runStartCh = channel('ci:cucumber:run:start')
-const runEndCh = channel('ci:cucumber:run:end')
-const runAsyncEndCh = channel('ci:cucumber:run:async-end')
+const runFinishCh = channel('ci:cucumber:run:finish')
 const runStepStartCh = channel('ci:cucumber:run-step:start')
-const runStepEndCh = channel('ci:cucumber:run-step:end')
 const errorCh = channel('ci:cucumber:error')
 
 // TODO: remove in a later major version
@@ -49,23 +47,24 @@ function wrapRun (pl, isLatestVersion) {
       return run.apply(this, arguments)
     }
 
-    runStartCh.publish({ pickleName: this.pickle.name, pickleUri: this.pickle.uri })
-    try {
-      const promise = run.apply(this, arguments)
-      promise.finally(() => {
-        const result = this.getWorstStepResult()
-        const { status, skipReason, errorMessage } = isLatestVersion
-          ? getStatusFromResultLatest(result) : getStatusFromResult(result)
-
-        runAsyncEndCh.publish({ status, skipReason, errorMessage })
-      })
-      return promise
-    } catch (err) {
-      errorCh.publish(err)
-      throw err
-    } finally {
-      runEndCh.publish(undefined)
-    }
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    return asyncResource.runInAsyncScope(() => {
+      runStartCh.publish({ pickleName: this.pickle.name, pickleUri: this.pickle.uri })
+      try {
+        const promise = run.apply(this, arguments)
+        promise.finally(() => {
+          const result = this.getWorstStepResult()
+          const { status, skipReason, errorMessage } = isLatestVersion
+            ? getStatusFromResultLatest(result) : getStatusFromResult(result)
+
+          runFinishCh.publish({ status, skipReason, errorMessage })
+        })
+        return promise
+      } catch (err) {
+        errorCh.publish(err)
+        throw err
+      }
+    })
   })
   shimmer.wrap(pl.prototype, 'runStep', runStep => function () {
     if (!runStepStartCh.hasSubscribers) {
@@ -80,23 +79,24 @@ function wrapRun (pl, isLatestVersion) {
       resource = testStep.isHook ? 'hook' : testStep.pickleStep.text
     }
 
-    runStepStartCh.publish({ resource })
-    try {
-      const promise = runStep.apply(this, arguments)
-
-      promise.then((result) => {
-        const { status, skipReason, errorMessage } = isLatestVersion
-          ? getStatusFromResultLatest(result) : getStatusFromResult(result)
-
-        runAsyncEndCh.publish({ isStep: true, status, skipReason, errorMessage })
-      })
-      return promise
-    } catch (err) {
-      errorCh.publish(err)
-      throw err
-    } finally {
-      runStepEndCh.publish(undefined)
-    }
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    return asyncResource.runInAsyncScope(() => {
+      runStepStartCh.publish({ resource })
+      try {
+        const promise = runStep.apply(this, arguments)
+
+        promise.then((result) => {
+          const { status, skipReason, errorMessage } = isLatestVersion
+            ? getStatusFromResultLatest(result) : getStatusFromResult(result)
+
+          runFinishCh.publish({ isStep: true, status, skipReason, errorMessage })
+        })
+        return promise
+      } catch (err) {
+        errorCh.publish(err)
+        throw err
+      }
+    })
   })
 }