dd-trace 5.103.0 → 5.105.0

package/packages/datadog-instrumentations/src/helpers/rewriter/transforms.js

@@ -1,245 +1,47 @@
 'use strict'
 
-// TODO: Move traceIterator to Orchestrion.
+// Custom transforms registered via InstrumentationMatcher.addTransform().
+//
+// Use this file for transforms that are not yet supported upstream in
+// @apm-js-collab/code-transformer (Orchestrion) or that cannot land there
+// for dd-trace-specific reasons. Once a transform is available natively in
+// the library, replace the custom registration with the built-in option and
+// remove the entry here.
 
-const { parse, query, traverse } = require('./compiler')
+const { parse, query } = require('./compiler')
 
-const tracingChannelPredicate = (node) => (
-  node.specifiers?.[0]?.local?.name === 'tr_ch_apm_tracingChannel' ||
-    node.declarations?.[0]?.id?.properties?.[0]?.value?.name === 'tr_ch_apm_tracingChannel'
-)
-
-const transforms = module.exports = {
-  tracingChannelImport ({ dcModule, sourceType }, node) {
-    if (node.body.some(tracingChannelPredicate)) return
-
-    const index = node.body.findIndex(child => child.directive === 'use strict')
-    const code = isModuleSourceType(sourceType)
-      ? `import { tracingChannel as tr_ch_apm_tracingChannel } from "${dcModule}"`
-      : `const {tracingChannel: tr_ch_apm_tracingChannel} = require("${dcModule}")`
-
-    node.body.splice(index + 1, 0, parse(code, {
-      isModule: isModuleSourceType(sourceType),
-    }).body[0])
-  },
-
-  tracingChannelDeclaration (state, node) {
-    const { channelName, module: { name } } = state
-    const channelVariable = 'tr_ch_apm$' + channelName.replaceAll(':', '_')
-
-    if (node.body.some(child => child.declarations?.[0]?.id?.name === channelVariable)) return
-
-    transforms.tracingChannelImport(state, node)
-
-    const index = node.body.findIndex(tracingChannelPredicate)
-    const code = `
-      const ${channelVariable} = tr_ch_apm_tracingChannel("orchestrion:${name}:${channelName}")
-    `
-
-    node.body.splice(index + 1, 0, parse(code).body[0])
-  },
-
-  traceAsyncIterator: traceAny,
-  traceIterator: traceAny,
-}
-
-function traceAny (state, node, _parent, ancestry) {
-  const program = ancestry[ancestry.length - 1]
-
-  if (node.type === 'ClassDeclaration' || node.type === 'ClassExpression') {
-    traceInstanceMethod(state, node, program)
-  } else {
-    traceFunction(state, node, program)
-  }
-}
+module.exports = { waitForAsyncEnd }
 
 /**
- * @param {string} sourceType
+ * Injects a wait for `ctx.asyncEndPromise` into a generated `tracePromise`
+ * wrapper's native-Promise fulfillment handler.
+ *
+ * @param {object} _state
+ * @param {import('estree').CallExpression} node
+ * @returns {void}
  */
-function isModuleSourceType (sourceType) {
-  return sourceType === 'module' || sourceType === 'esm'
-}
-
-function traceFunction (state, node, program) {
-  transforms.tracingChannelDeclaration(state, program)
+function waitForAsyncEnd (_state, node) {
+  const onFulfilled = node.arguments[0]
+  const statements = onFulfilled?.body?.body
 
-  node.body = wrap(state, {
-    type: 'FunctionExpression',
-    params: node.params,
-    body: node.body,
-    async: node.async,
-    expression: false,
-    generator: node.generator,
-  }, program)
-
-  // The original function no longer contains any calls to `await` or `yield` as
-  // the function body is copied to the internal wrapped function, so we set
-  // these to false to avoid altering the return value of the wrapper. The old
-  // values are instead copied to the new AST node above.
-  node.generator = false
-  node.async = false
-
-  wrapSuper(state, node)
-}
-
-function traceInstanceMethod (state, node, program) {
-  const { functionQuery, operator } = state
-  const { methodName } = functionQuery
-
-  const classBody = node.body
-
-  // If the method exists on the class, we return as it will be patched later
-  // while traversing child nodes later on.
-  if (classBody.body.some(({ key }) => key.name === methodName)) return
-
-  // Method doesn't exist on the class so we assume an instance method and
-  // wrap it in the constructor instead.
-  let ctor = classBody.body.find(({ kind }) => kind === 'constructor')
-
-  transforms.tracingChannelDeclaration(state, program)
-
-  if (!ctor) {
-    ctor = parse(
-      node.superClass
-        ? 'class A { constructor (...args) { super(...args) } }'
-        : 'class A { constructor () {} }'
-    ).body[0].body.body[0] // Extract constructor from dummy class body.
-
-    classBody.body.unshift(ctor)
+  if (!statements || query(onFulfilled.body, '[id.name=__apm$asyncEndPromise]').length > 0) {
+    return
   }
 
-  const ctorBody = parse(`
-    const __apm$${methodName} = this["${methodName}"]
-    this["${methodName}"] = function () {}
-  `).body
-
-  // Extract only right-hand side function of line 2.
-  const fn = ctorBody[1].expression.right
-
-  fn.async = operator === 'tracePromise'
-  fn.body = wrap(state, { type: 'Identifier', name: `__apm$${methodName}` }, program)
+  const returnIndex = statements.findIndex(statement => (
+    statement.type === 'ReturnStatement' && statement.argument?.name === 'result'
+  ))
 
-  wrapSuper(state, fn)
+  if (returnIndex === -1) return
 
-  ctor.value.body.body.push(...ctorBody)
-}
-
-function wrap (state, node, program) {
-  const { operator } = state
-
-  if (operator === 'traceAsyncIterator') return wrapIterator(state, node, program)
-  if (operator === 'traceIterator') return wrapIterator(state, node, program)
-}
-
-function wrapSuper (_state, node) {
-  const members = new Set()
-
-  traverse(
-    node.body,
-    '[object.type=Super]',
-    (node, parent) => {
-      const { name } = node.property
-
-      let child
-
-      if (parent.callee) {
-        // This is needed because for generator functions we have to move the
-        // original function to a nested wrapped function, but we can't use an
-        // arrow function because arrow function cannot be generator functions,
-        // and `super` cannot be called from a nested function, so we have to
-        // rewrite any `super` call to not use the keyword.
-        const { expression } = parse(`__apm$super['${name}'].call(this)`).body[0]
-
-        parent.callee = child = expression.callee
-        parent.arguments.unshift(...expression.arguments)
-      } else {
-        parent.expression = child = parse(`__apm$super['${name}']`).body[0]
-      }
-
-      child.computed = parent.callee.computed
-      child.optional = parent.callee.optional
-
-      members.add(name)
-    }
-  )
-
-  for (const name of members) {
-    const member = parse(`
-      class Wrapper {
-        wrapper () {
-          __apm$super['${name}'] = super['${name}']
-        }
-      }
-    `).body[0].body.body[0].value.body.body[0]
-
-    node.body.body.unshift(member)
-  }
-
-  if (members.size > 0) {
-    node.body.body.unshift(parse('const __apm$super = {}').body[0])
-  }
-}
-
-function wrapIterator (state, node, program) {
-  const { channelName, operator } = state
-  const baseChannel = channelName.replaceAll(':', '_')
-  const channelVariable = 'tr_ch_apm$' + baseChannel
-  const nextChannel = baseChannel + '_next'
-  const traceMethod = operator === 'traceAsyncIterator' ? 'tracePromise' : 'traceSync'
-  const traceNext = `tr_ch_apm$${nextChannel}.${traceMethod}`
-
-  transforms.tracingChannelDeclaration({ ...state, channelName: nextChannel }, program)
-
-  const wrapper = parse(`
+  const waitStatements = parse(`
     function wrapper () {
-      const __apm$traced = () => {
-        const __apm$wrapped = () => {};
-        return __apm$wrapped.apply(this, arguments);
-      };
-
-      if (!${channelVariable}.start.hasSubscribers) return __apm$traced();
-
-      {
-        const wrap = iter => {
-          const { next: iterNext, return: iterReturn, throw: iterThrow } = iter;
-
-          iter.next = (...args) => ${traceNext}(iterNext, ctx, iter, ...args);
-          iter.return = (...args) => ${traceNext}(iterReturn, ctx, iter, ...args);
-          iter.throw = (...args) => ${traceNext}(iterThrow, ctx, iter, ...args);
-
-          return iter;
-        };
-        const ctx = {
-          arguments,
-          self: this,
-          moduleVersion: "1.0.0"
-        };
-        const iter = ${channelVariable}.traceSync(__apm$traced, ctx);
-
-        if (typeof iter.then !== 'function') return wrap(iter);
-
-        return iter.then(result => {
-          ctx.result = result;
-
-          ${channelVariable}.asyncStart.publish(ctx);
-          ${channelVariable}.asyncEnd.publish(ctx);
-
-          return wrap(result);
-        }, err => {
-          ctx.error = err;
-
-          ${channelVariable}.error.publish(ctx);
-          ${channelVariable}.asyncStart.publish(ctx);
-          ${channelVariable}.asyncEnd.publish(ctx);
-
-          return Promise.reject(err);
-        });
-      };
+      const __apm$asyncEndPromise = __apm$ctx.asyncEndPromise;
+      if (__apm$asyncEndPromise && typeof __apm$asyncEndPromise.then === 'function') {
+        return __apm$asyncEndPromise.then(() => result, () => result);
+      }
     }
-  `).body[0].body // Extract only block statement of function body.
-
-  // Replace the right-hand side assignment of `const __apm$wrapped = () => {}`.
-  query(wrapper, '[id.name=__apm$wrapped]')[0].init = node
+  `).body[0].body.body
 
-  return wrapper
+  statements.splice(returnIndex, 0, ...waitStatements)
 }

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

@@ -14,6 +14,11 @@ const enterChannel = channel('apm:hono:middleware:enter')
 const exitChannel = channel('apm:hono:middleware:exit')
 const finishChannel = channel('apm:hono:middleware:finish')
 
+// Tracks handlers registered via `app.use()` so route-publishing wrappers
+// installed by `wrapRouterAdd` can skip middleware-only matches (a request
+// matching only middleware should keep the bare HTTP-method resource name).
+const middlewareHandlers = new WeakSet()
+
 // `app.request()` and non-node adapters call `app.fetch` without an `incoming`
 // IncomingMessage; the APM `web` helpers depend on one, so the wrappers below
 // skip publishing whenever it is missing.
@@ -27,6 +32,53 @@ function wrapFetch (fetch) {
   }
 }
 
+function wrapUse (originalUse) {
+  return function (arg1, ...handlers) {
+    if (typeof arg1 === 'function') middlewareHandlers.add(arg1)
+    for (const h of handlers) middlewareHandlers.add(h)
+    return originalUse.call(this, arg1, ...handlers)
+  }
+}
+
+// `app.basePath()` returns a clone Hono instance built via the library's
+// internal class binding, so it never hits our instrumented constructor. The
+// clone shares the parent router (so `router.add` stays wrapped), but its
+// `use` is a fresh per-instance method that must be wrapped too, otherwise
+// middleware registered on the sub-app never lands in `middlewareHandlers`.
+function wrapBasePath (originalBasePath) {
+  return function (path) {
+    const clone = originalBasePath.apply(this, arguments)
+    shimmer.wrap(clone, 'use', wrapUse)
+    shimmer.wrap(clone, 'basePath', wrapBasePath)
+    return clone
+  }
+}
+
+function wrapRouterAdd (originalAdd) {
+  return function (method, path, handlerData) {
+    const handler = handlerData?.[0]
+    if (typeof handler === 'function' && !middlewareHandlers.has(handler)) {
+      const meta = handlerData[1]
+      const wrappedHandler = function (context, next) {
+        const req = context.env?.incoming
+        if (req && routeChannel.hasSubscribers) {
+          routeChannel.publish({ req, route: meta?.path })
+        }
+        return handler.apply(this, arguments)
+      }
+      handlerData = [wrappedHandler, meta]
+    }
+    return originalAdd.call(this, method, path, handlerData)
+  }
+}
+
+function instrumentHonoInstance (instance) {
+  shimmer.wrap(instance, 'fetch', wrapFetch)
+  shimmer.wrap(instance, 'use', wrapUse)
+  shimmer.wrap(instance, 'basePath', wrapBasePath)
+  shimmer.wrap(instance.router, 'add', wrapRouterAdd)
+}
+
 function onErrorFn (error, _context_) {
   throw error
 }
@@ -74,7 +126,6 @@ function wrapMiddleware (middleware, route) {
         if (!req) {
           return middleware.apply(this, arguments)
         }
-        routeChannel.publish({ req, route })
         enterChannel.publish({ req, name, route })
         if (typeof next === 'function') {
           arguments[1] = wrapNext(req, route, next)
@@ -113,7 +164,7 @@ addHook({
   class Hono extends hono.Hono {
     constructor (...args) {
       super(...args)
-      shimmer.wrap(this, 'fetch', wrapFetch)
+      instrumentHonoInstance(this)
     }
   }
 
@@ -130,7 +181,7 @@ addHook({
   class Hono extends hono.Hono {
     constructor (...args) {
       super(...args)
-      shimmer.wrap(this, 'fetch', wrapFetch)
+      instrumentHonoInstance(this)
     }
   }
 

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

@@ -188,8 +188,8 @@ function patch (http, methodName) {
         let finished = false
         let callback = args.callback
 
-        if (callback) {
-          callback = shimmer.wrapFunction(args.callback, cb => function (...args) {
+        if (typeof callback === 'function') {
+          callback = shimmer.wrapCallback(args.callback, cb => function (...args) {
             return asyncStartChannel.runStores(ctx, () => {
               return cb.apply(this, args)
             })

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

@@ -43,7 +43,7 @@ function wrapResponseEmit (emit) {
       return emit.apply(this, arguments)
     }
 
-    if (['finish', 'close'].includes(eventName) && !requestFinishedSet.has(this)) {
+    if ((eventName === 'finish' || eventName === 'close') && !requestFinishedSet.has(this)) {
       finishServerCh.publish({ req: this.req })
       requestFinishedSet.add(this)
     }
@@ -51,6 +51,7 @@ function wrapResponseEmit (emit) {
     return emit.apply(this, arguments)
   }
 }
+
 function wrapEmit (emit) {
   return function (eventName, req, res) {
     if (!startServerCh.hasSubscribers) {
@@ -61,8 +62,12 @@ function wrapEmit (emit) {
       res.req = req
 
       const abortController = new AbortController()
+      // Single ctx shared with `exitServerCh` below and forwarded by the
+      // server plugin to `incomingHttpRequestStart`; existing subscribers
+      // only read the message, so the reuse is safe.
+      const ctx = { req, res, abortController }
 
-      startServerCh.publish({ req, res, abortController })
+      startServerCh.publish(ctx)
 
       try {
         if (abortController.signal.aborted) {
@@ -76,7 +81,7 @@ function wrapEmit (emit) {
 
         throw err
       } finally {
-        exitServerCh.publish({ req })
+        exitServerCh.publish(ctx)
       }
     }
     return emit.apply(this, arguments)
@@ -107,7 +112,7 @@ function wrapWriteHead (writeHead) {
     }
 
     // this doesn't support explicit duplicate headers, but it's an edge case
-    const responseHeaders = Object.assign(this.getHeaders(), obj)
+    const responseHeaders = obj === undefined ? this.getHeaders() : Object.assign(this.getHeaders(), obj)
 
     startWriteHeadCh.publish({
       req: this.req,

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

@@ -14,9 +14,9 @@ const connectionOptionsCache = new WeakMap()
 
 function wrapRedis (Redis) {
   shimmer.wrap(Redis.prototype, 'sendCommand', sendCommand => function (command, stream) {
-    if (!startCh.hasSubscribers) return sendCommand.apply(this, arguments)
+    if (!startCh.hasSubscribers) return sendCommand.call(this, command, stream)
 
-    if (!command || !command.promise) return sendCommand.apply(this, arguments)
+    if (!command?.promise) return sendCommand.call(this, command, stream)
 
     const options = this.options || {}
     let connectionOptions = connectionOptionsCache.get(this)
@@ -35,7 +35,7 @@ function wrapRedis (Redis) {
     return startCh.runStores(ctx, () => {
       command.promise.then(() => finish(finishCh, errorCh, ctx), err => finish(finishCh, errorCh, ctx, err))
 
-      return sendCommand.apply(this, arguments)
+      return sendCommand.call(this, command, stream)
     })
   })
   return Redis

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

@@ -0,0 +1,163 @@
+'use strict'
+
+const { readFileSync } = require('node:fs')
+const path = require('node:path')
+
+const COVERAGE_BACKFILL_CACHE_DIRECTORY = 'dd-trace-coverage-backfill'
+const TRANSFORM_OPTIONS = {
+  instrument: true,
+  supportsDynamicImport: true,
+  supportsExportNamespaceFrom: true,
+  supportsStaticESM: true,
+  supportsTopLevelAwait: true,
+}
+
+function getCoverageBackfillFiles (skippableSuitesCoverage, rootDir, getTestSuitePath) {
+  const files = []
+  for (const filename of Object.keys(skippableSuitesCoverage || {})) {
+    const relativeFilename = path.isAbsolute(filename)
+      ? getTestSuitePath(filename, rootDir)
+      : filename
+    files.push(relativeFilename)
+  }
+  return files
+}
+
+// Use a separate Jest cache namespace for synthetic backfill transforms so they cannot reuse or overwrite normal
+// Jest transform cache entries produced during the user's test run.
+function getCoverageBackfillConfig (config) {
+  if (!config?.cacheDirectory) return config
+
+  return {
+    ...config,
+    cacheDirectory: path.join(config.cacheDirectory, COVERAGE_BACKFILL_CACHE_DIRECTORY),
+  }
+}
+
+function getCoverageBackfillDependencies (CoverageReporter, getCoverageBackfillRequire) {
+  const coverageWorkerRequire = getCoverageBackfillRequire(CoverageReporter)
+
+  return {
+    createFileCoverage: coverageWorkerRequire('istanbul-lib-coverage').createFileCoverage,
+    createScriptTransformer: coverageWorkerRequire('@jest/transform').createScriptTransformer,
+    readInitialCoverage: coverageWorkerRequire('istanbul-lib-instrument').readInitialCoverage,
+  }
+}
+
+// Some transformers expose Istanbul coverage as a literal that readInitialCoverage does not parse.
+function extractCoverageDataObject (code) {
+  const marker = 'var coverageData = '
+  const start = code.indexOf(marker)
+  if (start === -1) return
+
+  let depth = 0
+  let quote
+  let escaped = false
+  let index = start + marker.length
+  for (; index < code.length; index++) {
+    const char = code[index]
+    if (quote) {
+      if (escaped) {
+        escaped = false
+      } else if (char === '\\') {
+        escaped = true
+      } else if (char === quote) {
+        quote = undefined
+      }
+      continue
+    }
+    if (char === '"' || char === "'" || char === '`') {
+      quote = char
+    } else if (char === '{') {
+      depth++
+    } else if (char === '}') {
+      depth--
+      if (depth === 0) {
+        index++
+        break
+      }
+    }
+  }
+  if (depth !== 0) return
+
+  try {
+    // eslint-disable-next-line no-new-func
+    return new Function(`return (${code.slice(start + marker.length, index)})`)()
+  } catch {
+    // Ignore transformer output that does not contain parseable Istanbul metadata.
+  }
+}
+
+// Read the Istanbul file metadata emitted by Jest's transformer.
+function getCoverageDataFromCode (code, readInitialCoverage) {
+  return readInitialCoverage(code)?.coverageData || extractCoverageDataObject(code)
+}
+
+function transformFileWithTransformers (absoluteFile, sourceText, transformers, readInitialCoverage) {
+  return Promise.all(transformers.map(transformer => {
+    return transformer.transformSourceAsync(absoluteFile, sourceText, TRANSFORM_OPTIONS)
+      .then(({ code }) => getCoverageDataFromCode(code, readInitialCoverage))
+      .catch(() => {})
+  })).then(coverageDataByContext => coverageDataByContext.find(Boolean))
+}
+
+function getBackfillCoverageDataForFile (file, rootDir, transformers, coverageMap, readInitialCoverage) {
+  const absoluteFile = path.isAbsolute(file) ? file : path.join(rootDir, file)
+  if (coverageMap.data[absoluteFile]) return Promise.resolve()
+
+  let sourceText
+  try {
+    sourceText = readFileSync(absoluteFile, 'utf8')
+  } catch {
+    return Promise.resolve()
+  }
+
+  return transformFileWithTransformers(absoluteFile, sourceText, transformers, readInitialCoverage)
+}
+
+// Seed Jest's coverage map with files that did not run locally but are covered by backend meta.coverage.
+function addCoverageBackfillUntestedFiles ({
+  coverageMap,
+  testContexts,
+  rootDir,
+  CoverageReporter,
+  coverageBackfillFiles,
+  getCoverageBackfillRequire,
+}) {
+  if (!coverageBackfillFiles?.length || !coverageMap || !rootDir) return Promise.resolve()
+
+  let createFileCoverage, createScriptTransformer, readInitialCoverage
+  try {
+    ({
+      createFileCoverage,
+      createScriptTransformer,
+      readInitialCoverage,
+    } = getCoverageBackfillDependencies(CoverageReporter, getCoverageBackfillRequire))
+  } catch {
+    return Promise.resolve()
+  }
+
+  const contexts = [...(testContexts || [])]
+  return Promise.all(contexts.map(context => {
+    return createScriptTransformer(getCoverageBackfillConfig(context.config)).catch(() => {})
+  }))
+    .then(transformers => transformers.filter(Boolean))
+    .then(transformers => {
+      if (!transformers.length) return []
+      return Promise.all(coverageBackfillFiles.map(file => {
+        return getBackfillCoverageDataForFile(file, rootDir, transformers, coverageMap, readInitialCoverage)
+      }))
+    })
+    .then(coverageDataByFile => {
+      for (const coverageData of coverageDataByFile) {
+        if (coverageData && !coverageMap.data[coverageData.path]) {
+          coverageMap.addFileCoverage(createFileCoverage(coverageData))
+        }
+      }
+    })
+}
+
+module.exports = {
+  addCoverageBackfillUntestedFiles,
+  getCoverageBackfillFiles,
+}