dd-trace 5.53.0 → 5.54.0

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

@@ -4,46 +4,34 @@ const { channel, addHook, AsyncResource } = require('./helpers/instrument')
 
 const shimmer = require('../../datadog-shimmer')
 
+const commandAddCh = channel('apm:mariadb:command:add')
 const startCh = channel('apm:mariadb:query:start')
 const finishCh = channel('apm:mariadb:query:finish')
 const errorCh = channel('apm:mariadb:query:error')
 const skipCh = channel('apm:mariadb:pool:skip')
-const unskipCh = channel('apm:mariadb:pool:unskip')
 
-function wrapCommandStart (start, callbackResource) {
+function wrapCommandStart (start, ctx) {
   return shimmer.wrapFunction(start, start => function () {
     if (!startCh.hasSubscribers) return start.apply(this, arguments)
 
-    const resolve = callbackResource.bind(this.resolve)
-    const reject = callbackResource.bind(this.reject)
-
-    const asyncResource = callbackResource.runInAsyncScope(() => new AsyncResource('bound-anonymous-fn'))
-
+    const { reject, resolve } = this
     shimmer.wrap(this, 'resolve', function wrapResolve () {
       return function () {
-        asyncResource.runInAsyncScope(() => {
-          finishCh.publish()
-        })
-
-        return resolve.apply(this, arguments)
+        return finishCh.runStores(ctx, resolve, this, ...arguments)
       }
     })
 
     shimmer.wrap(this, 'reject', function wrapReject () {
       return function (error) {
-        asyncResource.runInAsyncScope(() => {
-          errorCh.publish(error)
-          finishCh.publish()
-        })
+        ctx.error = error
+
+        errorCh.publish(ctx)
 
-        return reject.apply(this, arguments)
+        return finishCh.runStores(ctx, reject, this, ...arguments)
       }
     })
 
-    return asyncResource.runInAsyncScope(() => {
-      startCh.publish({ sql: this.sql, conf: this.opts })
-      return start.apply(this, arguments)
-    })
+    return startCh.runStores(ctx, start, this, ...arguments)
   })
 }
 
@@ -52,11 +40,13 @@ function wrapCommand (Command) {
     constructor (...args) {
       super(...args)
 
-      const callbackResource = new AsyncResource('bound-anonymous-fn')
+      if (!this.start) return
 
-      if (this.start) {
-        this.start = wrapCommandStart(this.start, callbackResource)
-      }
+      const ctx = { sql: this.sql, conf: this.opts }
+
+      commandAddCh.publish(ctx)
+
+      this.start = wrapCommandStart(this.start, ctx)
     }
   }
 }
@@ -66,21 +56,19 @@ function createWrapQuery (options) {
     return function (sql) {
       if (!startCh.hasSubscribers) return query.apply(this, arguments)
 
-      const asyncResource = new AsyncResource('bound-anonymous-fn')
-
-      return asyncResource.runInAsyncScope(() => {
-        startCh.publish({ sql, conf: options })
-
-        return query.apply(this, arguments)
-          .then(result => {
-            finishCh.publish()
-            return result
-          }, error => {
-            errorCh.publish(error)
-            finishCh.publish()
-            throw error
-          })
-      }, 'bound-anonymous-fn')
+      const ctx = { sql, conf: options }
+
+      return startCh.runStores(ctx, query, this, ...arguments)
+        .then(result => {
+          ctx.result = result
+          finishCh.publish(ctx)
+          return result
+        }, error => {
+          ctx.error
+          errorCh.publish(ctx)
+          finishCh.publish(ctx)
+          throw error
+        })
     }
   }
 }
@@ -91,30 +79,24 @@ function createWrapQueryCallback (options) {
       if (!startCh.hasSubscribers) return query.apply(this, arguments)
 
       const cb = arguments[arguments.length - 1]
-      const asyncResource = new AsyncResource('bound-anonymous-fn')
-      const callbackResource = new AsyncResource('bound-anonymous-fn')
+      const ctx = { sql, conf: options }
 
       if (typeof cb !== 'function') {
         arguments.length = arguments.length + 1
       }
 
-      arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => asyncResource.bind(function (err) {
+      arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => function (err) {
         if (err) {
-          errorCh.publish(err)
+          ctx.error = err
+          errorCh.publish(ctx)
         }
 
-        finishCh.publish()
+        return typeof cb === 'function'
+          ? finishCh.runStores(ctx, cb, this, ...arguments)
+          : finishCh.publish(ctx)
+      })
 
-        if (typeof cb === 'function') {
-          return callbackResource.runInAsyncScope(() => cb.apply(this, arguments))
-        }
-      }))
-
-      return asyncResource.runInAsyncScope(() => {
-        startCh.publish({ sql, conf: options })
-
-        return query.apply(this, arguments)
-      }, 'bound-anonymous-fn')
+      return startCh.runStores(ctx, query, this, ...arguments)
     }
   }
 }
@@ -144,12 +126,7 @@ function wrapPoolBase (PoolBase) {
 // and/or orphan spans.
 function wrapPoolMethod (createConnection) {
   return function () {
-    skipCh.publish()
-    try {
-      return createConnection.apply(this, arguments)
-    } finally {
-      unskipCh.publish()
-    }
+    return skipCh.runStores({}, createConnection, this, ...arguments)
   }
 }
 

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

@@ -66,6 +66,7 @@ const libraryConfigurationCh = channel('ci:mocha:library-configuration')
 const knownTestsCh = channel('ci:mocha:known-tests')
 const skippableSuitesCh = channel('ci:mocha:test-suite:skippable')
 const testManagementTestsCh = channel('ci:mocha:test-management-tests')
+const impactedTestsCh = channel('ci:mocha:modified-tests')
 const workerReportTraceCh = channel('ci:mocha:worker-report:trace')
 const testSessionStartCh = channel('ci:mocha:session:start')
 const testSessionFinishCh = channel('ci:mocha:session:finish')
@@ -175,7 +176,7 @@ function getOnEndHandler (isParallel) {
           originalCoverageMap.merge(fromCoverageMapToCoverage(untestedCoverage))
         }
         testCodeCoverageLinesTotal = originalCoverageMap.getCoverageSummary().lines.pct
-      } catch (e) {
+      } catch {
         // ignore errors
       }
       // restore the original coverage
@@ -209,6 +210,26 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
     } else {
       config.testManagementTests = receivedTestManagementTests
     }
+    if (config.isImpactedTestsEnabled) {
+      impactedTestsCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedImpactedTests)
+      })
+    } else if (config.isSuitesSkippingEnabled) {
+      skippableSuitesCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
+      })
+    } else {
+      onFinishRequest()
+    }
+  }
+
+  const onReceivedImpactedTests = ({ err, modifiedTests: receivedModifiedTests }) => {
+    if (err) {
+      config.modifiedTests = []
+      config.isImpactedTestsEnabled = false
+    } else {
+      config.modifiedTests = receivedModifiedTests
+    }
     if (config.isSuitesSkippingEnabled) {
       skippableSuitesCh.publish({
         onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
@@ -237,7 +258,7 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
 
     runner.suite.suites = suitesToRun
 
-    skippedSuites = Array.from(filteredSuites.skippedSuites)
+    skippedSuites = [...filteredSuites.skippedSuites]
 
     onFinishRequest()
   }
@@ -254,6 +275,10 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
       testManagementTestsCh.publish({
         onDone: mochaRunAsyncResource.bind(onReceivedTestManagementTests)
       })
+    } if (config.isImpactedTestsEnabled) {
+      impactedTestsCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedImpactedTests)
+      })
     } else if (config.isSuitesSkippingEnabled) {
       skippableSuitesCh.publish({
         onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
@@ -274,6 +299,7 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
     config.isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
     config.isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
     config.testManagementAttemptToFixRetries = libraryConfig.testManagementAttemptToFixRetries
+    config.isImpactedTestsEnabled = libraryConfig.isImpactedTestsEnabled
     // ITR and auto test retries are not supported in parallel mode yet
     config.isSuitesSkippingEnabled = !isParallel && libraryConfig.isSuitesSkippingEnabled
     config.isFlakyTestRetriesEnabled = !isParallel && libraryConfig.isFlakyTestRetriesEnabled
@@ -287,6 +313,10 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
       testManagementTestsCh.publish({
         onDone: mochaRunAsyncResource.bind(onReceivedTestManagementTests)
       })
+    } else if (config.isImpactedTestsEnabled) {
+      impactedTestsCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedImpactedTests)
+      })
     } else if (config.isSuitesSkippingEnabled) {
       skippableSuitesCh.publish({
         onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
@@ -441,7 +471,7 @@ addHook({
           itrCorrelationId
         }
         testFileToSuiteCtx.set(suite.file, ctx)
-        testSuiteStartCh.runStores(ctx, () => { })
+        testSuiteStartCh.runStores(ctx, () => {})
       }
     })
 
@@ -485,7 +515,7 @@ addHook({
 
       const ctx = testFileToSuiteCtx.get(suite.file)
       if (ctx) {
-        testSuiteFinishCh.publish({ status, ...ctx.currentStore }, () => { })
+        testSuiteFinishCh.publish({ status, ...ctx.currentStore }, () => {})
       } else {
         log.warn(() => `No AsyncResource found for suite ${suite.file}`)
       }
@@ -505,6 +535,15 @@ addHook({
   file: 'lib/runnable.js'
 }, (runnablePackage) => runnableWrapper(runnablePackage, config))
 
+function onMessage (message) {
+  if (Array.isArray(message)) {
+    const [messageCode, payload] = message
+    if (messageCode === MOCHA_WORKER_TRACE_PAYLOAD_CODE) {
+      workerReportTraceCh.publish(payload)
+    }
+  }
+}
+
 // Only used in parallel mode (--parallel flag is passed)
 // Used to generate suite events and receive test payloads from workers
 addHook({
@@ -523,42 +562,33 @@ addHook({
       return exec.apply(this, arguments)
     }
     const [testSuiteAbsolutePath] = path
-    const testSuiteContext = { }
-
-    function onMessage (message) {
-      if (Array.isArray(message)) {
-        const [messageCode, payload] = message
-        if (messageCode === MOCHA_WORKER_TRACE_PAYLOAD_CODE) {
-          workerReportTraceCh.publish(payload)
-        }
-      }
-    }
+    const testSuiteContext = {}
 
     this.worker.on('message', onMessage)
 
     testSuiteContext.testSuiteAbsolutePath = testSuiteAbsolutePath
-    testSuiteStartCh.runStores(testSuiteContext, () => { })
+    testSuiteStartCh.runStores(testSuiteContext, () => {})
 
     try {
       const promise = exec.apply(this, arguments)
       promise.then(
         (result) => {
           const status = result.failureCount === 0 ? 'pass' : 'fail'
-          testSuiteFinishCh.publish({ status, ...testSuiteContext.currentStore }, () => { })
+          testSuiteFinishCh.publish({ status, ...testSuiteContext.currentStore }, () => {})
           this.worker.off('message', onMessage)
         },
         (err) => {
           testSuiteContext.error = err
-          testSuiteErrorCh.runStores(testSuiteContext, () => { })
-          testSuiteFinishCh.publish({ status: 'fail', ...testSuiteContext.currentStore }, () => { })
+          testSuiteErrorCh.runStores(testSuiteContext, () => {})
+          testSuiteFinishCh.publish({ status: 'fail', ...testSuiteContext.currentStore }, () => {})
           this.worker.off('message', onMessage)
         }
       )
       return promise
     } catch (err) {
       testSuiteContext.error = err
-      testSuiteErrorCh.runStores(testSuiteContext, () => { })
-      testSuiteFinishCh.publish({ status: 'fail', ...testSuiteContext.currentStore }, () => { })
+      testSuiteErrorCh.runStores(testSuiteContext, () => {})
+      testSuiteFinishCh.publish({ status: 'fail', ...testSuiteContext.currentStore }, () => {})
       this.worker.off('message', onMessage)
       throw err
     }
@@ -616,7 +646,10 @@ addHook({
   const { BufferedWorkerPool } = BufferedWorkerPoolPackage
 
   shimmer.wrap(BufferedWorkerPool.prototype, 'run', run => async function (testSuiteAbsolutePath, workerArgs) {
-    if (!testFinishCh.hasSubscribers || (!config.isKnownTestsEnabled && !config.isTestManagementTestsEnabled)) {
+    if (!testFinishCh.hasSubscribers ||
+        (!config.isKnownTestsEnabled &&
+         !config.isTestManagementTestsEnabled &&
+         !config.isImpactedTestsEnabled)) {
       return run.apply(this, arguments)
     }
 
@@ -649,6 +682,12 @@ addHook({
       }
     }
 
+    if (config.isImpactedTestsEnabled) {
+      const testSuiteImpactedTests = config.modifiedTests || {}
+      newWorkerArgs._ddIsImpactedTestsEnabled = true
+      newWorkerArgs._ddModifiedTests = testSuiteImpactedTests
+    }
+
     // We pass the known tests for the test file to the worker
     const testFileResult = await run.apply(
       this,
@@ -669,10 +708,10 @@ addHook({
         const testFullName = getTestFullName(test)
         const tests = newTests[testFullName]
 
-        if (!tests) {
-          newTests[testFullName] = [test]
-        } else {
+        if (tests) {
           tests.push(test)
+        } else {
+          newTests[testFullName] = [test]
         }
       }
       // `testsQuarantined` is filled in the worker process, so we need to use the test results to fill it here too.

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

@@ -18,7 +18,7 @@ const testRetryCh = channel('ci:mocha:test:retry')
 const errorCh = channel('ci:mocha:test:error')
 const skipCh = channel('ci:mocha:test:skip')
 const testFnCh = channel('ci:mocha:test:fn')
-
+const isModifiedCh = channel('ci:mocha:test:is-modified')
 // suite channels
 const testSuiteErrorCh = channel('ci:mocha:test-suite:error')
 
@@ -209,7 +209,8 @@ function getOnTestHandler (isMain) {
       _ddIsEfdRetry: isEfdRetry,
       _ddIsAttemptToFix: isAttemptToFix,
       _ddIsDisabled: isDisabled,
-      _ddIsQuarantined: isQuarantined
+      _ddIsQuarantined: isQuarantined,
+      _ddIsModified: isModified
     } = test
 
     const testName = removeEfdStringFromTestName(removeAttemptToFixStringFromTestName(test.fullTitle()))
@@ -230,6 +231,7 @@ function getOnTestHandler (isMain) {
     testInfo.isAttemptToFix = isAttemptToFix
     testInfo.isDisabled = isDisabled
     testInfo.isQuarantined = isQuarantined
+    testInfo.isModified = isModified
     // We want to store the result of the new tests
     if (isNew) {
       const testFullName = getTestFullName(test)
@@ -246,7 +248,7 @@ function getOnTestHandler (isMain) {
 
     const ctx = testInfo
     testToContext.set(test.fn, ctx)
-    testStartCh.runStores(ctx, () => { })
+    testStartCh.runStores(ctx, () => {})
   }
 }
 
@@ -271,17 +273,17 @@ function getOnTestEndHandler (config) {
 
     const testName = getTestFullName(test)
 
-    if (!testsStatuses.get(testName)) {
-      testsStatuses.set(testName, [status])
-    } else {
+    if (testsStatuses.get(testName)) {
       testsStatuses.get(testName).push(status)
+    } else {
+      testsStatuses.set(testName, [status])
     }
     const testStatuses = testsStatuses.get(testName)
 
     const isLastAttempt = testStatuses.length === config.testManagementAttemptToFixRetries + 1
 
     if (test._ddIsAttemptToFix && isLastAttempt) {
-      if (testStatuses.some(status => status === 'fail')) {
+      if (testStatuses.includes('fail')) {
         attemptToFixFailed = true
       }
       if (testStatuses.every(status => status === 'fail')) {
@@ -351,12 +353,12 @@ function getOnFailHandler (isMain) {
       if (isHook) {
         err.message = `${testOrHook.fullTitle()}: ${err.message}`
         testContext.err = err
-        errorCh.runStores(testContext, () => { })
+        errorCh.runStores(testContext, () => {})
         // if it's a hook and it has failed, 'test end' will not be called
         testFinishCh.publish({ status: 'fail', hasBeenRetried: isMochaRetry(test), ...testContext.currentStore })
       } else {
         testContext.err = err
-        errorCh.runStores(testContext, () => { })
+        errorCh.runStores(testContext, () => {})
       }
     }
 
@@ -370,7 +372,7 @@ function getOnFailHandler (isMain) {
         )
         testSuiteError.stack = err.stack
         testSuiteContext.error = testSuiteError
-        testSuiteErrorCh.runStores(testSuiteContext, () => { })
+        testSuiteErrorCh.runStores(testSuiteContext, () => {})
       }
     }
   }
@@ -420,7 +422,7 @@ function getOnPendingHandler () {
       } else {
         testToContext.set(test, testCtx)
       }
-      skipCh.runStores(testCtx, () => { })
+      skipCh.runStores(testCtx, () => {})
     }
   }
 }
@@ -452,12 +454,34 @@ function getRunTestsWrapper (runTests, config) {
       })
     }
 
+    if (config.isImpactedTestsEnabled) {
+      suite.tests.forEach((test) => {
+        isModifiedCh.publish({
+          modifiedTests: config.modifiedTests,
+          file: suite.file,
+          onDone: (isModified) => {
+            if (isModified) {
+              test._ddIsModified = true
+              if (!test.isPending() && !test._ddIsAttemptToFix && config.isEarlyFlakeDetectionEnabled) {
+                retryTest(
+                  test,
+                  config.earlyFlakeDetectionNumRetries,
+                  addEfdStringToTestName,
+                  ['_ddIsModified', '_ddIsEfdRetry']
+                )
+              }
+            }
+          }
+        })
+      })
+    }
+
     if (config.isKnownTestsEnabled) {
       // 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
-          if (config.isEarlyFlakeDetectionEnabled) {
+          if (config.isEarlyFlakeDetectionEnabled && !test._ddIsAttemptToFix && !test._ddIsModified) {
             retryTest(
               test,
               config.earlyFlakeDetectionNumRetries,

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

@@ -34,6 +34,12 @@ addHook({
       delete this.options._ddEfdNumRetries
       delete this.options._ddIsKnownTestsEnabled
     }
+    if (this.options._ddIsImpactedTestsEnabled) {
+      config.isImpactedTestsEnabled = true
+      config.modifiedTests = this.options._ddModifiedTests
+      delete this.options._ddIsImpactedTestsEnabled
+      delete this.options._ddModifiedTests
+    }
     if (this.options._ddIsTestManagementTestsEnabled) {
       config.isTestManagementTestsEnabled = true
       // TODO: attempt to fix does not work in parallel mode yet

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

@@ -204,7 +204,7 @@ function instrumentPromise (operation, command, ctx, args, server, ns, ops, opti
       errorCh.publish(err)
       finishCh.publish()
 
-      return Promise.reject(err)
+      throw err
     })
   })
 }

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

@@ -1,10 +1,6 @@
 'use strict'
 
-const {
-  channel,
-  addHook,
-  AsyncResource
-} = require('./helpers/instrument')
+const { channel, addHook, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
 addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connection => {
@@ -19,43 +15,38 @@ addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connect
 
     const sql = arguments[0].sql || arguments[0]
     const conf = this.config
-    const payload = { sql, conf }
-
-    const callbackResource = new AsyncResource('bound-anonymous-fn')
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
-    return asyncResource.runInAsyncScope(() => {
-      startCh.publish(payload)
+    const ctx = { sql, conf }
 
+    return startCh.runStores(ctx, () => {
       if (arguments[0].sql) {
-        arguments[0].sql = payload.sql
+        arguments[0].sql = ctx.sql
       } else {
-        arguments[0] = payload.sql
+        arguments[0] = ctx.sql
       }
+
       try {
         const res = query.apply(this, arguments)
 
         if (res._callback) {
-          const cb = callbackResource.bind(res._callback)
-          res._callback = shimmer.wrapFunction(cb, cb => asyncResource.bind(function (error, result) {
+          const cb = res._callback
+          res._callback = shimmer.wrapFunction(cb, cb => function (error, result) {
             if (error) {
-              errorCh.publish(error)
+              ctx.error = error
+              errorCh.publish(ctx)
             }
-            finishCh.publish(result)
+            ctx.result = result
 
-            return cb.apply(this, arguments)
-          }))
-        } else {
-          const cb = asyncResource.bind(function () {
-            finishCh.publish(undefined)
+            return finishCh.runStores(ctx, cb, this, error, result)
           })
-          res.on('end', cb)
+        } else {
+          res.on('end', () => finishCh.publish(ctx))
         }
 
         return res
       } catch (err) {
         err.stack // trigger getting the stack at the original throwing point
-        errorCh.publish(err)
+        ctx.error = err
+        errorCh.publish(ctx)
 
         throw err
       }
@@ -79,22 +70,15 @@ addHook({ name: 'mysql', file: 'lib/Pool.js', versions: ['>=2'] }, Pool => {
       return query.apply(this, arguments)
     }
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
     const sql = arguments[0].sql || arguments[0]
+    const ctx = { sql }
+    const finish = () => finishPoolQueryCh.publish(ctx)
 
-    return asyncResource.runInAsyncScope(() => {
-      startPoolQueryCh.publish({ sql })
-
-      const finish = asyncResource.bind(function () {
-        finishPoolQueryCh.publish()
-      })
-
+    return startPoolQueryCh.runStores(ctx, () => {
       const cb = arguments[arguments.length - 1]
       if (typeof cb === 'function') {
         arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => function () {
-          finish()
-          return cb.apply(this, arguments)
+          return finishPoolQueryCh.runStores(ctx, cb, this, ...arguments)
         })
       }