dd-trace 5.17.0 → 5.19.0

package/packages/datadog-instrumentations/src/helpers/hook.js

@@ -11,8 +11,13 @@ const ritm = require('../../../dd-trace/src/ritm')
  * @param {string[]} modules list of modules to hook into
  * @param {Function} onrequire callback to be executed upon encountering module
  */
-function Hook (modules, onrequire) {
-  if (!(this instanceof Hook)) return new Hook(modules, onrequire)
+function Hook (modules, hookOptions, onrequire) {
+  if (!(this instanceof Hook)) return new Hook(modules, hookOptions, onrequire)
+
+  if (typeof hookOptions === 'function') {
+    onrequire = hookOptions
+    hookOptions = {}
+  }
 
   this._patched = Object.create(null)
 
@@ -28,7 +33,7 @@ function Hook (modules, onrequire) {
   }
 
   this._ritmHook = ritm(modules, {}, safeHook)
-  this._iitmHook = iitm(modules, {}, (moduleExports, moduleName, moduleBaseDir) => {
+  this._iitmHook = iitm(modules, hookOptions, (moduleExports, moduleName, moduleBaseDir) => {
     // TODO: Move this logic to import-in-the-middle and only do it for CommonJS
     // modules and not ESM. In the meantime, all the modules we instrument are
     // CommonJS modules for which the default export is always moved to

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -23,6 +23,7 @@ module.exports = {
   '@opentelemetry/sdk-trace-node': () => require('../otel-sdk-trace'),
   '@redis/client': () => require('../redis'),
   '@smithy/smithy-client': () => require('../aws-sdk'),
+  '@vitest/runner': { esmFirst: true, fn: () => require('../vitest') },
   aerospike: () => require('../aerospike'),
   amqp10: () => require('../amqp10'),
   amqplib: () => require('../amqplib'),
@@ -110,6 +111,7 @@ module.exports = {
   sharedb: () => require('../sharedb'),
   tedious: () => require('../tedious'),
   undici: () => require('../undici'),
+  vitest: { esmFirst: true, fn: () => require('../vitest') },
   when: () => require('../when'),
   winston: () => require('../winston')
 }

package/packages/datadog-instrumentations/src/helpers/instrument.js

@@ -17,10 +17,11 @@ exports.channel = function (name) {
 /**
  * @param {string} args.name module name
  * @param {string[]} args.versions array of semver range strings
- * @param {string} args.file path to file within package to instrument?
+ * @param {string} args.file path to file within package to instrument
+ * @param {string} args.filePattern pattern to match files within package to instrument
  * @param Function hook
  */
-exports.addHook = function addHook ({ name, versions, file }, hook) {
+exports.addHook = function addHook ({ name, versions, file, filePattern }, hook) {
   if (typeof name === 'string') {
     name = [name]
   }
@@ -29,7 +30,7 @@ exports.addHook = function addHook ({ name, versions, file }, hook) {
     if (!instrumentations[val]) {
       instrumentations[val] = []
     }
-    instrumentations[val].push({ name: val, versions, file, hook })
+    instrumentations[val].push({ name: val, versions, file, filePattern, hook })
   }
 }
 

package/packages/datadog-instrumentations/src/helpers/register.js

@@ -7,6 +7,7 @@ const Hook = require('./hook')
 const requirePackageJson = require('../../../dd-trace/src/require-package-json')
 const log = require('../../../dd-trace/src/log')
 const checkRequireCache = require('../check_require_cache')
+const telemetry = require('../../../dd-trace/src/telemetry/init-telemetry')
 
 const {
   DD_TRACE_DISABLED_INSTRUMENTATIONS = '',
@@ -35,22 +36,38 @@ if (DD_TRACE_DEBUG && DD_TRACE_DEBUG.toLowerCase() !== 'false') {
   setImmediate(checkRequireCache.checkForPotentialConflicts)
 }
 
+const seenCombo = new Set()
+
 // TODO: make this more efficient
 for (const packageName of names) {
   if (disabledInstrumentations.has(packageName)) continue
 
-  Hook([packageName], (moduleExports, moduleName, moduleBaseDir, moduleVersion) => {
+  const hookOptions = {}
+
+  let hook = hooks[packageName]
+
+  if (typeof hook === 'object') {
+    hookOptions.internals = hook.esmFirst
+    hook = hook.fn
+  }
+
+  Hook([packageName], hookOptions, (moduleExports, moduleName, moduleBaseDir, moduleVersion) => {
     moduleName = moduleName.replace(pathSepExpr, '/')
 
     // This executes the integration file thus adding its entries to `instrumentations`
-    hooks[packageName]()
+    hook()
 
     if (!instrumentations[packageName]) {
       return moduleExports
     }
 
-    for (const { name, file, versions, hook } of instrumentations[packageName]) {
+    const namesAndSuccesses = {}
+    for (const { name, file, versions, hook, filePattern } of instrumentations[packageName]) {
+      let fullFilePattern = filePattern
       const fullFilename = filename(name, file)
+      if (fullFilePattern) {
+        fullFilePattern = filename(name, fullFilePattern)
+      }
 
       // Create a WeakMap associated with the hook function so that patches on the same moduleExport only happens once
       // for example by instrumenting both dns and node:dns double the spans would be created
@@ -58,13 +75,29 @@ for (const packageName of names) {
       if (!hook[HOOK_SYMBOL]) {
         hook[HOOK_SYMBOL] = new WeakMap()
       }
+      let matchesFile = false
+
+      matchesFile = moduleName === fullFilename
 
-      if (moduleName === fullFilename) {
+      if (fullFilePattern) {
+        // Some libraries include a hash in their filenames when installed,
+        // so our instrumentation has to include a '.*' to match them for more than a single version.
+        matchesFile = matchesFile || new RegExp(fullFilePattern).test(moduleName)
+      }
+
+      if (matchesFile) {
         const version = moduleVersion || getVersion(moduleBaseDir)
+        if (!Object.hasOwnProperty(namesAndSuccesses, name)) {
+          namesAndSuccesses[name] = {
+            success: false,
+            version
+          }
+        }
 
         if (matchVersion(version, versions)) {
           // Check if the hook already has a set moduleExport
           if (hook[HOOK_SYMBOL].has(moduleExports)) {
+            namesAndSuccesses[name].success = true
             return moduleExports
           }
 
@@ -76,11 +109,29 @@ for (const packageName of names) {
             // Set the moduleExports in the hooks weakmap
             hook[HOOK_SYMBOL].set(moduleExports, name)
           } catch (e) {
-            log.error(e)
+            log.info('Error during ddtrace instrumentation of application, aborting.')
+            log.info(e)
+            telemetry('error', [
+              `error_type:${e.constructor.name}`,
+              `integration:${name}`,
+              `integration_version:${version}`
+            ])
           }
+          namesAndSuccesses[name].success = true
         }
       }
     }
+    for (const name of Object.keys(namesAndSuccesses)) {
+      const { success, version } = namesAndSuccesses[name]
+      if (!success && !seenCombo.has(`${name}@${version}`)) {
+        telemetry('abort.integration', [
+          `integration:${name}`,
+          `integration_version:${version}`
+        ])
+        log.info(`Found incompatible integration version: ${name}@${version}`)
+        seenCombo.add(`${name}@${version}`)
+      }
+    }
 
     return moduleExports
   })

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

@@ -132,7 +132,7 @@ function patch (http, methodName) {
   }
 
   function combineOptions (inputURL, inputOptions) {
-    if (typeof inputOptions === 'object') {
+    if (inputOptions !== null && typeof inputOptions === 'object') {
       return Object.assign(inputURL || {}, inputOptions)
     } else {
       return inputURL

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

@@ -12,7 +12,8 @@ const {
   getTestParametersString,
   addEfdStringToTestName,
   removeEfdStringFromTestName,
-  getIsFaultyEarlyFlakeDetection
+  getIsFaultyEarlyFlakeDetection,
+  NUM_FAILED_TEST_RETRIES
 } = require('../../dd-trace/src/plugins/util/test')
 const {
   getFormattedJestTestParameters,
@@ -49,6 +50,9 @@ const itrSkippedSuitesCh = channel('ci:jest:itr:skipped-suites')
 const CHILD_MESSAGE_CALL = 1
 // Maximum time we'll wait for the tracer to flush
 const FLUSH_TIMEOUT = 10000
+// eslint-disable-next-line
+// https://github.com/jestjs/jest/blob/41f842a46bb2691f828c3a5f27fc1d6290495b82/packages/jest-circus/src/types.ts#L9C8-L9C54
+const RETRY_TIMES = Symbol.for('RETRY_TIMES')
 
 let skippableSuites = []
 let knownTests = {}
@@ -127,6 +131,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       }
 
       this.isEarlyFlakeDetectionEnabled = this.testEnvironmentOptions._ddIsEarlyFlakeDetectionEnabled
+      this.isFlakyTestRetriesEnabled = this.testEnvironmentOptions._ddIsFlakyTestRetriesEnabled
 
       if (this.isEarlyFlakeDetectionEnabled) {
         const hasKnownTests = !!knownTests.jest
@@ -140,6 +145,13 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           this.isEarlyFlakeDetectionEnabled = false
         }
       }
+
+      if (this.isFlakyTestRetriesEnabled) {
+        const currentNumRetries = this.global[RETRY_TIMES]
+        if (!currentNumRetries) {
+          this.global[RETRY_TIMES] = NUM_FAILED_TEST_RETRIES
+        }
+      }
     }
 
     getHasSnapshotTests () {
@@ -218,6 +230,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             retriedTestsToNumAttempts.set(originalTestName, numEfdRetry + 1)
           }
         }
+        const isJestRetry = event.test?.invocations > 1
         asyncResource.runInAsyncScope(() => {
           testStartCh.publish({
             name: removeEfdStringFromTestName(testName),
@@ -228,7 +241,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             testParameters,
             frameworkVersion: jestVersion,
             isNew: isNewTest,
-            isEfdRetry: numEfdRetry > 0
+            isEfdRetry: numEfdRetry > 0,
+            isJestRetry
           })
           originalTestFns.set(event.test, event.test.fn)
           event.test.fn = asyncResource.bind(event.test.fn)
@@ -758,6 +772,7 @@ addHook({
       _ddIsEarlyFlakeDetectionEnabled,
       _ddEarlyFlakeDetectionNumRetries,
       _ddRepositoryRoot,
+      _ddIsFlakyTestRetriesEnabled,
       ...restOfTestEnvironmentOptions
     } = testEnvironmentOptions
 

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

@@ -59,7 +59,7 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
         try {
           const { topic, messages = [] } = arguments[0]
           for (const message of messages) {
-            if (typeof message === 'object') {
+            if (message !== null && typeof message === 'object') {
               message.headers = message.headers || {}
             }
           }

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

@@ -61,7 +61,7 @@ addHook({ name: 'ldapjs', versions: ['>=2'] }, ldapjs => {
       let filter
       if (isString(options)) {
         filter = options
-      } else if (typeof options === 'object' && options.filter) {
+      } else if (options !== null && typeof options === 'object' && options.filter) {
         if (isString(options.filter)) {
           filter = options.filter
         }
@@ -78,7 +78,7 @@ addHook({ name: 'ldapjs', versions: ['>=2'] }, ldapjs => {
       const callback = arguments[callbackIndex]
       // eslint-disable-next-line n/handle-callback-err
       arguments[callbackIndex] = shimmer.wrap(callback, function (err, corkedEmitter) {
-        if (typeof corkedEmitter === 'object' && typeof corkedEmitter.on === 'function') {
+        if (corkedEmitter !== null && typeof corkedEmitter === 'object' && typeof corkedEmitter.on === 'function') {
           wrapEmitter(corkedEmitter)
         }
         callback.apply(this, arguments)

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

@@ -21,6 +21,7 @@ const {
   runnableWrapper,
   getOnTestHandler,
   getOnTestEndHandler,
+  getOnTestRetryHandler,
   getOnHookEndHandler,
   getOnFailHandler,
   getOnPendingHandler,
@@ -37,10 +38,12 @@ 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 = {}
 
 // We'll preserve the original coverage here
 const originalCoverageMap = createCoverageMap()
@@ -227,6 +230,12 @@ addHook({
       isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
       isSuitesSkippingEnabled = libraryConfig.isSuitesSkippingEnabled
       earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
+      isFlakyTestRetriesEnabled = libraryConfig.isFlakyTestRetriesEnabled
+
+      config.isEarlyFlakeDetectionEnabled = isEarlyFlakeDetectionEnabled
+      config.isSuitesSkippingEnabled = isSuitesSkippingEnabled
+      config.earlyFlakeDetectionNumRetries = earlyFlakeDetectionNumRetries
+      config.isFlakyTestRetriesEnabled = isFlakyTestRetriesEnabled
 
       if (isEarlyFlakeDetectionEnabled) {
         knownTestsCh.publish({
@@ -317,6 +326,8 @@ addHook({
 
     this.on('test end', getOnTestEndHandler())
 
+    this.on('retry', getOnTestRetryHandler())
+
     // If the hook passes, 'hook end' will be emitted. Otherwise, 'fail' will be emitted
     this.on('hook end', getOnHookEndHandler())
 
@@ -401,7 +412,7 @@ addHook({
   name: 'mocha',
   versions: ['>=5.2.0'],
   file: 'lib/runnable.js'
-}, runnableWrapper)
+}, (runnablePackage) => runnableWrapper(runnablePackage, config))
 
 // Only used in parallel mode (--parallel flag is passed)
 // Used to generate suite events and receive test payloads from workers

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

@@ -3,7 +3,8 @@
 const {
   getTestSuitePath,
   removeEfdStringFromTestName,
-  addEfdStringToTestName
+  addEfdStringToTestName,
+  NUM_FAILED_TEST_RETRIES
 } = require('../../../dd-trace/src/plugins/util/test')
 const { channel, AsyncResource } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
@@ -11,6 +12,8 @@ const shimmer = require('../../../datadog-shimmer')
 // test channels
 const testStartCh = channel('ci:mocha:test:start')
 const testFinishCh = channel('ci:mocha:test:finish')
+// after a test has failed, we'll publish to this channel
+const testRetryCh = channel('ci:mocha:test:retry')
 const errorCh = channel('ci:mocha:test:error')
 const skipCh = channel('ci:mocha:test:skip')
 
@@ -70,6 +73,10 @@ function isMochaRetry (test) {
   return test._currentRetry !== undefined && test._currentRetry !== 0
 }
 
+function isLastRetry (test) {
+  return test._currentRetry === test._retries
+}
+
 function getTestFullName (test) {
   return `mocha.${getTestSuitePath(test.file, process.cwd())}.${removeEfdStringFromTestName(test.fullTitle())}`
 }
@@ -84,22 +91,34 @@ function getTestStatus (test) {
   return 'pass'
 }
 
-function getTestAsyncResource (test) {
+function getTestToArKey (test) {
   if (!test.fn) {
-    return testToAr.get(test)
+    return test
   }
   if (!wrappedFunctions.has(test.fn)) {
-    return testToAr.get(test.fn)
+    return test.fn
   }
   const originalFn = originalFns.get(test.fn)
-  return testToAr.get(originalFn)
+  return originalFn
+}
+
+function getTestAsyncResource (test) {
+  const key = getTestToArKey(test)
+  return testToAr.get(key)
 }
 
-function runnableWrapper (RunnablePackage) {
+function runnableWrapper (RunnablePackage, libraryConfig) {
   shimmer.wrap(RunnablePackage.prototype, 'run', run => function () {
     if (!testStartCh.hasSubscribers) {
       return run.apply(this, arguments)
     }
+    // Flaky test retries does not work in parallel mode
+    if (libraryConfig?.isFlakyTestRetriesEnabled) {
+      this.retries(NUM_FAILED_TEST_RETRIES)
+    }
+    // The reason why the wrapping logic is here is because we need to cover
+    // `afterEach` and `beforeEach` hooks as well.
+    // It can't be done in `getOnTestHandler` because it's only called for tests.
     const isBeforeEach = this.parent._beforeEach.includes(this)
     const isAfterEach = this.parent._afterEach.includes(this)
 
@@ -135,11 +154,16 @@ function runnableWrapper (RunnablePackage) {
 
 function getOnTestHandler (isMain, newTests) {
   return function (test) {
-    if (isMochaRetry(test)) {
-      return
-    }
     const testStartLine = testToStartLine.get(test)
     const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+    // This may be a retry. If this is the case, `test.fn` is already wrapped,
+    // so we need to restore it.
+    if (wrappedFunctions.has(test.fn)) {
+      const originalFn = originalFns.get(test.fn)
+      test.fn = originalFn
+      wrappedFunctions.delete(test.fn)
+    }
     testToAr.set(test.fn, asyncResource)
 
     const {
@@ -186,7 +210,7 @@ function getOnTestEndHandler () {
     // if there are afterEach to be run, we don't finish the test yet
     if (asyncResource && !test.parent._afterEach.length) {
       asyncResource.runInAsyncScope(() => {
-        testFinishCh.publish(status)
+        testFinishCh.publish({ status, hasBeenRetried: isMochaRetry(test) })
       })
     }
   }
@@ -197,12 +221,17 @@ function getOnHookEndHandler () {
     const test = hook.ctx.currentTest
     if (test && hook.parent._afterEach.includes(hook)) { // only if it's an afterEach
       const isLastAfterEach = hook.parent._afterEach.indexOf(hook) === hook.parent._afterEach.length - 1
+      if (test._retries > 0 && !isLastRetry(test)) {
+        return
+      }
       if (isLastAfterEach) {
         const status = getTestStatus(test)
         const asyncResource = getTestAsyncResource(test)
-        asyncResource.runInAsyncScope(() => {
-          testFinishCh.publish(status)
-        })
+        if (asyncResource) {
+          asyncResource.runInAsyncScope(() => {
+            testFinishCh.publish({ status, hasBeenRetried: isMochaRetry(test) })
+          })
+        }
       }
     }
   }
@@ -226,7 +255,7 @@ function getOnFailHandler (isMain) {
           err.message = `${testOrHook.fullTitle()}: ${err.message}`
           errorCh.publish(err)
           // if it's a hook and it has failed, 'test end' will not be called
-          testFinishCh.publish('fail')
+          testFinishCh.publish({ status: 'fail', hasBeenRetried: isMochaRetry(test) })
         } else {
           errorCh.publish(err)
         }
@@ -250,6 +279,20 @@ function getOnFailHandler (isMain) {
   }
 }
 
+function getOnTestRetryHandler () {
+  return function (test) {
+    const asyncResource = getTestAsyncResource(test)
+    if (asyncResource) {
+      const isFirstAttempt = test._currentRetry === 0
+      asyncResource.runInAsyncScope(() => {
+        testRetryCh.publish(isFirstAttempt)
+      })
+    }
+    const key = getTestToArKey(test)
+    testToAr.delete(key)
+  }
+}
+
 function getOnPendingHandler () {
   return function (test) {
     const testStartLine = testToStartLine.get(test)
@@ -299,6 +342,7 @@ module.exports = {
   testToStartLine,
   getOnTestHandler,
   getOnTestEndHandler,
+  getOnTestRetryHandler,
   getOnHookEndHandler,
   getOnFailHandler,
   getOnPendingHandler,

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

@@ -49,3 +49,4 @@ addHook({
   versions: ['>=5.2.0'],
   file: 'lib/runnable.js'
 }, runnableWrapper)
+// TODO: parallel mode does not support flaky test retries, so no library config is passed.

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

@@ -25,9 +25,9 @@ const methodsOptionalArgs = ['findOneAndUpdate']
 function getFilters (args, methodName) {
   const [arg0, arg1] = args
 
-  const filters = arg0 && typeof arg0 === 'object' ? [arg0] : []
+  const filters = arg0 !== null && typeof arg0 === 'object' ? [arg0] : []
 
-  if (arg1 && typeof arg1 === 'object' && methodsOptionalArgs.includes(methodName)) {
+  if (arg1 !== null && typeof arg1 === 'object' && methodsOptionalArgs.includes(methodName)) {
     filters.push(arg1)
   }
 

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

@@ -46,7 +46,7 @@ function wrapHandleApiRequest (handleApiRequest) {
 function wrapHandleApiRequestWithMatch (handleApiRequest) {
   return function (req, res, query, match) {
     return instrument(req, res, () => {
-      const page = (typeof match === 'object' && typeof match.definition === 'object')
+      const page = (match !== null && typeof match === 'object' && typeof match.definition === 'object')
         ? match.definition.pathname
         : undefined
 

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

@@ -35,7 +35,7 @@ function wrapQuery (query) {
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     const processId = this.processID
 
-    const pgQuery = arguments[0] && typeof arguments[0] === 'object'
+    const pgQuery = arguments[0] !== null && typeof arguments[0] === 'object'
       ? arguments[0]
       : { text: arguments[0] }
 
@@ -109,7 +109,7 @@ function wrapPoolQuery (query) {
 
     const asyncResource = new AsyncResource('bound-anonymous-fn')
 
-    const pgQuery = arguments[0] && typeof arguments[0] === 'object' ? arguments[0] : { text: arguments[0] }
+    const pgQuery = arguments[0] !== null && typeof arguments[0] === 'object' ? arguments[0] : { text: arguments[0] }
 
     return asyncResource.runInAsyncScope(() => {
       startPoolQueryCh.publish({