dd-trace 6.7.0 → 6.8.0

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

@@ -2,6 +2,8 @@
 
 const { addHook, channel } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
+const { getEnvironmentVariable } = require('../../../dd-trace/src/config/helper')
+const log = require('../../../dd-trace/src/log')
 const { DD_MAJOR } = require('../../../../version')
 
 const {
@@ -14,14 +16,351 @@ const {
   getOnTestRetryHandler,
   getRunTestsWrapper,
   patchFailedTestReplayHookUp,
+  adjustRunnerFailuresForTestOptimization,
+  efdTests,
+  getTestFullName,
 } = require('./utils')
+const {
+  CONFIGURATION_REQUEST,
+  CONFIGURATION_RESPONSE,
+  createWebdriverioWorkerMessage,
+  SUITE_FINISH,
+  WEBDRIVERIO_WORKER_ENV,
+  WORKER_READY,
+} = require('./webdriverio-protocol')
 require('./common')
 
 const MINIMUM_MOCHA_VERSION = DD_MAJOR >= 6 ? '>=8.0.0' : '>=5.2.0'
 
 const workerFinishCh = channel('ci:mocha:worker:finish')
+const workerConfigurationCh = channel('ci:mocha:worker:configuration')
 
 const config = {}
+const runnerToFiles = new WeakMap()
+const runnerToFailedHooks = new WeakMap()
+const isWebdriverioWorker = !!getEnvironmentVariable(WEBDRIVERIO_WORKER_ENV)
+let configurationRequestId = 0
+
+/**
+ * Sends a message to the WebdriverIO launcher without surfacing closed IPC channels.
+ *
+ * @param {object} message
+ * @param {() => void} [onError]
+ * @param {() => void} [onDone]
+ * @returns {void}
+ */
+function sendWebdriverioMessage (message, onError, onDone) {
+  if (!process.send || !process.connected) {
+    onError?.()
+    onDone?.()
+    return
+  }
+
+  process.send(createWebdriverioWorkerMessage(message), (error) => {
+    if (error) {
+      log.error('WebdriverIO Test Optimization IPC error', error)
+      onError?.()
+    }
+    onDone?.()
+  })
+}
+
+/**
+ * Applies configuration encoded as private Mocha options by its parallel runner.
+ *
+ * @param {object} options
+ * @returns {void}
+ */
+function applyMochaOptions (options) {
+  if (options._ddIsKnownTestsEnabled) {
+    config.isKnownTestsEnabled = true
+    config.isEarlyFlakeDetectionEnabled = options._ddIsEfdEnabled
+    config.knownTests = options._ddKnownTests
+    config.earlyFlakeDetectionNumRetries = options._ddEfdNumRetries
+    config.earlyFlakeDetectionSlowTestRetries = options._ddEfdSlowTestRetries ?? {}
+    delete options._ddIsEfdEnabled
+    delete options._ddKnownTests
+    delete options._ddEfdNumRetries
+    delete options._ddEfdSlowTestRetries
+    delete options._ddIsKnownTestsEnabled
+  }
+  if (options._ddIsImpactedTestsEnabled) {
+    config.isImpactedTestsEnabled = true
+    config.modifiedFiles = options._ddModifiedFiles
+    delete options._ddIsImpactedTestsEnabled
+    delete options._ddModifiedFiles
+  }
+  if (options._ddIsTestManagementTestsEnabled) {
+    config.isTestManagementTestsEnabled = true
+    config.testManagementAttemptToFixRetries = options._ddTestManagementAttemptToFixRetries
+    config.testManagementTests = options._ddTestManagementTests
+    delete options._ddIsTestManagementTestsEnabled
+    delete options._ddTestManagementAttemptToFixRetries
+    delete options._ddTestManagementTests
+  }
+  if (options._ddIsFlakyTestRetriesEnabled) {
+    config.isFlakyTestRetriesEnabled = true
+    config.flakyTestRetriesCount = options._ddFlakyTestRetriesCount
+    delete options._ddIsFlakyTestRetriesEnabled
+    delete options._ddFlakyTestRetriesCount
+  }
+  if (options._ddIsFailedTestReplayEnabled) {
+    config.isTestDynamicInstrumentationEnabled = true
+    config.isDiEnabled = true
+    delete options._ddIsFailedTestReplayEnabled
+  }
+}
+
+/**
+ * Removes files selected for suite-level skipping from an already loaded Mocha root suite.
+ *
+ * @param {object} runner
+ * @param {string[]} skippedFiles
+ * @returns {void}
+ */
+function filterSkippedFiles (runner, skippedFiles) {
+  if (!skippedFiles.length) {
+    return
+  }
+
+  const skippedFilesSet = new Set(skippedFiles)
+  runner.suite.suites = runner.suite.suites.filter(suite => !skippedFilesSet.has(suite.file))
+  runner.suite.tests = runner.suite.tests.filter(test => !skippedFilesSet.has(test.file))
+}
+
+/**
+ * Requests configuration from the WebdriverIO launcher before releasing Mocha's delayed root suite.
+ *
+ * @param {string} frameworkVersion
+ * @param {string[]} files
+ * @param {(response: object) => void} onDone
+ * @returns {void}
+ */
+function requestWebdriverioConfiguration (frameworkVersion, files, onDone) {
+  const requestId = `${process.pid}-${++configurationRequestId}`
+  let finished = false
+
+  /**
+   * Finishes the configuration request exactly once.
+   *
+   * @param {object} response
+   * @returns {void}
+   */
+  function finish (response) {
+    if (finished) {
+      return
+    }
+    finished = true
+    clearTimeout(timeout)
+    process.off('message', onMessage)
+    process.off('disconnect', onDisconnect)
+    onDone(response)
+  }
+
+  /**
+   * Receives the matching coordinator response.
+   *
+   * @param {object} message
+   * @returns {void}
+   */
+  function onMessage (message) {
+    if (message?.name === CONFIGURATION_RESPONSE && message.content?.requestId === requestId) {
+      finish(message.content)
+    }
+  }
+
+  /**
+   * Releases the runner if its parent disconnects.
+   *
+   * @returns {void}
+   */
+  function onDisconnect () {
+    finish({})
+  }
+
+  const timeout = setTimeout(() => finish({}), 30_000)
+  process.on('message', onMessage)
+  process.once('disconnect', onDisconnect)
+  sendWebdriverioMessage({
+    origin: 'datadog',
+    name: CONFIGURATION_REQUEST,
+    content: {
+      files,
+      frameworkVersion,
+      requestId,
+    },
+  }, () => finish({}))
+}
+
+/**
+ * Reports the Mocha version as soon as WebdriverIO loads its framework adapter.
+ *
+ * @param {string} frameworkVersion
+ * @returns {void}
+ */
+function reportWebdriverioWorkerReady (frameworkVersion) {
+  if (!isWebdriverioWorker) {
+    return
+  }
+
+  sendWebdriverioMessage({
+    origin: 'datadog',
+    name: WORKER_READY,
+    content: { frameworkVersion },
+  })
+}
+
+/**
+ * Checks whether Test Optimization converts a failed WebdriverIO test attempt to a passing result.
+ *
+ * @param {object|undefined} test
+ * @returns {boolean}
+ */
+function isWebdriverioFailureSuppressed (test) {
+  if (!test) {
+    return false
+  }
+  const hasPassingEfdAttempt = config.isEarlyFlakeDetectionEnabled &&
+    efdTests[getTestFullName(test)]?.some(attempt => attempt.state === 'passed' && !attempt._ddHookFailed)
+  return (test._ddIsQuarantined && !test._ddIsAttemptToFix) || hasPassingEfdAttempt
+}
+
+/**
+ * Gets the test owned by a per-test hook without associating suite hooks with boundary tests.
+ *
+ * @param {object} hook
+ * @returns {object|undefined}
+ */
+function getWebdriverioHookTest (hook) {
+  const { parent } = hook
+  const isTestHook = parent?._beforeEach?.includes(hook) || parent?._afterEach?.includes(hook)
+  return isTestHook ? hook.ctx?.currentTest : undefined
+}
+
+/**
+ * Removes managed hook failures from WebdriverIO's Mocha runner totals.
+ *
+ * @param {object} runner
+ * @returns {void}
+ */
+function adjustWebdriverioHookFailures (runner) {
+  let suppressedFailures = 0
+  for (const { test } of runnerToFailedHooks.get(runner) || []) {
+    if (isWebdriverioFailureSuppressed(test)) {
+      suppressedFailures++
+    }
+  }
+  if (runner.stats) {
+    runner.stats.failures -= suppressedFailures
+  }
+  runner.failures -= suppressedFailures
+}
+
+/**
+ * Computes a final result for every file loaded into one Mocha worker.
+ *
+ * @param {object} runner
+ * @returns {object[]}
+ */
+function getWebdriverioSuiteResults (runner) {
+  const resultsByFile = new Map()
+  const files = runnerToFiles.get(runner) || []
+
+  for (const file of files) {
+    resultsByFile.set(file, {
+      file,
+      hasPassingTest: false,
+      status: 'skip',
+    })
+  }
+
+  runner.suite.eachTest(test => {
+    const result = resultsByFile.get(test.file)
+    if (!result) {
+      return
+    }
+    const isSuppressedFailure = isWebdriverioFailureSuppressed(test)
+    if ((test.state === 'failed' || test.timedOut || test._ddHookFailed) && !isSuppressedFailure) {
+      result.status = 'fail'
+    } else if (test.state === 'passed' || isSuppressedFailure) {
+      result.hasPassingTest = true
+    }
+  })
+
+  for (const { file, test } of runnerToFailedHooks.get(runner) || []) {
+    const result = resultsByFile.get(file)
+    if (result && !isWebdriverioFailureSuppressed(test)) {
+      result.status = 'fail'
+    }
+  }
+
+  const results = []
+  let hasFailedSuite = false
+  for (const result of resultsByFile.values()) {
+    if (result.status === 'fail') {
+      hasFailedSuite = true
+    } else if (result.hasPassingTest) {
+      result.status = 'pass'
+    }
+    delete result.hasPassingTest
+    results.push(result)
+  }
+
+  if (runner.failures > 0 && !hasFailedSuite) {
+    for (const result of results) {
+      result.status = 'fail'
+    }
+  }
+
+  return results
+}
+
+/**
+ * Sends suite results to the WebdriverIO launcher.
+ *
+ * @param {object} runner
+ * @param {() => void} [onDone]
+ * @returns {void}
+ */
+function reportWebdriverioSuiteResults (runner, onDone) {
+  if (!isWebdriverioWorker) {
+    onDone?.()
+    return
+  }
+
+  sendWebdriverioMessage({
+    origin: 'datadog',
+    name: SUITE_FINISH,
+    content: {
+      results: getWebdriverioSuiteResults(runner),
+    },
+  }, undefined, onDone)
+}
+
+/**
+ * Flushes worker payloads before reporting suite results and completing Mocha.
+ *
+ * @param {object} runner
+ * @param {() => void} onDone
+ * @returns {void}
+ */
+function finishWebdriverioWorker (runner, onDone) {
+  try {
+    workerFinishCh.publish({
+      onDone: () => {
+        try {
+          reportWebdriverioSuiteResults(runner, onDone)
+        } catch (error) {
+          log.error('WebdriverIO Test Optimization worker completion error', error)
+          onDone()
+        }
+      },
+    })
+  } catch (error) {
+    log.error('WebdriverIO Test Optimization worker completion error', error)
+    onDone()
+  }
+}
 
 function isFailedTestReplayEnabled () {
   return config.isTestDynamicInstrumentationEnabled && config.isDiEnabled
@@ -31,46 +370,77 @@ addHook({
   name: 'mocha',
   versions: ['>=8.0.0'],
   file: 'lib/mocha.js',
-}, (Mocha) => {
+}, (Mocha, frameworkVersion) => {
+  reportWebdriverioWorkerReady(frameworkVersion)
+
   shimmer.wrap(Mocha.prototype, 'run', run => function (...args) {
-    if (this.options._ddIsKnownTestsEnabled) {
-      config.isKnownTestsEnabled = true
-      config.isEarlyFlakeDetectionEnabled = this.options._ddIsEfdEnabled
-      config.knownTests = this.options._ddKnownTests
-      config.earlyFlakeDetectionNumRetries = this.options._ddEfdNumRetries
-      config.earlyFlakeDetectionSlowTestRetries = this.options._ddEfdSlowTestRetries ?? {}
-      delete this.options._ddIsEfdEnabled
-      delete this.options._ddKnownTests
-      delete this.options._ddEfdNumRetries
-      delete this.options._ddEfdSlowTestRetries
-      delete this.options._ddIsKnownTestsEnabled
-    }
-    if (this.options._ddIsImpactedTestsEnabled) {
-      config.isImpactedTestsEnabled = true
-      config.modifiedFiles = this.options._ddModifiedFiles
-      delete this.options._ddIsImpactedTestsEnabled
-      delete this.options._ddModifiedFiles
-    }
-    if (this.options._ddIsTestManagementTestsEnabled) {
-      config.isTestManagementTestsEnabled = true
-      config.testManagementAttemptToFixRetries = this.options._ddTestManagementAttemptToFixRetries
-      config.testManagementTests = this.options._ddTestManagementTests
-      delete this.options._ddIsTestManagementTestsEnabled
-      delete this.options._ddTestManagementAttemptToFixRetries
-      delete this.options._ddTestManagementTests
-    }
-    if (this.options._ddIsFlakyTestRetriesEnabled) {
-      config.isFlakyTestRetriesEnabled = true
-      config.flakyTestRetriesCount = this.options._ddFlakyTestRetriesCount
-      delete this.options._ddIsFlakyTestRetriesEnabled
-      delete this.options._ddFlakyTestRetriesCount
-    }
-    if (this.options._ddIsFailedTestReplayEnabled) {
-      config.isTestDynamicInstrumentationEnabled = true
-      config.isDiEnabled = true
-      delete this.options._ddIsFailedTestReplayEnabled
+    applyMochaOptions(this.options)
+    if (!isWebdriverioWorker || !workerFinishCh.hasSubscribers) {
+      return run.apply(this, args)
     }
-    return run.apply(this, args)
+
+    const isUserDelayed = this.options.delay
+    const rootSuite = this.suite
+    const rootSuiteRun = rootSuite.run
+    const hasOwnRootSuiteRun = Object.hasOwn(rootSuite, 'run')
+    let configurationReady = false
+    let userReady = !isUserDelayed
+
+    /**
+     * Restores the root suite method after both delayed-mode gates are open.
+     *
+     * @returns {void}
+     */
+    function restoreRootSuiteRun () {
+      if (hasOwnRootSuiteRun) {
+        rootSuite.run = rootSuiteRun
+      } else {
+        delete rootSuite.run
+      }
+    }
+
+    if (isUserDelayed) {
+      rootSuite.run = function (...args) {
+        userReady = true
+        if (!configurationReady) {
+          return
+        }
+        restoreRootSuiteRun()
+        return rootSuiteRun.apply(this, args)
+      }
+    }
+
+    this.options.delay = true
+    const files = [...this.files]
+    const runner = run.apply(this, args)
+    runnerToFiles.set(runner, files)
+
+    requestWebdriverioConfiguration(frameworkVersion, files, ({
+      configuration,
+      skippedFiles = [],
+    }) => {
+      if (configuration) {
+        Object.assign(config, configuration)
+        workerConfigurationCh.publish({
+          libraryConfig: config,
+          repositoryRoot: config.repositoryRoot,
+          testFramework: config.testFramework,
+        })
+      }
+      filterSkippedFiles(runner, skippedFiles)
+      if (isFailedTestReplayEnabled()) {
+        patchFailedTestReplayHookUp(runner.constructor)
+      }
+      configurationReady = true
+      if (userReady) {
+        if (isUserDelayed) {
+          restoreRootSuiteRun()
+        }
+        rootSuite.run()
+      }
+    })
+
+    return runner
   })
 
   return Mocha
@@ -91,10 +461,32 @@ addHook({
     if (isFailedTestReplayEnabled()) {
       patchFailedTestReplayHookUp(Runner)
     }
-    // We flush when the worker ends with its test file (a mocha instance in a worker runs a single test file)
-    this.once('end', () => {
-      workerFinishCh.publish()
-    })
+    if (isWebdriverioWorker) {
+      this.prependOnceListener('end', () => {
+        try {
+          adjustRunnerFailuresForTestOptimization(this, config)
+          adjustWebdriverioHookFailures(this)
+        } catch (error) {
+          log.error('WebdriverIO Test Optimization failure adjustment error', error)
+        }
+      })
+    }
+    const onRunDone = args[0]
+    if (isWebdriverioWorker && typeof onRunDone === 'function') {
+      args[0] = (...onRunDoneArgs) => {
+        finishWebdriverioWorker(this, () => onRunDone(...onRunDoneArgs))
+      }
+    } else {
+      // Flush after the worker finishes its Mocha run, including grouped spec files.
+      this.once('end', () => {
+        try {
+          workerFinishCh.publish()
+          reportWebdriverioSuiteResults(this)
+        } catch (error) {
+          log.error('WebdriverIO Test Optimization worker completion error', error)
+        }
+      })
+    }
     this.on('test', getOnTestHandler(false))
 
     this.on('test end', getOnTestEndHandler(config))
@@ -104,6 +496,18 @@ addHook({
     // If the hook passes, 'hook end' will be emitted. Otherwise, 'fail' will be emitted
     this.on('hook end', getOnHookEndHandler(config))
 
+    if (isWebdriverioWorker) {
+      const failedHooks = []
+      runnerToFailedHooks.set(this, failedHooks)
+      this.on('fail', runnable => {
+        if (runnable.type === 'hook' && runnable.file) {
+          failedHooks.push({
+            file: runnable.file,
+            test: getWebdriverioHookTest(runnable),
+          })
+        }
+      })
+    }
     this.on('fail', getOnFailHandler(false, config))
 
     this.on('pending', getOnPendingHandler())

package/packages/datadog-instrumentations/src/moleculer/client.js

@@ -10,7 +10,7 @@ const errorChannel = channel('apm:moleculer:call:error')
 function wrapCall (call) {
   return function (actionName, params, opts) {
     opts = arguments[2] = opts || {}
-    opts.meta = opts.meta || {}
+    opts.meta ||= {}
 
     arguments.length = Math.max(3, arguments.length)
 

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

@@ -1350,7 +1350,7 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
       let totalFailedTestCount = 0
       let totalPureQuarantinedFailedTestCount = 0
 
-      for (const [fqn, testStatuses] of testsToTestStatuses.entries()) {
+      for (const [fqn, testStatuses] of testsToTestStatuses) {
         // Only count as failed if the final status (after retries) is 'fail'
         const lastStatus = testStatuses.at(-1)
         if (lastStatus === 'fail') {
@@ -1494,7 +1494,8 @@ createRootSuiteCh.subscribe({
 pageGotoCh.subscribe({
   asyncEnd (ctx) {
     // The Page.goto rewriter waits for this so tests closing immediately after navigation still get RUM tags.
-    ctx.asyncEndPromise = handlePageGoto(ctx.self)
+    const rumDetectionPromise = handlePageGoto(ctx.self)
+    ctx.resolveCallback = onDone => rumDetectionPromise.then(onDone, onDone)
   },
 })
 

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

@@ -222,7 +222,7 @@ function beforeFinish (delivery, state) {
 }
 
 function getStateFromData (stateData) {
-  if (stateData && stateData.descriptor && stateData.descriptor) {
+  if (stateData?.descriptor) {
     switch (stateData.descriptor.value) {
       case 0x24: return 'accepted'
       case 0x25: return 'rejected'