dd-trace 4.46.0 → 4.47.1

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

@@ -404,7 +404,7 @@ addHook({
 
 addHook({
   name: '@jest/test-sequencer',
-  versions: ['>=24.8.0']
+  versions: ['>=28']
 }, (sequencerPackage, frameworkVersion) => {
   shimmer.wrap(sequencerPackage.default.prototype, 'shard', shard => function () {
     const shardedTests = shard.apply(this, arguments)
@@ -648,6 +648,7 @@ function jestAdapterWrapper (jestAdapter, jestVersion) {
       testSuiteStartCh.publish({
         testSuite: environment.testSuite,
         testEnvironmentOptions: environment.testEnvironmentOptions,
+        testSourceFile: environment.testSourceFile,
         displayName: environment.displayName,
         frameworkVersion: jestVersion
       })
@@ -765,6 +766,7 @@ addHook({
       _ddTestModuleId,
       _ddTestSessionId,
       _ddTestCommand,
+      _ddTestSessionName,
       _ddForcedToRun,
       _ddUnskippable,
       _ddItrCorrelationId,

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

@@ -17,6 +17,10 @@ const consumerCommitCh = channel('apm:kafkajs:consume:commit')
 const consumerFinishCh = channel('apm:kafkajs:consume:finish')
 const consumerErrorCh = channel('apm:kafkajs:consume:error')
 
+const batchConsumerStartCh = channel('apm:kafkajs:consume-batch:start')
+const batchConsumerFinishCh = channel('apm:kafkajs:consume-batch:finish')
+const batchConsumerErrorCh = channel('apm:kafkajs:consume-batch:error')
+
 function commitsFromEvent (event) {
   const { payload: { groupId, topics } } = event
   const commitList = []
@@ -96,6 +100,17 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
       return createConsumer.apply(this, arguments)
     }
 
+    const eachMessageExtractor = (args) => {
+      const { topic, partition, message } = args[0]
+      return { topic, partition, message, groupId }
+    }
+
+    const eachBatchExtractor = (args) => {
+      const { batch } = args[0]
+      const { topic, partition, messages } = batch
+      return { topic, partition, messages, groupId }
+    }
+
     const consumer = createConsumer.apply(this, arguments)
 
     consumer.on(consumer.events.COMMIT_OFFSETS, commitsFromEvent)
@@ -103,43 +118,64 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
     const run = consumer.run
 
     const groupId = arguments[0].groupId
-    consumer.run = function ({ eachMessage, ...runArgs }) {
-      if (typeof eachMessage !== 'function') return run({ eachMessage, ...runArgs })
+    consumer.run = function ({ eachMessage, eachBatch, ...runArgs }) {
+      eachMessage = wrapFunction(
+        eachMessage,
+        consumerStartCh,
+        consumerFinishCh,
+        consumerErrorCh,
+        eachMessageExtractor
+      )
+
+      eachBatch = wrapFunction(
+        eachBatch,
+        batchConsumerStartCh,
+        batchConsumerFinishCh,
+        batchConsumerErrorCh,
+        eachBatchExtractor
+      )
 
       return run({
-        eachMessage: function (...eachMessageArgs) {
-          const innerAsyncResource = new AsyncResource('bound-anonymous-fn')
-          return innerAsyncResource.runInAsyncScope(() => {
-            const { topic, partition, message } = eachMessageArgs[0]
-            consumerStartCh.publish({ topic, partition, message, groupId })
-            try {
-              const result = eachMessage.apply(this, eachMessageArgs)
-              if (result && typeof result.then === 'function') {
-                result.then(
-                  innerAsyncResource.bind(() => consumerFinishCh.publish(undefined)),
-                  innerAsyncResource.bind(err => {
-                    if (err) {
-                      consumerErrorCh.publish(err)
-                    }
-                    consumerFinishCh.publish(undefined)
-                  })
-                )
-              } else {
-                consumerFinishCh.publish(undefined)
-              }
-
-              return result
-            } catch (e) {
-              consumerErrorCh.publish(e)
-              consumerFinishCh.publish(undefined)
-              throw e
-            }
-          })
-        },
+        eachMessage,
+        eachBatch,
         ...runArgs
       })
     }
+
     return consumer
   })
   return Kafka
 })
+
+const wrapFunction = (fn, startCh, finishCh, errorCh, extractArgs) => {
+  return typeof fn === 'function'
+    ? function (...args) {
+      const innerAsyncResource = new AsyncResource('bound-anonymous-fn')
+      return innerAsyncResource.runInAsyncScope(() => {
+        const extractedArgs = extractArgs(args)
+        startCh.publish(extractedArgs)
+        try {
+          const result = fn.apply(this, args)
+          if (result && typeof result.then === 'function') {
+            result.then(
+              innerAsyncResource.bind(() => finishCh.publish(undefined)),
+              innerAsyncResource.bind(err => {
+                if (err) {
+                  errorCh.publish(err)
+                }
+                finishCh.publish(undefined)
+              })
+            )
+          } else {
+            finishCh.publish(undefined)
+          }
+          return result
+        } catch (e) {
+          errorCh.publish(e)
+          finishCh.publish(undefined)
+          throw e
+        }
+      })
+    }
+    : fn
+}

package/packages/datadog-instrumentations/src/microgateway-core.js

@@ -8,7 +8,9 @@ const routeChannel = channel('apm:microgateway-core:request:route')
 const errorChannel = channel('apm:microgateway-core:request:error')
 
 const name = 'microgateway-core'
-const versions = ['>=2.1']
+
+// TODO Remove " <=3.0.0" when "volos-util-apigee" module is fixed
+const versions = ['>=2.1 <=3.0.0']
 const requestResources = new WeakMap()
 
 function wrapConfigProxyFactory (configProxyFactory) {

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

@@ -11,12 +11,12 @@ const {
   fromCoverageMapToCoverage,
   getCoveredFilenamesFromCoverage,
   mergeCoverage,
-  resetCoverage
+  resetCoverage,
+  getIsFaultyEarlyFlakeDetection
 } = require('../../../dd-trace/src/plugins/util/test')
 
 const {
   isNewTest,
-  retryTest,
   getSuitesByTestFile,
   runnableWrapper,
   getOnTestHandler,
@@ -25,22 +25,21 @@ const {
   getOnHookEndHandler,
   getOnFailHandler,
   getOnPendingHandler,
-  testFileToSuiteAr
+  testFileToSuiteAr,
+  newTests,
+  getTestFullName,
+  getRunTestsWrapper
 } = require('./utils')
+
 require('./common')
 
 const testSessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 const patched = new WeakSet()
-const newTests = {}
-let suitesToSkip = []
+
 const unskippableSuites = []
+let suitesToSkip = []
 let isSuitesSkipped = false
 let skippedSuites = []
-let isEarlyFlakeDetectionEnabled = false
-let isSuitesSkippingEnabled = false
-let isFlakyTestRetriesEnabled = false
-let earlyFlakeDetectionNumRetries = 0
-let knownTests = []
 let itrCorrelationId = ''
 let isForcedToRun = false
 const config = {}
@@ -69,6 +68,17 @@ const itrSkippedSuitesCh = channel('ci:mocha:itr:skipped-suites')
 
 const getCodeCoverageCh = channel('ci:nyc:get-coverage')
 
+// Tests from workers do not come with `isFailed` method
+function isTestFailed (test) {
+  if (test.isFailed) {
+    return test.isFailed()
+  }
+  if (test.isPending) {
+    return !test.isPending() && test.state !== 'failed'
+  }
+  return false
+}
+
 function getFilteredSuites (originalSuites) {
   return originalSuites.reduce((acc, suite) => {
     const testPath = getTestSuitePath(suite.file, process.cwd())
@@ -107,7 +117,7 @@ function getOnEndHandler (isParallel) {
       status = 'fail'
     }
 
-    if (!isParallel && isEarlyFlakeDetectionEnabled) {
+    if (config.isEarlyFlakeDetectionEnabled) {
       /**
        * If Early Flake Detection (EFD) is enabled the logic is as follows:
        * - If all attempts for a test are failing, the test has failed and we will let the test process fail.
@@ -116,7 +126,7 @@ function getOnEndHandler (isParallel) {
        * on flakiness (the test will be considered flaky), but you may choose to unblock the pipeline too.
        */
       for (const tests of Object.values(newTests)) {
-        const failingNewTests = tests.filter(test => test.isFailed())
+        const failingNewTests = tests.filter(test => isTestFailed(test))
         const areAllNewTestsFailing = failingNewTests.length === tests.length
         if (failingNewTests.length && !areAllNewTestsFailing) {
           this.stats.failures -= failingNewTests.length
@@ -153,13 +163,14 @@ function getOnEndHandler (isParallel) {
       hasForcedToRunSuites: isForcedToRun,
       hasUnskippableSuites: !!unskippableSuites.length,
       error,
-      isEarlyFlakeDetectionEnabled,
+      isEarlyFlakeDetectionEnabled: config.isEarlyFlakeDetectionEnabled,
+      isEarlyFlakeDetectionFaulty: config.isEarlyFlakeDetectionFaulty,
       isParallel
     })
   })
 }
 
-function getExecutionConfiguration (runner, onFinishRequest) {
+function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
   const mochaRunAsyncResource = new AsyncResource('bound-anonymous-fn')
 
   const onReceivedSkippableSuites = ({ err, skippableSuites, itrCorrelationId: responseItrCorrelationId }) => {
@@ -186,15 +197,15 @@ function getExecutionConfiguration (runner, onFinishRequest) {
     onFinishRequest()
   }
 
-  const onReceivedKnownTests = ({ err, knownTests: receivedKnownTests }) => {
+  const onReceivedKnownTests = ({ err, knownTests }) => {
     if (err) {
-      knownTests = []
-      isEarlyFlakeDetectionEnabled = false
+      config.knownTests = []
+      config.isEarlyFlakeDetectionEnabled = false
     } else {
-      knownTests = receivedKnownTests
+      config.knownTests = knownTests
     }
 
-    if (isSuitesSkippingEnabled) {
+    if (config.isSuitesSkippingEnabled) {
       skippableSuitesCh.publish({
         onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
       })
@@ -208,22 +219,19 @@ function getExecutionConfiguration (runner, onFinishRequest) {
       return onFinishRequest()
     }
 
-    isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
-    isSuitesSkippingEnabled = libraryConfig.isSuitesSkippingEnabled
-    earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
-    isFlakyTestRetriesEnabled = libraryConfig.isFlakyTestRetriesEnabled
-
-    config.isEarlyFlakeDetectionEnabled = isEarlyFlakeDetectionEnabled
-    config.isSuitesSkippingEnabled = isSuitesSkippingEnabled
-    config.earlyFlakeDetectionNumRetries = earlyFlakeDetectionNumRetries
-    config.isFlakyTestRetriesEnabled = isFlakyTestRetriesEnabled
-    config.flakyTestRetriesCount = libraryConfig.flakyTestRetriesCount
+    config.isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
+    config.earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
+    config.earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
+    // ITR and auto test retries are not supported in parallel mode yet
+    config.isSuitesSkippingEnabled = !isParallel && libraryConfig.isSuitesSkippingEnabled
+    config.isFlakyTestRetriesEnabled = !isParallel && libraryConfig.isFlakyTestRetriesEnabled
+    config.flakyTestRetriesCount = !isParallel && libraryConfig.flakyTestRetriesCount
 
-    if (isEarlyFlakeDetectionEnabled) {
+    if (config.isEarlyFlakeDetectionEnabled) {
       knownTestsCh.publish({
         onDone: mochaRunAsyncResource.bind(onReceivedKnownTests)
       })
-    } else if (isSuitesSkippingEnabled) {
+    } else if (config.isSuitesSkippingEnabled) {
       skippableSuitesCh.publish({
         onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
       })
@@ -251,8 +259,8 @@ addHook({
       return run.apply(this, arguments)
     }
 
-    // `options.delay` does not work in parallel mode, so ITR and EFD can't work.
-    // TODO: use `lib/cli/run-helpers.js#runMocha` to get the data in parallel mode.
+    // `options.delay` does not work in parallel mode, so we can't delay the execution this way
+    // This needs to be both here and in `runMocha` hook. Read the comment in `runMocha` hook for more info.
     this.options.delay = true
 
     const runner = run.apply(this, arguments)
@@ -264,7 +272,19 @@ addHook({
       }
     })
 
-    getExecutionConfiguration(runner, () => {
+    getExecutionConfiguration(runner, false, () => {
+      if (config.isEarlyFlakeDetectionEnabled) {
+        const testSuites = this.files.map(file => getTestSuitePath(file, process.cwd()))
+        const isFaulty = getIsFaultyEarlyFlakeDetection(
+          testSuites,
+          config.knownTests?.mocha || {},
+          config.earlyFlakeDetectionFaultyThreshold
+        )
+        if (isFaulty) {
+          config.isEarlyFlakeDetectionEnabled = false
+          config.isEarlyFlakeDetectionFaulty = true
+        }
+      }
       if (getCodeCoverageCh.hasSubscribers) {
         getCodeCoverageCh.publish({
           onDone: (receivedCodeCoverage) => {
@@ -282,9 +302,6 @@ addHook({
   return Mocha
 })
 
-// Only used to set `mocha.options.delay` to true in serial mode. When the mocha CLI is used,
-// setting options.delay in Mocha#run is not enough to delay the execution.
-// TODO: modify this hook to grab the data in parallel mode, so that ITR and EFD can work.
 addHook({
   name: 'mocha',
   versions: ['>=5.2.0'],
@@ -294,15 +311,20 @@ addHook({
     if (!testStartCh.hasSubscribers) {
       return runMocha.apply(this, arguments)
     }
-
     const mocha = arguments[0]
+
     /**
      * This attaches `run` to the global context, which we'll call after
-     * our configuration and skippable suites requests
+     * our configuration and skippable suites requests.
+     * You need this both here and in Mocha#run hook: the programmatic API
+     * does not call `runMocha`, so it needs to be in Mocha#run. When using
+     * the CLI, modifying `options.delay` in Mocha#run is not enough (it's too late),
+     * so it also needs to be here.
      */
     if (!mocha.options.parallel) {
       mocha.options.delay = true
     }
+
     return runMocha.apply(this, arguments)
   })
   return run
@@ -319,18 +341,7 @@ addHook({
 
   patched.add(Runner)
 
-  shimmer.wrap(Runner.prototype, 'runTests', runTests => function (suite, fn) {
-    if (isEarlyFlakeDetectionEnabled) {
-      // by the time we reach `this.on('test')`, it is too late. We need to add retries here
-      suite.tests.forEach(test => {
-        if (!test.isPending() && isNewTest(test, knownTests)) {
-          test._ddIsNew = true
-          retryTest(test, earlyFlakeDetectionNumRetries)
-        }
-      })
-    }
-    return runTests.apply(this, arguments)
-  })
+  shimmer.wrap(Runner.prototype, 'runTests', runTests => getRunTestsWrapper(runTests, config))
 
   shimmer.wrap(Runner.prototype, 'run', run => function () {
     if (!testStartCh.hasSubscribers) {
@@ -514,10 +525,10 @@ addHook({
 // Used to start and finish test session and test module
 addHook({
   name: 'mocha',
-  versions: ['>=5.2.0'],
+  versions: ['>=8.0.0'],
   file: 'lib/nodejs/parallel-buffered-runner.js'
 }, (ParallelBufferedRunner, frameworkVersion) => {
-  shimmer.wrap(ParallelBufferedRunner.prototype, 'run', run => function () {
+  shimmer.wrap(ParallelBufferedRunner.prototype, 'run', run => function (cb, { files }) {
     if (!testStartCh.hasSubscribers) {
       return run.apply(this, arguments)
     }
@@ -525,8 +536,82 @@ addHook({
     this.once('start', getOnStartHandler(true, frameworkVersion))
     this.once('end', getOnEndHandler(true))
 
-    return run.apply(this, arguments)
+    getExecutionConfiguration(this, true, () => {
+      if (config.isEarlyFlakeDetectionEnabled) {
+        const testSuites = files.map(file => getTestSuitePath(file, process.cwd()))
+        const isFaulty = getIsFaultyEarlyFlakeDetection(
+          testSuites,
+          config.knownTests?.mocha || {},
+          config.earlyFlakeDetectionFaultyThreshold
+        )
+        if (isFaulty) {
+          config.isEarlyFlakeDetectionEnabled = false
+          config.isEarlyFlakeDetectionFaulty = true
+        }
+      }
+      run.apply(this, arguments)
+    })
+
+    return this
   })
 
   return ParallelBufferedRunner
 })
+
+// Only in parallel mode: BufferedWorkerPool#run is used to run a test file in a worker
+// If Early Flake Detection is enabled,
+// In this hook we pass the known tests to the worker and collect the new tests that run
+addHook({
+  name: 'mocha',
+  versions: ['>=8.0.0'],
+  file: 'lib/nodejs/buffered-worker-pool.js'
+}, (BufferedWorkerPoolPackage) => {
+  const { BufferedWorkerPool } = BufferedWorkerPoolPackage
+
+  shimmer.wrap(BufferedWorkerPool.prototype, 'run', run => async function (testSuiteAbsolutePath, workerArgs) {
+    if (!testStartCh.hasSubscribers || !config.isEarlyFlakeDetectionEnabled) {
+      return run.apply(this, arguments)
+    }
+
+    const testPath = getTestSuitePath(testSuiteAbsolutePath, process.cwd())
+    const testSuiteKnownTests = config.knownTests.mocha?.[testPath] || []
+
+    // We pass the known tests for the test file to the worker
+    const testFileResult = await run.apply(
+      this,
+      [
+        testSuiteAbsolutePath,
+        {
+          ...workerArgs,
+          _ddEfdNumRetries: config.earlyFlakeDetectionNumRetries,
+          _ddKnownTests: {
+            mocha: {
+              [testPath]: testSuiteKnownTests
+            }
+          }
+        }
+      ]
+    )
+    const tests = testFileResult
+      .events
+      .filter(event => event.eventName === 'test end')
+      .map(event => event.data)
+
+    // `newTests` is filled in the worker process, so we need to use the test results to fill it here too.
+    for (const test of tests) {
+      if (isNewTest(test, config.knownTests)) {
+        const testFullName = getTestFullName(test)
+        const tests = newTests[testFullName]
+
+        if (!tests) {
+          newTests[testFullName] = [test]
+        } else {
+          tests.push(test)
+        }
+      }
+    }
+    return testFileResult
+  })
+
+  return BufferedWorkerPoolPackage
+})

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

@@ -24,6 +24,7 @@ const originalFns = new WeakMap()
 const testToStartLine = new WeakMap()
 const testFileToSuiteAr = new Map()
 const wrappedFunctions = new WeakSet()
+const newTests = {}
 
 function isNewTest (test, knownTests) {
   const testSuite = getTestSuitePath(test.file, process.cwd())
@@ -151,7 +152,7 @@ function runnableWrapper (RunnablePackage, libraryConfig) {
   return RunnablePackage
 }
 
-function getOnTestHandler (isMain, newTests) {
+function getOnTestHandler (isMain) {
   return function (test) {
     const testStartLine = testToStartLine.get(test)
     const asyncResource = new AsyncResource('bound-anonymous-fn')
@@ -179,22 +180,22 @@ function getOnTestHandler (isMain, newTests) {
       testStartLine
     }
 
-    if (isMain) {
-      testInfo.isNew = isNew
-      testInfo.isEfdRetry = isEfdRetry
-      // We want to store the result of the new tests
-      if (isNew) {
-        const testFullName = getTestFullName(test)
-        if (newTests[testFullName]) {
-          newTests[testFullName].push(test)
-        } else {
-          newTests[testFullName] = [test]
-        }
-      }
-    } else {
+    if (!isMain) {
       testInfo.isParallel = true
     }
 
+    testInfo.isNew = isNew
+    testInfo.isEfdRetry = isEfdRetry
+    // We want to store the result of the new tests
+    if (isNew) {
+      const testFullName = getTestFullName(test)
+      if (newTests[testFullName]) {
+        newTests[testFullName].push(test)
+      } else {
+        newTests[testFullName] = [test]
+      }
+    }
+
     asyncResource.runInAsyncScope(() => {
       testStartCh.publish(testInfo)
     })
@@ -327,6 +328,23 @@ function getOnPendingHandler () {
     }
   }
 }
+
+// Hook to add retries to tests if EFD is enabled
+function getRunTestsWrapper (runTests, config) {
+  return function (suite, fn) {
+    if (config.isEarlyFlakeDetectionEnabled) {
+      // by the time we reach `this.on('test')`, it is too late. We need to add retries here
+      suite.tests.forEach(test => {
+        if (!test.isPending() && isNewTest(test, config.knownTests)) {
+          test._ddIsNew = true
+          retryTest(test, config.earlyFlakeDetectionNumRetries)
+        }
+      })
+    }
+    return runTests.apply(this, arguments)
+  }
+}
+
 module.exports = {
   isNewTest,
   retryTest,
@@ -345,5 +363,7 @@ module.exports = {
   getOnHookEndHandler,
   getOnFailHandler,
   getOnPendingHandler,
-  testFileToSuiteAr
+  testFileToSuiteAr,
+  getRunTestsWrapper,
+  newTests
 }

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

@@ -9,19 +9,47 @@ const {
   getOnTestEndHandler,
   getOnHookEndHandler,
   getOnFailHandler,
-  getOnPendingHandler
+  getOnPendingHandler,
+  getRunTestsWrapper
 } = require('./utils')
 require('./common')
 
 const workerFinishCh = channel('ci:mocha:worker:finish')
 
+const config = {}
+
+addHook({
+  name: 'mocha',
+  versions: ['>=8.0.0'],
+  file: 'lib/mocha.js'
+}, (Mocha) => {
+  shimmer.wrap(Mocha.prototype, 'run', run => function () {
+    if (this.options._ddKnownTests) {
+      // EFD is enabled if there's a list of known tests
+      config.isEarlyFlakeDetectionEnabled = true
+      config.knownTests = this.options._ddKnownTests
+      config.earlyFlakeDetectionNumRetries = this.options._ddEfdNumRetries
+      delete this.options._ddKnownTests
+      delete this.options._ddEfdNumRetries
+    }
+    return run.apply(this, arguments)
+  })
+
+  return Mocha
+})
+
 // Runner is also hooked in mocha/main.js, but in here we only generate test events.
 addHook({
   name: 'mocha',
   versions: ['>=5.2.0'],
   file: 'lib/runner.js'
 }, function (Runner) {
+  shimmer.wrap(Runner.prototype, 'runTests', runTests => getRunTestsWrapper(runTests, config))
+
   shimmer.wrap(Runner.prototype, 'run', run => function () {
+    if (!workerFinishCh.hasSubscribers) {
+      return run.apply(this, arguments)
+    }
     // We flush when the worker ends with its test file (a mocha instance in a worker runs a single test file)
     this.on('end', () => {
       workerFinishCh.publish()

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

@@ -165,10 +165,12 @@ function addStreamedChunk (content, chunk) {
 
       if (tools) {
         oldChoice.delta.tool_calls = tools.map((newTool, toolIdx) => {
-          const oldTool = oldChoice.delta.tool_calls[toolIdx]
+          const oldTool = oldChoice.delta.tool_calls?.[toolIdx]
 
           if (oldTool) {
             oldTool.function.arguments += newTool.function.arguments
+          } else {
+            return newTool
           }
 
           return oldTool
@@ -247,7 +249,7 @@ function wrapStreamIterator (response, options, n, ctx) {
             return res
           })
           .catch(err => {
-            finish(undefined, err)
+            finish(ctx, undefined, err)
 
             throw err
           })