dd-trace 6.9.0 → 6.11.0

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/webdriverio.js

@@ -172,4 +172,85 @@ module.exports = [
     },
     channelName: 'testFrameworkFnWrapper',
   },
+  {
+    module: {
+      name: '@wdio/utils',
+      versionRange: '>=9.0.0',
+      filePath: 'build/index.js',
+    },
+    functionQuery: {
+      functionName: 'executeAsync',
+      kind: 'Async',
+    },
+    channelName: 'executeAsync',
+  },
+  {
+    module: {
+      name: '@wdio/utils',
+      versionRange: '>=9.0.0',
+      filePath: 'build/index.js',
+    },
+    astQuery: 'FunctionDeclaration[id.name="executeAsync"] CatchClause ' +
+      'IfStatement[test.operator=">"][test.left.object.name="retries"]' +
+      '[test.left.property.name="limit"][test.right.object.name="retries"]' +
+      '[test.right.property.name="attempts"]',
+    channelName: 'executeAsync',
+    transform: 'awaitContextCallback',
+    transformOptions: {
+      callbackArgumentNames: ['err'],
+      callbackName: 'retryCallback',
+    },
+  },
+  {
+    module: {
+      name: 'jasmine-core',
+      versionRange: '>=5.0.0 <6.0.0',
+      filePath: 'lib/jasmine-core/jasmine.js',
+    },
+    astQuery: 'AssignmentExpression[left.object.object.name="Spec"]' +
+      '[left.object.property.name="prototype"][left.property.name="execute"] > FunctionExpression',
+    functionQuery: {
+      kind: 'Sync',
+    },
+    channelName: 'Spec_execute',
+  },
+  {
+    module: {
+      name: 'jasmine-core',
+      versionRange: '>=5.0.0 <6.0.0',
+      filePath: 'lib/jasmine-core/jasmine.js',
+    },
+    astQuery: 'AssignmentExpression[left.object.object.name="Spec"]' +
+      '[left.object.property.name="prototype"][left.property.name="status"] > FunctionExpression',
+    functionQuery: {
+      kind: 'Sync',
+    },
+    channelName: 'Spec_attemptDone',
+  },
+  {
+    module: {
+      name: 'jasmine-core',
+      versionRange: '>=5.0.0 <6.0.0',
+      filePath: 'lib/jasmine-core/jasmine.js',
+    },
+    functionQuery: {
+      className: 'Spec',
+      methodName: 'executionFinished',
+      kind: 'Sync',
+    },
+    channelName: 'Spec_attemptDone',
+  },
+  {
+    module: {
+      name: 'jasmine-core',
+      versionRange: '>=5.0.0 <6.0.0',
+      filePath: 'lib/jasmine-core/jasmine.js',
+    },
+    functionQuery: {
+      className: 'TreeRunner',
+      methodName: '_executeSpec',
+      kind: 'Sync',
+    },
+    channelName: 'Spec_execute',
+  },
 ]

package/packages/datadog-instrumentations/src/helpers/rewriter/targets.json

@@ -54,6 +54,7 @@
   "graphql/utilities/index.mjs": "graphql",
   "graphql/validation/validate.js": "graphql",
   "graphql/validation/validate.mjs": "graphql",
+  "jasmine-core/lib/jasmine-core/jasmine.js": "jasmine-core",
   "mercurius/index.js": "mercurius",
   "playwright-core/lib/coreBundle.js": "playwright-core",
   "playwright/lib/index.js": "playwright",

package/packages/datadog-instrumentations/src/helpers/rewriter/transforms.js

@@ -14,7 +14,89 @@ const clone = require('../../../../../vendor/dist/rfdc')({ proto: false, circles
 
 const { parse, query } = require('./compiler')
 
-module.exports = { waitForAsyncEnd }
+const functionTypes = new Set(['ArrowFunctionExpression', 'FunctionDeclaration', 'FunctionExpression'])
+const identifierPattern = /^[$A-Z_a-z][$\w]*$/
+
+module.exports = { awaitContextCallback, waitForAsyncEnd }
+
+/**
+ * Awaits an optional context callback before continuing through a matched conditional branch.
+ *
+ * The branch condition is checked again after the callback settles so the
+ * original body does not run against state that changed while awaiting.
+ *
+ * @param {{
+ *   transformOptions?: {
+ *     callbackArgumentNames?: string[],
+ *     callbackName?: string
+ *   }
+ * }} state
+ * @param {import('estree').IfStatement} node
+ * @param {import('estree').Node} _parent
+ * @param {import('estree').Node[]} ancestry
+ * @returns {void}
+ */
+function awaitContextCallback (state, node, _parent, ancestry) {
+  assert(node.type === 'IfStatement' && node.consequent?.type === 'BlockStatement',
+    'awaitContextCallback: expected an if statement with a block body')
+
+  const { callbackArgumentNames = [], callbackName } = state.transformOptions ?? {}
+
+  assert(identifierPattern.test(callbackName), 'awaitContextCallback: callbackName must be an identifier')
+  assert(callbackArgumentNames.every(name => identifierPattern.test(name)),
+    'awaitContextCallback: callbackArgumentNames must be identifiers')
+
+  let enclosingFunction
+  let hasTraceWrapper = false
+  for (const ancestor of ancestry) {
+    if (!functionTypes.has(ancestor.type)) continue
+
+    enclosingFunction ??= ancestor
+    if (ancestor.body?.type !== 'BlockStatement') continue
+
+    let hasContextBinding = false
+    let hasTracedBinding = false
+    for (const statement of ancestor.body.body) {
+      if (statement.type !== 'VariableDeclaration') continue
+
+      for (const declaration of statement.declarations) {
+        hasContextBinding ||= declaration.id?.name === '__apm$ctx'
+        hasTracedBinding ||= declaration.id?.name === '__apm$traced'
+      }
+    }
+    hasTraceWrapper ||= hasContextBinding && hasTracedBinding
+  }
+
+  assert(enclosingFunction?.async, 'awaitContextCallback: expected an enclosing async function')
+  assert(hasTraceWrapper, 'awaitContextCallback: expected an enclosing trace wrapper')
+
+  const callbackVariable = `__apm$${callbackName}`
+  if (query(node, `[id.name="${callbackVariable}"]`).length > 0) {
+    return
+  }
+
+  const originalStatements = node.consequent.body
+  const callbackStatements = parse(`
+    async function wrapper () {
+      const ${callbackVariable} = __apm$ctx.${callbackName};
+      if (typeof ${callbackVariable} === 'function') {
+        try {
+          await ${callbackVariable}(${callbackArgumentNames.join(', ')});
+        } catch {}
+        if (true) {}
+      } else {
+      }
+    }
+  `).body[0].body.body
+
+  const callbackBranch = callbackStatements[1]
+  const recheckedBranch = callbackBranch.consequent.body[1]
+  recheckedBranch.test = clone(node.test)
+  recheckedBranch.consequent.body.push(...clone(originalStatements))
+  recheckedBranch.alternate = clone(node.alternate)
+  callbackBranch.alternate.body.push(...originalStatements)
+  node.consequent.body = callbackStatements
+}
 
 /**
  * Injects settlement-specific asyncEnd waits into a generated `tracePromise`

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

@@ -49,7 +49,7 @@ const {
   getRawJestTestName,
   getJestSuitesToRun,
   removeSeedSuffixFromTestName,
-} = require('../../datadog-plugin-jest/src/util')
+} = require('../../dd-trace/src/plugins/util/jest')
 const {
   addCoverageBackfillUntestedFiles,
   getCoverageBackfillFiles,
@@ -97,7 +97,9 @@ const itrSkippedSuitesCh = channel('ci:jest:itr:skipped-suites')
 const CHILD_MESSAGE_CALL = 1
 
 // Maximum time we'll wait for the tracer to flush
-const FLUSH_TIMEOUT = 10_000
+// The exporter has a 10-second bounded final-flush deadline. Leave enough time
+// for its completion callback before Jest's --forceExit fallback takes over.
+const FLUSH_TIMEOUT = 12_000
 const JEST_SESSION_STATE = Symbol.for('dd-trace:jest:session')
 const JEST_BAIL_REPORTER_PATH = require.resolve('./jest/bail-reporter')
 const DD_JEST_HANDLE_TEST_EVENT_WRAPPED = Symbol('dd-trace:jest:handle-test-event-wrapped')
@@ -110,7 +112,7 @@ const jestSessionState = (globalThis[JEST_SESSION_STATE] ||= {})
 const RETRY_TIMES = Symbol.for('RETRY_TIMES')
 
 let skippableSuites = []
-let skippableSuitesCoverage = {}
+let skippableSuitesCoverage
 let skippedSuitesCoverage = {}
 let knownTests = {}
 let isCodeCoverageEnabled = false
@@ -131,7 +133,7 @@ let isTestManagementTestsEnabled = false
 let testManagementTests = {}
 let testManagementAttemptToFixRetries = 0
 let isImpactedTestsEnabled = false
-let modifiedFiles = {}
+let modifiedFiles
 let repositoryRoot
 let lastCoverageMap
 let lastCoverageMapRootDir
@@ -688,8 +690,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
 
       if (this.isImpactedTestsEnabled) {
         try {
-          const hasImpactedTests = Object.keys(modifiedFiles).length > 0
-          this.modifiedFiles = hasImpactedTests ? modifiedFiles : this.testEnvironmentOptions._ddModifiedFiles
+          this.modifiedFiles = modifiedFiles ?? this.testEnvironmentOptions._ddModifiedFiles
         } catch (e) {
           log.error('Error parsing impacted tests', e)
           this.isImpactedTestsEnabled = false
@@ -2489,12 +2490,6 @@ function getRepositoryRootFromTest (test, fallbackRootDir) {
   return getRepositoryRootFromConfig(test?.context?.config, fallbackRootDir)
 }
 
-function hasSkippableSuitesCoverage () {
-  return skippableSuitesCoverage &&
-    typeof skippableSuitesCoverage === 'object' &&
-    Object.keys(skippableSuitesCoverage).length > 0
-}
-
 function shouldCollectJestCoverageForTia () {
   return shouldReportJestSuiteCoverageForTia() ||
     (isJestCoverageBackfillSupported && isItrEnabled && isCoverageReportUploadEnabled)
@@ -2605,7 +2600,7 @@ function resetLibraryConfiguration () {
   testManagementTests = {}
   testManagementAttemptToFixRetries = 0
   isImpactedTestsEnabled = false
-  modifiedFiles = {}
+  modifiedFiles = undefined
   repositoryRoot = undefined
 }
 
@@ -2627,13 +2622,14 @@ function applySuiteSkipping (originalTests, rootDir, frameworkVersion) {
 
   isSuitesSkipped ||= jestSuitesToRun.suitesToRun.length !== originalTests.length
   numSkippedSuites += jestSuitesToRun.skippedSuites.length
-  skippedSuitesCoverage = isSuitesSkipped && isTiaCoverageBackfillEnabled() && hasSkippableSuitesCoverage()
+  const hasSkippableSuitesCoverage = skippableSuitesCoverage !== undefined
+  skippedSuitesCoverage = isSuitesSkipped && isTiaCoverageBackfillEnabled() && hasSkippableSuitesCoverage
     ? skippableSuitesCoverage
     : {}
   coverageBackfillContexts = isSuitesSkipped && isTiaCoverageBackfillEnabled()
     ? getTestContexts(originalTests)
     : undefined
-  coverageBackfillFiles = isSuitesSkipped && isTiaCoverageBackfillEnabled() && hasSkippableSuitesCoverage()
+  coverageBackfillFiles = isSuitesSkipped && isTiaCoverageBackfillEnabled() && hasSkippableSuitesCoverage
     ? getCoverageBackfillFiles(skippableSuitesCoverage, repositoryRoot, getTestSuitePath)
     : undefined
 
@@ -3022,10 +3018,10 @@ function getCliWrapper (isNewJestVersion) {
             skippableSuitesCoverage: receivedSkippableSuitesCoverage,
           } = skippableSuitesResponse || await getChannelPromise(skippableSuitesCh)
           if (err) {
-            skippableSuitesCoverage = {}
+            skippableSuitesCoverage = undefined
           } else {
             skippableSuites = receivedSkippableSuites
-            skippableSuitesCoverage = receivedSkippableSuitesCoverage || {}
+            skippableSuitesCoverage = receivedSkippableSuitesCoverage
           }
           skippedSuitesCoverage = {}
         } catch (err) {
@@ -3066,7 +3062,19 @@ function getCliWrapper (isNewJestVersion) {
         frameworkVersion: jestVersion,
       })
 
-      const result = await runCLI.apply(this, arguments)
+      let result
+      try {
+        result = await runCLI.apply(this, arguments)
+      } catch (error) {
+        try {
+          await waitForTestSessionFinish(getTestSessionFinishPayload('fail', error, {
+            isTestSessionFinalizationError: true,
+          }))
+        } catch (finalizationError) {
+          log.error('Jest test session finalization error: %s', finalizationError)
+        }
+        throw error
+      }
 
       const {
         results: {

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

@@ -1,7 +1,19 @@
 'use strict'
 
+const { performance } = require('node:perf_hooks')
+
 const shimmer = require('../../datadog-shimmer')
 const { channel, addHook } = require('./helpers/instrument')
+const {
+  acquireWait,
+  clearPoolWaitTime,
+  isPoolQueryAcquire,
+  runOutsidePoolQueryAcquire,
+  runPoolAcquireError,
+  runWithPoolWait,
+  takePoolWaitTime,
+  wrapPoolQueryMethod,
+} = require('./helpers/pool-acquire')
 
 const commandAddCh = channel('apm:mariadb:command:add')
 const connectionStartCh = channel('apm:mariadb:connection:start')
@@ -10,11 +22,37 @@ const startCh = channel('apm:mariadb:query:start')
 const finishCh = channel('apm:mariadb:query:finish')
 const errorCh = channel('apm:mariadb:query:error')
 const skipCh = channel('apm:mariadb:pool:skip')
+const acquireStartCh = channel('apm:mariadb:pool:acquire:start')
+const acquireFinishCh = channel('apm:mariadb:pool:acquire:finish')
+const poolAcquireChannels = {
+  connectionFinishCh,
+  acquireStartCh,
+  acquireFinishCh,
+}
+const wrappedPools = new WeakSet()
+
+/**
+ * @typedef {object} PoolAcquireTiming
+ * @property {number} [poolAcquireStart]
+ * @property {number} [poolAcquireStartedAt]
+ * @property {number} [poolWaitTime]
+ */
+
+/** @typedef {{ length: number, [index: number]: unknown } & Iterable<unknown>} ArgumentsLike */
+
+/** @type {PoolAcquireTiming|undefined} */
+let currentPoolAcquireTiming
+let explicitPoolAcquire = false
 
 function wrapCommandStart (start, ctx) {
   return shimmer.wrapFunction(start, start => function (...args) {
     if (!startCh.hasSubscribers) return start.apply(this, args)
 
+    const poolWaitTime = takePoolWaitTime(args[0])
+    if (poolWaitTime !== undefined) {
+      ctx.poolWaitTime = poolWaitTime
+    }
+
     const { reject, resolve } = this
     shimmer.wrap(this, 'resolve', function wrapResolve () {
       return function (...args) {
@@ -133,43 +171,262 @@ function wrapPoolMethod (createConnection) {
   }
 }
 
+/**
+ * @param {Function} getConnection
+ * @returns {Function}
+ */
+function wrapExplicitPoolGetConnection (getConnection) {
+  return function wrappedExplicitPoolGetConnection () {
+    if (!connectionStartCh.hasSubscribers) {
+      return getConnection.apply(this, arguments)
+    }
+
+    const previous = explicitPoolAcquire
+    explicitPoolAcquire = true
+    try {
+      return runOutsidePoolQueryAcquire(getConnection, this, arguments)
+    } finally {
+      explicitPoolAcquire = previous
+    }
+  }
+}
+
+/**
+ * @param {Function} method
+ * @returns {Function}
+ */
+function wrapPoolQuery (method) {
+  return wrapPoolQueryMethod(method, connectionStartCh)
+}
+
+/**
+ * @param {Function} Pool
+ * @returns {boolean}
+ */
+function claimPoolWrap (Pool) {
+  if (wrappedPools.has(Pool)) return false
+  wrappedPools.add(Pool)
+  return true
+}
+
+/**
+ * @param {Function} Pool
+ * @returns {Function}
+ */
+function wrapPublicPool (Pool) {
+  if (!claimPoolWrap(Pool)) return Pool
+
+  shimmer.wrap(Pool.prototype, 'getConnection', wrapExplicitPoolGetConnection)
+  shimmer.wrap(Pool.prototype, 'query', wrapPoolQuery)
+  shimmer.wrap(Pool.prototype, 'execute', wrapPoolQuery)
+  return Pool
+}
+
+/**
+ * @param {Function} Pool
+ * @returns {Function}
+ */
+function wrapInternalPool (Pool) {
+  if (!claimPoolWrap(Pool)) return Pool
+
+  // The idle callback must be replaced before validation and observed before the method returns,
+  // which cannot be expressed by Orchestrion's subscriber lifecycle.
+  shimmer.wrap(Pool.prototype, '_acquireIdleConnection', wrapPoolAcquireIdleMethod)
+  shimmer.wrap(Pool.prototype, 'getConnection', wrapPoolGetConnectionMethod)
+  shimmer.wrap(Pool.prototype, '_createPoolConnection', wrapPoolMethod)
+  return Pool
+}
+
+/**
+ * @param {Record<string, unknown>} acquireCtx
+ * @param {Function} callback
+ * @param {unknown} thisArg
+ * @param {ArgumentsLike} args
+ * @returns {unknown}
+ */
+function finishExplicitPoolAcquire (acquireCtx, callback, thisArg, args) {
+  acquireFinishCh.publish(acquireCtx)
+  return callback.apply(thisArg, args)
+}
+
+/**
+ * @param {PoolAcquireTiming} timing
+ */
+function startPoolAcquireTiming (timing) {
+  const start = performance.now()
+  timing.poolAcquireStart = start
+  timing.poolAcquireStartedAt ??= start
+}
+
+/**
+ * @param {PoolAcquireTiming} timing
+ * @returns {number}
+ */
+function finishPoolAcquireTiming (timing) {
+  const poolWaitTime = (timing.poolWaitTime ?? 0) + acquireWait(timing.poolAcquireStart)
+  timing.poolAcquireStart = undefined
+  timing.poolWaitTime = poolWaitTime
+  return poolWaitTime
+}
+
+/**
+ * @param {Function} acquireIdleConnection
+ * @returns {Function}
+ */
+function wrapPoolAcquireIdleMethod (acquireIdleConnection) {
+  return function wrappedAcquireIdleConnection (callback) {
+    const timing = currentPoolAcquireTiming
+    if (timing === undefined) {
+      return acquireIdleConnection.apply(this, arguments)
+    }
+    currentPoolAcquireTiming = undefined
+
+    let completed = false
+    let synchronous = true
+
+    /**
+     * @param {unknown} error
+     * @returns {unknown}
+     */
+    arguments[0] = function wrappedCallback (error) {
+      completed = true
+      if (error) {
+        if (synchronous) {
+          startPoolAcquireTiming(timing)
+        }
+      } else if (synchronous) {
+        timing.poolWaitTime = 0
+      } else {
+        finishPoolAcquireTiming(timing)
+      }
+      return callback.apply(this, arguments)
+    }
+
+    const result = acquireIdleConnection.apply(this, arguments)
+    synchronous = false
+    if (!completed) {
+      startPoolAcquireTiming(timing)
+    }
+    return result
+  }
+}
+
+/**
+ * @param {Function} getConnection
+ * @returns {Function}
+ */
 function wrapPoolGetConnectionMethod (getConnection) {
-  return function wrappedGetConnection (...args) {
-    const cb = args.at(-1)
-    if (typeof cb !== 'function') return getConnection.apply(this, args)
+  const poolWaitTransfer = { deferred: false }
+
+  return function wrappedGetConnection (cmdParam, callback) {
+    if (!connectionStartCh.hasSubscribers) {
+      return getConnection.apply(this, arguments)
+    }
 
     const ctx = {}
+    const poolQueryAcquire = isPoolQueryAcquire()
+    const acquireCtx = !poolQueryAcquire && explicitPoolAcquire && acquireStartCh.hasSubscribers
+      ? { conf: this.opts.connOptions }
+      : undefined
+    const pool = this
+
+    if (acquireCtx !== undefined) {
+      acquireStartCh.publish(acquireCtx)
+    }
 
-    args[args.length - 1] = function (...args) {
-      return connectionFinishCh.runStores(ctx, cb, this, ...args)
+    /**
+     * @param {unknown} error
+     * @param {{ streamOut: object }|undefined} connection
+     * @returns {unknown}
+     */
+    arguments[1] = function wrappedCallback (error, connection) {
+      const poolWaitTime = poolQueryAcquire || acquireCtx !== undefined
+        ? finishPoolAcquireTiming(ctx)
+        : undefined
+
+      if (poolQueryAcquire) {
+        if (error) {
+          return runPoolAcquireError(
+            ctx.poolAcquireStartedAt,
+            error,
+            { conf: pool.opts.connOptions },
+            poolAcquireChannels,
+            ctx,
+            callback,
+            this,
+            arguments,
+            poolWaitTime
+          )
+        }
+
+        return runWithPoolWait(
+          poolWaitTransfer,
+          connection.streamOut,
+          poolWaitTime,
+          connectionFinishCh,
+          ctx,
+          callback,
+          this,
+          arguments
+        )
+      }
+
+      if (acquireCtx !== undefined) {
+        if (!error && connection !== undefined) {
+          clearPoolWaitTime(connection.streamOut)
+        }
+        acquireCtx.error = error
+        acquireCtx.poolWaitTime = poolWaitTime
+        return connectionFinishCh.runStores(
+          ctx,
+          finishExplicitPoolAcquire,
+          undefined,
+          acquireCtx,
+          callback,
+          this,
+          arguments
+        )
+      }
+      return connectionFinishCh.runStores(ctx, callback, this, ...arguments)
     }
 
     connectionStartCh.publish(ctx)
 
-    return getConnection.apply(this, args)
+    if (!poolQueryAcquire && acquireCtx === undefined) {
+      return getConnection.apply(pool, arguments)
+    }
+
+    const previousTiming = currentPoolAcquireTiming
+    const previousExplicitPoolAcquire = explicitPoolAcquire
+    currentPoolAcquireTiming = ctx
+    if (previousExplicitPoolAcquire) explicitPoolAcquire = false
+    try {
+      return poolQueryAcquire
+        ? runOutsidePoolQueryAcquire(getConnection, pool, arguments)
+        : getConnection.apply(pool, arguments)
+    } finally {
+      currentPoolAcquireTiming = previousTiming
+      if (previousExplicitPoolAcquire) explicitPoolAcquire = true
+    }
   }
 }
 
 const name = 'mariadb'
 
-addHook({ name, file: 'lib/cmd/query.js', versions: ['>=3'] }, (Query) => {
-  return wrapCommand(Query)
-})
+addHook({ name, file: 'lib/cmd/query.js', versions: ['>=3'], patchDefault: true }, wrapCommand)
+addHook({ name, file: 'lib/cmd/execute.js', versions: ['>=3'], patchDefault: true }, wrapCommand)
 
-addHook({ name, file: 'lib/cmd/execute.js', versions: ['>=3'] }, (Execute) => {
-  return wrapCommand(Execute)
-})
+// mariadb 3.4.1 switched its internal getConnection from promises to callbacks. That exposes synchronous
+// recent-idle reuse without a clock read while still letting us time validation and queueing.
+// The same release renamed _createConnection to _createPoolConnection.
+addHook({ name, file: 'lib/pool.js', versions: ['>=3.4.1'], patchDefault: true }, wrapInternalPool)
 
-// mariadb 3.4.1 refactored the pool: getConnection switched from promises to
-// callbacks and _createConnection was renamed to _createPoolConnection.
-addHook({ name, file: 'lib/pool.js', versions: ['>=3.4.1'] }, (Pool) => {
-  shimmer.wrap(Pool.prototype, 'getConnection', wrapPoolGetConnectionMethod)
-  shimmer.wrap(Pool.prototype, '_createPoolConnection', wrapPoolMethod)
-
-  return Pool
-})
+// Orchestrion completion follows the returned Promise, but operation classification must end as
+// soon as the facade calls its private internal pool, so these methods need a synchronous bracket.
+addHook({ name, file: 'lib/pool-promise.js', versions: ['>=3.4.1'], patchDefault: true }, wrapPublicPool)
+addHook({ name, file: 'lib/pool-callback.js', versions: ['>=3.4.1'], patchDefault: true }, wrapPublicPool)
 
-addHook({ name, file: 'lib/pool.js', versions: ['>=3 <3.4.1'] }, (Pool) => {
+addHook({ name, file: 'lib/pool.js', versions: ['>=3 <3.4.1'], patchDefault: true }, (Pool) => {
   shimmer.wrap(Pool.prototype, '_createConnection', wrapPoolMethod)
 
   return Pool