dd-trace 5.104.0 → 5.105.0

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

@@ -7,21 +7,26 @@ const shimmer = require('../../datadog-shimmer')
 const log = require('../../dd-trace/src/log')
 const { getEnvironmentVariable } = require('../../dd-trace/src/config/helper')
 const {
-  getCoveredFilenamesFromCoverage,
+  getCoveredFilesFromCoverage,
+  getExecutableFilesFromCoverage,
   resetCoverage,
   mergeCoverage,
   fromCoverageMapToCoverage,
   getTestSuitePath,
+  getRelativeCoverageFiles,
   CUCUMBER_WORKER_TRACE_PAYLOAD_CODE,
   getIsFaultyEarlyFlakeDetection,
   getEfdRetryCount,
   getMaxEfdRetryCount,
+  applySkippedCoverageToCoverage,
+  getTestCoverageLinesPercentage,
   recordAttemptToFixExecution,
   collectAttemptToFixExecutionsFromTraces,
   logAttemptToFixTestExecution,
   logTestOptimizationSummary,
   getTestOptimizationRequestResults,
 } = require('../../dd-trace/src/plugins/util/test')
+const { writeCoverageBackfillToCache } = require('../../dd-trace/src/ci-visibility/test-optimization-cache')
 const satisfies = require('../../../vendor/dist/semifies')
 const { addHook, channel } = require('./helpers/instrument')
 
@@ -86,10 +91,14 @@ let pickleByFile = {}
 const pickleResultByFile = {}
 
 let skippableSuites = []
+let skippableSuitesCoverage = {}
+let skippedSuitesCoverage = {}
 let itrCorrelationId = ''
 let isForcedToRun = false
 let isUnskippable = false
+let isItrEnabled = false
 let isSuitesSkippingEnabled = false
+let isCoverageReportUploadEnabled = false
 let isEarlyFlakeDetectionEnabled = false
 let earlyFlakeDetectionNumRetries = 0
 let earlyFlakeDetectionSlowTestRetries = {}
@@ -106,11 +115,55 @@ let numTestRetries = 0
 let knownTests = {}
 let skippedSuites = []
 let isSuitesSkipped = false
+let repositoryRoot
 
 function isValidKnownTests (receivedKnownTests) {
   return !!receivedKnownTests.cucumber
 }
 
+function hasSkippableSuitesCoverage () {
+  return skippableSuitesCoverage &&
+    typeof skippableSuitesCoverage === 'object' &&
+    Object.keys(skippableSuitesCoverage).length > 0
+}
+
+function isTiaCoverageBackfillEnabled () {
+  return isItrEnabled && isCoverageReportUploadEnabled
+}
+
+function getCoverageRootDir () {
+  return repositoryRoot || process.cwd()
+}
+
+function shouldReportCodeCoverageLinesPct (hasBackfilledCoverage) {
+  return !isSuitesSkipped || hasBackfilledCoverage
+}
+
+function getSkippedSuitesCoverageForRun () {
+  return isSuitesSkipped && isTiaCoverageBackfillEnabled() && hasSkippableSuitesCoverage()
+    ? skippableSuitesCoverage
+    : {}
+}
+
+function applySkippedCoverageToCucumberCoverageMap () {
+  if (!isTiaCoverageBackfillEnabled()) return false
+  return applySkippedCoverageToCoverage(originalCoverageMap, skippedSuitesCoverage, getCoverageRootDir())
+}
+
+function getCucumberTestSessionCoverageFiles () {
+  return getRelativeCoverageFiles(getExecutableFilesFromCoverage(originalCoverageMap), getCoverageRootDir())
+}
+
+function resetSuiteSkippingRunState () {
+  skippableSuites = []
+  skippableSuitesCoverage = {}
+  skippedSuitesCoverage = {}
+  skippedSuites = []
+  isSuitesSkipped = false
+  repositoryRoot = undefined
+  writeCoverageBackfillToCache({})
+}
+
 function getSuiteStatusFromTestStatuses (testStatuses) {
   if (testStatuses.includes('fail')) {
     return 'fail'
@@ -683,6 +736,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
     if (!libraryConfigurationCh.hasSubscribers) {
       return start.apply(this, arguments)
     }
+    resetSuiteSkippingRunState()
     const options = getCucumberOptions(this)
 
     if (!isParallel && this.adapter?.options) {
@@ -692,11 +746,14 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
 
     const configurationResponse = await getChannelPromise(libraryConfigurationCh, frameworkVersion)
 
+    repositoryRoot = configurationResponse.repositoryRoot
+    isItrEnabled = configurationResponse.libraryConfig?.isItrEnabled
     isEarlyFlakeDetectionEnabled = configurationResponse.libraryConfig?.isEarlyFlakeDetectionEnabled
     earlyFlakeDetectionNumRetries = configurationResponse.libraryConfig?.earlyFlakeDetectionNumRetries
     earlyFlakeDetectionSlowTestRetries = configurationResponse.libraryConfig?.earlyFlakeDetectionSlowTestRetries ?? {}
     earlyFlakeDetectionFaultyThreshold = configurationResponse.libraryConfig?.earlyFlakeDetectionFaultyThreshold
-    isSuitesSkippingEnabled = configurationResponse.libraryConfig?.isSuitesSkippingEnabled
+    isSuitesSkippingEnabled = isItrEnabled && configurationResponse.libraryConfig?.isSuitesSkippingEnabled
+    isCoverageReportUploadEnabled = configurationResponse.libraryConfig?.isCoverageReportUploadEnabled
     isFlakyTestRetriesEnabled = configurationResponse.libraryConfig?.isFlakyTestRetriesEnabled
     const configRetryCount = configurationResponse.libraryConfig?.flakyTestRetriesCount
     numTestRetries = (typeof configRetryCount === 'number' && configRetryCount > 0) ? configRetryCount : 0
@@ -733,6 +790,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
 
       errorSkippableRequest = skippableResponse.err
       skippableSuites = skippableResponse.skippableSuites ?? []
+      skippableSuitesCoverage = skippableResponse.skippableSuitesCoverage ?? {}
 
       if (!errorSkippableRequest) {
         const filteredPickles = isCoordinator
@@ -753,6 +811,8 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
         }
 
         skippedSuites = [...filteredPickles.skippedSuites]
+        skippedSuitesCoverage = getSkippedSuitesCoverageForRun()
+        writeCoverageBackfillToCache(skippedSuitesCoverage, getCoverageRootDir())
         itrCorrelationId = skippableResponse.itrCorrelationId
       }
     }
@@ -816,13 +876,25 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
     }
 
     let testCodeCoverageLinesTotal
+    let testSessionCoverageFiles
 
-    if (global.__coverage__) {
+    if (global.__coverage__ || untestedCoverage) {
       try {
+        let hasBackfilledCoverage = false
         if (untestedCoverage) {
           originalCoverageMap.merge(fromCoverageMapToCoverage(untestedCoverage))
         }
-        testCodeCoverageLinesTotal = originalCoverageMap.getCoverageSummary().lines.pct
+        hasBackfilledCoverage = applySkippedCoverageToCucumberCoverageMap()
+        if (shouldReportCodeCoverageLinesPct(hasBackfilledCoverage)) {
+          testCodeCoverageLinesTotal = getTestCoverageLinesPercentage(
+            originalCoverageMap,
+            undefined,
+            getCoverageRootDir()
+          )
+        }
+        if (isTiaCoverageBackfillEnabled()) {
+          testSessionCoverageFiles = getCucumberTestSessionCoverageFiles()
+        }
       } catch {
         // ignore errors
       }
@@ -834,6 +906,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
       status: success ? 'pass' : 'fail',
       isSuitesSkipped,
       testCodeCoverageLinesTotal,
+      testSessionCoverageFiles,
       numSkippedSuites: skippedSuites.length,
       hasUnskippableSuites: isUnskippable,
       hasForcedToRunSuites: isForcedToRun,
@@ -1008,7 +1081,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       // last test in suite
       const testSuiteStatus = getSuiteStatusFromTestStatuses(pickleResultByFile[testFileAbsolutePath])
       if (global.__coverage__) {
-        const coverageFiles = getCoveredFilenamesFromCoverage(global.__coverage__)
+        const coverageFiles = getCoveredFilesFromCoverage(global.__coverage__)
 
         testSuiteCodeCoverageCh.publish({
           coverageFiles,

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

@@ -3,6 +3,7 @@
 const shimmer = require('../../datadog-shimmer')
 const { addHook } = require('./helpers/instrument')
 const { createCallbackInstrumentor } = require('./helpers/callback-instrumentor')
+const { createPromiseInstrumentor } = require('./helpers/promise-instrumentor')
 
 const rrtypes = {
   resolveAny: 'ANY',
@@ -18,30 +19,55 @@ const rrtypes = {
   resolveSoa: 'SOA',
 }
 
-addHook({ name: 'dns' }, dns => {
-  const lookup = createCallbackInstrumentor('apm:dns:lookup', { captureResult: true })
-  const lookupService = createCallbackInstrumentor('apm:dns:lookup_service', { captureResult: true })
-  const resolve = createCallbackInstrumentor('apm:dns:resolve', { captureResult: true })
-  const reverse = createCallbackInstrumentor('apm:dns:reverse', { captureResult: true })
-
-  shimmer.wrap(dns, 'lookup', lookup(buildArgsContext()))
-  shimmer.wrap(dns, 'lookupService', lookupService(buildArgsContext()))
-  shimmer.wrap(dns, 'resolve', resolve(buildArgsContext()))
-  shimmer.wrap(dns, 'reverse', reverse(buildArgsContext()))
-
-  patchResolveShorthands(dns, resolve)
+// `dns.promises` and `require('dns/promises')` resolve to the same exports object. Both
+// access paths register a hook, so without a guard the second hook to fire would stack a
+// second wrap layer on top and publish every `apm:dns:*` event twice per call. The WeakSet
+// collapses the two hooks to one wrap regardless of which one runs first.
+const wrappedPromiseApis = new WeakSet()
 
-  if (dns.Resolver) {
-    shimmer.wrap(dns.Resolver.prototype, 'resolve', resolve(buildArgsContext()))
-    shimmer.wrap(dns.Resolver.prototype, 'reverse', reverse(buildArgsContext()))
+addHook({ name: 'dns' }, dns => {
+  patchApi(dns, createCallbackInstrumentor, buildCallbackArgsContext)
 
-    patchResolveShorthands(dns.Resolver.prototype, resolve)
+  if (dns.promises) {
+    patchPromiseApi(dns.promises)
   }
 
   return dns
 })
 
-function patchResolveShorthands (prototype, resolve) {
+addHook({ name: 'dns/promises' }, dnsPromises => {
+  patchPromiseApi(dnsPromises)
+  return dnsPromises
+})
+
+function patchPromiseApi (api) {
+  if (wrappedPromiseApis.has(api)) return
+  wrappedPromiseApis.add(api)
+  patchApi(api, createPromiseInstrumentor, buildPromiseArgsContext)
+}
+
+function patchApi (api, instrumentorFactory, buildArgsContext) {
+  const lookup = instrumentorFactory('apm:dns:lookup', { captureResult: true })
+  const lookupService = instrumentorFactory('apm:dns:lookup_service', { captureResult: true })
+  const resolve = instrumentorFactory('apm:dns:resolve', { captureResult: true })
+  const reverse = instrumentorFactory('apm:dns:reverse', { captureResult: true })
+
+  shimmer.wrap(api, 'lookup', lookup(buildArgsContext()))
+  shimmer.wrap(api, 'lookupService', lookupService(buildArgsContext()))
+  shimmer.wrap(api, 'resolve', resolve(buildArgsContext()))
+  shimmer.wrap(api, 'reverse', reverse(buildArgsContext()))
+
+  patchResolveShorthands(api, resolve, buildArgsContext)
+
+  if (api.Resolver) {
+    shimmer.wrap(api.Resolver.prototype, 'resolve', resolve(buildArgsContext()))
+    shimmer.wrap(api.Resolver.prototype, 'reverse', reverse(buildArgsContext()))
+
+    patchResolveShorthands(api.Resolver.prototype, resolve, buildArgsContext)
+  }
+}
+
+function patchResolveShorthands (prototype, resolve, buildArgsContext) {
   for (const method of Object.keys(rrtypes)) {
     if (prototype[method]) {
       shimmer.wrap(prototype, method, resolve(buildArgsContext(rrtypes[method])))
@@ -49,7 +75,7 @@ function patchResolveShorthands (prototype, resolve) {
   }
 }
 
-function buildArgsContext (rrtype) {
+function buildCallbackArgsContext (rrtype) {
   return function (_, args) {
     if (args.length < 2) return
     const captured = [...args]
@@ -60,3 +86,13 @@ function buildArgsContext (rrtype) {
     return { args: captured }
   }
 }
+
+function buildPromiseArgsContext (rrtype) {
+  return function (_, args) {
+    const captured = [...args]
+    if (rrtype) {
+      captured.push(rrtype)
+    }
+    return { args: captured }
+  }
+}

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

@@ -54,65 +54,119 @@ function wrapAddHook (addHook) {
 
     if (typeof fn !== 'function') return addHook.apply(this, arguments)
 
-    arguments[arguments.length - 1] = shimmer.wrapFunction(fn, fn => function (request, reply, done) {
-      const req = getReq(request)
-      const ctx = { req }
-
-      try {
-        // done callback is always the last argument
-        const doneCallback = arguments[arguments.length - 1]
-
-        if (typeof doneCallback === 'function') {
-          arguments[arguments.length - 1] = function (err) {
-            ctx.error = err
-            publishError(ctx)
-
-            const hasCookies = request.cookies && Object.keys(request.cookies).length > 0
-
-            if (cookieParserReadCh.hasSubscribers && hasCookies && !cookiesPublished.has(req)) {
-              ctx.res = getRes(reply)
-              ctx.abortController = new AbortController()
-              ctx.cookies = request.cookies
-
-              cookieParserReadCh.publish(ctx)
-              cookiesPublished.add(req)
-
-              if (ctx.abortController.signal.aborted) return
-            }
-
-            if (name === 'onRequest' || name === 'preParsing') {
-              parsingContexts.set(req, ctx)
-
-              return callbackFinishCh.runStores(ctx, () => {
-                return doneCallback.apply(this, arguments)
-              })
-            }
-            return doneCallback.apply(this, arguments)
-          }
-
-          return fn.apply(this, arguments)
-        }
-
-        const promise = fn.apply(this, arguments)
-
-        if (promise && typeof promise.catch === 'function') {
-          return promise.catch(err => {
-            ctx.error = err
-            return publishError(ctx)
-          })
-        }
-
-        return promise
-      } catch (e) {
-        ctx.error = e
-        throw publishError(ctx)
+    arguments[arguments.length - 1] = shimmer.wrapFunction(fn, fn => function wrappedHook () {
+      // Fast path: every fastify request invokes each addHook'd handler, so the wrap
+      // runs in the user's hot path. The only side effects this wrapper carries are
+      // the three channels below; when none of them have a subscriber (the default
+      // plugin config, and the steady state once appsec / cookie subscribers detach),
+      // the wrap has nothing to do, and a `fn.apply(this, arguments)` forward keeps
+      // V8's CallApplyArguments fast path intact.
+      //
+      // The previous shape mutated `arguments[arguments.length - 1]` to swap `done`.
+      // That mutation materialises the magical arguments object and disables V8
+      // inlining of the enclosing function. The slow path below builds a fresh args
+      // array instead so the hot fast path keeps a clean forward.
+      if (errorChannel.hasSubscribers || cookieParserReadCh.hasSubscribers || callbackFinishCh.hasSubscribers) {
+        return invokeHookWithContext(name, fn, this, arguments)
       }
+      return fn.apply(this, arguments)
     })
 
     return addHook.apply(this, arguments)
   })
 }
 
+/**
+ * Slow path of {@link wrapAddHook}; entered only when at least one wrap-fed
+ * channel has a subscriber. Allocates the per-request context, rewraps `done`,
+ * and forwards to the user-supplied hook.
+ *
+ * @param {string} name Lifecycle phase the hook was registered against.
+ * @param {Function} fn User-supplied hook.
+ * @param {unknown} thisArg `this` Fastify passes to the hook.
+ * @param {ArrayLike<unknown>} args Fastify's positional args; the dispatcher always
+ *   places `done` as the trailing positional (see fastify/lib/hooks.js hookIterator,
+ *   onSendHookRunner, preParsingHookRunner, onRequestAbortHookRunner).
+ */
+function invokeHookWithContext (name, fn, thisArg, args) {
+  const request = args[0]
+  const reply = args[1]
+  const req = getReq(request)
+  const ctx = { req }
+
+  try {
+    const lastArg = args[args.length - 1]
+
+    if (typeof lastArg === 'function') {
+      // Copy the args so we can swap the trailing `done` without touching the
+      // caller's magical arguments object. Fastify hook arities are 2 to 4
+      // across lifecycle phases, but `done` is always last.
+      const callArgs = [...args]
+      callArgs[callArgs.length - 1] = wrapHookDone(ctx, request, reply, req, name, lastArg)
+      return fn.apply(thisArg, callArgs)
+    }
+
+    const promise = fn.apply(thisArg, args)
+
+    if (promise && typeof promise.catch === 'function') {
+      return promise.catch(error => {
+        ctx.error = error
+        return publishError(ctx)
+      })
+    }
+
+    return promise
+  } catch (error) {
+    ctx.error = error
+    throw publishError(ctx)
+  }
+}
+
+/**
+ * Per-request closure invoked when fastify resolves the user hook's `done`.
+ * Captures `ctx` plus the dispatcher-level fields needed to publish on the
+ * cookie / callback channels. The closure cannot be hoisted: fastify invokes
+ * `done` with a single `(err)` arg, so request / reply / req / name / doneCallback
+ * must close over rather than ride the call signature.
+ *
+ * @param {{ req: unknown, [key: string]: unknown }} ctx
+ * @param {{ cookies?: Record<string, unknown>, [key: string]: unknown }} request
+ * @param {object} reply
+ * @param {unknown} req
+ * @param {string} name
+ * @param {Function} doneCallback
+ */
+function wrapHookDone (ctx, request, reply, req, name, doneCallback) {
+  return function wrappedDone (error) {
+    ctx.error = error
+    publishError(ctx)
+
+    const hasCookies = request.cookies && Object.keys(request.cookies).length > 0
+
+    if (cookieParserReadCh.hasSubscribers && hasCookies && !cookiesPublished.has(req)) {
+      ctx.res = getRes(reply)
+      ctx.abortController = new AbortController()
+      ctx.cookies = request.cookies
+
+      cookieParserReadCh.publish(ctx)
+      cookiesPublished.add(req)
+
+      if (ctx.abortController.signal.aborted) return
+    }
+
+    if (name === 'onRequest' || name === 'preParsing') {
+      parsingContexts.set(req, ctx)
+
+      if (callbackFinishCh.hasSubscribers) {
+        const self = this
+        const allArgs = arguments
+        return callbackFinishCh.runStores(ctx, () => doneCallback.apply(self, allArgs))
+      }
+    }
+    return doneCallback.apply(this, arguments)
+  }
+}
+
 function onRequest (request, reply, done) {
   if (typeof done !== 'function') return
 
@@ -157,45 +211,51 @@ function preValidation (request, reply, done) {
   const ctx = parsingContexts.get(req)
   ctx.res = res
 
-  const processInContext = () => {
-    let abortController
+  if (!ctx) return processInContext(request, ctx, done, req)
 
-    if (queryParamsReadCh.hasSubscribers && request.query) {
-      abortController ??= new AbortController()
-      ctx.abortController = abortController
-      ctx.query = request.query
-      queryParamsReadCh.publish(ctx)
-
-      if (abortController.signal.aborted) return
-    }
+  preValidationCh.runStores(ctx, processInContext, undefined, request, ctx, done, req)
+}
 
-    // Analyze body before schema validation
-    if (bodyParserReadCh.hasSubscribers && request.body && !bodyPublished.has(req)) {
-      abortController ??= new AbortController()
-      ctx.abortController = abortController
-      ctx.body = request.body
-      bodyParserReadCh.publish(ctx)
+/**
+ * @param {{ query?: object, body?: object, params?: object, [key: string]: unknown }} request
+ * @param {{ res?: object, abortController?: AbortController, [key: string]: unknown }} ctx
+ * @param {Function} done
+ * @param {unknown} req
+ */
+function processInContext (request, ctx, done, req) {
+  let abortController
+
+  if (queryParamsReadCh.hasSubscribers && request.query) {
+    abortController ??= new AbortController()
+    ctx.abortController = abortController
+    ctx.query = request.query
+    queryParamsReadCh.publish(ctx)
+
+    if (abortController.signal.aborted) return
+  }
 
-      bodyPublished.add(req)
+  // Analyze body before schema validation
+  if (bodyParserReadCh.hasSubscribers && request.body && !bodyPublished.has(req)) {
+    abortController ??= new AbortController()
+    ctx.abortController = abortController
+    ctx.body = request.body
+    bodyParserReadCh.publish(ctx)
 
-      if (abortController.signal.aborted) return
-    }
+    bodyPublished.add(req)
 
-    if (pathParamsReadCh.hasSubscribers && request.params) {
-      abortController ??= new AbortController()
-      ctx.abortController = abortController
-      ctx.params = request.params
-      pathParamsReadCh.publish(ctx)
+    if (abortController.signal.aborted) return
+  }
 
-      if (abortController.signal.aborted) return
-    }
+  if (pathParamsReadCh.hasSubscribers && request.params) {
+    abortController ??= new AbortController()
+    ctx.abortController = abortController
+    ctx.params = request.params
+    pathParamsReadCh.publish(ctx)
 
-    done()
+    if (abortController.signal.aborted) return
   }
 
-  if (!ctx) return processInContext()
-
-  preValidationCh.runStores(ctx, processInContext)
+  done()
 }
 
 function preParsing (request, reply, payload, done) {