dd-trace 4.11.1 → 4.13.0

package/README.md

@@ -2,8 +2,6 @@
 
 [![npm v4](https://img.shields.io/npm/v/dd-trace/latest?color=blue&label=dd-trace%40v4&logo=npm)](https://www.npmjs.com/package/dd-trace)
 [![npm v3](https://img.shields.io/npm/v/dd-trace/latest-node14?color=blue&label=dd-trace%40v3&logo=npm)](https://www.npmjs.com/package/dd-trace/v/latest-node12)
-[![npm v2](https://img.shields.io/npm/v/dd-trace/latest-node12?color=blue&label=dd-trace%40v2&logo=npm)](https://www.npmjs.com/package/dd-trace/v/latest-node12)
-[![npm dev](https://img.shields.io/npm/v/dd-trace/dev?color=orange&label=dd-trace%40dev&logo=npm)](https://www.npmjs.com/package/dd-trace/v/dev)
 [![codecov](https://codecov.io/gh/DataDog/dd-trace-js/branch/master/graph/badge.svg)](https://codecov.io/gh/DataDog/dd-trace-js)
 
 <img align="right" src="https://user-images.githubusercontent.com/551402/208212084-1d0c07e2-4135-4c61-b2da-8f2fddbc66ed.png" alt="Bits the dog  JavaScript" width="200px"/>
@@ -28,12 +26,12 @@ Most of the documentation for `dd-trace` is available on these webpages:
 | Release Line                                             | Latest Version                                                                                         | Node.js  | Status          |Initial Release | End of Life |
 | :---:                                                    | :---:                                                                                                  | :---:    | :---:           | :---:          | :---:       |
 | [`v1`](https://github.com/DataDog/dd-trace-js/tree/v1.x) | ![npm v1](https://img.shields.io/npm/v/dd-trace/legacy-v1?color=white&label=%20&style=flat-square)     | `>= v12` | **End of Life** | 2021-07-13     | 2022-02-25  |
-| [`v2`](https://github.com/DataDog/dd-trace-js/tree/v2.x) | ![npm v2](https://img.shields.io/npm/v/dd-trace/latest-node12?color=white&label=%20&style=flat-square) | `>= v12` | **Maintenance** | 2022-01-28     | 2023-08-15  |
+| [`v2`](https://github.com/DataDog/dd-trace-js/tree/v2.x) | ![npm v2](https://img.shields.io/npm/v/dd-trace/latest-node12?color=white&label=%20&style=flat-square) | `>= v12` | **End of Life** | 2022-01-28     | 2023-08-15  |
 | [`v3`](https://github.com/DataDog/dd-trace-js/tree/v3.x) | ![npm v3](https://img.shields.io/npm/v/dd-trace/latest-node14?color=white&label=%20&style=flat-square) | `>= v14` | **Maintenance** | 2022-08-15     | 2024-05-15  |
 | [`v4`](https://github.com/DataDog/dd-trace-js/tree/v4.x) | ![npm v4](https://img.shields.io/npm/v/dd-trace/latest?color=white&label=%20&style=flat-square)        | `>= v16` | **Current**     | 2023-05-12     | Unknown     |
 
-We currently maintain three release lines, namely `v2`, `v3` and `v4`.
-Features and bug fixes that are merged are released to the `v4` line and, if appropriate, also the `v2` and `v3` line.
+We currently maintain two release lines, namely `v3` and `v4`.
+Features and bug fixes that are merged are released to the `v4` line and, if appropriate, also the `v3` line.
 
 For any new projects it is recommended to use the `v4` release line:
 
@@ -42,15 +40,12 @@ $ npm install dd-trace
 $ yarn add dd-trace
 ```
 
-However, existing projects that already use the `v2` or `v3` release lines, or projects that need to support EOL versions of Node.js, may continue to use these release lines.
+However, existing projects that already use the `v3` release line, or projects that need to support EOL versions of Node.js, may continue to use these release lines.
 This is done by specifying the version when installing the package.
-Note that we also publish to npm using a `latest-node12` and `latest-node14` tag that can also be used for install:
 
 ```sh
 $ npm install dd-trace@3
 $ yarn add dd-trace@3
-$ npm install dd-trace@latest-node14
-$ yarn add dd-trace@latest-node14
 ```
 
 Any backwards-breaking functionality that is introduced into the library will result in an increase of the major version of the library and therefore a new release line.

package/index.d.ts

@@ -121,6 +121,8 @@ export declare interface Tracer extends opentracing.Tracer {
   appsec: Appsec;
 
   TracerProvider: opentelemetry.TracerProvider;
+
+  dogstatsd: DogStatsD;
 }
 
 export declare interface TraceOptions extends Analyzable {
@@ -642,6 +644,47 @@ export declare interface User {
   [key: string]: string | undefined
 }
 
+export declare interface DogStatsD {
+  /**
+   * Increments a metric by the specified value, optionally specifying tags.
+   * @param {string} stat The dot-separated metric name.
+   * @param {number} value The amount to increment the stat by.
+   * @param {[tag:string]:string|number} tags Tags to pass along, such as `[ 'foo:bar' ]`. Values are combined with config.tags.
+   */
+  increment(stat: string, value?: number, tags?: { [tag: string]: string|number }): void
+
+  /**
+   * Decrements a metric by the specified value, optionally specifying tags.
+   * @param {string} stat The dot-separated metric name.
+   * @param {number} value The amount to decrement the stat by.
+   * @param {[tag:string]:string|number} tags Tags to pass along, such as `[ 'foo:bar' ]`. Values are combined with config.tags.
+   */
+  decrement(stat: string, value?: number, tags?: { [tag: string]: string|number }): void
+
+  /**
+   * Sets a distribution value, optionally specifying tags.
+   * @param {string} stat The dot-separated metric name.
+   * @param {number} value The amount to increment the stat by.
+   * @param {[tag:string]:string|number} tags Tags to pass along, such as `[ 'foo:bar' ]`. Values are combined with config.tags.
+   */
+  distribution(stat: string, value?: number, tags?: { [tag: string]: string|number }): void
+
+  /**
+   * Sets a gauge value, optionally specifying tags.
+   * @param {string} stat The dot-separated metric name.
+   * @param {number} value The amount to increment the stat by.
+   * @param {[tag:string]:string|number} tags Tags to pass along, such as `[ 'foo:bar' ]`. Values are combined with config.tags.
+   */
+  gauge(stat: string, value?: number, tags?: { [tag: string]: string|number }): void
+
+  /**
+   * Forces any unsent metrics to be sent
+   *
+   * @beta This method is experimental and could be removed in future versions.
+   */
+  flush(): void
+}
+
 export declare interface Appsec {
   /**
    * Links a successful login event to the current trace. Will link the passed user to the current trace with Appsec.setUser() internally.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "4.11.1",
+  "version": "4.13.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -37,6 +37,7 @@
     "test:integration:cypress": "mocha --colors --timeout 30000 \"integration-tests/cypress/*.spec.js\"",
     "test:integration:playwright": "mocha --colors --timeout 30000 \"integration-tests/playwright/*.spec.js\"",
     "test:integration:serverless": "mocha --colors --timeout 30000 \"integration-tests/serverless/*.spec.js\"",
+    "test:integration:plugins": "mocha --colors --timeout 30000 \"packages/datadog-plugin-*/test/integration-test/*.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'",
@@ -70,7 +71,7 @@
     "@datadog/native-iast-rewriter": "2.0.1",
     "@datadog/native-iast-taint-tracking": "1.5.0",
     "@datadog/native-metrics": "^2.0.0",
-    "@datadog/pprof": "3.1.0",
+    "@datadog/pprof": "3.2.0",
     "@datadog/sketches-js": "^2.1.0",
     "@opentelemetry/api": "^1.0.0",
     "@opentelemetry/core": "^1.14.0",

package/packages/datadog-esbuild/index.js

@@ -50,21 +50,41 @@ for (const pkg of INSTRUMENTED) {
 module.exports.name = 'datadog-esbuild'
 
 module.exports.setup = function (build) {
+  const externalModules = new Set(build.initialOptions.external || [])
   build.onResolve({ filter: /.*/ }, args => {
+    if (externalModules.has(args.path)) {
+      // Internal Node.js packages will still be instrumented via require()
+      if (DEBUG) console.log(`EXTERNAL: ${args.path}`)
+      return
+    }
+
+    // TODO: Should this also check for namespace === 'file'?
+    if (args.path.startsWith('.') && !args.importer.includes('node_modules/')) {
+      // This is local application code, not an instrumented package
+      if (DEBUG) console.log(`LOCAL: ${args.path}`)
+      return
+    }
+
+    // TODO: Should this also check for namespace === 'file'?
+    if (args.path.startsWith('@') && !args.importer.includes('node_modules/')) {
+      // This is the Next.js convention for loading local files
+      if (DEBUG) console.log(`@LOCAL: ${args.path}`)
+      return
+    }
+
     let fullPathToModule
     try {
       fullPathToModule = dotFriendlyResolve(args.path, args.resolveDir)
     } catch (err) {
-      console.warn(`Unable to find "${args.path}". Is the package dead code?`)
+      console.warn(`MISSING: Unable to find "${args.path}". Is the package dead code?`)
       return
     }
     const extracted = extractPackageAndModulePath(fullPathToModule)
-    const packageName = args.path
 
     const internal = builtins.has(args.path)
 
     if (args.namespace === 'file' && (
-      modulesOfInterest.has(packageName) || modulesOfInterest.has(`${extracted.pkg}/${extracted.path}`))
+      modulesOfInterest.has(args.path) || modulesOfInterest.has(`${extracted.pkg}/${extracted.path}`))
     ) {
       // The file namespace is used when requiring files from disk in userland
 
@@ -74,7 +94,7 @@ module.exports.setup = function (build) {
       } catch (err) {
         if (err.code === 'MODULE_NOT_FOUND') {
           if (!internal) {
-            console.warn(`Unable to find "${extracted.pkg}/package.json". Is the package dead code?`)
+            console.warn(`MISSING: Unable to find "${extracted.pkg}/package.json". Is the package dead code?`)
           }
           return
         } else {
@@ -84,7 +104,7 @@ module.exports.setup = function (build) {
 
       const packageJson = require(pathToPackageJson)
 
-      if (DEBUG) console.log(`RESOLVE ${packageName}@${packageJson.version}`)
+      if (DEBUG) console.log(`RESOLVE: ${args.path}@${packageJson.version}`)
 
       // https://esbuild.github.io/plugins/#on-resolve-arguments
       return {
@@ -95,17 +115,17 @@ module.exports.setup = function (build) {
           pkg: extracted.pkg,
           path: extracted.path,
           full: fullPathToModule,
-          raw: packageName,
+          raw: args.path,
           internal
         }
       }
     } else if (args.namespace === NAMESPACE) {
       // The datadog namespace is used when requiring files that are injected during the onLoad stage
 
-      if (builtins.has(packageName)) return
+      if (builtins.has(args.path)) return
 
       return {
-        path: require.resolve(packageName, { paths: [ args.resolveDir ] }),
+        path: require.resolve(args.path, { paths: [ args.resolveDir ] }),
         namespace: 'file'
       }
     }
@@ -114,7 +134,7 @@ module.exports.setup = function (build) {
   build.onLoad({ filter: /.*/, namespace: NAMESPACE }, args => {
     const data = args.pluginData
 
-    if (DEBUG) console.log(`LOAD ${data.pkg}@${data.version}, pkg "${data.path}"`)
+    if (DEBUG) console.log(`LOAD: ${data.pkg}@${data.version}, pkg "${data.path}"`)
 
     const path = data.raw !== data.pkg
       ? `${data.pkg}/${data.path}`

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

@@ -21,6 +21,8 @@ const skippableSuitesCh = channel('ci:cucumber:test-suite:skippable')
 const sessionStartCh = channel('ci:cucumber:session:start')
 const sessionFinishCh = channel('ci:cucumber:session:finish')
 
+const itrSkippedSuitesCh = channel('ci:cucumber:itr:skipped-suites')
+
 const {
   getCoveredFilenamesFromCoverage,
   resetCoverage,
@@ -37,7 +39,6 @@ const patched = new WeakSet()
 
 let pickleByFile = {}
 const pickleResultByFile = {}
-let isSuitesSkipped = false
 
 function getSuiteStatusFromTestStatuses (testStatuses) {
   if (testStatuses.some(status => status === 'fail')) {
@@ -216,11 +217,18 @@ addHook({
   file: 'lib/runtime/test_case_runner.js'
 }, testCaseHook)
 
-function getPicklesToRun (runtime, suitesToSkip) {
-  return runtime.pickleIds.filter((pickleId) => {
+function getFilteredPickles (runtime, suitesToSkip) {
+  return runtime.pickleIds.reduce((acc, pickleId) => {
     const test = runtime.eventDataCollector.getPickle(pickleId)
-    return !suitesToSkip.includes(getTestSuitePath(test.uri, process.cwd()))
-  }, {})
+    const testSuitePath = getTestSuitePath(test.uri, process.cwd())
+    const isSkipped = suitesToSkip.includes(testSuitePath)
+    if (isSkipped) {
+      acc.skippedSuites.add(testSuitePath)
+    } else {
+      acc.picklesToRun.push(pickleId)
+    }
+    return acc
+  }, { skippedSuites: new Set(), picklesToRun: [] })
 }
 
 function getPickleByFile (runtime) {
@@ -239,7 +247,7 @@ addHook({
   name: '@cucumber/cucumber',
   versions: ['>=7.0.0'],
   file: 'lib/runtime/index.js'
-}, (runtimePackage, cucumberVersion) => {
+}, (runtimePackage, frameworkVersion) => {
   shimmer.wrap(runtimePackage.default.prototype, 'start', start => async function () {
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     let onDone
@@ -263,11 +271,16 @@ addHook({
     })
 
     const { err, skippableSuites } = await skippableSuitesPromise
+    let skippedSuites = []
+    let isSuitesSkipped = false
 
     if (!err) {
-      const newPickleIds = getPicklesToRun(this, skippableSuites)
-      isSuitesSkipped = newPickleIds.length !== this.pickleIds.length
-      this.pickleIds = newPickleIds
+      const filteredPickles = getFilteredPickles(this, skippableSuites)
+      const { picklesToRun } = filteredPickles
+      isSuitesSkipped = picklesToRun.length !== this.pickleIds.length
+      this.pickleIds = picklesToRun
+
+      skippedSuites = Array.from(filteredPickles.skippedSuites)
     }
 
     pickleByFile = getPickleByFile(this)
@@ -276,8 +289,13 @@ addHook({
     const command = process.env.npm_lifecycle_script || `cucumber-js ${processArgv}`
 
     asyncResource.runInAsyncScope(() => {
-      sessionStartCh.publish({ command, frameworkVersion: cucumberVersion })
+      sessionStartCh.publish({ command, frameworkVersion })
     })
+
+    if (!err && skippedSuites.length) {
+      itrSkippedSuitesCh.publish({ skippedSuites, frameworkVersion })
+    }
+
     const success = await start.apply(this, arguments)
 
     let testCodeCoverageLinesTotal
@@ -296,7 +314,8 @@ addHook({
       sessionFinishCh.publish({
         status: success ? 'pass' : 'fail',
         isSuitesSkipped,
-        testCodeCoverageLinesTotal
+        testCodeCoverageLinesTotal,
+        numSkippedSuites: skippedSuites.length
       })
     })
     return success

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

@@ -39,10 +39,13 @@ const testErrCh = channel('ci:jest:test:err')
 const skippableSuitesCh = channel('ci:jest:test-suite:skippable')
 const jestItrConfigurationCh = channel('ci:jest:itr-configuration')
 
+const itrSkippedSuitesCh = channel('ci:jest:itr:skipped-suites')
+
 let skippableSuites = []
 let isCodeCoverageEnabled = false
 let isSuitesSkippingEnabled = false
 let isSuitesSkipped = false
+let numSkippedSuites = 0
 
 const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 
@@ -102,7 +105,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         await super.handleTestEvent(event, state)
       }
 
-      const setNameToParams = (name, params) => { this.nameToParams[name] = params }
+      const setNameToParams = (name, params) => { this.nameToParams[name] = [...params] }
 
       if (event.name === 'setup') {
         if (this.global.test) {
@@ -191,7 +194,7 @@ addHook({
 addHook({
   name: '@jest/test-sequencer',
   versions: ['>=24.8.0']
-}, sequencerPackage => {
+}, (sequencerPackage, frameworkVersion) => {
   shimmer.wrap(sequencerPackage.default.prototype, 'shard', shard => function () {
     const shardedTests = shard.apply(this, arguments)
 
@@ -202,13 +205,15 @@ addHook({
     const [test] = shardedTests
     const rootDir = test && test.context && test.context.config && test.context.config.rootDir
 
-    const filteredTests = getJestSuitesToRun(skippableSuites, shardedTests, rootDir || process.cwd())
+    const { skippedSuites, suitesToRun } = getJestSuitesToRun(skippableSuites, shardedTests, rootDir || process.cwd())
 
-    isSuitesSkipped = filteredTests.length !== shardedTests.length
+    isSuitesSkipped = suitesToRun.length !== shardedTests.length
+    numSkippedSuites = skippedSuites.length
 
-    skippableSuites = []
+    itrSkippedSuitesCh.publish({ skippedSuites, frameworkVersion })
 
-    return filteredTests
+    skippableSuites = []
+    return suitesToRun
   })
   return sequencerPackage
 })
@@ -279,10 +284,13 @@ function cliWrapper (cli, jestVersion) {
         isSuitesSkipped,
         isSuitesSkippingEnabled,
         isCodeCoverageEnabled,
-        testCodeCoverageLinesTotal
+        testCodeCoverageLinesTotal,
+        numSkippedSuites
       })
     })
 
+    numSkippedSuites = 0
+
     return result
   })
 
@@ -468,7 +476,7 @@ addHook({
   name: '@jest/core',
   versions: ['>=24.8.0'],
   file: 'build/SearchSource.js'
-}, searchSourcePackage => {
+}, (searchSourcePackage, frameworkVersion) => {
   const SearchSource = searchSourcePackage.default ? searchSourcePackage.default : searchSourcePackage
 
   shimmer.wrap(SearchSource.prototype, 'getTestPaths', getTestPaths => async function () {
@@ -492,13 +500,16 @@ addHook({
     const testPaths = await getTestPaths.apply(this, arguments)
     const { tests } = testPaths
 
-    const filteredTests = getJestSuitesToRun(skippableSuites, tests, rootDir)
+    const { skippedSuites, suitesToRun } = getJestSuitesToRun(skippableSuites, tests, rootDir)
+
+    isSuitesSkipped = suitesToRun.length !== tests.length
+    numSkippedSuites = skippedSuites.length
 
-    isSuitesSkipped = filteredTests.length !== tests.length
+    itrSkippedSuitesCh.publish({ skippedSuites, frameworkVersion })
 
     skippableSuites = []
 
-    return { ...testPaths, tests: filteredTests }
+    return { ...testPaths, tests: suitesToRun }
   })
 
   return searchSourcePackage

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

@@ -30,6 +30,8 @@ const testSuiteFinishCh = channel('ci:mocha:test-suite:finish')
 const testSuiteErrorCh = channel('ci:mocha:test-suite:error')
 const testSuiteCodeCoverageCh = channel('ci:mocha:test-suite:code-coverage')
 
+const itrSkippedSuitesCh = channel('ci:mocha:itr:skipped-suites')
+
 // TODO: remove when root hooks and fixtures are implemented
 const patched = new WeakSet()
 
@@ -47,6 +49,7 @@ const originalCoverageMap = createCoverageMap()
 let suitesToSkip = []
 let frameworkVersion
 let isSuitesSkipped = false
+let skippedSuites = []
 
 function getSuitesByTestFile (root) {
   const suitesByTestFile = {}
@@ -97,10 +100,17 @@ function getTestAsyncResource (test) {
   return testToAr.get(originalFn)
 }
 
-function getSuitesToRun (originalSuites) {
-  return originalSuites.filter(suite =>
-    !suitesToSkip.includes(getTestSuitePath(suite.file, process.cwd()))
-  )
+function getFilteredSuites (originalSuites) {
+  return originalSuites.reduce((acc, suite) => {
+    const testPath = getTestSuitePath(suite.file, process.cwd())
+    const shouldSkip = suitesToSkip.includes(testPath)
+    if (shouldSkip) {
+      acc.skippedSuites.add(testPath)
+    } else {
+      acc.suitesToRun.push(suite)
+    }
+    return acc
+  }, { suitesToRun: [], skippedSuites: new Set() })
 }
 
 function mochaHook (Runner) {
@@ -137,13 +147,21 @@ function mochaHook (Runner) {
         global.__coverage__ = fromCoverageMapToCoverage(originalCoverageMap)
       }
 
-      testSessionFinishCh.publish({ status, isSuitesSkipped, testCodeCoverageLinesTotal })
+      testSessionFinishCh.publish({
+        status,
+        isSuitesSkipped,
+        testCodeCoverageLinesTotal,
+        numSkippedSuites: skippedSuites.length
+      })
     }))
 
     this.once('start', testRunAsyncResource.bind(function () {
       const processArgv = process.argv.slice(2).join(' ')
       const command = `mocha ${processArgv}`
       testSessionStartCh.publish({ command, frameworkVersion })
+      if (skippedSuites.length) {
+        itrSkippedSuitesCh.publish({ skippedSuites, frameworkVersion })
+      }
     }))
 
     this.on('suite', function (suite) {
@@ -359,9 +377,13 @@ addHook({
         suitesToSkip = skippableSuites
       }
       // We remove the suites that we skip through ITR
-      const newSuites = getSuitesToRun(runner.suite.suites)
-      isSuitesSkipped = newSuites.length !== runner.suite.suites.length
-      runner.suite.suites = newSuites
+      const filteredSuites = getFilteredSuites(runner.suite.suites)
+      const { suitesToRun } = filteredSuites
+
+      isSuitesSkipped = suitesToRun.length !== runner.suite.suites.length
+      runner.suite.suites = suitesToRun
+
+      skippedSuites = Array.from(filteredSuites.skippedSuites)
 
       global.run()
     }

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

@@ -2,7 +2,7 @@
 
 // TODO: either instrument all or none of the render functions
 
-const { channel, addHook, AsyncResource } = require('./helpers/instrument')
+const { channel, addHook } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 const { DD_MAJOR } = require('../../../version')
 
@@ -11,7 +11,8 @@ const finishChannel = channel('apm:next:request:finish')
 const errorChannel = channel('apm:next:request:error')
 const pageLoadChannel = channel('apm:next:page:load')
 
-const requestResources = new WeakMap()
+const requests = new WeakSet()
+const requestToNextjsPagePath = new WeakMap()
 
 function wrapHandleRequest (handleRequest) {
   return function (req, res, pathname, query) {
@@ -105,38 +106,91 @@ function getPageFromPath (page, dynamicRoutes = []) {
 }
 
 function instrument (req, res, handler) {
-  if (requestResources.has(req)) return handler()
+  req = req.originalRequest || req
+  res = res.originalResponse || res
 
-  const requestResource = new AsyncResource('bound-anonymous-fn')
+  if (requests.has(req)) return handler()
 
-  requestResources.set(req, requestResource)
+  requests.add(req)
 
-  return requestResource.runInAsyncScope(() => {
-    startChannel.publish({ req, res })
+  const ctx = { req, res }
 
+  return startChannel.runStores(ctx, () => {
     try {
-      const promise = handler()
+      const promise = handler(ctx)
 
       // promise should only reject when propagateError is true:
       // https://github.com/vercel/next.js/blob/cee656238a/packages/next/server/api-utils/node.ts#L547
       return promise.then(
-        result => finish(req, res, result),
-        err => finish(req, res, null, err)
+        result => finish(ctx, result),
+        err => finish(ctx, null, err)
       )
     } catch (e) {
       // this will probably never happen as the handler caller is an async function:
       // https://github.com/vercel/next.js/blob/cee656238a/packages/next/server/api-utils/node.ts#L420
-      return finish(req, res, null, e)
+      return finish(ctx, null, e)
     }
   })
 }
 
-function finish (req, res, result, err) {
+function wrapSetupServerWorker (setupServerWorker) {
+  return function (requestHandler) {
+    arguments[0] = shimmer.wrap(requestHandler, wrapRequestHandler(requestHandler))
+    return setupServerWorker.apply(this, arguments)
+  }
+}
+
+function wrapInitialize (initialize) {
+  return async function () {
+    const result = await initialize.apply(this, arguments)
+    if (Array.isArray(result)) {
+      const requestHandler = result[0]
+      result[0] = shimmer.wrap(requestHandler, wrapRequestHandler(requestHandler))
+    }
+    return result
+  }
+}
+
+function wrapRequestHandler (requestHandler) {
+  return function (req, res) {
+    return instrument(req, res, async () => {
+      const result = await requestHandler.apply(this, arguments) // apply here first to get page path association
+
+      const page = requestToNextjsPagePath.get(req)
+      if (page && pageLoadChannel.hasSubscribers) pageLoadChannel.publish({ page })
+
+      return result
+    })
+  }
+}
+
+// these two functions make sure we get path groups for routes in standalone,
+// as it doesn't route through `next-server`/`base-server`
+function wrapGetResolveRoutes (getResolveRoutes) {
+  return function () {
+    const result = getResolveRoutes.apply(this, arguments)
+    return shimmer.wrap(result, wrapResolveRoutes(result))
+  }
+}
+
+function wrapResolveRoutes (resolveRoutes) {
+  return async function (req) {
+    const result = await resolveRoutes.apply(this, arguments)
+    if (result && result.matchedOutput) {
+      const path = result.matchedOutput.itemPath
+      requestToNextjsPagePath.set(req, path)
+    }
+    return result
+  }
+}
+
+function finish (ctx, result, err) {
   if (err) {
-    errorChannel.publish(err)
+    ctx.error = err
+    errorChannel.publish(ctx)
   }
 
-  finishChannel.publish({ req, res })
+  finishChannel.publish(ctx)
 
   if (err) {
     throw err
@@ -145,11 +199,27 @@ function finish (req, res, result, err) {
   return result
 }
 
+addHook({
+  name: 'next',
+  versions: ['>=13.4.13'],
+  file: 'dist/server/lib/router-utils/resolve-routes.js'
+}, resolveRoutesModule => shimmer.wrap(resolveRoutesModule, 'getResolveRoutes', wrapGetResolveRoutes))
+
+addHook({
+  name: 'next',
+  versions: ['13.4.13'],
+  file: 'dist/server/lib/setup-server-worker.js'
+}, setupServerWorker => shimmer.wrap(setupServerWorker, 'initializeServerWorker', wrapSetupServerWorker))
+
+addHook({
+  name: 'next',
+  versions: ['>=13.4.15'],
+  file: 'dist/server/lib/router-server.js'
+}, routerServer => shimmer.wrap(routerServer, 'initialize', wrapInitialize))
+
 addHook({ name: 'next', versions: ['>=13.2'], file: 'dist/server/next-server.js' }, nextServer => {
   const Server = nextServer.default
 
-  shimmer.wrap(Server.prototype, 'handleRequest', wrapHandleRequest)
-  shimmer.wrap(Server.prototype, 'handleApiRequest', wrapHandleApiRequestWithMatch)
   shimmer.wrap(Server.prototype, 'renderToResponse', wrapRenderToResponse)
   shimmer.wrap(Server.prototype, 'renderErrorToResponse', wrapRenderErrorToResponse)
   shimmer.wrap(Server.prototype, 'findPageComponents', wrapFindPageComponents)
@@ -157,6 +227,22 @@ addHook({ name: 'next', versions: ['>=13.2'], file: 'dist/server/next-server.js'
   return nextServer
 })
 
+// these functions wrapped in all versions above 13.2 except:
+// 13.4.13 due to tests failing when these functions are wrapped
+// 13.4.14 due to it not being in the NPM registry/officially released
+addHook({
+  name: 'next',
+  versions: ['>=13.2 <13.4.13', '>=13.4.15'],
+  file: 'dist/server/next-server.js'
+}, nextServer => {
+  const Server = nextServer.default
+
+  shimmer.wrap(Server.prototype, 'handleRequest', wrapHandleRequest)
+  shimmer.wrap(Server.prototype, 'handleApiRequest', wrapHandleApiRequestWithMatch)
+
+  return nextServer
+})
+
 addHook({ name: 'next', versions: ['>=11.1 <13.2'], file: 'dist/server/next-server.js' }, nextServer => {
   const Server = nextServer.default
 

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

@@ -10,7 +10,7 @@ const startCh = channel('apm:openai:request:start')
 const finishCh = channel('apm:openai:request:finish')
 const errorCh = channel('apm:openai:request:error')
 
-addHook({ name: 'openai', file: 'dist/api.js', versions: ['>=3.0.0'] }, exports => {
+addHook({ name: 'openai', file: 'dist/api.js', versions: ['>=3.0.0 <4'] }, exports => {
   const methodNames = Object.getOwnPropertyNames(exports.OpenAIApi.prototype)
   methodNames.shift() // remove leading 'constructor' method