DataDog
diff --git a/‎packages/datadog-instrumentations/src/path-to-regexp.js‎
Lines changed: 67 additions & 1 deletion b/‎packages/datadog-instrumentations/src/path-to-regexp.js‎
Lines changed: 67 additions & 1 deletion
diff --git a/‎packages/datadog-instrumentations/test/path-to-regexp/index.spec.js‎
Lines changed: 51 additions & 0 deletions b/‎packages/datadog-instrumentations/test/path-to-regexp/index.spec.js‎
Lines changed: 51 additions & 0 deletions
@@ -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 }
@@ -0,0 +1,51 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+
+const { describe, it } = require('mocha')
+
+const satisfies = require('../../../../vendor/dist/semifies')
+const instrumentations = require('../../src/helpers/instrumentations')
+const { getParse, getMatch } = require('../../src/path-to-regexp')
+
+// Run the hooks the loader would run for `version`, exactly as register.js selects them.
+function applyHooksFor (version, moduleExports) {
+  for (const { versions, hook } of instrumentations['path-to-regexp']) {
+    if (!versions || versions.some(range => satisfies(version, range))) hook(moduleExports)
+  }
+}
+
+// 7.x `parse()` also returns `{ tokens }`, but its tokens are bare strings rather than typed nodes,
+// so adopting it would make every route normalize to '/'. Only 8.x may install the adapters.
+const v7Module = {
+  parse: () => ({ tokens: ['/a/', { name: 'id' }], delimiter: '/' }),
+  match: () => () => ({ params: {} }),
+  pathToRegexp: () => ({ regexp: /^\/a\/([^/]+)$/, keys: [] }),
+}
+
+const v8Module = {
+  parse: pattern => ({ tokens: [{ type: 'text', value: pattern }] }),
+  match: () => () => ({ params: { id: '1' } }),
+  pathToRegexp: () => ({ regexp: /^\/a\/([^/]+)$/, keys: [] }),
+}
+
+describe('path-to-regexp instrumentation', () => {
+  it('does not let 7.x install the parse/match adapters', () => {
+    const parseBefore = getParse()
+    const matchBefore = getMatch()
+
+    applyHooksFor('7.2.0', v7Module)
+
+    assert.equal(getParse(), parseBefore)
+    assert.equal(getMatch(), matchBefore)
+  })
+
+  it('installs the adapters for 8.x', () => {
+    applyHooksFor('8.4.2', v8Module)
+
+    assert.equal(typeof getParse(), 'function')
+    assert.equal(typeof getMatch(), 'function')
+    assert.deepStrictEqual(getParse()('/x'), { tokens: [{ type: 'text', value: '/x' }] })
+    assert.deepStrictEqual(getMatch()('/a/:id')('/a/1'), { id: '1' })
+  })
+})