dd-trace 6.8.0 → 6.10.0

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

@@ -2,6 +2,13 @@
 
 const shimmer = require('../../datadog-shimmer')
 const { channel, addHook } = require('./helpers/instrument')
+const {
+  dispatchesAcquireSynchronously,
+  takePoolWaitTime,
+  wrapPoolClusterQueryMethod,
+  wrapPoolGetConnection,
+  wrapPoolQueryMethod,
+} = require('./helpers/pool-acquire')
 
 addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connection => {
   const startCh = channel('apm:mysql:query:start')
@@ -17,6 +24,11 @@ addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connect
     const conf = this.config
     const ctx = { sql, conf }
 
+    const waitTime = takePoolWaitTime(this)
+    if (waitTime !== undefined) {
+      ctx.poolWaitTime = waitTime
+    }
+
     return startCh.runStores(ctx, () => {
       if (args[0].sql) {
         args[0].sql = ctx.sql
@@ -36,7 +48,7 @@ addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connect
             }
             ctx.result = result
 
-            return finishCh.runStores(ctx, cb, this, error, result)
+            return finishCh.runStores(ctx, cb, this, ...arguments)
           })
         } else {
           res.once('end', () => finishCh.publish(ctx))
@@ -61,20 +73,24 @@ addHook({ name: 'mysql', file: 'lib/Pool.js', versions: ['>=2'] }, Pool => {
   const connectionFinishCh = channel('apm:mysql:connection:finish')
   const startPoolQueryCh = channel('datadog:mysql:pool:query:start')
   const finishPoolQueryCh = channel('datadog:mysql:pool:query:finish')
-
-  shimmer.wrap(Pool.prototype, 'getConnection', getConnection => function (cb) {
-    arguments[0] = function (...args) {
-      return connectionFinishCh.runStores(ctx, cb, this, ...args)
-    }
-
-    const ctx = {}
-
-    connectionStartCh.publish(ctx)
-
-    return getConnection.apply(this, arguments)
-  })
-
-  shimmer.wrap(Pool.prototype, 'query', query => function (...args) {
+  const acquireStartCh = channel('apm:mysql:pool:acquire:start')
+  const acquireFinishCh = channel('apm:mysql:pool:acquire:finish')
+  const deferredPoolAcquire = !dispatchesAcquireSynchronously(
+    Pool.prototype.query,
+    Object.assign(Object.create(Pool.prototype), { config: { connectionConfig: {} } }),
+    'getConnection',
+    ['SELECT 1', () => {}]
+  )
+
+  shimmer.wrap(Pool.prototype, 'getConnection', getConnection => wrapPoolGetConnection(getConnection, {
+    connectionStartCh,
+    connectionFinishCh,
+    acquireStartCh,
+    acquireFinishCh,
+    reentersQueuedCallbacks: true,
+  }, deferredPoolAcquire))
+
+  shimmer.wrap(Pool.prototype, 'query', query => wrapPoolQueryMethod(function (...args) {
     if (!startPoolQueryCh.hasSubscribers) {
       return query.apply(this, args)
     }
@@ -99,7 +115,21 @@ addHook({ name: 'mysql', file: 'lib/Pool.js', versions: ['>=2'] }, Pool => {
 
       return retval
     })
-  })
+  }, connectionStartCh, deferredPoolAcquire))
 
   return Pool
 })
+
+// A `canRetry` failover re-invokes `query` with the same Query object. Key the acquire state by that
+// object so a retry remains part of the query even if a future mysql version defers it.
+addHook({ name: 'mysql', file: 'lib/PoolNamespace.js', versions: ['>=2'] }, PoolNamespace => {
+  const channels = {
+    connectionStartCh: channel('apm:mysql:connection:start'),
+    connectionFinishCh: channel('apm:mysql:connection:finish'),
+    acquireStartCh: channel('apm:mysql:pool:acquire:start'),
+    acquireFinishCh: channel('apm:mysql:pool:acquire:finish'),
+  }
+  shimmer.wrap(PoolNamespace.prototype, 'query', query => wrapPoolClusterQueryMethod(query, channels))
+
+  return PoolNamespace
+})

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

@@ -5,10 +5,55 @@ const { errorMonitor } = require('node:events')
 const shimmer = require('../../datadog-shimmer')
 const satisfies = require('../../../vendor/dist/semifies')
 const { channel, addHook } = require('./helpers/instrument')
+const {
+  dispatchesAcquireSynchronously,
+  takePoolWaitTime,
+  wrapPoolClusterGetConnection,
+  wrapPoolClusterMethod,
+  wrapPoolGetConnection,
+  wrapPoolQueryMethod,
+} = require('./helpers/pool-acquire')
 
 /** @type {WeakMap<object, Function>} */
 const wrappedOnResult = new WeakMap()
 
+/** @type {WeakSet<object>} */
+const flagWrappedNamespaces = new WeakSet()
+
+const connectionStartCh = channel('apm:mysql2:connection:start')
+const connectionFinishCh = channel('apm:mysql2:connection:finish')
+const acquireStartCh = channel('apm:mysql2:pool:acquire:start')
+const acquireFinishCh = channel('apm:mysql2:pool:acquire:finish')
+const poolAcquireChannels = {
+  connectionStartCh,
+  connectionFinishCh,
+  acquireStartCh,
+  acquireFinishCh,
+}
+
+/**
+ * Bracket a pool-cluster namespace's internal acquires and key retry state by its stable callback.
+ * @param {{ query?: Function, execute?: Function, getConnection?: Function }} poolNamespace
+ */
+function flagWrapNamespace (poolNamespace) {
+  if (poolNamespace == null || flagWrappedNamespaces.has(poolNamespace)) return
+  flagWrappedNamespaces.add(poolNamespace)
+
+  if (typeof poolNamespace.query === 'function') {
+    shimmer.wrap(poolNamespace, 'query', query => wrapPoolClusterMethod(query, connectionStartCh))
+  }
+  if (typeof poolNamespace.execute === 'function') {
+    shimmer.wrap(poolNamespace, 'execute', execute => wrapPoolClusterMethod(execute, connectionStartCh))
+  }
+  if (typeof poolNamespace.getConnection === 'function') {
+    shimmer.wrap(
+      poolNamespace,
+      'getConnection',
+      getConnection => wrapPoolClusterGetConnection(getConnection, poolAcquireChannels)
+    )
+  }
+}
+
 /**
  * @param {unknown} sql
  * @returns {string|undefined}
@@ -43,6 +88,11 @@ function wrapConnection (Connection, version) {
     const ctx = {}
 
     if (isQuery) {
+      const waitTime = takePoolWaitTime(this)
+      if (waitTime !== undefined) {
+        ctx.poolWaitTime = waitTime
+      }
+
       command.execute = wrapExecute(command, command.execute, ctx, this.config)
 
       return commandAddCh.runStores(ctx, addCommand, this, ...arguments)
@@ -212,22 +262,41 @@ function wrapConnection (Connection, version) {
  * by the queued query attach to the caller rather than the previous query that freed the connection.
  *
  * @param {Function} Pool
+ * @param {boolean} deferredPoolAcquire
  * @returns {Function}
  */
-function wrapGetConnection (Pool) {
-  const connectionStartCh = channel('apm:mysql2:connection:start')
-  const connectionFinishCh = channel('apm:mysql2:connection:finish')
+function wrapGetConnection (Pool, deferredPoolAcquire) {
+  shimmer.wrap(
+    Pool.prototype,
+    'getConnection',
+    getConnection => wrapPoolGetConnection(getConnection, poolAcquireChannels, deferredPoolAcquire)
+  )
 
-  shimmer.wrap(Pool.prototype, 'getConnection', getConnection => function (cb) {
-    const ctx = {}
-    arguments[0] = function (...args) {
-      return connectionFinishCh.runStores(ctx, cb, this, ...args)
-    }
-
-    connectionStartCh.publish(ctx)
+  return Pool
+}
 
-    return getConnection.apply(this, arguments)
-  })
+/**
+ * mysql2 >=3.11.5 keeps the outer-query abort at the connection level, so the pool only needs the
+ * acquire wrap plus the pool-query flag around `query` / `execute`.
+ *
+ * @param {Function} Pool
+ * @returns {Function}
+ */
+function wrapBasePool (Pool) {
+  const deferredQueryAcquire = defersPoolAcquire(Pool, 'query')
+  const deferredExecuteAcquire = defersPoolAcquire(Pool, 'execute')
+  wrapGetConnection(Pool, deferredQueryAcquire || deferredExecuteAcquire)
+
+  shimmer.wrap(
+    Pool.prototype,
+    'query',
+    query => wrapPoolQueryMethod(query, connectionStartCh, deferredQueryAcquire)
+  )
+  shimmer.wrap(
+    Pool.prototype,
+    'execute',
+    execute => wrapPoolQueryMethod(execute, connectionStartCh, deferredExecuteAcquire)
+  )
 
   return Pool
 }
@@ -240,10 +309,12 @@ function wrapGetConnection (Pool) {
 function wrapPool (Pool, version) {
   const startOuterQueryCh = channel('datadog:mysql2:outerquery:start')
   const shouldEmitEndAfterQueryAbort = satisfies(version, '>=1.3.3')
+  const deferredQueryAcquire = defersPoolAcquire(Pool, 'query')
+  const deferredExecuteAcquire = defersPoolAcquire(Pool, 'execute')
 
-  wrapGetConnection(Pool)
+  wrapGetConnection(Pool, deferredQueryAcquire || deferredExecuteAcquire)
 
-  shimmer.wrap(Pool.prototype, 'query', query => function (sql, values, cb) {
+  shimmer.wrap(Pool.prototype, 'query', query => wrapPoolQueryMethod(function (sql, values, cb) {
     if (!startOuterQueryCh.hasSubscribers) return query.apply(this, arguments)
 
     const resolvedSql = resolveSqlString(sql)
@@ -279,9 +350,9 @@ function wrapPool (Pool, version) {
     }
 
     return query.apply(this, arguments)
-  })
+  }, connectionStartCh, deferredQueryAcquire))
 
-  shimmer.wrap(Pool.prototype, 'execute', execute => function (sql, values, cb) {
+  shimmer.wrap(Pool.prototype, 'execute', execute => wrapPoolQueryMethod(function (sql, values, cb) {
     if (!startOuterQueryCh.hasSubscribers) return execute.apply(this, arguments)
 
     const resolvedSql = resolveSqlString(sql)
@@ -304,11 +375,25 @@ function wrapPool (Pool, version) {
     }
 
     return execute.apply(this, arguments)
-  })
+  }, connectionStartCh, deferredExecuteAcquire))
 
   return Pool
 }
 
+/**
+ * @param {Function} Pool
+ * @param {'query'|'execute'} method
+ * @returns {boolean}
+ */
+function defersPoolAcquire (Pool, method) {
+  return !dispatchesAcquireSynchronously(
+    Pool.prototype[method],
+    Object.assign(Object.create(Pool.prototype), { config: { connectionConfig: {} } }),
+    'getConnection',
+    ['SELECT 1', () => {}]
+  )
+}
+
 /**
  * @param {Function} PoolCluster
  * @returns {Function}
@@ -319,6 +404,7 @@ function wrapPoolCluster (PoolCluster) {
 
   shimmer.wrap(PoolCluster.prototype, 'of', of => function (...args) {
     const poolNamespace = of.apply(this, args)
+    flagWrapNamespace(poolNamespace)
 
     if (startOuterQueryCh.hasSubscribers && !wrappedPoolNamespaces.has(poolNamespace)) {
       shimmer.wrap(poolNamespace, 'query', query => function (sql, values, cb) {
@@ -404,7 +490,7 @@ addHook(
 // mysql2 >=3.11.5 moved the pool onto BasePool in lib/base/pool.js.
 addHook(
   { name: 'mysql2', file: 'lib/base/pool.js', versions: ['>=3.11.5'] },
-  /** @type {(moduleExports: unknown, version: string) => unknown} */ (wrapGetConnection)
+  /** @type {(moduleExports: unknown, version: string) => unknown} */ (wrapBasePool)
 )
 
 // PoolNamespace.prototype.query does not exist in mysql2<2.3.0
@@ -412,3 +498,18 @@ addHook(
   { name: 'mysql2', file: 'lib/pool_cluster.js', versions: ['2.3.0 - 3.11.4'] },
   /** @type {(moduleExports: unknown, version: string) => unknown} */ (wrapPoolCluster)
 )
+
+// mysql2 >=3.11.5 keeps the outer-query abort at the connection level, so a cluster namespace only
+// needs the pool-query flag so its internal query/execute acquire does not open an acquire span.
+addHook(
+  { name: 'mysql2', file: 'lib/pool_cluster.js', versions: ['>=3.11.5'] },
+  /** @type {(moduleExports: unknown, version: string) => unknown} */ (PoolCluster => {
+    shimmer.wrap(PoolCluster.prototype, 'of', of => function () {
+      const poolNamespace = of.apply(this, arguments)
+      flagWrapNamespace(poolNamespace)
+      return poolNamespace
+    })
+
+    return PoolCluster
+  })
+)

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

@@ -15,6 +15,7 @@ const queryParsedChannel = channel('apm:next:query-parsed')
 
 const requests = new WeakSet()
 const nodeNextRequestsToNextRequests = new WeakMap()
+const requestErrors = new WeakMap()
 
 // Next.js <= 14.2.6
 const MIDDLEWARE_HEADER = 'x-middleware-invoke'
@@ -213,10 +214,8 @@ function wrapServeStatic (serveStatic) {
 }
 
 function finish (ctx, result, err) {
-  if (err) {
-    ctx.error = err
-    errorChannel.publish(ctx)
-  }
+  publishError(ctx.req, ctx, err)
+  requestErrors.delete(ctx.req)
 
   const maybeNextRequest = nodeNextRequestsToNextRequests.get(ctx.req)
   if (maybeNextRequest) {
@@ -226,6 +225,27 @@ function finish (ctx, result, err) {
   finishChannel.publish(ctx)
 }
 
+function publishError (req, ctx, error) {
+  if (!error) return
+
+  req = req.originalRequest || req
+  let errors = requestErrors.get(req)
+  if (errors?.has(error)) return
+
+  if (!errors) {
+    errors = new Set()
+    requestErrors.set(req, errors)
+  }
+  errors.add(error)
+
+  if (ctx) {
+    ctx.error = error
+    errorChannel.publish(ctx)
+  } else {
+    errorChannel.publish({ error })
+  }
+}
+
 // also wrapped in dist/server/future/route-handlers/app-route-route-handler.js
 // in versions below 13.3.0 that support middleware,
 // however, it is not provided as a class function or exported property
@@ -244,15 +264,11 @@ addHook({
   return NextRequestAdapter
 })
 
-// From next 15.4.1 each app-route build inlines its own copy of `fromNodeNextRequest`, so the hook
-// above no longer maps the node request to the app-route NextRequest and a thrown handler error
-// cannot reach `finish`. The app-route runtime reports real errors (redirect/notFound and other
-// control-flow signals excluded by next) through `RouteModule.onRequestError`, which next loads from
-// a precompiled `app-route*.runtime.{dev,prod}.js` bundle regardless of how the route chunk is
-// bundled. The bundler/experimental part of the name is matched with a pattern rather than
-// enumerated, so a variant next adds later is picked up without a code change.
-const patchedAppRouteModules = new WeakSet()
-
+// From Next 15.4.1, route modules execute through precompiled runtime bundles that bypass the
+// classic server hooks above. Match bundler and experimental filename variants without enumerating
+// them so App Routes, Pages APIs, and App Pages reuse the existing Next request lifecycle.
+const patchedRouteModules = new WeakSet()
+const COMPILED_RUNTIME_PATH = 'dist/compiled/next-server/'
 function wrapOnRequestError (onRequestError) {
   return function (req, error) {
     if (error) {
@@ -262,21 +278,137 @@ function wrapOnRequestError (onRequestError) {
   }
 }
 
-function instrumentAppRouteRuntime (runtime) {
-  const AppRouteRouteModule = runtime.AppRouteRouteModule
-  const proto = AppRouteRouteModule?.prototype
-  if (proto && typeof proto.onRequestError === 'function' && !patchedAppRouteModules.has(AppRouteRouteModule)) {
-    patchedAppRouteModules.add(AppRouteRouteModule)
+function getRoutePage (routeModule, fallbackPage) {
+  const definition = routeModule?.definition
+  if (typeof definition?.pathname === 'string') {
+    return { page: definition.pathname, isFilesystemPath: false }
+  }
+
+  if (typeof definition?.page === 'string') {
+    return { page: definition.page, isFilesystemPath: true }
+  }
+
+  return { page: fallbackPage, isFilesystemPath: false }
+}
+
+function publishRoutePage (ctx, routeModule, fallbackPage, isAppPath) {
+  if (!ctx || !pageLoadChannel.hasSubscribers) return
+
+  const pageData = getRoutePage(routeModule, fallbackPage)
+  if (pageData.page) {
+    pageLoadChannel.publish(isAppPath ? { ...pageData, isAppPath: true } : pageData)
+  }
+}
+
+function wrapAppRouteHandle (handle) {
+  return function (req, context) {
+    if (!startChannel.hasSubscribers && !queryParsedChannel.hasSubscribers) {
+      return handle.apply(this, arguments)
+    }
+
+    const res = { statusCode: 500 }
+    nodeNextRequestsToNextRequests.set(req, req)
+
+    return instrument(req, res, ctx => {
+      publishRoutePage(ctx, this, undefined, true)
+
+      return handle.apply(this, arguments).then(response => {
+        if (ctx) ctx.res.statusCode = response?.status || 200
+        return response
+      })
+    })
+  }
+}
+
+function instrumentRouteModule (RouteModule, method, wrapper, handleErrors) {
+  const proto = RouteModule?.prototype
+  if (!proto || patchedRouteModules.has(RouteModule)) return
+
+  patchedRouteModules.add(RouteModule)
+  if (typeof proto[method] === 'function') {
+    shimmer.wrap(proto, method, wrapper)
+  }
+  if (handleErrors && typeof proto.onRequestError === 'function') {
     shimmer.wrap(proto, 'onRequestError', wrapOnRequestError)
   }
+}
+
+function instrumentAppRouteRuntime (runtime) {
+  instrumentRouteModule(runtime.AppRouteRouteModule, 'handle', wrapAppRouteHandle, true)
   return runtime
 }
 
-addHook({
-  name: 'next',
-  versions: ['>=15.4.1'],
-  filePattern: String.raw`dist/compiled/next-server/app-route[\w-]*\.runtime\.(?:dev|prod)\.js$`,
-}, instrumentAppRouteRuntime)
+function wrapPagesApiRender (render) {
+  return function (req, res, context = {}) {
+    if (!startChannel.hasSubscribers && !queryParsedChannel.hasSubscribers) {
+      return render.apply(this, arguments)
+    }
+
+    return instrument(req, res, ctx => {
+      publishRoutePage(ctx, this, context.page, false)
+
+      const { onError } = context
+      return render.call(this, req, res, {
+        ...context,
+        onError: function (error) {
+          publishError(req, ctx, error)
+          return onError?.apply(this, arguments)
+        },
+      })
+    })
+  }
+}
+
+function instrumentPagesApiRuntime (runtime) {
+  const PagesAPIRouteModule = runtime.PagesAPIRouteModule || runtime.default
+  instrumentRouteModule(PagesAPIRouteModule, 'render', wrapPagesApiRender, false)
+  return runtime
+}
+
+function wrapAppPageRender (render) {
+  return function (req, res, context = {}) {
+    if (!startChannel.hasSubscribers && !queryParsedChannel.hasSubscribers) {
+      return render.apply(this, arguments)
+    }
+
+    return instrument(req, res, ctx => {
+      publishRoutePage(ctx, this, context.page, true)
+
+      return render.apply(this, arguments).then(result => {
+        const statusCode = result?.metadata?.statusCode
+        if (ctx && typeof statusCode === 'number') {
+          ctx.res.statusCode = statusCode
+        }
+
+        return result
+      }, error => {
+        if (ctx && (typeof ctx.res.statusCode !== 'number' || ctx.res.statusCode < 400)) {
+          ctx.res.statusCode = 500
+        }
+
+        throw error
+      })
+    })
+  }
+}
+
+function instrumentAppPageRuntime (runtime) {
+  const AppPageRouteModule = runtime.AppPageRouteModule || runtime.default
+  instrumentRouteModule(AppPageRouteModule, 'render', wrapAppPageRender, true)
+  return runtime
+}
+
+for (const [runtime, instrumentRuntime] of [
+  ['app-route', instrumentAppRouteRuntime],
+  ['pages-api', instrumentPagesApiRuntime],
+  ['app-page', instrumentAppPageRuntime],
+]) {
+  addHook({
+    name: 'next',
+    versions: ['>=15.4.1'],
+    filePattern: String.raw`${COMPILED_RUNTIME_PATH}${runtime}[\w-]*\.runtime\.(?:dev|prod)\.js$`,
+  }, instrumentRuntime)
+}
 
 addHook({
   name: 'next',

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

@@ -210,10 +210,24 @@ addHook({ name: 'openai', file: 'dist/api.js', versions: ['>=3.0.0 <4'] }, expor
   return exports
 })
 
+/**
+ * @typedef {{
+ *   methodName: string,
+ *   args: unknown[],
+ *   basePath?: string,
+ *   result?: Record<string, unknown>,
+ *   error?: unknown,
+ * }} OpenAiContext
+ */
+
 /**
  * For streamed responses, we need to accumulate all of the content in
  * the chunks, and let the combined content be the final response.
  * This way, spans look the same as when not streamed.
+ *
+ * @param {{ headers: unknown, url: string }} response
+ * @param {{ method: string }} options
+ * @param {OpenAiContext} ctx
  */
 function wrapStreamIterator (response, options, ctx) {
   return function (itr) {

package/packages/datadog-instrumentations/src/path-to-regexp.js

@@ -5,6 +5,12 @@ const { addHook } = require('./helpers/instrument')
 /** @type {((pattern: string | RegExp) => RegExp | undefined) | undefined} */
 let compileToRegexp
 
+/** @type {((pattern: string) => { tokens: object[] } | undefined) | undefined} */
+let parseTokens
+
+/** @type {((route: string) => ((url: string) => object | undefined) | undefined) | undefined} */
+let makeMatcher
+
 addHook({ name: 'path-to-regexp', versions: ['*'] }, moduleExports => {
   // 0.1.x and 6.x: `module.exports = (path, ...) => RegExp`.
   // 7.x: `module.exports = { pathToRegexp(path, ...) => RegExp }`.
@@ -29,6 +35,47 @@ addHook({ name: 'path-to-regexp', versions: ['*'] }, moduleExports => {
   return moduleExports
 })
 
+// 8.x only: earlier majors also expose `parse`/`match`, but with incompatible shapes — 7.x returns
+// `{ tokens }` too, yet its tokens are bare strings rather than typed nodes. Gating on the version
+// keeps those from installing adapters the consumers would misread.
+addHook({ name: 'path-to-regexp', versions: ['>=8'] }, moduleExports => {
+  const { parse, match } = moduleExports
+
+  if (typeof parse === 'function' && typeof match === 'function') {
+    parseTokens = pattern => {
+      let result
+      try {
+        result = parse(pattern)
+      } catch {
+        return
+      }
+      if (Array.isArray(result?.tokens)) return result
+    }
+
+    makeMatcher = route => {
+      let matcher
+      try {
+        // Callers read which params matched, never their values: skipping decode is faster and
+        // stops a malformed escape ('%ZZ') from throwing URIError, which would read as "no match".
+        matcher = match(route, { decode: false })
+      } catch {
+        return
+      }
+      return url => {
+        let result
+        try {
+          result = matcher(url)
+        } catch {
+          return
+        }
+        return result ? result.params : undefined
+      }
+    }
+  }
+
+  return moduleExports
+})
+
 /**
  * Returns whatever path-to-regexp compile adapter the host most recently
  * loaded. Capture this once at addHook fire time so each express/router
@@ -41,4 +88,23 @@ function getCompileToRegexp () {
   return compileToRegexp
 }
 
-module.exports = { getCompileToRegexp }
+/**
+ * Returns the host's path-to-regexp `parse` adapter (8.x token tree), or `undefined` when the
+ * host has not loaded an 8.x path-to-regexp (e.g. Express 4 ships 0.1.x, which has no `parse`).
+ * @returns {((pattern: string) => { tokens: object[] } | undefined) | undefined}
+ */
+function getParse () {
+  return parseTokens
+}
+
+/**
+ * Returns the host's path-to-regexp 8.x `match` adapter: a factory `route => (url => params)` that
+ * compiles a route once and returns a matcher yielding the captured params (or undefined on no
+ * match / unusable route). `undefined` when the host has not loaded an 8.x path-to-regexp.
+ * @returns {((route: string) => ((url: string) => object | undefined) | undefined) | undefined}
+ */
+function getMatch () {
+  return makeMatcher
+}
+
+module.exports = { getCompileToRegexp, getParse, getMatch }