dd-trace 3.12.1 → 3.15.0

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

@@ -0,0 +1,358 @@
+
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const startChannel = channel('apm:fs:operation:start')
+const finishChannel = channel('apm:fs:operation:finish')
+const errorChannel = channel('apm:fs:operation:error')
+const ddFhSym = Symbol('ddFileHandle')
+let kHandle, kDirReadPromisified, kDirClosePromisified
+
+const paramsByMethod = {
+  access: ['path', 'mode'],
+  appendFile: ['path', 'data', 'options'],
+  chmod: ['path', 'mode'],
+  chown: ['path', 'uid', 'gid'],
+  close: ['fd'],
+  copyFile: ['src', 'dest', 'mode'],
+  cp: ['src', 'dest', 'options'],
+  exists: ['path'],
+  fchmod: ['fd', 'mode'],
+  fchown: ['fd', 'uid', 'gid'],
+  fdatasync: ['fd'],
+  fstat: ['fd', 'options'],
+  fsync: ['fd'],
+  ftruncate: ['fd', 'len'],
+  futimes: ['fd', 'atime', 'mtime'],
+  lchmod: ['path', 'mode'],
+  lchown: ['path', 'uid', 'gid'],
+  link: ['existingPath', 'newPath'],
+  lstat: ['path', 'options'],
+  lutimes: ['path', 'atime', 'mtime'],
+  mkdir: ['path', 'options'],
+  mkdtemp: ['prefix', 'options'],
+  open: ['path', 'flag', 'mode'],
+  opendir: ['path', 'options'],
+  read: ['fd'],
+  readdir: ['path', 'options'],
+  readFile: ['path', 'options'],
+  readlink: ['path', 'options'],
+  readv: ['fd'],
+  realpath: ['path', 'options'],
+  rename: ['oldPath', 'newPath'],
+  rmdir: ['path', 'options'],
+  rm: ['path', 'options'],
+  stat: ['path', 'options'],
+  symlink: ['target', 'path', 'type'],
+  truncate: ['path', 'len'],
+  unlink: ['path'],
+  utimes: ['path', 'atime', 'mtime'],
+  write: ['fd'],
+  writeFile: ['file', 'data', 'options'],
+  writev: ['fd']
+}
+
+const watchMethods = {
+  unwatchFile: ['path', 'listener'],
+  watch: ['path', 'options', 'listener'],
+  watchFile: ['path', 'options', 'listener']
+}
+
+const paramsByFileHandleMethods = {
+  appendFile: ['data', 'options'],
+  chmod: ['mode'],
+  chown: ['uid', 'gid'],
+  close: [],
+  createReadStream: ['options'],
+  createWriteStream: ['options'],
+  datasync: [],
+  read: ['buffer', 'offset', 'length', 'position'],
+  readableWebStream: [],
+  readFile: ['options'],
+  readLines: ['options'],
+  readv: ['buffers', 'position'],
+  stat: ['options'],
+  sync: [],
+  truncate: ['len'],
+  utimes: ['atime', 'mtime'],
+  write: ['buffer', 'offset', 'length', 'position'],
+  writeFile: ['data', 'options'],
+  writev: ['buffers', 'position']
+}
+const names = ['fs', 'node:fs']
+names.forEach(name => {
+  addHook({ name }, fs => {
+    const asyncMethods = Object.keys(paramsByMethod)
+    const syncMethods = asyncMethods.map(name => `${name}Sync`)
+
+    massWrap(fs, asyncMethods, createWrapFunction())
+    massWrap(fs, syncMethods, createWrapFunction())
+    massWrap(fs.promises, asyncMethods, createWrapFunction('promises.'))
+
+    wrap(fs.realpath, 'native', createWrapFunction('', 'realpath.native'))
+    wrap(fs.realpathSync, 'native', createWrapFunction('', 'realpath.native'))
+    wrap(fs.promises.realpath, 'native', createWrapFunction('', 'realpath.native'))
+
+    wrap(fs, 'createReadStream', wrapCreateStream)
+    wrap(fs, 'createWriteStream', wrapCreateStream)
+    if (fs.Dir) {
+      wrap(fs.Dir.prototype, 'close', createWrapFunction('dir.'))
+      wrap(fs.Dir.prototype, 'closeSync', createWrapFunction('dir.'))
+      wrap(fs.Dir.prototype, 'read', createWrapFunction('dir.'))
+      wrap(fs.Dir.prototype, 'readSync', createWrapFunction('dir.'))
+      wrap(fs.Dir.prototype, Symbol.asyncIterator, createWrapDirAsyncIterator())
+    }
+
+    wrap(fs, 'unwatchFile', createWatchWrapFunction())
+    wrap(fs, 'watch', createWatchWrapFunction())
+    wrap(fs, 'watchFile', createWatchWrapFunction())
+
+    return fs
+  })
+})
+function isFirstMethodReturningFileHandle (original) {
+  return !kHandle && original.name === 'open'
+}
+function wrapFileHandle (fh) {
+  const fileHandlePrototype = getFileHandlePrototype(fh)
+  const desc = Reflect.getOwnPropertyDescriptor(fileHandlePrototype, kHandle)
+  if (!desc || !desc.get) {
+    Reflect.defineProperty(fileHandlePrototype, kHandle, {
+      get () {
+        return this[ddFhSym]
+      },
+      set (h) {
+        this[ddFhSym] = h
+        wrap(this, 'close', createWrapFunction('filehandle.'))
+      },
+      configurable: true
+    })
+  }
+  for (const name of Reflect.ownKeys(fileHandlePrototype)) {
+    if (typeof name !== 'string' || name === 'constructor' || name === 'fd' || name === 'getAsyncId') {
+      continue
+    }
+    wrap(fileHandlePrototype, name, createWrapFunction('filehandle.'))
+  }
+}
+
+function getFileHandlePrototype (fh) {
+  if (!kHandle) {
+    kHandle = Reflect.ownKeys(fh).find(key => typeof key === 'symbol' && key.toString().includes('kHandle'))
+  }
+  return Object.getPrototypeOf(fh)
+}
+
+function getSymbolName (sym) {
+  return sym.description || sym.toString()
+}
+function initDirAsyncIteratorProperties (iterator) {
+  const keys = Reflect.ownKeys(iterator)
+  for (const key of keys) {
+    if (kDirReadPromisified && kDirClosePromisified) break
+    if (typeof key !== 'symbol') continue
+    if (!kDirReadPromisified && getSymbolName(key).includes('kDirReadPromisified')) {
+      kDirReadPromisified = key
+    }
+    if (!kDirClosePromisified && getSymbolName(key).includes('kDirClosePromisified')) {
+      kDirClosePromisified = key
+    }
+  }
+}
+
+function createWrapDirAsyncIterator () {
+  return function wrapDirAsyncIterator (asyncIterator) {
+    return function wrappedAsyncIterator () {
+      if (!kDirReadPromisified || !kDirClosePromisified) {
+        initDirAsyncIteratorProperties(this)
+      }
+      wrap(this, kDirReadPromisified, createWrapFunction('dir.', 'read'))
+      wrap(this, kDirClosePromisified, createWrapFunction('dir.', 'close'))
+      return asyncIterator.apply(this, arguments)
+    }
+  }
+}
+
+function wrapCreateStream (original) {
+  const classes = {
+    createReadStream: 'ReadStream',
+    createWriteStream: 'WriteStream'
+  }
+  const name = classes[original.name]
+
+  return function (path, options) {
+    if (!startChannel.hasSubscribers) return original.apply(this, arguments)
+
+    const innerResource = new AsyncResource('bound-anonymous-fn')
+    const message = getMessage(name, ['path', 'options'], arguments)
+
+    return innerResource.runInAsyncScope(() => {
+      startChannel.publish(message)
+
+      try {
+        const stream = original.apply(this, arguments)
+        const onError = innerResource.bind(error => {
+          errorChannel.publish(error)
+          onFinish()
+        })
+        const onFinish = innerResource.bind(() => {
+          finishChannel.publish()
+          stream.off('close', onFinish)
+          stream.off('end', onFinish)
+          stream.off('finish', onFinish)
+          stream.off('error', onError)
+        })
+
+        stream.once('close', onFinish)
+        stream.once('end', onFinish)
+        stream.once('finish', onFinish)
+        stream.once('error', onError)
+
+        return stream
+      } catch (error) {
+        errorChannel.publish(error)
+        finishChannel.publish()
+      }
+    })
+  }
+}
+
+function getMethodParamsRelationByPrefix (prefix) {
+  if (prefix === 'filehandle.') {
+    return paramsByFileHandleMethods
+  }
+  return paramsByMethod
+}
+
+function createWatchWrapFunction (override = '') {
+  return function wrapFunction (original) {
+    const name = override || original.name
+    const method = name
+    const operation = name
+    return function () {
+      if (!startChannel.hasSubscribers) return original.apply(this, arguments)
+      const message = getMessage(method, watchMethods[operation], arguments, this)
+      const innerResource = new AsyncResource('bound-anonymous-fn')
+      return innerResource.runInAsyncScope(() => {
+        startChannel.publish(message)
+        try {
+          const result = original.apply(this, arguments)
+          finishChannel.publish()
+          return result
+        } catch (error) {
+          errorChannel.publish(error)
+          finishChannel.publish()
+          throw error
+        }
+      })
+    }
+  }
+}
+
+function createWrapFunction (prefix = '', override = '') {
+  return function wrapFunction (original) {
+    const name = override || original.name
+    const method = `${prefix}${name}`
+    const operation = name.match(/^(.+?)(Sync)?(\.native)?$/)[1]
+
+    return function () {
+      if (!startChannel.hasSubscribers) return original.apply(this, arguments)
+
+      const lastIndex = arguments.length - 1
+      const cb = typeof arguments[lastIndex] === 'function' && arguments[lastIndex]
+      const innerResource = new AsyncResource('bound-anonymous-fn')
+      const message = getMessage(method, getMethodParamsRelationByPrefix(prefix)[operation], arguments, this)
+
+      if (cb) {
+        const outerResource = new AsyncResource('bound-anonymous-fn')
+
+        arguments[lastIndex] = innerResource.bind(function (e) {
+          if (typeof e === 'object') { // fs.exists receives a boolean
+            errorChannel.publish(e)
+          }
+
+          finishChannel.publish()
+
+          return outerResource.runInAsyncScope(() => cb.apply(this, arguments))
+        })
+      }
+
+      return innerResource.runInAsyncScope(() => {
+        startChannel.publish(message)
+        try {
+          const result = original.apply(this, arguments)
+          if (cb) return result
+          if (result && typeof result.then === 'function') {
+            // TODO method open returning promise and filehandle prototype not initialized, initialize it
+
+            return result.then(
+              value => {
+                if (isFirstMethodReturningFileHandle(original)) {
+                  wrapFileHandle(value)
+                }
+                finishChannel.publish()
+                return value
+              },
+              error => {
+                errorChannel.publish(error)
+                finishChannel.publish()
+                throw error
+              }
+            )
+          }
+
+          finishChannel.publish()
+
+          return result
+        } catch (error) {
+          errorChannel.publish(error)
+          finishChannel.publish()
+          throw error
+        }
+      })
+    }
+  }
+}
+
+function getMessage (operation, params, args, self) {
+  const metadata = {}
+  if (params) {
+    for (let i = 0; i < params.length; i++) {
+      if (!params[i] || typeof args[i] === 'function') continue
+      metadata[params[i]] = args[i]
+    }
+  }
+
+  if (self) {
+    // For `Dir` the path is available on `this.path`
+    if (self.path) {
+      metadata.path = self.path
+    }
+    // For FileHandle fs is available on `this.fd`
+    if (self.fd) {
+      metadata.fd = self.fd
+    }
+  }
+
+  return { operation, ...metadata }
+}
+
+function massWrap (target, methods, wrapper) {
+  for (const method of methods) {
+    wrap(target, method, wrapper)
+  }
+}
+
+function wrap (target, method, wrapper) {
+  try {
+    shimmer.wrap(target, method, wrapper)
+  } catch (e) {
+    // skip unavailable method
+  }
+}

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -1,7 +1,9 @@
 'use strict'
 
 module.exports = {
+  '@aws-sdk/smithy-client': () => require('../aws-sdk'),
   '@cucumber/cucumber': () => require('../cucumber'),
+  '@playwright/test': () => require('../playwright'),
   '@elastic/elasticsearch': () => require('../elasticsearch'),
   '@elastic/transport': () => require('../elasticsearch'),
   '@google-cloud/pubsub': () => require('../google-cloud-pubsub'),
@@ -31,6 +33,8 @@ module.exports = {
   'express': () => require('../express'),
   'fastify': () => require('../fastify'),
   'find-my-way': () => require('../find-my-way'),
+  'fs': () => require('../fs'),
+  'node:fs': () => require('../fs'),
   'graphql': () => require('../graphql'),
   'grpc': () => require('../grpc'),
   'hapi': () => require('../hapi'),

package/packages/datadog-instrumentations/src/helpers/register.js

@@ -32,7 +32,7 @@ for (const packageName of names) {
           try {
             loadChannel.publish({ name, version, file })
 
-            moduleExports = hook(moduleExports)
+            moduleExports = hook(moduleExports, version)
           } catch (e) {
             log.error(e)
           }

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

@@ -72,7 +72,7 @@ function getTestEnvironmentOptions (config) {
   return {}
 }
 
-function getWrappedEnvironment (BaseEnvironment) {
+function getWrappedEnvironment (BaseEnvironment, jestVersion) {
   return class DatadogEnvironment extends BaseEnvironment {
     constructor (config, context) {
       super(config, context)
@@ -116,7 +116,8 @@ function getWrappedEnvironment (BaseEnvironment) {
             name: getJestTestName(event.test),
             suite: this.testSuite,
             runner: 'jest-circus',
-            testParameters
+            testParameters,
+            frameworkVersion: jestVersion
           })
           originalTestFns.set(event.test, event.test.fn)
           event.test.fn = asyncResource.bind(event.test.fn)
@@ -142,7 +143,8 @@ function getWrappedEnvironment (BaseEnvironment) {
           testSkippedCh.publish({
             name: getJestTestName(event.test),
             suite: this.testSuite,
-            runner: 'jest-circus'
+            runner: 'jest-circus',
+            frameworkVersion: jestVersion
           })
         })
       }
@@ -150,14 +152,14 @@ function getWrappedEnvironment (BaseEnvironment) {
   }
 }
 
-function getTestEnvironment (pkg) {
+function getTestEnvironment (pkg, jestVersion) {
   if (pkg.default) {
-    const wrappedTestEnvironment = getWrappedEnvironment(pkg.default)
+    const wrappedTestEnvironment = getWrappedEnvironment(pkg.default, jestVersion)
     pkg.default = wrappedTestEnvironment
     pkg.TestEnvironment = wrappedTestEnvironment
     return pkg
   }
-  return getWrappedEnvironment(pkg)
+  return getWrappedEnvironment(pkg, jestVersion)
 }
 
 addHook({
@@ -170,7 +172,7 @@ addHook({
   versions: ['>=24.8.0']
 }, getTestEnvironment)
 
-function cliWrapper (cli) {
+function cliWrapper (cli, jestVersion) {
   const wrapped = shimmer.wrap(cli, 'runCLI', runCLI => async function () {
     let onDone
     const configurationPromise = new Promise((resolve) => {
@@ -186,13 +188,12 @@ function cliWrapper (cli) {
 
     try {
       const { err, itrConfig } = await configurationPromise
-      if (err) {
-        log.error(err)
+      if (!err) {
+        isCodeCoverageEnabled = itrConfig.isCodeCoverageEnabled
+        isSuitesSkippingEnabled = itrConfig.isSuitesSkippingEnabled
       }
-      isCodeCoverageEnabled = itrConfig.isCodeCoverageEnabled
-      isSuitesSkippingEnabled = itrConfig.isSuitesSkippingEnabled
-    } catch (e) {
-      log.error(e)
+    } catch (err) {
+      log.error(err)
     }
 
     if (isSuitesSkippingEnabled) {
@@ -206,13 +207,11 @@ function cliWrapper (cli) {
 
       try {
         const { err, skippableSuites: receivedSkippableSuites } = await skippableSuitesPromise
-        if (err) {
-          log.error(err)
-        } else {
+        if (!err) {
           skippableSuites = receivedSkippableSuites
         }
-      } catch (e) {
-        log.error(e)
+      } catch (err) {
+        log.error(err)
       }
     }
 
@@ -220,7 +219,7 @@ function cliWrapper (cli) {
 
     const processArgv = process.argv.slice(2).join(' ')
     sessionAsyncResource.runInAsyncScope(() => {
-      testSessionStartCh.publish(`jest ${processArgv}`)
+      testSessionStartCh.publish({ command: `jest ${processArgv}`, frameworkVersion: jestVersion })
     })
 
     const result = await runCLI.apply(this, arguments)
@@ -288,7 +287,7 @@ addHook({
   versions: ['>=24.8.0']
 }, cliWrapper)
 
-function jestAdapterWrapper (jestAdapter) {
+function jestAdapterWrapper (jestAdapter, jestVersion) {
   const adapter = jestAdapter.default ? jestAdapter.default : jestAdapter
   const newAdapter = shimmer.wrap(adapter, function () {
     const environment = arguments[2]
@@ -299,7 +298,8 @@ function jestAdapterWrapper (jestAdapter) {
     return asyncResource.runInAsyncScope(() => {
       testSuiteStartCh.publish({
         testSuite: environment.testSuite,
-        testEnvironmentOptions: environment.testEnvironmentOptions
+        testEnvironmentOptions: environment.testEnvironmentOptions,
+        frameworkVersion: jestVersion
       })
       return adapter.apply(this, arguments).then(suiteResults => {
         const { numFailingTests, skipped, failureMessage: errorMessage } = suiteResults
@@ -440,7 +440,7 @@ addHook({
   versions: ['24.8.0 - 24.9.0']
 }, jestConfigSyncWrapper)
 
-function jasmineAsyncInstallWraper (jasmineAsyncInstallExport) {
+function jasmineAsyncInstallWraper (jasmineAsyncInstallExport, jestVersion) {
   return function (globalConfig, globalInput) {
     globalInput._ddtrace = global._ddtrace
     shimmer.wrap(globalInput.jasmine.Spec.prototype, 'execute', execute => function (onComplete) {
@@ -450,7 +450,8 @@ function jasmineAsyncInstallWraper (jasmineAsyncInstallExport) {
         testStartCh.publish({
           name: this.getFullName(),
           suite: testSuite,
-          runner: 'jest-jasmine2'
+          runner: 'jest-jasmine2',
+          frameworkVersion: jestVersion
         })
         const spec = this
         const callback = asyncResource.bind(function () {

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

@@ -35,7 +35,7 @@ function wrapEmitter (corkedEmitter) {
       }
       arguments[1] = bindedFn
     }
-    on.apply(this, arguments)
+    return on.apply(this, arguments)
   }
   shimmer.wrap(corkedEmitter, 'on', addListener)
   shimmer.wrap(corkedEmitter, 'addListener', addListener)
@@ -47,7 +47,7 @@ function wrapEmitter (corkedEmitter) {
         arguments[1] = emitterOn
       }
     }
-    off.apply(this, arguments)
+    return off.apply(this, arguments)
   }
   shimmer.wrap(corkedEmitter, 'off', removeListener)
   shimmer.wrap(corkedEmitter, 'removeListener', removeListener)
@@ -87,5 +87,15 @@ addHook({ name: 'ldapjs', versions: ['>=2'] }, ldapjs => {
     return _send.apply(this, arguments)
   })
 
+  shimmer.wrap(ldapjs.Client.prototype, 'bind', bind => function (dn, password, controls, callback) {
+    if (typeof controls === 'function') {
+      arguments[2] = AsyncResource.bind(controls)
+    } else if (typeof callback === 'function') {
+      arguments[3] = AsyncResource.bind(callback)
+    }
+
+    return bind.apply(this, arguments)
+  })
+
   return ldapjs
 })

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

@@ -2,7 +2,6 @@ const { createCoverageMap } = require('istanbul-lib-coverage')
 
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
-const log = require('../../dd-trace/src/log')
 const {
   getCoveredFilenamesFromCoverage,
   resetCoverage,
@@ -39,6 +38,7 @@ const testFileToSuiteAr = new Map()
 const originalCoverageMap = createCoverageMap()
 
 let suitesToSkip = []
+let frameworkVersion
 
 function getSuitesByTestFile (root) {
   const suitesByTestFile = {}
@@ -128,7 +128,7 @@ function mochaHook (Runner) {
     this.once('start', testRunAsyncResource.bind(function () {
       const processArgv = process.argv.slice(2).join(' ')
       const command = `mocha ${processArgv}`
-      testSessionStartCh.publish(command)
+      testSessionStartCh.publish({ command, frameworkVersion })
     }))
 
     this.on('suite', function (suite) {
@@ -313,9 +313,9 @@ addHook({
   name: 'mocha',
   versions: ['>=5.2.0'],
   file: 'lib/mocha.js'
-}, (Mocha) => {
+}, (Mocha, mochaVersion) => {
+  frameworkVersion = mochaVersion
   const mochaRunAsyncResource = new AsyncResource('bound-anonymous-fn')
-
   /**
    * Get ITR configuration and skippable suites
    * If ITR is disabled, `onDone` is called immediately on the subscriber
@@ -330,7 +330,6 @@ addHook({
 
     const onReceivedSkippableSuites = ({ err, skippableSuites }) => {
       if (err) {
-        log.error(err)
         suitesToSkip = []
       } else {
         suitesToSkip = skippableSuites
@@ -342,7 +341,6 @@ addHook({
 
     const onReceivedConfiguration = ({ err }) => {
       if (err) {
-        log.error(err)
         return global.run()
       }
       if (!skippableSuitesCh.hasSubscribers) {
@@ -417,8 +415,13 @@ addHook({
 
         // we store the original function, not to lose it
         originalFns.set(newFn, this.fn)
-
         this.fn = newFn
+
+        // Temporarily keep functionality when .asyncResource is removed from node
+        // in https://github.com/nodejs/node/pull/46432
+        if (!this.fn.asyncResource) {
+          this.fn.asyncResource = asyncResource
+        }
       }
     }
 

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

@@ -19,7 +19,7 @@ function wrapAddQueue (addQueue) {
 
 addHook({
   name: 'mongoose',
-  versions: ['>=4.6.4']
+  versions: ['>=4.6.4 <7'] // TODO: Mongoose v7 compat
 }, mongoose => {
   if (mongoose.Promise !== global.Promise) {
     shimmer.wrap(mongoose.Promise.prototype, 'then', wrapThen)

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

@@ -19,13 +19,19 @@ addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connect
 
     const sql = arguments[0].sql ? arguments[0].sql : arguments[0]
     const conf = this.config
+    const payload = { sql, conf }
 
     const callbackResource = new AsyncResource('bound-anonymous-fn')
     const asyncResource = new AsyncResource('bound-anonymous-fn')
 
     return asyncResource.runInAsyncScope(() => {
-      startCh.publish({ sql, conf })
+      startCh.publish(payload)
 
+      if (arguments[0].sql) {
+        arguments[0].sql = payload.sql
+      } else {
+        arguments[0] = payload.sql
+      }
       try {
         const res = query.apply(this, arguments)
 

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

@@ -45,8 +45,14 @@ addHook({ name: 'mysql2', file: 'lib/connection.js', versions: ['>=1'] }, Connec
 
     return asyncResource.bind(function executeWithTrace (packet, connection) {
       const sql = cmd.statement ? cmd.statement.query : cmd.sql
+      const payload = { sql, conf: config }
+      startCh.publish(payload)
 
-      startCh.publish({ sql, conf: config })
+      if (cmd.statement) {
+        cmd.statement.query = payload.sql
+      } else {
+        cmd.sql = payload.sql
+      }
 
       if (this.onResult) {
         const onResult = callbackResource.bind(this.onResult)

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

@@ -127,7 +127,8 @@ function finish (req, res, result, err) {
   return result
 }
 
-addHook({ name: 'next', versions: ['>=11.1'], file: 'dist/server/next-server.js' }, nextServer => {
+// TODO: 13.2 support
+addHook({ name: 'next', versions: ['>=11.1 <13.2'], file: 'dist/server/next-server.js' }, nextServer => {
   const Server = nextServer.default
 
   shimmer.wrap(Server.prototype, 'handleRequest', wrapHandleRequest)