dd-trace 2.5.0 → 2.7.1

package/LICENSE-3rdparty.csv

@@ -39,8 +39,6 @@ dev,eslint-plugin-import,MIT,Copyright 2015 Ben Mosher
 dev,eslint-plugin-node,MIT,Copyright 2015 Toru Nagashima
 dev,eslint-plugin-promise,ISC,jden and other contributors
 dev,eslint-plugin-standard,MIT,Copyright 2015 Jamund Ferguson
-dev,mocha-junit-reporter,MIT,Copyright 2015 Michael Allen
-dev,mocha-multi-reporters,MIT,Copyright 2015 Stanley Ng 2019 Yousaf Nabi
 dev,express,MIT,Copyright 2009-2014 TJ Holowaychuk 2013-2014 Roman Shtylman 2014-2015 Douglas Christopher Wilson
 dev,get-port,MIT,Copyright Sindre Sorhus
 dev,glob,ISC,Copyright Isaac Z. Schlueter and Contributors

package/index.d.ts

@@ -428,7 +428,23 @@ export declare interface TracerOptions {
      * Controls the maximum amount of traces sampled by AppSec attacks, per second.
      * @default 100
      */
-    rateLimit?: number
+    rateLimit?: number,
+
+    /**
+     * Controls the maximum amount of time in microseconds the WAF is allowed to run synchronously for.
+     * @default 5000
+     */
+    wafTimeout?: number,
+
+    /**
+     * Specifies a regex that will redact sensitive data by its key in attack reports.
+     */
+    obfuscatorKeyRegex?: string,
+
+    /**
+     * Specifies a regex that will redact sensitive data by its value in attack reports.
+     */
+    obfuscatorValueRegex?: string
   };
 }
 
@@ -559,7 +575,6 @@ interface Plugins {
   "kafkajs": plugins.kafkajs
   "knex": plugins.knex;
   "koa": plugins.koa;
-  "limitd-client": plugins.limitd_client;
   "memcached": plugins.memcached;
   "microgateway-core": plugins.microgateway_core;
   "mocha": plugins.mocha;
@@ -1143,12 +1158,6 @@ declare namespace plugins {
    */
   interface kafkajs extends Instrumentation {}
 
-  /**
-   * This plugin automatically instruments the
-   * [limitd-client](https://github.com/limitd/node-client) module.
-   */
-  interface limitd_client extends Integration {}
-
   /**
    * This plugin automatically instruments the
    * [memcached](https://github.com/3rd-Eden/memcached) module.

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "dd-trace",
-  "version": "2.5.0",
+  "version": "2.7.1",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
   "scripts": {
     "preinstall": "node scripts/preinstall.js",
-    "postpublish": "node scripts/postpublish.js",
     "bench": "node benchmark",
     "bench:profiler": "node benchmark/profiler",
     "bench:e2e": "SERVICES=mongo yarn services && cd benchmark/e2e && node benchmark-run.js --duration=30",
@@ -16,24 +15,23 @@
     "lint": "node scripts/check_licenses.js && eslint . && yarn audit --groups dependencies",
     "services": "node ./scripts/install_plugin_modules && node packages/dd-trace/test/setup/services",
     "tdd": "node scripts/tdd.js",
-    "test": "SERVICES=* yarn services && mocha --exit --expose-gc 'packages/dd-trace/test/setup/node.js' 'packages/*/test/**/*.spec.js'",
-    "test:trace:core": "mocha --exit --expose-gc --file packages/dd-trace/test/setup/core.js \"packages/dd-trace/test/**/*.spec.js\"",
-    "test:trace:core:ci": "nyc --include \"packages/dd-trace/src/**/*.js\" -- npm run test:trace:core --  --reporter mocha-multi-reporters --reporter-options configFile=mocha-reporter-config.json",
-    "test:instrumentations": "mocha --file 'packages/dd-trace/test/setup/core.js' 'packages/datadog-instrumentations/test/**/*.spec.js'",
-    "test:instrumentations:ci": "nyc --include 'packages/datadog-instrumentations/src/**/*.js' -- npm run test:instrumentations -- --reporter mocha-multi-reporters --reporter-options configFile=mocha-reporter-config.json",
-    "test:core": "mocha --file packages/datadog-core/test/setup.js 'packages/datadog-core/test/**/*.spec.js'",
-    "test:core:ci": "nyc --include 'packages/datadog-core/src/**/*.js' -- npm run test:core -- --reporter mocha-multi-reporters --reporter-options configFile=mocha-reporter-config.json",
-    "test:plugins": "mocha --exit --file \"packages/dd-trace/test/setup/core.js\" \"packages/datadog-plugin-@($(echo $PLUGINS))/test/**/*.spec.js\"",
-    "test:plugins:ci": "yarn services && nyc --include \"packages/datadog-plugin-@($(echo $PLUGINS))/src/**/*.js\" -- npm run test:plugins -- --reporter mocha-multi-reporters --reporter-options configFile=mocha-reporter-config.json",
+    "test": "SERVICES=* yarn services && mocha --colors --exit --expose-gc 'packages/dd-trace/test/setup/node.js' 'packages/*/test/**/*.spec.js'",
+    "test:trace:core": "mocha --colors --exit --expose-gc --file packages/dd-trace/test/setup/core.js --exclude \"packages/dd-trace/test/profiling/**/*.spec.js\" \"packages/dd-trace/test/**/*.spec.js\"",
+    "test:trace:core:ci": "nyc --no-clean --include \"packages/dd-trace/src/**/*.js\" --exclude \"packages/dd-trace/src/profiling/**/*.js\" -- npm run test:trace:core",
+    "test:instrumentations": "mocha --colors --file 'packages/dd-trace/test/setup/core.js' 'packages/datadog-instrumentations/test/**/*.spec.js'",
+    "test:instrumentations:ci": "nyc --no-clean --include 'packages/datadog-instrumentations/src/**/*.js' -- npm run test:instrumentations",
+    "test:core": "mocha --colors --file packages/datadog-core/test/setup.js 'packages/datadog-core/test/**/*.spec.js'",
+    "test:core:ci": "nyc --no-clean --include 'packages/datadog-core/src/**/*.js' -- npm run test:core",
+    "test:plugins": "mocha --colors --exit --file \"packages/dd-trace/test/setup/core.js\" \"packages/datadog-instrumentations/test/@($(echo $PLUGINS)).spec.js\" \"packages/datadog-plugin-@($(echo $PLUGINS))/test/**/*.spec.js\"",
+    "test:plugins:ci": "yarn services && nyc --no-clean --include \"packages/datadog-instrumentations/src/@($(echo $PLUGINS)).js\" --include \"packages/datadog-instrumentations/src/@($(echo $PLUGINS))/**/*.js\" --include \"packages/datadog-plugin-@($(echo $PLUGINS))/src/**/*.js\" -- npm run test:plugins",
     "test:plugins:upstream": "node ./packages/dd-trace/test/plugins/suite.js",
-    "test:profiler": "mocha --exit --file \"packages/dd-trace/test/setup/core.js\" \"packages/dd-trace/test/profiling/**/*.spec.js\"",
-    "test:integration": "mocha --timeout 30000 \"integration-tests/**/*.spec.js\"",
-    "test:shimmer": "mocha 'packages/datadog-shimmer/test/**/*.spec.js'",
-    "test:shimmer:ci": "nyc --include 'packages/datadog-shimmer/src/**/*.js' -- npm run test:shimmer -- --reporter mocha-multi-reporters --reporter-options configFile=mocha-reporter-config.json",
+    "test:profiler": "mocha --colors --exit --file \"packages/dd-trace/test/setup/core.js\" \"packages/dd-trace/test/profiling/**/*.spec.js\"",
+    "test:profiler:ci": "nyc --no-clean --include \"packages/dd-trace/src/profiling/**/*.js\" -- npm run test:profiler",
+    "test:integration": "mocha --colors --timeout 30000 \"integration-tests/**/*.spec.js\"",
+    "test:shimmer": "mocha --colors 'packages/datadog-shimmer/test/**/*.spec.js'",
+    "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\"",
-    "cover:merge": "nyc merge ./.nyc_output ./.nyc_merge/$CIRCLE_JOB.json",
-    "cover:report": "nyc report -t ./.nyc_merge -n 'packages/**/*.js'",
     "codecov": "codecov",
     "junit:upload": "node ./scripts/junit_report.js"
   },
@@ -61,9 +59,9 @@
     "node": ">=12"
   },
   "dependencies": {
-    "@datadog/native-appsec": "^1.0.1",
-    "@datadog/native-metrics": "^1.1.0",
-    "@datadog/pprof": "^0.3.0",
+    "@datadog/native-appsec": "^1.1.1",
+    "@datadog/native-metrics": "^1.2.0",
+    "@datadog/pprof": "^0.4.0",
     "@datadog/sketches-js": "^1.0.4",
     "@types/node": ">=12",
     "crypto-randomuuid": "^1.0.0",
@@ -97,7 +95,7 @@
     "cli-table3": "^0.5.1",
     "codecov": "3.8.1",
     "dotenv": "8.2.0",
-    "eslint": "^4.15.0",
+    "eslint": "^7.32.0",
     "eslint-config-standard": "^11.0.0-beta.0",
     "eslint-plugin-import": "^2.8.0",
     "eslint-plugin-node": "^5.2.1",
@@ -111,8 +109,6 @@
     "jszip": "^3.5.0",
     "mkdirp": "^0.5.1",
     "mocha": "8",
-    "mocha-junit-reporter": "^2.0.0",
-    "mocha-multi-reporters": "^1.5.1",
     "msgpack-lite": "^0.1.26",
     "nock": "^11.3.3",
     "nyc": "^15.1.0",

package/packages/datadog-instrumentations/index.js

@@ -2,16 +2,26 @@
 
 require('./src/amqplib')
 require('./src/amqp10')
+require('./src/aws-sdk')
 require('./src/bluebird')
 require('./src/bunyan')
 require('./src/cassandra-driver')
+require('./src/connect')
 require('./src/couchbase')
 require('./src/cucumber')
 require('./src/dns')
 require('./src/elasticsearch')
+require('./src/express')
+require('./src/fastify')
+require('./src/find-my-way')
 require('./src/generic-pool')
+require('./src/google-cloud-pubsub')
 require('./src/http')
 require('./src/ioredis')
+require('./src/jest')
+require('./src/kafkajs')
+require('./src/knex')
+require('./src/koa')
 require('./src/memcached')
 require('./src/mongodb-core')
 require('./src/mongoose')
@@ -19,14 +29,19 @@ require('./src/mysql')
 require('./src/mysql2')
 require('./src/mocha')
 require('./src/net')
+require('./src/oracledb')
+require('./src/paperplane')
 require('./src/pino')
 require('./src/pg')
 require('./src/promise')
 require('./src/promise-js')
 require('./src/q')
 require('./src/redis')
+require('./src/restify')
+require('./src/router')
 require('./src/rhea')
 require('./src/sharedb')
 require('./src/tedious')
 require('./src/when')
 require('./src/winston')
+require('./src/limitd-client')

package/packages/datadog-instrumentations/src/aws-sdk.js

@@ -0,0 +1,104 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+function wrapRequest (send) {
+  return function wrappedRequest (cb) {
+    if (!this.service) return send.apply(this, arguments)
+
+    const serviceIdentifier = this.service.serviceIdentifier
+    const channelSuffix = getChannelSuffix(serviceIdentifier)
+    const startCh = channel(`apm:aws:request:start:${channelSuffix}`)
+    if (!startCh.hasSubscribers) return send.apply(this, arguments)
+    const outerAr = new AsyncResource('apm:aws:request:outer')
+
+    this.on('complete', response => {
+      channel(`apm:aws:request:complete:${channelSuffix}`).publish({ response })
+    })
+
+    return new AsyncResource('apm:aws:request:inner').runInAsyncScope(() => {
+      startCh.publish({
+        serviceIdentifier,
+        operation: this.operation,
+        awsRegion: this.service.config && this.service.config.region,
+        awsService: this.service.api && this.service.api.className,
+        request: this
+      })
+
+      if (typeof cb === 'function') {
+        arguments[0] = wrapCb(cb, channelSuffix, this, outerAr)
+      }
+      return send.apply(this, arguments)
+    })
+  }
+}
+
+function wrapCb (cb, serviceName, request, ar) {
+  return function wrappedCb (err, response) {
+    const obj = { request, response }
+    return ar.runInAsyncScope(() => {
+      channel(`apm:aws:response:start:${serviceName}`).publish(obj)
+      // TODO(bengl) make this work without needing a needsFinish property added to the object
+      if (!obj.needsFinish) {
+        return cb.apply(this, arguments)
+      }
+      const finishChannel = channel(`apm:aws:response:finish:${serviceName}`)
+      try {
+        let result = cb.apply(this, arguments)
+        if (result && result.then) {
+          result = result.then(x => {
+            finishChannel.publish()
+            return x
+          }, e => {
+            finishChannel.publish(e)
+            throw e
+          })
+        } else {
+          finishChannel.publish()
+        }
+        return result
+      } catch (e) {
+        finishChannel.publish(e)
+        throw e
+      }
+    })
+  }
+}
+
+function getChannelSuffix (name) {
+  return [
+    'cloudwatchlogs',
+    'dynamodb',
+    'eventbridge',
+    'kinesis',
+    'lambda',
+    'redshift',
+    's3',
+    'sns',
+    'sqs'
+  ].includes(name) ? name : 'default'
+}
+
+addHook({ name: 'aws-sdk', versions: ['>=2.3.0'] }, AWS => {
+  shimmer.wrap(AWS.Request.prototype, 'promise', wrapRequest)
+  shimmer.wrap(AWS.config, 'setPromisesDependency', setPromisesDependency => {
+    return function wrappedSetPromisesDependency (dep) {
+      const result = setPromisesDependency.apply(this, arguments)
+      shimmer.wrap(AWS.Request.prototype, 'promise', wrapRequest)
+      return result
+    }
+  })
+  return AWS
+})
+
+// <2.1.35 has breaking changes for instrumentation
+// https://github.com/aws/aws-sdk-js/pull/629
+addHook({ name: 'aws-sdk', versions: ['>=2.1.35'] }, AWS => {
+  shimmer.wrap(AWS.Request.prototype, 'send', wrapRequest)
+  return AWS
+})

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

@@ -0,0 +1,111 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+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 handleChannel = channel('apm:connect:request:handle')
+
+function wrapConnect (connect) {
+  if (typeof connect !== 'function') return connect
+
+  return function connectWithTrace () {
+    const app = connect()
+
+    if (!app) return app
+
+    shimmer.wrap(app, 'use', wrapUse)
+    shimmer.wrap(app, 'handle', wrapHandle)
+
+    return app
+  }
+}
+
+function wrapUse (use) {
+  if (typeof use !== 'function') return use
+
+  return function useWithTrace (route, fn) {
+    const result = use.apply(this, arguments)
+
+    if (!this || !Array.isArray(this.stack)) return result
+
+    const index = this.stack.length - 1
+    const layer = this.stack[index]
+
+    if (layer && layer.handle) {
+      this.stack[index].handle = wrapLayerHandle(layer)
+    }
+
+    return result
+  }
+}
+
+function wrapHandle (handle) {
+  return function handleWithTrace (req, res) {
+    if (handleChannel.hasSubscribers) {
+      handleChannel.publish({ req, res })
+    }
+
+    return handle.apply(this, arguments)
+  }
+}
+
+function wrapLayerHandle (layer) {
+  if (typeof layer.handle !== 'function') return layer.handle
+
+  const original = layer.handle
+
+  return shimmer.wrap(original, function () {
+    if (!enterChannel.hasSubscribers) return original.apply(this, arguments)
+
+    const middlewareResource = new AsyncResource('bound-anonymous-fn')
+    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])
+
+    if (typeof next === 'function') {
+      arguments[lastIndex] = wrapNext(req, middlewareResource.bind(next))
+    }
+
+    return middlewareResource.runInAsyncScope(() => {
+      const route = layer.route
+
+      enterChannel.publish({ name, req, route })
+
+      try {
+        return original.apply(this, arguments)
+      } catch (e) {
+        errorChannel.publish(e)
+        exitChannel.publish({ req })
+
+        throw e
+      }
+    })
+  })
+}
+
+function wrapNext (req, next) {
+  return function (error) {
+    if (error) {
+      errorChannel.publish(error)
+    }
+
+    exitChannel.publish({ req })
+
+    next.apply(null, arguments)
+  }
+}
+
+addHook({ name: 'connect', versions: ['>=3'] }, connect => {
+  return shimmer.wrap(connect, wrapConnect(connect))
+})
+
+addHook({ name: 'connect', versions: ['2.2.2'] }, connect => {
+  shimmer.wrap(connect.proto, 'use', wrapUse)
+  shimmer.wrap(connect.proto, 'handle', wrapHandle)
+
+  return connect
+})

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

@@ -0,0 +1,27 @@
+'use strict'
+
+const { createWrapRouterMethod } = require('./router')
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel } = require('./helpers/instrument')
+
+const handleChannel = channel('apm:express:request:handle')
+
+function wrapHandle (handle) {
+  return function handleWithTrace (req, res) {
+    if (handleChannel.hasSubscribers) {
+      handleChannel.publish({ req })
+    }
+
+    return handle.apply(this, arguments)
+  }
+}
+
+const wrapRouterMethod = createWrapRouterMethod('express')
+
+addHook({ name: 'express', versions: ['>=4'] }, express => {
+  shimmer.wrap(express.application, 'handle', wrapHandle)
+  shimmer.wrap(express.Router, 'use', wrapRouterMethod)
+  shimmer.wrap(express.Router, 'route', wrapRouterMethod)
+
+  return express
+})

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

@@ -0,0 +1,187 @@
+'use strict'
+
+const methods = require('methods').concat('all')
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+
+const errorChannel = channel('apm:fastify:middleware:error')
+const handleChannel = channel('apm:fastify:request:handle')
+
+const requestResources = new WeakMap()
+
+function wrapFastify (fastify) {
+  if (typeof fastify !== 'function') return fastify
+
+  return function fastifyWithTrace () {
+    const app = fastify.apply(this, arguments)
+
+    if (!app) return app
+
+    if (typeof app.addHook === 'function') {
+      app.addHook('onRequest', onRequest)
+      app.addHook = wrapAddHook(app.addHook)
+      app.addHook('preHandler', preHandler)
+    }
+
+    methods.forEach(method => {
+      app[method] = wrapMethod(app[method])
+    })
+
+    app.route = wrapRoute(app.route)
+
+    return app
+  }
+}
+
+function wrapAddHook (addHook) {
+  return function addHookWithTrace (name, fn) {
+    fn = arguments[arguments.length - 1]
+
+    if (typeof fn !== 'function') return addHook.apply(this, arguments)
+
+    arguments[arguments.length - 1] = shimmer.wrap(fn, function (request, reply, done) {
+      const req = getReq(request)
+      const requestResource = requestResources.get(req)
+
+      if (!requestResource) return fn.apply(this, arguments)
+
+      return requestResource.runInAsyncScope(() => {
+        const hookResource = new AsyncResource('bound-anonymous-fn')
+
+        try {
+          if (typeof done === 'function') {
+            done = arguments[arguments.length - 1]
+
+            arguments[arguments.length - 1] = hookResource.bind(function (err) {
+              errorChannel.publish(err)
+              return done.apply(this, arguments)
+            })
+
+            return hookResource.bind(fn).apply(this, arguments)
+          } else {
+            const promise = hookResource.bind(fn).apply(this, arguments)
+
+            if (promise && typeof promise.catch === 'function') {
+              return promise.catch(err => {
+                errorChannel.publish(err)
+                throw err
+              })
+            }
+
+            return promise
+          }
+        } catch (e) {
+          errorChannel.publish(e)
+          throw e
+        }
+      })
+    })
+
+    return addHook.apply(this, arguments)
+  }
+}
+
+function onRequest (request, reply, next) {
+  if (typeof next !== 'function') return
+
+  const req = getReq(request)
+  const res = getRes(reply)
+
+  requestResources.set(req, new AsyncResource('bound-anonymous-fn'))
+  handleChannel.publish({ req, res })
+
+  return next()
+}
+
+function preHandler (request, reply, next) {
+  if (typeof next !== 'function') return
+  if (!reply || typeof reply.send !== 'function') return next()
+
+  const req = getReq(request)
+
+  reply.send = requestResources.get(req).bind(wrapSend(reply.send))
+
+  next()
+}
+
+function wrapSend (send) {
+  return function sendWithTrace (payload) {
+    if (payload instanceof Error) {
+      errorChannel.publish(payload)
+    }
+
+    return send.apply(this, arguments)
+  }
+}
+
+function wrapRoute (route) {
+  if (typeof route !== 'function') return route
+
+  return function routeWithTrace (opts) {
+    opts.handler = wrapHandler(opts.handler)
+
+    return route.apply(this, arguments)
+  }
+}
+
+function wrapMethod (method) {
+  if (typeof method !== 'function') return method
+
+  return function methodWithTrace (url, opts, handler) {
+    const lastIndex = arguments.length - 1
+
+    handler = arguments[lastIndex]
+
+    if (typeof handler === 'function') {
+      arguments[lastIndex] = wrapHandler(handler)
+    } else if (handler) {
+      arguments[lastIndex].handler = wrapHandler(handler.handler)
+    }
+
+    return method.apply(this, arguments)
+  }
+}
+
+function wrapHandler (handler) {
+  if (!handler || typeof handler !== 'function' || handler.name === 'handlerWithTrace') {
+    return handler
+  }
+
+  return function handlerWithTrace (request, reply) {
+    const req = getReq(request)
+
+    return requestResources.get(req).runInAsyncScope(() => {
+      return handler.apply(this, arguments)
+    })
+  }
+}
+
+function getReq (request) {
+  return request && (request.raw || request.req || request)
+}
+
+function getRes (reply) {
+  return reply && (reply.raw || reply.res || reply)
+}
+
+addHook({ name: 'fastify', versions: ['>=3.25.2'] }, fastify => {
+  const wrapped = shimmer.wrap(fastify, wrapFastify(fastify, false))
+
+  wrapped.fastify = wrapped
+  wrapped.default = wrapped
+
+  return wrapped
+})
+
+addHook({ name: 'fastify', versions: ['3 - 3.25.1'] }, fastify => {
+  const wrapped = shimmer.wrap(fastify, wrapFastify(fastify, true))
+
+  wrapped.fastify = wrapped
+  wrapped.default = wrapped
+
+  return wrapped
+})
+
+addHook({ name: 'fastify', versions: ['1 - 2'] }, fastify => {
+  return shimmer.wrap(fastify, wrapFastify(fastify, true))
+})

package/packages/datadog-instrumentations/src/find-my-way.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel } = require('./helpers/instrument')
+
+const routeChannel = channel('apm:find-my-way:request:route')
+
+function wrapOn (on) {
+  return function onWithTrace (method, path, opts) {
+    const index = typeof opts === 'function' ? 2 : 3
+    const handler = arguments[index]
+    const wrapper = function (req) {
+      routeChannel.publish({ req, route: path })
+
+      return handler.apply(this, arguments)
+    }
+
+    if (typeof handler === 'function') {
+      arguments[index] = wrapper
+    }
+
+    return on.apply(this, arguments)
+  }
+}
+
+addHook({ name: 'find-my-way', versions: ['>=1'] }, Router => {
+  shimmer.wrap(Router.prototype, 'on', wrapOn)
+
+  return Router
+})