dd-trace 5.100.0 → 5.102.0

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

@@ -1,5 +1,7 @@
 'use strict'
 
+const { performance } = require('node:perf_hooks')
+
 const { createCoverageMap } = require('../../../vendor/dist/istanbul-lib-coverage')
 const shimmer = require('../../datadog-shimmer')
 const log = require('../../dd-trace/src/log')
@@ -12,6 +14,7 @@ const {
   getTestSuitePath,
   CUCUMBER_WORKER_TRACE_PAYLOAD_CODE,
   getIsFaultyEarlyFlakeDetection,
+  getEfdRetryCount,
   recordAttemptToFixExecution,
   collectAttemptToFixExecutionsFromTraces,
   logAttemptToFixTestExecution,
@@ -62,6 +65,9 @@ const lastStatusByPickleId = new Map()
 /** For ATR: statuses keyed by stable scenario id (uri:name) so retries accumulate correctly */
 const atrStatusesByScenarioKey = new Map()
 const numRetriesByPickleId = new Map()
+const efdRetryCountByPickleId = new Map()
+const efdSlowAbortedPickleIds = new Set()
+const testCaseStartedTimesById = new Map()
 const numAttemptToCtx = new Map()
 const newTestsByTestFullname = new Map()
 const attemptToFixTestsByTestFullname = new Map()
@@ -82,6 +88,7 @@ let isUnskippable = false
 let isSuitesSkippingEnabled = false
 let isEarlyFlakeDetectionEnabled = false
 let earlyFlakeDetectionNumRetries = 0
+let earlyFlakeDetectionSlowTestRetries = {}
 let earlyFlakeDetectionFaultyThreshold = 0
 let isEarlyFlakeDetectionFaulty = false
 let isFlakyTestRetriesEnabled = false
@@ -290,9 +297,9 @@ function wrapRun (pl, isLatestVersion, version) {
 
   patched.add(pl)
 
-  shimmer.wrap(pl.prototype, 'run', run => function () {
+  shimmer.wrap(pl.prototype, 'run', run => function (...args) {
     if (!testFinishCh.hasSubscribers) {
-      return run.apply(this, arguments)
+      return run.apply(this, args)
     }
 
     let numAttempt = 0
@@ -360,9 +367,10 @@ function wrapRun (pl, isLatestVersion, version) {
       }
       this.eventBroadcaster.on('envelope', onEnvelope)
       let promise
+      const executionStart = performance.now()
 
       testFnCh.runStores(ctx, () => {
-        promise = run.apply(this, arguments)
+        promise = run.apply(this, args)
       })
       promise.finally(async () => {
         this.eventBroadcaster.removeListener('envelope', onEnvelope)
@@ -424,15 +432,31 @@ function wrapRun (pl, isLatestVersion, version) {
           isEfdRetry = numRetries > 0
         }
 
+        if (
+          isEarlyFlakeDetectionEnabled &&
+          status !== 'skip' &&
+          (isNew || isModified) &&
+          !isEfdRetry &&
+          !efdRetryCountByPickleId.has(this.pickle.id)
+        ) {
+          const retryCount = getEfdRetryCount(performance.now() - executionStart, earlyFlakeDetectionSlowTestRetries)
+          efdRetryCountByPickleId.set(this.pickle.id, retryCount)
+          if (retryCount === 0) {
+            efdSlowAbortedPickleIds.add(this.pickle.id)
+          }
+        }
+
+        const efdRetryCount = efdRetryCountByPickleId.get(this.pickle.id) ?? earlyFlakeDetectionNumRetries
+
         // Check if all EFD retries failed
         if (isEfdRetry && (isNew || isModified)) {
           const statuses = lastStatusByPickleId.get(this.pickle.id)
-          if (statuses.length === earlyFlakeDetectionNumRetries + 1) {
+          if (statuses.length === efdRetryCount + 1) {
             const { fail } = statuses.reduce((acc, status) => {
               acc[status]++
               return acc
             }, { pass: 0, fail: 0 })
-            if (fail === earlyFlakeDetectionNumRetries + 1) {
+            if (fail === efdRetryCount + 1) {
               hasFailedAllRetries = true
             }
           }
@@ -480,7 +504,7 @@ function wrapRun (pl, isLatestVersion, version) {
         const isLastAtrRetry = isFlakyTestRetriesEnabled && !isAttemptToFix && !isEfdRetry && numTestRetries > 0
 
         const statuses = lastStatusByPickleId.get(this.pickle.id)
-        const isLastEfdRetry = isEfdRetry && statuses?.length === earlyFlakeDetectionNumRetries + 1
+        const isLastEfdRetry = isEfdRetry && statuses?.length === efdRetryCount + 1
         const isLastAttemptToFixRetry = isAttemptToFix && statuses?.length === testManagementAttemptToFixRetries + 1
 
         // Intermediate (non-last EFD or ATF retries) executions do not report a final status
@@ -514,6 +538,7 @@ function wrapRun (pl, isLatestVersion, version) {
           isDisabled,
           isQuarantined,
           isModified,
+          earlyFlakeAbortReason: efdSlowAbortedPickleIds.has(this.pickle.id) ? 'slow' : undefined,
           ...attemptCtx.currentStore,
           finalStatus,
         })
@@ -526,11 +551,11 @@ function wrapRun (pl, isLatestVersion, version) {
       })
     }
   })
-  shimmer.wrap(pl.prototype, 'runStep', runStep => function () {
+  shimmer.wrap(pl.prototype, 'runStep', runStep => function (...args) {
     if (!testFinishCh.hasSubscribers) {
-      return runStep.apply(this, arguments)
+      return runStep.apply(this, args)
     }
-    const testStep = arguments[0]
+    const testStep = args[0]
     let resource
 
     if (isLatestVersion) {
@@ -542,7 +567,7 @@ function wrapRun (pl, isLatestVersion, version) {
     const ctx = { resource }
     return testStepStartCh.runStores(ctx, () => {
       try {
-        const promise = runStep.apply(this, arguments)
+        const promise = runStep.apply(this, args)
 
         promise.then((result) => {
           const finalResult = satisfies(version, '>=12.0.0') ? result.result : result
@@ -603,6 +628,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
 
     isEarlyFlakeDetectionEnabled = configurationResponse.libraryConfig?.isEarlyFlakeDetectionEnabled
     earlyFlakeDetectionNumRetries = configurationResponse.libraryConfig?.earlyFlakeDetectionNumRetries
+    earlyFlakeDetectionSlowTestRetries = configurationResponse.libraryConfig?.earlyFlakeDetectionSlowTestRetries ?? {}
     earlyFlakeDetectionFaultyThreshold = configurationResponse.libraryConfig?.earlyFlakeDetectionFaultyThreshold
     isSuitesSkippingEnabled = configurationResponse.libraryConfig?.isSuitesSkippingEnabled
     isFlakyTestRetriesEnabled = configurationResponse.libraryConfig?.isFlakyTestRetriesEnabled
@@ -692,6 +718,10 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
 
     atrStatusesByScenarioKey.clear()
     attemptToFixTestsByTestFullname.clear()
+    efdRetryCountByPickleId.clear()
+    efdSlowAbortedPickleIds.clear()
+    testCaseStartedTimesById.clear()
+    newTestsByTestFullname.clear()
     sessionStartCh.publish({ command, frameworkVersion })
 
     if (!errorSkippableRequest && skippedSuites.length) {
@@ -816,7 +846,9 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       }
     }
     // TODO: for >=11 we could use `runTestCaseResult` instead of accumulating results in `lastStatusByPickleId`
+    const firstExecutionStart = performance.now()
     let runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
+    const firstExecutionDurationMs = performance.now() - firstExecutionStart
 
     // Restore dryRun so it doesn't affect subsequent tests in the same worker
     this.options.dryRun = originalDryRun
@@ -835,7 +867,15 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
 
     // If it's a new test and it hasn't been skipped, we run it again
     if (isEarlyFlakeDetectionEnabled && lastTestStatus !== 'skip' && (isNew || isModified)) {
-      for (let retryIndex = 0; retryIndex < earlyFlakeDetectionNumRetries; retryIndex++) {
+      let efdRetryCount = efdRetryCountByPickleId.get(pickle.id)
+      if (efdRetryCount === undefined) {
+        efdRetryCount = getEfdRetryCount(firstExecutionDurationMs, earlyFlakeDetectionSlowTestRetries)
+        efdRetryCountByPickleId.set(pickle.id, efdRetryCount)
+        if (efdRetryCount === 0) {
+          efdSlowAbortedPickleIds.add(pickle.id)
+        }
+      }
+      for (let retryIndex = 0; retryIndex < efdRetryCount; retryIndex++) {
         numRetriesByPickleId.set(pickle.id, retryIndex + 1)
         // eslint-disable-next-line no-await-in-loop
         runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
@@ -952,6 +992,9 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
     let pickle
 
     if (parsed.testCaseStarted) {
+      if (parsed.testCaseStarted.id) {
+        testCaseStartedTimesById.set(parsed.testCaseStarted.id, performance.now())
+      }
       if (isNewVersion) {
         pickle = this.inProgress[worker.id].pickle
       } else {
@@ -973,6 +1016,10 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
 
     // after calling `parseWorkerMessageFunction`, the test status can already be read
     if (parsed.testCaseFinished) {
+      const testCaseStartedId = parsed.testCaseFinished.testCaseStartedId
+      const testCaseStartedAt = testCaseStartedTimesById.get(testCaseStartedId)
+      testCaseStartedTimesById.delete(testCaseStartedId)
+
       let worstTestStepResult
       if (isNewVersion && eventDataCollector) {
         pickle = this.inProgress[worker.id].pickle
@@ -1003,8 +1050,19 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
           testStatuses = [status]
           newTestsByTestFullname.set(testFullname, testStatuses)
         }
+        let efdRetryCount = efdRetryCountByPickleId.get(pickle.id)
+        if (efdRetryCount === undefined) {
+          const firstExecutionDurationMs = testCaseStartedAt === undefined ? 0 : performance.now() - testCaseStartedAt
+          efdRetryCount = status === 'skip'
+            ? 0
+            : getEfdRetryCount(firstExecutionDurationMs, earlyFlakeDetectionSlowTestRetries)
+          efdRetryCountByPickleId.set(pickle.id, efdRetryCount)
+          if (efdRetryCount === 0 && status !== 'skip') {
+            efdSlowAbortedPickleIds.add(pickle.id)
+          }
+        }
         // We have finished all retries
-        if (testStatuses.length === earlyFlakeDetectionNumRetries + 1) {
+        if (testStatuses.length === efdRetryCount + 1) {
           const newTestFinalStatus = getTestStatusFromRetries(testStatuses)
           // we only push to `finished` if the retries have finished
           finished.push(newTestFinalStatus)
@@ -1143,9 +1201,9 @@ addHook({
   versions: ['>=11.0.0'],
   file: 'lib/formatter/helpers/event_data_collector.js',
 }, (eventDataCollectorPackage) => {
-  shimmer.wrap(eventDataCollectorPackage.default.prototype, 'parseEnvelope', parseEnvelope => function () {
+  shimmer.wrap(eventDataCollectorPackage.default.prototype, 'parseEnvelope', parseEnvelope => function (...args) {
     eventDataCollector = this
-    return parseEnvelope.apply(this, arguments)
+    return parseEnvelope.apply(this, args)
   })
   return eventDataCollectorPackage
 })
@@ -1164,18 +1222,20 @@ addHook({
     parseWorkerMessage => getWrappedParseWorkerMessage(parseWorkerMessage, true)
   )
   // EFD in parallel mode only supported in >=11.0.0
-  shimmer.wrap(adapterPackage.ChildProcessAdapter.prototype, 'startWorker', startWorker => function () {
+  shimmer.wrap(adapterPackage.ChildProcessAdapter.prototype, 'startWorker', startWorker => function (...args) {
     if (isKnownTestsEnabled && isValidKnownTests(knownTests)) {
       this.options.worldParameters._ddIsKnownTestsEnabled = true
       this.options.worldParameters._ddIsEarlyFlakeDetectionEnabled = isEarlyFlakeDetectionEnabled
       this.options.worldParameters._ddKnownTests = knownTests
       this.options.worldParameters._ddEarlyFlakeDetectionNumRetries = earlyFlakeDetectionNumRetries
+      this.options.worldParameters._ddEarlyFlakeDetectionSlowTestRetries = earlyFlakeDetectionSlowTestRetries
     } else {
       isEarlyFlakeDetectionEnabled = false
       isKnownTestsEnabled = false
       this.options.worldParameters._ddIsEarlyFlakeDetectionEnabled = false
       this.options.worldParameters._ddIsKnownTestsEnabled = false
       this.options.worldParameters._ddEarlyFlakeDetectionNumRetries = 0
+      this.options.worldParameters._ddEarlyFlakeDetectionSlowTestRetries = {}
     }
 
     if (isImpactedTestsEnabled) {
@@ -1192,7 +1252,7 @@ addHook({
       this.options.worldParameters._ddTestManagementAttemptToFixRetries = testManagementAttemptToFixRetries
     }
 
-    return startWorker.apply(this, arguments)
+    return startWorker.apply(this, args)
   })
   return adapterPackage
 })
@@ -1222,6 +1282,7 @@ addHook({
       isEarlyFlakeDetectionEnabled = !!this.options.worldParameters._ddIsEarlyFlakeDetectionEnabled
       if (isEarlyFlakeDetectionEnabled) {
         earlyFlakeDetectionNumRetries = this.options.worldParameters._ddEarlyFlakeDetectionNumRetries
+        earlyFlakeDetectionSlowTestRetries = this.options.worldParameters._ddEarlyFlakeDetectionSlowTestRetries ?? {}
       }
       isImpactedTestsEnabled = !!this.options.worldParameters._ddImpactedTestsEnabled
       if (isImpactedTestsEnabled) {

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

@@ -8,11 +8,13 @@ const {
   wrapConfig,
 } = require('./cypress-config')
 
+const MINIMUM_CYPRESS_VERSION = DD_MAJOR >= 6 ? '>=12.0.0' : '>=10.2.0'
+
 // Wrap defineConfig() so configs are instrumented when loaded in Cypress's
 // config child process. This covers both CLI and programmatic usage with CJS configs.
 addHook({
   name: 'cypress',
-  versions: ['>=10.2.0'],
+  versions: [MINIMUM_CYPRESS_VERSION],
 }, (cypress) => {
   if (typeof cypress.defineConfig === 'function') {
     shimmer.wrap(cypress, 'defineConfig', (defineConfig) => function (config) {
@@ -61,7 +63,7 @@ function wrapStartOnModule (mod) {
 for (const file of ['lib/exec/run.js', 'lib/exec/open.js', 'dist/exec/run.js', 'dist/exec/open.js']) {
   addHook({
     name: 'cypress',
-    versions: ['>=10.2.0'],
+    versions: [MINIMUM_CYPRESS_VERSION],
     file,
   }, wrapStartOnModule)
 }
@@ -70,7 +72,7 @@ for (const file of ['lib/exec/run.js', 'lib/exec/open.js', 'dist/exec/run.js', '
 // The chunk exports runModule and openModule, each with a start() method.
 addHook({
   name: 'cypress',
-  versions: ['>=10.2.0'],
+  versions: [MINIMUM_CYPRESS_VERSION],
   filePattern: 'dist/cli.*',
 }, (cliChunk) => {
   if (cliChunk.runModule?.start) {

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

@@ -18,8 +18,6 @@ const rrtypes = {
   resolveSoa: 'SOA',
 }
 
-const rrtypeMap = new WeakMap()
-
 addHook({ name: 'dns' }, dns => {
   const lookup = createCallbackInstrumentor('apm:dns:lookup', { captureResult: true })
   const lookupService = createCallbackInstrumentor('apm:dns:lookup_service', { captureResult: true })
@@ -46,7 +44,6 @@ addHook({ name: 'dns' }, dns => {
 function patchResolveShorthands (prototype, resolve) {
   for (const method of Object.keys(rrtypes)) {
     if (prototype[method]) {
-      rrtypeMap.set(prototype[method], rrtypes[method])
       shimmer.wrap(prototype, method, resolve(buildArgsContext(rrtypes[method])))
     }
   }

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

@@ -24,24 +24,21 @@ function wrapTransportPrototype (Transport) {
 addHook({ name: '@elastic/elasticsearch', file: 'lib/Transport.js', versions: ['>=5.6.16 <8', '>=8'] }, Transport => {
   shimmer.wrap(Transport.prototype, 'request', createWrapRequest('elasticsearch'))
   shimmer.wrap(Transport.prototype, 'getConnection', createWrapGetConnection('elasticsearch'))
-  return Transport
 })
 
 addHook({ name: 'elasticsearch', file: 'src/lib/transport.js', versions: ['>=10'] }, Transport => {
   shimmer.wrap(Transport.prototype, 'request', createWrapRequest('elasticsearch'))
-  return Transport
 })
 
 addHook({ name: 'elasticsearch', file: 'src/lib/connection_pool.js', versions: ['>=10'] }, ConnectionPool => {
-  shimmer.wrap(ConnectionPool.prototype, 'select', createWrapSelect('elasticsearch'))
-  return ConnectionPool
+  shimmer.wrap(ConnectionPool.prototype, 'select', createWrapSelect())
 })
 
 function createWrapGetConnection (name) {
   const connectCh = channel(`apm:${name}:query:connect`)
   return function wrapRequest (request) {
-    return function () {
-      const connection = request.apply(this, arguments)
+    return function (...args) {
+      const connection = request.apply(this, args)
       if (connectCh.hasSubscribers && connection && connection.url) {
         connectCh.publish(connection.url)
       }
@@ -53,17 +50,17 @@ function createWrapGetConnection (name) {
 function createWrapSelect () {
   const connectCh = channel('apm:elasticsearch:query:connect')
   return function wrapRequest (request) {
-    return function () {
-      if (arguments.length === 1) {
-        const cb = arguments[0]
-        arguments[0] = shimmer.wrapFunction(cb, cb => function (err, connection) {
+    return function (...args) {
+      if (args.length === 1) {
+        const cb = args[0]
+        args[0] = shimmer.wrapFunction(cb, cb => function (err, connection) {
           if (connectCh.hasSubscribers && connection && connection.host) {
             connectCh.publish({ hostname: connection.host.host, port: connection.host.port })
           }
           cb(err, connection)
         })
       }
-      return request.apply(this, arguments)
+      return request.apply(this, args)
     }
   }
 }

package/packages/datadog-instrumentations/src/express-mongo-sanitize.js

@@ -12,8 +12,8 @@ const sanitizeMiddlewareFinished = channel('datadog:express-mongo-sanitize:filte
 const propertiesToSanitize = ['body', 'params', 'headers', 'query']
 
 addHook({ name: 'express-mongo-sanitize', versions: ['>=1.0.0'] }, expressMongoSanitize => {
-  shimmer.wrap(expressMongoSanitize, 'sanitize', sanitize => function () {
-    const sanitizedObject = sanitize.apply(this, arguments)
+  shimmer.wrap(expressMongoSanitize, 'sanitize', sanitize => function (...args) {
+    const sanitizedObject = sanitize.apply(this, args)
 
     if (sanitizeMethodFinished.hasSubscribers) {
       sanitizeMethodFinished.publish({ sanitizedObject })
@@ -22,21 +22,21 @@ addHook({ name: 'express-mongo-sanitize', versions: ['>=1.0.0'] }, expressMongoS
     return sanitizedObject
   })
 
-  return shimmer.wrapFunction(expressMongoSanitize, expressMongoSanitize => function () {
-    const middleware = expressMongoSanitize.apply(this, arguments)
+  return shimmer.wrapFunction(expressMongoSanitize, expressMongoSanitize => function (...args) {
+    const middleware = expressMongoSanitize.apply(this, args)
 
     return shimmer.wrapFunction(middleware, middleware => function (req, res, next) {
       if (!sanitizeMiddlewareFinished.hasSubscribers) {
         return middleware.apply(this, arguments)
       }
 
-      const wrappedNext = shimmer.wrapFunction(next, next => function () {
+      const wrappedNext = shimmer.wrapFunction(next, next => function (...args) {
         sanitizeMiddlewareFinished.publish({
           sanitizedProperties: propertiesToSanitize,
           req,
         })
 
-        return next.apply(this, arguments)
+        return next.apply(this, args)
       })
 
       return middleware.call(this, req, res, wrappedNext)

package/packages/datadog-instrumentations/src/express-session.js

@@ -8,7 +8,7 @@ const sessionMiddlewareFinishCh = channel('datadog:express-session:middleware:fi
 function wrapSessionMiddleware (sessionMiddleware) {
   return function wrappedSessionMiddleware (req, res, next) {
     shimmer.wrap(arguments, 2, function wrapNext (next) {
-      return function wrappedNext () {
+      return function wrappedNext (...args) {
         if (sessionMiddlewareFinishCh.hasSubscribers) {
           const abortController = new AbortController()
 
@@ -17,7 +17,7 @@ function wrapSessionMiddleware (sessionMiddleware) {
           if (abortController.signal.aborted) return
         }
 
-        return next.apply(this, arguments)
+        return next.apply(this, args)
       }
     })
 
@@ -26,8 +26,8 @@ function wrapSessionMiddleware (sessionMiddleware) {
 }
 
 function wrapSession (session) {
-  return function wrappedSession () {
-    const sessionMiddleware = session.apply(this, arguments)
+  return function wrappedSession (...args) {
+    const sessionMiddleware = session.apply(this, args)
 
     return shimmer.wrapFunction(sessionMiddleware, wrapSessionMiddleware)
   }

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

@@ -54,13 +54,12 @@ function wrapResponseRender (render) {
 
     const abortController = new AbortController()
     return responseRenderChannel.traceSync(
-      function () {
+      function (...args) {
         if (abortController.signal.aborted) {
-          const error = abortController.signal.reason || new Error('Aborted')
-          throw error
+          throw abortController.signal.reason || new Error('Aborted')
         }
 
-        return render.apply(this, arguments)
+        return render.apply(this, args)
       },
       {
         req: this.req,
@@ -173,7 +172,7 @@ addHook({ name: 'express', versions: ['4'], file: 'lib/express.js' }, express =>
 const queryParserReadCh = channel('datadog:query:read:finish')
 
 function publishQueryParsedAndNext (req, res, next) {
-  return shimmer.wrapFunction(next, next => function () {
+  return shimmer.wrapFunction(next, next => function (...args) {
     if (queryParserReadCh.hasSubscribers && req) {
       const abortController = new AbortController()
       const query = req.query
@@ -183,7 +182,7 @@ function publishQueryParsedAndNext (req, res, next) {
       if (abortController.signal.aborted) return
     }
 
-    return next.apply(this, arguments)
+    return next.apply(this, args)
   })
 }
 
@@ -192,8 +191,8 @@ addHook({
   versions: ['4'],
   file: 'lib/middleware/query.js',
 }, query => {
-  return shimmer.wrapFunction(query, query => function () {
-    const queryMiddleware = query.apply(this, arguments)
+  return shimmer.wrapFunction(query, query => function (...args) {
+    const queryMiddleware = query.apply(this, args)
 
     return shimmer.wrapFunction(queryMiddleware, queryMiddleware => function (req, res, next) {
       arguments[2] = publishQueryParsedAndNext(req, res, next)
@@ -205,9 +204,9 @@ addHook({
 const processParamsStartCh = channel('datadog:express:process_params:start')
 function wrapProcessParamsMethod (requestPositionInArguments) {
   return function wrapProcessParams (original) {
-    return function wrappedProcessParams () {
+    return function wrappedProcessParams (...args) {
       if (processParamsStartCh.hasSubscribers) {
-        const req = arguments[requestPositionInArguments]
+        const req = args[requestPositionInArguments]
         const abortController = new AbortController()
 
         processParamsStartCh.publish({
@@ -220,7 +219,7 @@ function wrapProcessParamsMethod (requestPositionInArguments) {
         if (abortController.signal.aborted) return
       }
 
-      return original.apply(this, arguments)
+      return original.apply(this, args)
     }
   }
 }

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

@@ -25,8 +25,8 @@ const bodyPublished = new WeakSet()
 function wrapFastify (fastify, hasParsingEvents) {
   if (typeof fastify !== 'function') return fastify
 
-  return function fastifyWithTrace () {
-    const app = fastify.apply(this, arguments)
+  return function fastifyWithTrace (...args) {
+    const app = fastify.apply(this, args)
 
     if (!app || typeof app.addHook !== 'function') return app
 

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

@@ -165,13 +165,13 @@ function initDirAsyncIteratorProperties (iterator) {
 
 function createWrapDirAsyncIterator () {
   return function wrapDirAsyncIterator (asyncIterator) {
-    return function wrappedAsyncIterator () {
+    return function wrappedAsyncIterator (...args) {
       if (!kDirReadPromisified || !kDirClosePromisified) {
         initDirAsyncIteratorProperties(this)
       }
       wrap(this, kDirReadPromisified, createWrapFunction('dir.', 'read'))
       wrap(this, kDirClosePromisified, createWrapFunction('dir.', 'close'))
-      return asyncIterator.apply(this, arguments)
+      return asyncIterator.apply(this, args)
     }
   }
 }
@@ -231,12 +231,12 @@ function createWatchWrapFunction (override = '') {
     const name = override || original.name
     const method = name
     const operation = name
-    return function () {
-      if (!startChannel.hasSubscribers) return original.apply(this, arguments)
-      const ctx = getMessage(method, watchMethods[operation], arguments, this)
+    return function (...args) {
+      if (!startChannel.hasSubscribers) return original.apply(this, args)
+      const ctx = getMessage(method, watchMethods[operation], args, this)
       return startChannel.runStores(ctx, () => {
         try {
-          const result = original.apply(this, arguments)
+          const result = original.apply(this, args)
           finishChannel.runStores(ctx, () => {})
           return result
         } catch (error) {
@@ -256,14 +256,14 @@ function createWrapFunction (prefix = '', override = '') {
     const method = `${prefix}${name}`
     const operation = name.match(/^(.+?)(Sync)?(\.native)?$/)[1]
 
-    return function () {
-      if (!startChannel.hasSubscribers) return original.apply(this, arguments)
+    return function (...args) {
+      if (!startChannel.hasSubscribers) return original.apply(this, args)
 
-      const lastIndex = arguments.length - 1
-      const cb = typeof arguments[lastIndex] === 'function' && arguments[lastIndex]
+      const lastIndex = args.length - 1
+      const cb = typeof args[lastIndex] === 'function' && args[lastIndex]
       const params = getMethodParamsRelationByPrefix(prefix)[operation]
       const abortController = new AbortController()
-      const ctx = { ...getMessage(method, params, arguments, this), abortController }
+      const ctx = { ...getMessage(method, params, args, this), abortController }
 
       const finish = function (error, cb = () => {}) {
         if (error !== null && typeof error === 'object') { // fs.exists receives a boolean
@@ -274,7 +274,7 @@ function createWrapFunction (prefix = '', override = '') {
       }
 
       if (cb) {
-        arguments[lastIndex] = shimmer.wrapFunction(cb, cb => function (e) {
+        args[lastIndex] = shimmer.wrapFunction(cb, cb => function (e) {
           return finish(e, () => cb.apply(this, arguments))
         })
       }
@@ -290,13 +290,13 @@ function createWrapFunction (prefix = '', override = '') {
             finish(error)
             throw error
           } else if (cb) {
-            arguments[lastIndex](error)
+            args[lastIndex](error)
             return
           }
         }
 
         try {
-          const result = original.apply(this, arguments)
+          const result = original.apply(this, args)
           if (cb) return result
           if (result && typeof result.then === 'function') {
             // TODO method open returning promise and filehandle prototype not initialized, initialize it

package/packages/datadog-instrumentations/src/google-cloud-pubsub.js

@@ -167,17 +167,17 @@ addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'], file: 'build/src/su
    * Flow: message.ack() -> store context -> acknowledge() API -> retrieve context
    */
   if (Message?.prototype?.ack) {
-    shimmer.wrap(Message.prototype, 'ack', originalAck => function () {
+    shimmer.wrap(Message.prototype, 'ack', originalAck => function (...args) {
       if (this.ackId) {
         const ctx = {
           message: this,
           ackId: this.ackId,
         }
 
-        return messageAckStoreCh.runStores(ctx, originalAck, this, ...arguments)
+        return messageAckStoreCh.runStores(ctx, originalAck, this, ...args)
       }
 
-      return originalAck.apply(this, arguments)
+      return originalAck.apply(this, args)
     })
   }
 
@@ -212,7 +212,7 @@ addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'], file: 'build/src/le
     return receiveFinishCh.runStores(ctx || { message }, remove, this, ...arguments)
   })
 
-  shimmer.wrap(LeaseManager.prototype, 'clear', clear => function () {
+  shimmer.wrap(LeaseManager.prototype, 'clear', clear => function (...args) {
     if (this._messages) {
       for (const message of this._messages.values()) {
         const ctx = messageContexts.get(message)
@@ -222,10 +222,8 @@ addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'], file: 'build/src/le
         }
       }
     }
-    return clear.apply(this, arguments)
+    return clear.apply(this, args)
   })
-
-  return obj
 })
 
 /**

package/packages/datadog-instrumentations/src/google-genai.js

@@ -46,10 +46,10 @@ function wrapGenerateContent (method) {
 }
 
 function wrapStreamIterator (iterator, ctx) {
-  return function () {
-    const itr = iterator.apply(this, arguments)
-    shimmer.wrap(itr, 'next', next => function () {
-      return next.apply(this, arguments)
+  return function (...args) {
+    const itr = iterator.apply(this, args)
+    shimmer.wrap(itr, 'next', next => function (...args) {
+      return next.apply(this, args)
         .then(res => {
           const { done, value: chunk } = res
           onStreamedChunkCh.publish({ ctx, chunk, done })

package/packages/datadog-instrumentations/src/grpc/server.js

@@ -49,9 +49,9 @@ function wrapHandler (func, name) {
         }
 
         shimmer.wrap(call, 'emit', emit => {
-          return function () {
+          return function (...args) {
             return emitChannel.runStores(ctx, () => {
-              return emit.apply(this, arguments)
+              return emit.apply(this, args)
             })
           }
         })