dd-trace 6.8.0 → 6.10.0

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

@@ -3,6 +3,7 @@
 const { AsyncResource } = require('node:async_hooks')
 const { fileURLToPath } = require('node:url')
 
+const { EMPTY_EFD_RETRY_POLICY } = require('../../dd-trace/src/ci-visibility/efd-retry-policy')
 const { getEnvironmentVariable } = require('../../dd-trace/src/config/helper')
 const log = require('../../dd-trace/src/log')
 const {
@@ -11,6 +12,7 @@ const {
   getTestSuitePath,
   logTestOptimizationSummary,
   MOCHA_WORKER_LOGS_PAYLOAD_CODE,
+  MOCHA_WORKER_TELEMETRY_PAYLOAD_CODE,
   MOCHA_WORKER_TRACE_PAYLOAD_CODE,
   TEST_SUITE_EXECUTION_ID,
 } = require('../../dd-trace/src/plugins/util/test')
@@ -18,31 +20,43 @@ const { addHook, channel, tracingChannel } = require('./helpers/instrument')
 const {
   CONFIGURATION_REQUEST,
   CONFIGURATION_RESPONSE,
+  sendWebdriverioWorkerMessage,
   SUITE_FINISH,
   WEBDRIVERIO_WORKER_ENV,
   WEBDRIVERIO_WORKER_EVENT,
   WEBDRIVERIO_WORKER_ORIGIN,
   WORKER_READY,
+  WORKER_READY_RESPONSE,
 } = require('./mocha/webdriverio-protocol')
 
+const jasmineDoneCh = channel('ci:webdriverio:jasmine:done')
 const testFinishCh = channel('ci:mocha:test:finish')
 const testSessionStartCh = channel('ci:mocha:session:start')
 const testSessionFinishCh = channel('ci:mocha:session:finish')
+const testSuiteErrorCh = channel('ci:mocha:test-suite:error')
 const testSuiteStartCh = channel('ci:mocha:test-suite:start')
 const testSuiteFinishCh = channel('ci:mocha:test-suite:finish')
 const knownTestsCh = channel('ci:mocha:known-tests')
 const libraryConfigurationCh = channel('ci:mocha:library-configuration')
 const modifiedFilesCh = channel('ci:mocha:modified-files')
 const testManagementTestsCh = channel('ci:mocha:test-management-tests')
+const workerConfigurationCh = channel('ci:mocha:worker:configuration')
 const workerReportLogsCh = channel('ci:mocha:worker-report:logs')
+const workerReportTelemetryCh = channel('ci:mocha:worker-report:telemetry')
 const workerReportTraceCh = channel('ci:mocha:worker-report:trace')
 
+const jasmineAdapterInitCh = tracingChannel('orchestrion:@wdio/jasmine-framework:JasmineAdapter_init')
 const launcherStartInstanceCh = tracingChannel('orchestrion:@wdio/cli:Launcher_startInstance')
 const localRunnerRunCh = tracingChannel('orchestrion:@wdio/local-runner:LocalRunner_run')
 const localRunnerShutdownCh = tracingChannel('orchestrion:@wdio/local-runner:LocalRunner_shutdown')
 
 const NODE_OPTIONS_SEPARATOR_RE = /\s/
+const JASMINE_FRAMEWORK_ADAPTER = 'jasmine'
+const MOCHA_FRAMEWORK_ADAPTER = 'mocha'
+const SUPPORTED_FRAMEWORK_ADAPTERS = new Set([JASMINE_FRAMEWORK_ADAPTER, MOCHA_FRAMEWORK_ADAPTER])
 const TEST_FRAMEWORK = 'webdriverio'
+const isWebdriverioWorker = !!getEnvironmentVariable(WEBDRIVERIO_WORKER_ENV)
+let jasmineWorkerRequestId = 0
 
 const loadCh = channel('dd-trace:instrumentation:load')
 if (loadCh.hasSubscribers) {
@@ -66,7 +80,7 @@ addHook({
  * @typedef {object} WebdriverioRunnerConfig
  * @property {string} framework
  * @property {string|undefined} rootDir
- * @property {NodeJS.ProcessEnv|undefined} runnerEnv
+ * @property {typeof process.env|undefined} runnerEnv
  */
 
 /**
@@ -79,6 +93,7 @@ addHook({
  * @typedef {object} WorkerRecord
  * @property {object} worker
  * @property {string[]} specs
+ * @property {Map<string, WebdriverioSuiteResult>} reportedSuiteResults
  * @property {Map<string, WebdriverioSuiteContext>} suiteContexts
  * @property {string} testSuiteExecutionId
  * @property {boolean|undefined} hasTests
@@ -89,11 +104,18 @@ addHook({
 /**
  * @typedef {object} WebdriverioSuiteContext
  * @property {object|undefined} currentStore
+ * @property {Error|undefined} error
  * @property {string|undefined} status
  * @property {string} testSuiteAbsolutePath
  * @property {string} testSuiteExecutionId
  */
 
+/**
+ * @typedef {object} WebdriverioSuiteResult
+ * @property {{message?: string, stack?: string}|undefined} error
+ * @property {string|undefined} status
+ */
+
 /**
  * @typedef {object} CoordinatorState
  * @property {WebdriverioLocalRunner} localRunner
@@ -112,21 +134,21 @@ addHook({
  * @property {Set<string>} newTestsWithDynamicNames
  * @property {number} nextWorkerId
  * @property {Set<string>} scheduledFiles
+ * @property {Map<string, object>} testManagementExecutions
  * @property {unknown} runError
  * @property {Set<WorkerRecord>} workers
  * @property {Map<object, string>} suiteStatuses
  */
 
 /**
- * Creates the configuration consumed by Mocha workers.
+ * Creates the configuration consumed by WebdriverIO workers.
  *
  * @returns {object}
  */
 function createWorkerConfiguration () {
   return {
     earlyFlakeDetectionFaultyThreshold: 30,
-    earlyFlakeDetectionNumRetries: 0,
-    earlyFlakeDetectionSlowTestRetries: {},
+    earlyFlakeDetectionRetryPolicy: EMPTY_EFD_RETRY_POLICY,
     flakyTestRetriesCount: 0,
     isCodeCoverageEnabled: false,
     isCoverageReportUploadEnabled: false,
@@ -148,6 +170,105 @@ function createWorkerConfiguration () {
   }
 }
 
+/**
+ * Configures a Jasmine worker and waits for its coordinator-owned optimization settings.
+ *
+ * @param {{_jrunner?: {env?: {addReporter?: (reporter: object) => void}}, _specs?: string[]}} adapter
+ * @param {{
+ *   resolveCallback?: (onDone: () => void) => void,
+ *   rejectCallback?: (onDone: () => void) => void
+ * }} context
+ * @returns {void}
+ */
+function initializeJasmineWorker (adapter, context) {
+  if (!isWebdriverioWorker) {
+    return
+  }
+
+  const specs = adapter?._specs || []
+
+  if (jasmineDoneCh.hasSubscribers) {
+    adapter?._jrunner?.env?.addReporter?.({
+      /**
+       * Publishes run-level failures that are absent from suiteDone.
+       *
+       * @param {object} result
+       * @returns {void}
+       */
+      jasmineDone (result) {
+        jasmineDoneCh.publish({ result })
+      },
+    })
+  }
+
+  /**
+   * Waits until the coordinator has started this worker's parent spans.
+   *
+   * @param {() => void} onDone
+   * @returns {void}
+   */
+  const waitForCoordinator = onDone => {
+    const requestId = `${process.pid}-${++jasmineWorkerRequestId}`
+    let finished = false
+
+    /**
+     * Releases Jasmine initialization exactly once.
+     *
+     * @param {object} [configuration]
+     * @returns {void}
+     */
+    function finish (configuration = createWorkerConfiguration()) {
+      if (finished) {
+        return
+      }
+      finished = true
+      clearTimeout(timeout)
+      process.off('message', onMessage)
+      process.off('disconnect', finish)
+      workerConfigurationCh.publish({
+        libraryConfig: configuration,
+        repositoryRoot: configuration.repositoryRoot,
+        specs,
+        testFramework: TEST_FRAMEWORK,
+        testFrameworkAdapter: JASMINE_FRAMEWORK_ADAPTER,
+      })
+      onDone()
+    }
+
+    /**
+     * Receives coordinator readiness for this worker.
+     *
+     * @param {object} message
+     * @returns {void}
+     */
+    function onMessage (message) {
+      if (message?.name === WORKER_READY_RESPONSE && message.content?.requestId === requestId) {
+        finish(message.content.configuration)
+      }
+    }
+
+    const timeout = setTimeout(finish, 30_000)
+    process.on('message', onMessage)
+    process.once('disconnect', finish)
+    sendWebdriverioWorkerMessage({
+      origin: 'datadog',
+      name: WORKER_READY,
+      content: {
+        requestId,
+        testFrameworkAdapter: JASMINE_FRAMEWORK_ADAPTER,
+      },
+    }, error => {
+      if (error) {
+        log.error('WebdriverIO Test Optimization IPC error', error)
+      }
+      finish()
+    })
+  }
+
+  context.resolveCallback = waitForCoordinator
+  context.rejectCallback = waitForCoordinator
+}
+
 /**
  * Gets the public runner configuration, or the private equivalent used by older releases.
  *
@@ -187,6 +308,7 @@ function getCoordinatorState (localRunner) {
     newTestsWithDynamicNames: new Set(),
     nextWorkerId: 0,
     scheduledFiles: new Set(),
+    testManagementExecutions: new Map(),
     runError: undefined,
     workers: new Set(),
     suiteStatuses: new Map(),
@@ -247,7 +369,7 @@ function includesNodeOptions (workerNodeOptions, launcherNodeOptions) {
 }
 
 /**
- * Starts the single Mocha session owned by the WebdriverIO launcher.
+ * Starts the single test session owned by the WebdriverIO launcher.
  *
  * @param {CoordinatorState} state
  * @returns {void}
@@ -326,6 +448,18 @@ function getMochaFrameworkData (frameworkData) {
   return frameworkData?.[TEST_FRAMEWORK] ?? frameworkData?.mocha
 }
 
+/**
+ * Applies the worker configuration for an EFD session with faulty known-tests data.
+ *
+ * @param {object} configuration
+ * @returns {void}
+ */
+function setEarlyFlakeDetectionFaulty (configuration) {
+  configuration.isEarlyFlakeDetectionEnabled = false
+  configuration.isEarlyFlakeDetectionFaulty = true
+  configuration.isKnownTestsEnabled = false
+}
+
 /**
  * Applies settings and requests the enabled non-TIA datasets once for the whole run.
  *
@@ -349,8 +483,7 @@ function configureCoordinator (state, response) {
   }
 
   configuration.earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
-  configuration.earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
-  configuration.earlyFlakeDetectionSlowTestRetries = libraryConfig.earlyFlakeDetectionSlowTestRetries ?? {}
+  configuration.earlyFlakeDetectionRetryPolicy = libraryConfig.earlyFlakeDetectionRetryPolicy ?? EMPTY_EFD_RETRY_POLICY
   configuration.flakyTestRetriesCount = libraryConfig.flakyTestRetriesCount
   configuration.isDiEnabled = libraryConfig.isDiEnabled
   configuration.isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
@@ -379,9 +512,11 @@ function configureCoordinator (state, response) {
     pendingRequests++
     requestCoordinatorData(state, knownTestsCh, ({ err, knownTests } = {}) => {
       const mochaKnownTests = getMochaFrameworkData(knownTests)
-      if (err || !mochaKnownTests) {
+      if (err) {
         configuration.isEarlyFlakeDetectionEnabled = false
         configuration.isKnownTestsEnabled = false
+      } else if (mochaKnownTests === undefined) {
+        setEarlyFlakeDetectionFaulty(configuration)
       } else {
         configuration.knownTests = { mocha: mochaKnownTests }
       }
@@ -476,7 +611,10 @@ function startWorkerSuites (workerRecord, files) {
       continue
     }
 
+    const reportedResult = workerRecord.reportedSuiteResults.get(file)
     const suiteContext = {
+      error: getWebdriverioSuiteError(reportedResult?.error),
+      status: reportedResult?.status,
       testSuiteAbsolutePath: file,
       testSuiteExecutionId: workerRecord.testSuiteExecutionId,
     }
@@ -502,6 +640,9 @@ function finishWorkerSuite (state, workerRecord, rawFile, status) {
   }
 
   state.suiteStatuses.set(suiteContext, status)
+  if (suiteContext.error) {
+    testSuiteErrorCh.runStores(suiteContext, () => {})
+  }
   testSuiteFinishCh.publish({ status, ...suiteContext.currentStore })
 }
 
@@ -552,7 +693,7 @@ function sendWorkerMessage (workerRecord, message) {
 }
 
 /**
- * Handles a worker request for its Mocha execution configuration.
+ * Handles a worker request for its execution configuration.
  *
  * @param {CoordinatorState} state
  * @param {WorkerRecord} workerRecord
@@ -601,14 +742,30 @@ function updateEarlyFlakeDetectionFaultyState (state, files) {
     configuration.earlyFlakeDetectionFaultyThreshold
   )
   if (isFaulty) {
-    configuration.isEarlyFlakeDetectionEnabled = false
-    configuration.isEarlyFlakeDetectionFaulty = true
-    configuration.isKnownTestsEnabled = false
+    setEarlyFlakeDetectionFaulty(configuration)
+  }
+}
+
+/**
+ * Reconstructs an Error received from a WebdriverIO worker.
+ *
+ * @param {{message?: string, stack?: string}|undefined} error
+ * @returns {Error|undefined}
+ */
+function getWebdriverioSuiteError (error) {
+  if (!error?.message) {
+    return
   }
+
+  const suiteError = new Error(error.message)
+  if (error.stack) {
+    suiteError.stack = error.stack
+  }
+  return suiteError
 }
 
 /**
- * Handles suite results reported by a Mocha worker.
+ * Handles suite results reported by a WebdriverIO worker.
  *
  * @param {WorkerRecord} workerRecord
  * @param {object} message
@@ -616,9 +773,12 @@ function updateEarlyFlakeDetectionFaultyState (state, files) {
  */
 function handleSuiteResults (workerRecord, message) {
   const { results = [] } = message.content || {}
-  for (const { file, status } of results) {
-    const suiteContext = workerRecord.suiteContexts.get(normalizeFile(file))
+  for (const { error, file, status } of results) {
+    const normalizedFile = normalizeFile(file)
+    workerRecord.reportedSuiteResults.set(normalizedFile, { error, status })
+    const suiteContext = workerRecord.suiteContexts.get(normalizedFile)
     if (suiteContext) {
+      suiteContext.error = getWebdriverioSuiteError(error)
       suiteContext.status = status
     }
   }
@@ -643,6 +803,7 @@ function handleWorkerMessage (state, workerRecord, message) {
       collectTestOptimizationSummariesFromTraces(payload, {
         attemptToFixExecutions: state.attemptToFixExecutions,
         newTestsWithDynamicNames: state.newTestsWithDynamicNames,
+        testManagementExecutions: state.testManagementExecutions,
       })
       workerReportTraceCh.publish({
         traces: payload,
@@ -650,6 +811,8 @@ function handleWorkerMessage (state, workerRecord, message) {
       })
     } else if (messageCode === MOCHA_WORKER_LOGS_PAYLOAD_CODE) {
       workerReportLogsCh.publish(payload)
+    } else if (messageCode === MOCHA_WORKER_TELEMETRY_PAYLOAD_CODE) {
+      workerReportTelemetryCh.publish(payload)
     }
     return
   }
@@ -659,7 +822,19 @@ function handleWorkerMessage (state, workerRecord, message) {
   }
 
   if (message.name === WORKER_READY) {
-    initializeCoordinator(state)
+    initializeCoordinator(state, configuration => {
+      if (state.testFrameworkAdapter === JASMINE_FRAMEWORK_ADAPTER) {
+        updateEarlyFlakeDetectionFaultyState(state, workerRecord.specs)
+        startWorkerSuites(workerRecord, workerRecord.specs)
+      }
+      if (message.content?.requestId) {
+        sendWorkerMessage(workerRecord, {
+          origin: 'datadog',
+          name: WORKER_READY_RESPONSE,
+          content: { configuration, requestId: message.content.requestId },
+        })
+      }
+    })
     return
   }
   if (message.name === CONFIGURATION_REQUEST) {
@@ -721,6 +896,7 @@ function registerWorker (state, worker, specs) {
   const workerRecord = {
     worker,
     specs: normalizedSpecs,
+    reportedSuiteResults: new Map(),
     suiteContexts: new Map(),
     testSuiteExecutionId: String(++state.nextWorkerId),
     hasTests: undefined,
@@ -768,7 +944,7 @@ function getSessionStatus (state) {
 }
 
 /**
- * Finishes the single WebdriverIO-owned Mocha session.
+ * Finishes the single WebdriverIO-owned test session.
  *
  * @param {CoordinatorState} state
  * @param {unknown} error
@@ -801,6 +977,7 @@ function finishCoordinator (state, error, onDone) {
     logTestOptimizationSummary({
       attemptToFixExecutions: state.attemptToFixExecutions,
       newTestsWithDynamicNames: state.newTestsWithDynamicNames,
+      testManagementExecutions: state.testManagementExecutions,
     })
     onDone()
     return
@@ -819,24 +996,37 @@ function finishCoordinator (state, error, onDone) {
   logTestOptimizationSummary({
     attemptToFixExecutions: state.attemptToFixExecutions,
     newTestsWithDynamicNames: state.newTestsWithDynamicNames,
+    testManagementExecutions: state.testManagementExecutions,
   })
 }
 
+// dc-polyfill supports partial tracing-channel subscribers, unlike the Node.js type definition.
+// @ts-expect-error
+jasmineAdapterInitCh.subscribe({
+  asyncEnd (context) {
+    initializeJasmineWorker(context.result || context.self, context)
+  },
+})
+
 // dc-polyfill supports partial tracing-channel subscribers, unlike the Node.js type definition.
 // @ts-expect-error
 launcherStartInstanceCh.subscribe({
   start (context) {
     const localRunner = context.self?.runner
     const runnerConfiguration = localRunner && getRunnerConfiguration(localRunner)
-    if (!testFinishCh.hasSubscribers || runnerConfiguration?.framework !== 'mocha') {
+    if (!testFinishCh.hasSubscribers || !SUPPORTED_FRAMEWORK_ADAPTERS.has(runnerConfiguration?.framework)) {
       return
     }
 
     const state = getCoordinatorState(localRunner)
     addScheduledFiles(state, context.arguments?.[0] || [])
-    for (const schedule of context.self._schedule || []) {
-      for (const { files } of schedule.specs || []) {
-        addScheduledFiles(state, files)
+    if (context.self._schedule) {
+      for (const schedule of context.self._schedule) {
+        if (schedule.specs) {
+          for (const { files } of schedule.specs) {
+            addScheduledFiles(state, files)
+          }
+        }
       }
     }
   },
@@ -847,7 +1037,7 @@ launcherStartInstanceCh.subscribe({
 localRunnerRunCh.subscribe({
   start (context) {
     const runnerConfiguration = getRunnerConfiguration(context.self)
-    if (!testFinishCh.hasSubscribers || runnerConfiguration?.framework !== 'mocha') {
+    if (!testFinishCh.hasSubscribers || !SUPPORTED_FRAMEWORK_ADAPTERS.has(runnerConfiguration?.framework)) {
       return
     }
 

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

@@ -8,7 +8,7 @@ addHook({
   name: 'when',
   file: 'lib/Promise.js',
   versions: ['>=3'],
-}, Promise => {
-  shimmer.wrap(Promise.prototype, 'then', wrapThen)
-  return Promise
+}, LibraryPromise => {
+  shimmer.wrap(LibraryPromise.prototype, 'then', wrapThen)
+  return LibraryPromise
 })

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

@@ -49,7 +49,11 @@ const setSocketCh = channel('tracing:ws:server:connect:setSocket')
  */
 
 /**
- * @typedef {string | Buffer | ArrayBuffer | ArrayBufferView | Blob | Buffer[]} WebSocketMessageData
+ * @typedef {{ buffer: ArrayBuffer | SharedArrayBuffer, byteLength: number, byteOffset: number }} BufferView
+ */
+
+/**
+ * @typedef {string | Buffer | ArrayBuffer | BufferView | Blob | Buffer[]} WebSocketMessageData
  */
 
 /**

package/packages/datadog-plugin-aws-durable-execution-sdk-js/src/trace-checkpoint.js

@@ -1,6 +1,12 @@
 'use strict'
 
 const crypto = require('crypto')
+const {
+  deleteDatadogParentId,
+  readDatadogParentId,
+  readDatadogTraceId,
+  writeDatadogParentId,
+} = require('../../dd-trace/src/carrier')
 const log = require('../../dd-trace/src/log')
 const TextMapPropagator = require('../../dd-trace/src/opentracing/propagation/text_map')
 
@@ -37,7 +43,7 @@ function getDatadogOnlyPropagator (tracer) {
  * @returns {Record<string, string>}
  */
 function injectHeaders (tracer, span) {
-  const headers = {}
+  const headers = /** @type {Record<string, string>} */ ({})
   const propagator = getDatadogOnlyPropagator(tracer)
   const ctx = typeof span?.context === 'function' ? span.context() : span
   propagator.inject(ctx, headers)
@@ -51,8 +57,8 @@ function injectHeaders (tracer, span) {
  */
 function overrideParentId (headers, parentId) {
   if (!parentId) return
-  if (headers['x-datadog-trace-id']) {
-    headers['x-datadog-parent-id'] = String(parentId)
+  if (readDatadogTraceId(headers)) {
+    writeDatadogParentId(headers, String(parentId))
   }
 }
 
@@ -192,7 +198,7 @@ async function saveTraceContextCheckpointIfUpdated (
   if (typeof checkpointManager?.checkpoint !== 'function') return
 
   const currentHeaders = injectHeaders(tracer, span)
-  if (currentHeaders['x-datadog-trace-id'] === undefined) return
+  if (readDatadogTraceId(currentHeaders) === undefined) return
 
   const latest = findLastCheckpoint(event)
 
@@ -204,8 +210,8 @@ async function saveTraceContextCheckpointIfUpdated (
     // x-datadog-parent-id reflects the active span at save time and always differs, so exclude it
     // from the comparison. Capture the previous anchor first to carry it forward on a real update.
     // needsCheckpointUpdate only reads currentHeaders' keys, so deleting it from there is enough.
-    const anchoredSpanId = previousHeaders['x-datadog-parent-id']
-    delete currentHeaders['x-datadog-parent-id']
+    const anchoredSpanId = readDatadogParentId(previousHeaders)
+    deleteDatadogParentId(currentHeaders)
     if (!needsCheckpointUpdate(currentHeaders, previousHeaders)) return
 
     newNumber = latest.checkpointNumber + 1