dd-trace 5.16.0 → 5.18.0

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/server.js

@@ -10,6 +10,7 @@ const startServerCh = channel('apm:http:server:request:start')
 const exitServerCh = channel('apm:http:server:request:exit')
 const errorServerCh = channel('apm:http:server:request:error')
 const finishServerCh = channel('apm:http:server:request:finish')
+const startWriteHeadCh = channel('apm:http:server:response:writeHead:start')
 const finishSetHeaderCh = channel('datadog:http:server:response:set-header:finish')
 
 const requestFinishedSet = new WeakSet()
@@ -20,6 +21,9 @@ const httpsNames = ['https', 'node:https']
 addHook({ name: httpNames }, http => {
   shimmer.wrap(http.ServerResponse.prototype, 'emit', wrapResponseEmit)
   shimmer.wrap(http.Server.prototype, 'emit', wrapEmit)
+  shimmer.wrap(http.ServerResponse.prototype, 'writeHead', wrapWriteHead)
+  shimmer.wrap(http.ServerResponse.prototype, 'write', wrapWrite)
+  shimmer.wrap(http.ServerResponse.prototype, 'end', wrapEnd)
   return http
 })
 
@@ -86,3 +90,97 @@ function wrapSetHeader (res) {
     }
   })
 }
+
+function wrapWriteHead (writeHead) {
+  return function wrappedWriteHead (statusCode, reason, obj) {
+    if (!startWriteHeadCh.hasSubscribers) {
+      return writeHead.apply(this, arguments)
+    }
+
+    const abortController = new AbortController()
+
+    if (typeof reason !== 'string') {
+      obj ??= reason
+    }
+
+    // support writeHead(200, ['key1', 'val1', 'key2', 'val2'])
+    if (Array.isArray(obj)) {
+      const headers = {}
+
+      for (let i = 0; i < obj.length; i += 2) {
+        headers[obj[i]] = obj[i + 1]
+      }
+
+      obj = headers
+    }
+
+    // this doesn't support explicit duplicate headers, but it's an edge case
+    const responseHeaders = Object.assign(this.getHeaders(), obj)
+
+    startWriteHeadCh.publish({
+      req: this.req,
+      res: this,
+      abortController,
+      statusCode,
+      responseHeaders
+    })
+
+    if (abortController.signal.aborted) {
+      return this
+    }
+
+    return writeHead.apply(this, arguments)
+  }
+}
+
+function wrapWrite (write) {
+  return function wrappedWrite () {
+    if (!startWriteHeadCh.hasSubscribers) {
+      return write.apply(this, arguments)
+    }
+
+    const abortController = new AbortController()
+
+    const responseHeaders = this.getHeaders()
+
+    startWriteHeadCh.publish({
+      req: this.req,
+      res: this,
+      abortController,
+      statusCode: this.statusCode,
+      responseHeaders
+    })
+
+    if (abortController.signal.aborted) {
+      return true
+    }
+
+    return write.apply(this, arguments)
+  }
+}
+
+function wrapEnd (end) {
+  return function wrappedEnd () {
+    if (!startWriteHeadCh.hasSubscribers) {
+      return end.apply(this, arguments)
+    }
+
+    const abortController = new AbortController()
+
+    const responseHeaders = this.getHeaders()
+
+    startWriteHeadCh.publish({
+      req: this.req,
+      res: this,
+      abortController,
+      statusCode: this.statusCode,
+      responseHeaders
+    })
+
+    if (abortController.signal.aborted) {
+      return this
+    }
+
+    return end.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/playwright.js

@@ -249,7 +249,7 @@ function testEndHandler (test, annotations, testStatus, error, isTimeout) {
   testAsyncResource.runInAsyncScope(() => {
     testFinishCh.publish({
       testStatus,
-      steps: testResult.steps,
+      steps: testResult?.steps || [],
       error,
       extraTags: annotationTags,
       isNew: test._ddIsNew,

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

@@ -0,0 +1,18 @@
+'use strict'
+
+const {
+  addHook
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const tracingChannel = require('dc-polyfill').tracingChannel
+const ch = tracingChannel('apm:undici:fetch')
+
+const { createWrapFetch } = require('./helpers/fetch')
+
+addHook({
+  name: 'undici',
+  versions: ['^4.4.1', '5', '>=6.0.0']
+}, undici => {
+  return shimmer.wrap(undici, 'fetch', createWrapFetch(undici.Request, ch))
+})