dd-trace 5.52.0 → 5.54.0

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

@@ -8,6 +8,7 @@ const {
   PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE
 } = require('../../dd-trace/src/plugins/util/test')
 const log = require('../../dd-trace/src/log')
+const { DD_MAJOR } = require('../../../version')
 
 const testStartCh = channel('ci:playwright:test:start')
 const testFinishCh = channel('ci:playwright:test:finish')
@@ -18,6 +19,8 @@ const testSessionFinishCh = channel('ci:playwright:session:finish')
 const libraryConfigurationCh = channel('ci:playwright:library-configuration')
 const knownTestsCh = channel('ci:playwright:known-tests')
 const testManagementTestsCh = channel('ci:playwright:test-management-tests')
+const impactedTestsCh = channel('ci:playwright:modified-tests')
+const isModifiedCh = channel('ci:playwright:test:is-modified')
 
 const testSuiteStartCh = channel('ci:playwright:test-suite:start')
 const testSuiteFinishCh = channel('ci:playwright:test-suite:finish')
@@ -25,8 +28,8 @@ const testSuiteFinishCh = channel('ci:playwright:test-suite:finish')
 const workerReportCh = channel('ci:playwright:worker:report')
 const testPageGotoCh = channel('ci:playwright:test:page-goto')
 
-const testToAr = new WeakMap()
-const testSuiteToAr = new Map()
+const testToCtx = new WeakMap()
+const testSuiteToCtx = new Map()
 const testSuiteToTestStatuses = new Map()
 const testSuiteToErrors = new Map()
 const testsToTestStatuses = new Map()
@@ -53,9 +56,11 @@ let knownTests = {}
 let isTestManagementTestsEnabled = false
 let testManagementAttemptToFixRetries = 0
 let testManagementTests = {}
+let isImpactedTestsEnabled = false
+let modifiedTests = {}
 const quarantinedOrDisabledTestsAttemptToFix = []
 let rootDir = ''
-const MINIMUM_SUPPORTED_VERSION_RANGE_EFD = '>=1.38.0'
+const MINIMUM_SUPPORTED_VERSION_RANGE_EFD = '>=1.38.0' // TODO: remove this once we drop support for v5
 
 function getTestProperties (test) {
   const testName = getTestFullname(test)
@@ -104,11 +109,7 @@ function deepCloneSuite (suite, filterTest, tags = []) {
 
 function getTestsBySuiteFromTestGroups (testGroups) {
   return testGroups.reduce((acc, { requireFile, tests }) => {
-    if (acc[requireFile]) {
-      acc[requireFile] = acc[requireFile].concat(tests)
-    } else {
-      acc[requireFile] = tests
-    }
+    acc[requireFile] = acc[requireFile] ? acc[requireFile].concat(tests) : tests
     return acc
   }, {})
 }
@@ -132,10 +133,10 @@ function getTestsBySuiteFromTestsById (testsById) {
 function getPlaywrightConfig (playwrightRunner) {
   try {
     return playwrightRunner._configLoader.fullConfig()
-  } catch (e) {
+  } catch {
     try {
       return playwrightRunner._loader.fullConfig()
-    } catch (e) {
+    } catch {
       return playwrightRunner._config || {}
     }
   }
@@ -235,14 +236,14 @@ function getTestByTestId (dispatcher, testId) {
   }
 }
 
-function getChannelPromise (channelToPublishTo) {
+function getChannelPromise (channelToPublishTo, params) {
   return new Promise(resolve => {
     testSessionAsyncResource.runInAsyncScope(() => {
-      channelToPublishTo.publish({ onDone: resolve })
+      channelToPublishTo.publish({ onDone: resolve, ...params })
     })
   })
 }
-// eslint-disable-next-line
+
 // Inspired by https://github.com/microsoft/playwright/blob/2b77ed4d7aafa85a600caa0b0d101b72c8437eeb/packages/playwright/src/reporters/base.ts#L293
 // We can't use test.outcome() directly because it's set on follow up handlers:
 // our `testEndHandler` is called before the outcome is set.
@@ -279,11 +280,9 @@ function testBeginHandler (test, browserName, isMainProcess) {
 
   if (isNewTestSuite) {
     startedSuites.push(testSuiteAbsolutePath)
-    const testSuiteAsyncResource = new AsyncResource('bound-anonymous-fn')
-    testSuiteToAr.set(testSuiteAbsolutePath, testSuiteAsyncResource)
-    testSuiteAsyncResource.runInAsyncScope(() => {
-      testSuiteStartCh.publish(testSuiteAbsolutePath)
-    })
+    const testSuiteCtx = { testSuiteAbsolutePath }
+    testSuiteToCtx.set(testSuiteAbsolutePath, testSuiteCtx)
+    testSuiteStartCh.runStores(testSuiteCtx, () => {})
   }
 
   // We disable retries by default if attemptToFix is true
@@ -293,19 +292,17 @@ function testBeginHandler (test, browserName, isMainProcess) {
 
   // this handles tests that do not go through the worker process (because they're skipped)
   if (isMainProcess) {
-    const testAsyncResource = new AsyncResource('bound-anonymous-fn')
-    testToAr.set(test, testAsyncResource)
     const testName = getTestFullname(test)
+    const testCtx = {
+      testName,
+      testSuiteAbsolutePath,
+      testSourceLine,
+      browserName,
+      isDisabled: test._ddIsDisabled
+    }
+    testToCtx.set(test, testCtx)
 
-    testAsyncResource.runInAsyncScope(() => {
-      testStartCh.publish({
-        testName,
-        testSuiteAbsolutePath,
-        testSourceLine,
-        browserName,
-        isDisabled: test._ddIsDisabled
-      })
-    })
+    testStartCh.runStores(testCtx, () => {})
   }
 }
 
@@ -337,7 +334,7 @@ function testEndHandler (test, annotations, testStatus, error, isTimeout, isMain
   }
 
   if (testStatuses.length === testManagementAttemptToFixRetries + 1) {
-    if (testStatuses.some(status => status === 'fail')) {
+    if (testStatuses.includes('fail')) {
       test._ddHasFailedAttemptToFixRetries = true
     }
     if (testStatuses.every(status => status === 'fail')) {
@@ -349,29 +346,29 @@ function testEndHandler (test, annotations, testStatus, error, isTimeout, isMain
 
   // this handles tests that do not go through the worker process (because they're skipped)
   if (isMainProcess) {
-    const testResult = results[results.length - 1]
-    const testAsyncResource = testToAr.get(test)
+    const testResult = results.at(-1)
+    const testCtx = testToCtx.get(test)
     const isAtrRetry = testResult?.retry > 0 &&
       isFlakyTestRetriesEnabled &&
       !test._ddIsAttemptToFix &&
       !test._ddIsEfdRetry
-    testAsyncResource.runInAsyncScope(() => {
-      testFinishCh.publish({
-        testStatus,
-        steps: testResult?.steps || [],
-        isRetry: testResult?.retry > 0,
-        error,
-        extraTags: annotationTags,
-        isNew: test._ddIsNew,
-        isAttemptToFix: test._ddIsAttemptToFix,
-        isAttemptToFixRetry: test._ddIsAttemptToFixRetry,
-        isQuarantined: test._ddIsQuarantined,
-        isEfdRetry: test._ddIsEfdRetry,
-        hasFailedAllRetries: test._ddHasFailedAllRetries,
-        hasPassedAttemptToFixRetries: test._ddHasPassedAttemptToFixRetries,
-        hasFailedAttemptToFixRetries: test._ddHasFailedAttemptToFixRetries,
-        isAtrRetry
-      })
+    testFinishCh.publish({
+      testStatus,
+      steps: testResult?.steps || [],
+      isRetry: testResult?.retry > 0,
+      error,
+      extraTags: annotationTags,
+      isNew: test._ddIsNew,
+      isAttemptToFix: test._ddIsAttemptToFix,
+      isAttemptToFixRetry: test._ddIsAttemptToFixRetry,
+      isQuarantined: test._ddIsQuarantined,
+      isEfdRetry: test._ddIsEfdRetry,
+      hasFailedAllRetries: test._ddHasFailedAllRetries,
+      hasPassedAttemptToFixRetries: test._ddHasPassedAttemptToFixRetries,
+      hasFailedAttemptToFixRetries: test._ddHasFailedAttemptToFixRetries,
+      isAtrRetry,
+      isModified: test._ddIsModified,
+      ...testCtx.currentStore
     })
   }
 
@@ -394,17 +391,15 @@ function testEndHandler (test, annotations, testStatus, error, isTimeout, isMain
   if (!remainingTestsByFile[testSuiteAbsolutePath].length) {
     const testStatuses = testSuiteToTestStatuses.get(testSuiteAbsolutePath)
     let testSuiteStatus = 'pass'
-    if (testStatuses.some(status => status === 'fail')) {
+    if (testStatuses.includes('fail')) {
       testSuiteStatus = 'fail'
     } else if (testStatuses.every(status => status === 'skip')) {
       testSuiteStatus = 'skip'
     }
 
     const suiteError = getTestSuiteError(testSuiteAbsolutePath)
-    const testSuiteAsyncResource = testSuiteToAr.get(testSuiteAbsolutePath)
-    testSuiteAsyncResource.runInAsyncScope(() => {
-      testSuiteFinishCh.publish({ status: testSuiteStatus, error: suiteError })
-    })
+    const testSuiteCtx = testSuiteToCtx.get(testSuiteAbsolutePath)
+    testSuiteFinishCh.publish({ status: testSuiteStatus, error: suiteError, ...testSuiteCtx.currentStore })
   }
 }
 
@@ -420,7 +415,7 @@ function dispatcherRunWrapperNew (run) {
     if (!this._allTests) {
       // Removed in https://github.com/microsoft/playwright/commit/1e52c37b254a441cccf332520f60225a5acc14c7
       // Not available from >=1.44.0
-      this._ddAllTests = testGroups.map(g => g.tests).flat()
+      this._ddAllTests = testGroups.flatMap(g => g.tests)
     }
     remainingTestsByFile = getTestsBySuiteFromTestGroups(arguments[0])
     return run.apply(this, arguments)
@@ -442,7 +437,7 @@ function dispatcherHook (dispatcherExport) {
         const { test } = dispatcher._testById.get(params.testId)
 
         const { results } = test
-        const testResult = results[results.length - 1]
+        const testResult = results.at(-1)
 
         const isTimeout = testResult.status === 'timedOut'
         testEndHandler(
@@ -478,7 +473,7 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
 
       const isTimeout = status === 'timedOut'
       testEndHandler(test, annotations, STATUS_TO_TEST_STATUS[status], errors && errors[0], isTimeout, false)
-      const testResult = test.results[test.results.length - 1]
+      const testResult = test.results.at(-1)
       const isAtrRetry = testResult?.retry > 0 &&
         isFlakyTestRetriesEnabled &&
         !test._ddIsAttemptToFix &&
@@ -497,7 +492,8 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
           _ddHasFailedAllRetries: test._ddHasFailedAllRetries,
           _ddHasPassedAttemptToFixRetries: test._ddHasPassedAttemptToFixRetries,
           _ddHasFailedAttemptToFixRetries: test._ddHasFailedAttemptToFixRetries,
-          _ddIsAtrRetry: isAtrRetry
+          _ddIsAtrRetry: isAtrRetry,
+          _ddIsModified: test._ddIsModified
         }
       })
     })
@@ -529,22 +525,24 @@ function runnerHook (runnerExport, playwrightVersion) {
         flakyTestRetriesCount = libraryConfig.flakyTestRetriesCount
         isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
         testManagementAttemptToFixRetries = libraryConfig.testManagementAttemptToFixRetries
+        isImpactedTestsEnabled = libraryConfig.isImpactedTestsEnabled
       }
     } catch (e) {
       isEarlyFlakeDetectionEnabled = false
       isKnownTestsEnabled = false
       isTestManagementTestsEnabled = false
+      isImpactedTestsEnabled = false
       log.error('Playwright session start error', e)
     }
 
     if (isKnownTestsEnabled && satisfies(playwrightVersion, MINIMUM_SUPPORTED_VERSION_RANGE_EFD)) {
       try {
         const { err, knownTests: receivedKnownTests } = await getChannelPromise(knownTestsCh)
-        if (!err) {
-          knownTests = receivedKnownTests
-        } else {
+        if (err) {
           isEarlyFlakeDetectionEnabled = false
           isKnownTestsEnabled = false
+        } else {
+          knownTests = receivedKnownTests
         }
       } catch (err) {
         isEarlyFlakeDetectionEnabled = false
@@ -556,10 +554,10 @@ function runnerHook (runnerExport, playwrightVersion) {
     if (isTestManagementTestsEnabled && satisfies(playwrightVersion, MINIMUM_SUPPORTED_VERSION_RANGE_EFD)) {
       try {
         const { err, testManagementTests: receivedTestManagementTests } = await getChannelPromise(testManagementTestsCh)
-        if (!err) {
-          testManagementTests = receivedTestManagementTests
-        } else {
+        if (err) {
           isTestManagementTestsEnabled = false
+        } else {
+          testManagementTests = receivedTestManagementTests
         }
       } catch (err) {
         isTestManagementTestsEnabled = false
@@ -567,6 +565,20 @@ function runnerHook (runnerExport, playwrightVersion) {
       }
     }
 
+    if (isImpactedTestsEnabled && satisfies(playwrightVersion, MINIMUM_SUPPORTED_VERSION_RANGE_EFD)) {
+      try {
+        const { err, modifiedTests: receivedModifiedTests } = await getChannelPromise(impactedTestsCh)
+        if (err) {
+          isImpactedTestsEnabled = false
+        } else {
+          modifiedTests = receivedModifiedTests
+        }
+      } catch (err) {
+        isImpactedTestsEnabled = false
+        log.error('Playwright impacted tests error', err)
+      }
+    }
+
     const projects = getProjectsFromRunner(this)
 
     const shouldSetRetries = isFlakyTestRetriesEnabled &&
@@ -610,7 +622,7 @@ function runnerHook (runnerExport, playwrightVersion) {
         totalAttemptToFixFailedTestCount += testStatuses.filter(status => status === 'fail').length
       }
 
-      if (totalFailedTestCount === totalAttemptToFixFailedTestCount) {
+      if (totalFailedTestCount > 0 && totalFailedTestCount === totalAttemptToFixFailedTestCount) {
         runAllTestsReturn = 'passed'
       }
     }
@@ -639,37 +651,38 @@ function runnerHook (runnerExport, playwrightVersion) {
   return runnerExport
 }
 
-addHook({
-  name: '@playwright/test',
-  file: 'lib/runner.js',
-  versions: ['>=1.18.0 <=1.30.0']
-}, runnerHook)
-
-addHook({
-  name: '@playwright/test',
-  file: 'lib/dispatcher.js',
-  versions: ['>=1.18.0 <1.30.0']
-}, dispatcherHook)
-
-addHook({
-  name: '@playwright/test',
-  file: 'lib/dispatcher.js',
-  versions: ['>=1.30.0 <1.31.0']
-}, (dispatcher) => dispatcherHookNew(dispatcher, dispatcherRunWrapper))
-
-addHook({
-  name: '@playwright/test',
-  file: 'lib/runner/dispatcher.js',
-  versions: ['>=1.31.0 <1.38.0']
-}, (dispatcher) => dispatcherHookNew(dispatcher, dispatcherRunWrapperNew))
-
-addHook({
-  name: '@playwright/test',
-  file: 'lib/runner/runner.js',
-  versions: ['>=1.31.0 <1.38.0']
-}, runnerHook)
+if (DD_MAJOR < 6) { // <1.38.0 is only supported up to version 5
+  addHook({
+    name: '@playwright/test',
+    file: 'lib/runner.js',
+    versions: ['>=1.18.0 <=1.30.0']
+  }, runnerHook)
+
+  addHook({
+    name: '@playwright/test',
+    file: 'lib/dispatcher.js',
+    versions: ['>=1.18.0 <1.30.0']
+  }, dispatcherHook)
+
+  addHook({
+    name: '@playwright/test',
+    file: 'lib/dispatcher.js',
+    versions: ['>=1.30.0 <1.31.0']
+  }, (dispatcher) => dispatcherHookNew(dispatcher, dispatcherRunWrapper))
+
+  addHook({
+    name: '@playwright/test',
+    file: 'lib/runner/dispatcher.js',
+    versions: ['>=1.31.0 <1.38.0']
+  }, (dispatcher) => dispatcherHookNew(dispatcher, dispatcherRunWrapperNew))
+
+  addHook({
+    name: '@playwright/test',
+    file: 'lib/runner/runner.js',
+    versions: ['>=1.31.0 <1.38.0']
+  }, runnerHook)
+}
 
-// From >=1.38.0
 addHook({
   name: 'playwright',
   file: 'lib/runner/runner.js',
@@ -682,11 +695,10 @@ addHook({
   versions: ['>=1.38.0']
 }, (dispatcher) => dispatcherHookNew(dispatcher, dispatcherRunWrapperNew))
 
-// Hook used for early flake detection. EFD only works from >=1.38.0
 addHook({
   name: 'playwright',
   file: 'lib/common/suiteUtils.js',
-  versions: [MINIMUM_SUPPORTED_VERSION_RANGE_EFD]
+  versions: ['>=1.38.0']
 }, suiteUtilsPackage => {
   // We grab `applyRepeatEachIndex` to use it later
   // `applyRepeatEachIndex` needs to be applied to a cloned suite
@@ -694,16 +706,15 @@ addHook({
   return suiteUtilsPackage
 })
 
-// Hook used for early flake detection. EFD only works from >=1.38.0
 addHook({
   name: 'playwright',
   file: 'lib/runner/loadUtils.js',
-  versions: [MINIMUM_SUPPORTED_VERSION_RANGE_EFD]
+  versions: ['>=1.38.0']
 }, (loadUtilsPackage) => {
   const oldCreateRootSuite = loadUtilsPackage.createRootSuite
 
   async function newCreateRootSuite () {
-    if (!isKnownTestsEnabled && !isTestManagementTestsEnabled) {
+    if (!isKnownTestsEnabled && !isTestManagementTestsEnabled && !isImpactedTestsEnabled) {
       return oldCreateRootSuite.apply(this, arguments)
     }
     const rootSuite = await oldCreateRootSuite.apply(this, arguments)
@@ -742,13 +753,41 @@ addHook({
       }
     }
 
+    if (isImpactedTestsEnabled) {
+      for (const test of allTests) {
+        const isNew = isKnownTestsEnabled && isNewTest(test)
+        const { isModified } = await getChannelPromise(isModifiedCh, {
+          filePath: test._requireFile,
+          modifiedTests
+        })
+        if (isModified) {
+          test._ddIsModified = true
+        }
+        if (isEarlyFlakeDetectionEnabled && test.expectedStatus !== 'skipped') {
+          const fileSuite = getSuiteType(test, 'file')
+          const projectSuite = getSuiteType(test, 'project')
+          // If something change in the file, all tests in the file are impacted
+          const isModifiedTest = () => isModified
+          for (let repeatEachIndex = 1; repeatEachIndex <= earlyFlakeDetectionNumRetries; repeatEachIndex++) {
+            const copyFileSuite = deepCloneSuite(fileSuite, isModifiedTest, [
+              isNew && '_ddIsNew',
+              '_ddIsModified',
+              '_ddIsEfdRetry'
+            ])
+            applyRepeatEachIndex(projectSuite._fullProject, copyFileSuite, repeatEachIndex + 1)
+            projectSuite._addSuite(copyFileSuite)
+          }
+        }
+      }
+    }
+
     if (isKnownTestsEnabled) {
       const newTests = allTests.filter(isNewTest)
 
       for (const newTest of newTests) {
         // No need to filter out attempt to fix tests here because attempt to fix tests are never new
         newTest._ddIsNew = true
-        if (isEarlyFlakeDetectionEnabled && newTest.expectedStatus !== 'skipped') {
+        if (isEarlyFlakeDetectionEnabled && newTest.expectedStatus !== 'skipped' && !newTest._ddIsModified) {
           const fileSuite = getSuiteType(newTest, 'file')
           const projectSuite = getSuiteType(newTest, 'project')
           for (let repeatEachIndex = 1; repeatEachIndex <= earlyFlakeDetectionNumRetries; repeatEachIndex++) {
@@ -821,11 +860,7 @@ addHook({
     try {
       if (page) {
         const isRumActive = await page.evaluate(() => {
-          if (window.DD_RUM && window.DD_RUM.getInternalContext) {
-            return !!window.DD_RUM.getInternalContext()
-          } else {
-            return false
-          }
+          return window.DD_RUM && window.DD_RUM.getInternalContext ? !!window.DD_RUM.getInternalContext() : false
         })
 
         if (isRumActive) {
@@ -835,7 +870,7 @@ addHook({
           })
         }
       }
-    } catch (e) {
+    } catch {
       // ignore errors such as redirects, context destroyed, etc
     }
 
@@ -873,17 +908,16 @@ addHook({
     // If test events are created in the worker process I need to stop creating it in the main process
     // Probably yet another test worker exporter is needed in addition to the ones for mocha, jest and cucumber
     // it's probably hard to tell that's a playwright worker though, as I don't think there is a specific env variable
-    const testAsyncResource = new AsyncResource('bound-anonymous-fn')
+    const testCtx = {
+      testName,
+      testSuiteAbsolutePath,
+      testSourceLine,
+      browserName
+    }
+    testToCtx.set(test, testCtx)
     // TODO - In the future we may need to implement a mechanism to send test properties
     // to the worker process before _runTest is called
-    testAsyncResource.runInAsyncScope(() => {
-      testStartCh.publish({
-        testName,
-        testSuiteAbsolutePath,
-        testSourceLine,
-        browserName
-      })
-
+    testStartCh.runStores(testCtx, () => {
       let existAfterEachHook = false
 
       // We try to find an existing afterEach hook with _ddHook to avoid adding a new one
@@ -924,7 +958,7 @@ addHook({
                   }
                 }
               }
-            } catch (e) {
+            } catch {
               // ignore errors
             }
           },
@@ -976,25 +1010,25 @@ addHook({
     // Wait for the properties to be received
     await ddPropertiesPromise
 
-    testAsyncResource.runInAsyncScope(() => {
-      testFinishCh.publish({
-        testStatus: STATUS_TO_TEST_STATUS[status],
-        steps: steps.filter(step => step.testId === testId),
-        error,
-        extraTags: annotationTags,
-        isNew: test._ddIsNew,
-        isRetry: retry > 0,
-        isEfdRetry: test._ddIsEfdRetry,
-        isAttemptToFix: test._ddIsAttemptToFix,
-        isDisabled: test._ddIsDisabled,
-        isQuarantined: test._ddIsQuarantined,
-        isAttemptToFixRetry: test._ddIsAttemptToFixRetry,
-        hasFailedAllRetries: test._ddHasFailedAllRetries,
-        hasPassedAttemptToFixRetries: test._ddHasPassedAttemptToFixRetries,
-        hasFailedAttemptToFixRetries: test._ddHasFailedAttemptToFixRetries,
-        isAtrRetry: test._ddIsAtrRetry,
-        onDone
-      })
+    testFinishCh.publish({
+      testStatus: STATUS_TO_TEST_STATUS[status],
+      steps: steps.filter(step => step.testId === testId),
+      error,
+      extraTags: annotationTags,
+      isNew: test._ddIsNew,
+      isRetry: retry > 0,
+      isEfdRetry: test._ddIsEfdRetry,
+      isAttemptToFix: test._ddIsAttemptToFix,
+      isDisabled: test._ddIsDisabled,
+      isQuarantined: test._ddIsQuarantined,
+      isAttemptToFixRetry: test._ddIsAttemptToFixRetry,
+      hasFailedAllRetries: test._ddHasFailedAllRetries,
+      hasPassedAttemptToFixRetries: test._ddHasPassedAttemptToFixRetries,
+      hasFailedAttemptToFixRetries: test._ddHasFailedAttemptToFixRetries,
+      isAtrRetry: test._ddIsAtrRetry,
+      isModified: test._ddIsModified,
+      onDone,
+      ...testCtx.currentStore
     })
 
     await flushPromise

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

@@ -47,7 +47,7 @@ function wrapCommandQueueClass (cls) {
           if (parsed) {
             this._url = { host: parsed.hostname, port: +parsed.port || 6379 }
           }
-        } catch (error) {
+        } catch {
           // ignore
         }
       }
@@ -130,8 +130,8 @@ addHook({ name: 'redis', versions: ['>=0.12 <2.6'] }, redis => {
       if (typeof callback === 'function') {
         const cb = callbackResource.bind(callback)
         arguments[2] = asyncResource.bind(wrapCallback(finishCh, errorCh, cb))
-      } else if (Array.isArray(args) && typeof args[args.length - 1] === 'function') {
-        const cb = callbackResource.bind(args[args.length - 1])
+      } else if (Array.isArray(args) && typeof args.at(-1) === 'function') {
+        const cb = callbackResource.bind(args.at(-1))
         args[args.length - 1] = asyncResource.bind(wrapCallback(finishCh, errorCh, cb))
       } else {
         arguments[2] = asyncResource.bind(wrapCallback(finishCh, errorCh))

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

@@ -20,8 +20,8 @@ function wrapSetupRequest (setupRequest) {
 }
 
 function wrapMethod (method) {
-  return function (path) {
-    const middleware = wrapMiddleware(Array.prototype.slice.call(arguments, 1))
+  return function (path, ...rest) {
+    const middleware = wrapMiddleware(rest)
 
     return method.apply(this, [path].concat(middleware))
   }