dd-trace 4.11.1 → 4.16.0

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

@@ -39,10 +39,13 @@ const testErrCh = channel('ci:jest:test:err')
 const skippableSuitesCh = channel('ci:jest:test-suite:skippable')
 const jestItrConfigurationCh = channel('ci:jest:itr-configuration')
 
+const itrSkippedSuitesCh = channel('ci:jest:itr:skipped-suites')
+
 let skippableSuites = []
 let isCodeCoverageEnabled = false
 let isSuitesSkippingEnabled = false
 let isSuitesSkipped = false
+let numSkippedSuites = 0
 
 const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 
@@ -102,7 +105,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         await super.handleTestEvent(event, state)
       }
 
-      const setNameToParams = (name, params) => { this.nameToParams[name] = params }
+      const setNameToParams = (name, params) => { this.nameToParams[name] = [...params] }
 
       if (event.name === 'setup') {
         if (this.global.test) {
@@ -191,7 +194,7 @@ addHook({
 addHook({
   name: '@jest/test-sequencer',
   versions: ['>=24.8.0']
-}, sequencerPackage => {
+}, (sequencerPackage, frameworkVersion) => {
   shimmer.wrap(sequencerPackage.default.prototype, 'shard', shard => function () {
     const shardedTests = shard.apply(this, arguments)
 
@@ -202,13 +205,15 @@ addHook({
     const [test] = shardedTests
     const rootDir = test && test.context && test.context.config && test.context.config.rootDir
 
-    const filteredTests = getJestSuitesToRun(skippableSuites, shardedTests, rootDir || process.cwd())
+    const { skippedSuites, suitesToRun } = getJestSuitesToRun(skippableSuites, shardedTests, rootDir || process.cwd())
 
-    isSuitesSkipped = filteredTests.length !== shardedTests.length
+    isSuitesSkipped = suitesToRun.length !== shardedTests.length
+    numSkippedSuites = skippedSuites.length
 
-    skippableSuites = []
+    itrSkippedSuitesCh.publish({ skippedSuites, frameworkVersion })
 
-    return filteredTests
+    skippableSuites = []
+    return suitesToRun
   })
   return sequencerPackage
 })
@@ -279,10 +284,13 @@ function cliWrapper (cli, jestVersion) {
         isSuitesSkipped,
         isSuitesSkippingEnabled,
         isCodeCoverageEnabled,
-        testCodeCoverageLinesTotal
+        testCodeCoverageLinesTotal,
+        numSkippedSuites
       })
     })
 
+    numSkippedSuites = 0
+
     return result
   })
 
@@ -468,7 +476,7 @@ addHook({
   name: '@jest/core',
   versions: ['>=24.8.0'],
   file: 'build/SearchSource.js'
-}, searchSourcePackage => {
+}, (searchSourcePackage, frameworkVersion) => {
   const SearchSource = searchSourcePackage.default ? searchSourcePackage.default : searchSourcePackage
 
   shimmer.wrap(SearchSource.prototype, 'getTestPaths', getTestPaths => async function () {
@@ -492,13 +500,16 @@ addHook({
     const testPaths = await getTestPaths.apply(this, arguments)
     const { tests } = testPaths
 
-    const filteredTests = getJestSuitesToRun(skippableSuites, tests, rootDir)
+    const { skippedSuites, suitesToRun } = getJestSuitesToRun(skippableSuites, tests, rootDir)
+
+    isSuitesSkipped = suitesToRun.length !== tests.length
+    numSkippedSuites = skippedSuites.length
 
-    isSuitesSkipped = filteredTests.length !== tests.length
+    itrSkippedSuitesCh.publish({ skippedSuites, frameworkVersion })
 
     skippableSuites = []
 
-    return { ...testPaths, tests: filteredTests }
+    return { ...testPaths, tests: suitesToRun }
   })
 
   return searchSourcePackage

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

@@ -15,15 +15,14 @@ const consumerStartCh = channel('apm:kafkajs:consume:start')
 const consumerFinishCh = channel('apm:kafkajs:consume:finish')
 const consumerErrorCh = channel('apm:kafkajs:consume:error')
 
-addHook({ name: 'kafkajs', versions: ['>=1.4'] }, (obj) => {
-  class Kafka extends obj.Kafka {
+addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKafka) => {
+  class Kafka extends BaseKafka {
     constructor (options) {
       super(options)
       this._brokers = (options.brokers && typeof options.brokers !== 'function')
         ? options.brokers.join(',') : undefined
     }
   }
-  obj.Kafka = Kafka
 
   shimmer.wrap(Kafka.prototype, 'producer', createProducer => function () {
     const producer = createProducer.apply(this, arguments)
@@ -117,5 +116,5 @@ addHook({ name: 'kafkajs', versions: ['>=1.4'] }, (obj) => {
     }
     return consumer
   })
-  return obj
+  return Kafka
 })

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

@@ -30,6 +30,8 @@ const testSuiteFinishCh = channel('ci:mocha:test-suite:finish')
 const testSuiteErrorCh = channel('ci:mocha:test-suite:error')
 const testSuiteCodeCoverageCh = channel('ci:mocha:test-suite:code-coverage')
 
+const itrSkippedSuitesCh = channel('ci:mocha:itr:skipped-suites')
+
 // TODO: remove when root hooks and fixtures are implemented
 const patched = new WeakSet()
 
@@ -47,6 +49,7 @@ const originalCoverageMap = createCoverageMap()
 let suitesToSkip = []
 let frameworkVersion
 let isSuitesSkipped = false
+let skippedSuites = []
 
 function getSuitesByTestFile (root) {
   const suitesByTestFile = {}
@@ -97,10 +100,17 @@ function getTestAsyncResource (test) {
   return testToAr.get(originalFn)
 }
 
-function getSuitesToRun (originalSuites) {
-  return originalSuites.filter(suite =>
-    !suitesToSkip.includes(getTestSuitePath(suite.file, process.cwd()))
-  )
+function getFilteredSuites (originalSuites) {
+  return originalSuites.reduce((acc, suite) => {
+    const testPath = getTestSuitePath(suite.file, process.cwd())
+    const shouldSkip = suitesToSkip.includes(testPath)
+    if (shouldSkip) {
+      acc.skippedSuites.add(testPath)
+    } else {
+      acc.suitesToRun.push(suite)
+    }
+    return acc
+  }, { suitesToRun: [], skippedSuites: new Set() })
 }
 
 function mochaHook (Runner) {
@@ -137,13 +147,21 @@ function mochaHook (Runner) {
         global.__coverage__ = fromCoverageMapToCoverage(originalCoverageMap)
       }
 
-      testSessionFinishCh.publish({ status, isSuitesSkipped, testCodeCoverageLinesTotal })
+      testSessionFinishCh.publish({
+        status,
+        isSuitesSkipped,
+        testCodeCoverageLinesTotal,
+        numSkippedSuites: skippedSuites.length
+      })
     }))
 
     this.once('start', testRunAsyncResource.bind(function () {
       const processArgv = process.argv.slice(2).join(' ')
       const command = `mocha ${processArgv}`
       testSessionStartCh.publish({ command, frameworkVersion })
+      if (skippedSuites.length) {
+        itrSkippedSuitesCh.publish({ skippedSuites, frameworkVersion })
+      }
     }))
 
     this.on('suite', function (suite) {
@@ -359,9 +377,13 @@ addHook({
         suitesToSkip = skippableSuites
       }
       // We remove the suites that we skip through ITR
-      const newSuites = getSuitesToRun(runner.suite.suites)
-      isSuitesSkipped = newSuites.length !== runner.suite.suites.length
-      runner.suite.suites = newSuites
+      const filteredSuites = getFilteredSuites(runner.suite.suites)
+      const { suitesToRun } = filteredSuites
+
+      isSuitesSkipped = suitesToRun.length !== runner.suite.suites.length
+      runner.suite.suites = suitesToRun
+
+      skippedSuites = Array.from(filteredSuites.skippedSuites)
 
       global.run()
     }
@@ -419,6 +441,9 @@ addHook({
   file: 'lib/cli/run-helpers.js'
 }, (run) => {
   shimmer.wrap(run, 'runMocha', runMocha => async function () {
+    if (!testStartCh.hasSubscribers) {
+      return runMocha.apply(this, arguments)
+    }
     const mocha = arguments[0]
     /**
      * This attaches `run` to the global context, which we'll call after

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

@@ -17,7 +17,7 @@ addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connect
       return query.apply(this, arguments)
     }
 
-    const sql = arguments[0].sql ? arguments[0].sql : arguments[0]
+    const sql = arguments[0].sql || arguments[0]
     const conf = this.config
     const payload = { sql, conf }
 
@@ -66,9 +66,47 @@ addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connect
 })
 
 addHook({ name: 'mysql', file: 'lib/Pool.js', versions: ['>=2'] }, Pool => {
+  const startPoolQueryCh = channel('datadog:mysql:pool:query:start')
+  const finishPoolQueryCh = channel('datadog:mysql:pool:query:finish')
+
   shimmer.wrap(Pool.prototype, 'getConnection', getConnection => function (cb) {
     arguments[0] = AsyncResource.bind(cb)
     return getConnection.apply(this, arguments)
   })
+
+  shimmer.wrap(Pool.prototype, 'query', query => function () {
+    if (!startPoolQueryCh.hasSubscribers) {
+      return query.apply(this, arguments)
+    }
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+    const sql = arguments[0].sql || arguments[0]
+
+    return asyncResource.runInAsyncScope(() => {
+      startPoolQueryCh.publish({ sql })
+
+      const finish = asyncResource.bind(function () {
+        finishPoolQueryCh.publish()
+      })
+
+      const cb = arguments[arguments.length - 1]
+      if (typeof cb === 'function') {
+        arguments[arguments.length - 1] = shimmer.wrap(cb, function () {
+          finish()
+          return cb.apply(this, arguments)
+        })
+      }
+
+      const retval = query.apply(this, arguments)
+
+      if (retval && retval.then) {
+        retval.then(finish).catch(finish)
+      }
+
+      return retval
+    })
+  })
+
   return Pool
 })

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

@@ -2,7 +2,7 @@
 
 // TODO: either instrument all or none of the render functions
 
-const { channel, addHook, AsyncResource } = require('./helpers/instrument')
+const { channel, addHook } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 const { DD_MAJOR } = require('../../../version')
 
@@ -11,7 +11,7 @@ const finishChannel = channel('apm:next:request:finish')
 const errorChannel = channel('apm:next:request:error')
 const pageLoadChannel = channel('apm:next:page:load')
 
-const requestResources = new WeakMap()
+const requests = new WeakSet()
 
 function wrapHandleRequest (handleRequest) {
   return function (req, res, pathname, query) {
@@ -28,9 +28,9 @@ function wrapHandleApiRequest (handleApiRequest) {
         if (!handled) return handled
 
         return this.hasPage(pathname).then(pageFound => {
-          const page = pageFound ? pathname : getPageFromPath(pathname, this.dynamicRoutes)
+          const pageData = pageFound ? { page: pathname } : getPageFromPath(pathname, this.dynamicRoutes)
 
-          pageLoadChannel.publish({ page })
+          pageLoadChannel.publish(pageData)
 
           return handled
         })
@@ -83,15 +83,19 @@ function wrapFindPageComponents (findPageComponents) {
     const result = findPageComponents.apply(this, arguments)
 
     if (result) {
-      pageLoadChannel.publish({ page: getPagePath(pathname) })
+      pageLoadChannel.publish(getPagePath(pathname))
     }
 
     return result
   }
 }
 
-function getPagePath (page) {
-  return typeof page === 'object' ? page.pathname : page
+function getPagePath (maybePage) {
+  if (typeof maybePage !== 'object') return { page: maybePage }
+
+  const isAppPath = maybePage.isAppPath
+  const page = maybePage.pathname || maybePage.page
+  return { page, isAppPath }
 }
 
 function getPageFromPath (page, dynamicRoutes = []) {
@@ -105,38 +109,50 @@ function getPageFromPath (page, dynamicRoutes = []) {
 }
 
 function instrument (req, res, handler) {
-  if (requestResources.has(req)) return handler()
+  req = req.originalRequest || req
+  res = res.originalResponse || res
 
-  const requestResource = new AsyncResource('bound-anonymous-fn')
+  if (requests.has(req)) return handler()
 
-  requestResources.set(req, requestResource)
+  requests.add(req)
 
-  return requestResource.runInAsyncScope(() => {
-    startChannel.publish({ req, res })
+  const ctx = { req, res }
 
+  return startChannel.runStores(ctx, () => {
     try {
-      const promise = handler()
+      const promise = handler(ctx)
 
       // promise should only reject when propagateError is true:
       // https://github.com/vercel/next.js/blob/cee656238a/packages/next/server/api-utils/node.ts#L547
       return promise.then(
-        result => finish(req, res, result),
-        err => finish(req, res, null, err)
+        result => finish(ctx, result),
+        err => finish(ctx, null, err)
       )
     } catch (e) {
       // this will probably never happen as the handler caller is an async function:
       // https://github.com/vercel/next.js/blob/cee656238a/packages/next/server/api-utils/node.ts#L420
-      return finish(req, res, null, e)
+      return finish(ctx, null, e)
     }
   })
 }
 
-function finish (req, res, result, err) {
+function wrapServeStatic (serveStatic) {
+  return function (req, res, path) {
+    return instrument(req, res, () => {
+      if (pageLoadChannel.hasSubscribers && path) pageLoadChannel.publish({ page: path })
+
+      return serveStatic.apply(this, arguments)
+    })
+  }
+}
+
+function finish (ctx, result, err) {
   if (err) {
-    errorChannel.publish(err)
+    ctx.error = err
+    errorChannel.publish(ctx)
   }
 
-  finishChannel.publish({ req, res })
+  finishChannel.publish(ctx)
 
   if (err) {
     throw err
@@ -145,6 +161,18 @@ function finish (req, res, result, err) {
   return result
 }
 
+addHook({
+  name: 'next',
+  versions: ['>=11.1'],
+  file: 'dist/server/serve-static.js'
+}, serveStatic => shimmer.wrap(serveStatic, 'serveStatic', wrapServeStatic))
+
+addHook({
+  name: 'next',
+  versions: DD_MAJOR >= 4 ? ['>=10.2 <11.1'] : ['>=9.5 <11.1'],
+  file: 'dist/next-server/server/serve-static.js'
+}, serveStatic => shimmer.wrap(serveStatic, 'serveStatic', wrapServeStatic))
+
 addHook({ name: 'next', versions: ['>=13.2'], file: 'dist/server/next-server.js' }, nextServer => {
   const Server = nextServer.default
 

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

@@ -10,7 +10,7 @@ const startCh = channel('apm:openai:request:start')
 const finishCh = channel('apm:openai:request:finish')
 const errorCh = channel('apm:openai:request:error')
 
-addHook({ name: 'openai', file: 'dist/api.js', versions: ['>=3.0.0'] }, exports => {
+addHook({ name: 'openai', file: 'dist/api.js', versions: ['>=3.0.0 <4'] }, exports => {
   const methodNames = Object.getOwnPropertyNames(exports.OpenAIApi.prototype)
   methodNames.shift() // remove leading 'constructor' method
 

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

@@ -11,8 +11,12 @@ const startCh = channel('apm:pg:query:start')
 const finishCh = channel('apm:pg:query:finish')
 const errorCh = channel('apm:pg:query:error')
 
+const startPoolQueryCh = channel('datadog:pg:pool:query:start')
+const finishPoolQueryCh = channel('datadog:pg:pool:query:finish')
+
 addHook({ name: 'pg', versions: ['>=8.0.3'] }, pg => {
   shimmer.wrap(pg.Client.prototype, 'query', query => wrapQuery(query))
+  shimmer.wrap(pg.Pool.prototype, 'query', query => wrapPoolQuery(query))
   return pg
 })
 
@@ -35,28 +39,27 @@ function wrapQuery (query) {
       ? arguments[0]
       : { text: arguments[0] }
 
-    // The query objects passed in can be pretty complex. They can be instances of EventEmitter.
-    //   For this reason we can't make a shallow clone of the object.
-    // Some libraries, such as sql-template-tags, can provide a getter .text property.
-    //   For this reason we can't replace the .text property.
-    // Instead, we create a new object, and set the original query as the prototype.
-    // This allows any existing methods to still work and lets us easily provide a new query.
-    let newQuery = {
-      __ddInjectableQuery: '',
-      get text () {
-        return this.__ddInjectableQuery || Object.getPrototypeOf(this).text
-      }
+    const textProp = Object.getOwnPropertyDescriptor(pgQuery, 'text')
+
+    // Only alter `text` property if safe to do so.
+    if (!textProp || textProp.configurable) {
+      const originalText = pgQuery.text
+
+      Object.defineProperty(pgQuery, 'text', {
+        get () {
+          return this?.__ddInjectableQuery || originalText
+        }
+      })
     }
-    Object.setPrototypeOf(newQuery, pgQuery)
 
     return asyncResource.runInAsyncScope(() => {
       startCh.publish({
         params: this.connectionParameters,
-        query: newQuery,
+        query: pgQuery,
         processId
       })
 
-      arguments[0] = newQuery
+      arguments[0] = pgQuery
 
       const finish = asyncResource.bind(function (error) {
         if (error) {
@@ -69,7 +72,7 @@ function wrapQuery (query) {
       const queryQueue = this.queryQueue || this._queryQueue
       const activeQuery = this.activeQuery || this._activeQuery
 
-      newQuery = queryQueue[queryQueue.length - 1] || activeQuery
+      const newQuery = queryQueue[queryQueue.length - 1] || activeQuery
 
       if (!newQuery) {
         return retval
@@ -97,3 +100,45 @@ function wrapQuery (query) {
     })
   }
 }
+
+function wrapPoolQuery (query) {
+  return function () {
+    if (!startPoolQueryCh.hasSubscribers) {
+      return query.apply(this, arguments)
+    }
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+    const pgQuery = arguments[0] && typeof arguments[0] === 'object' ? arguments[0] : { text: arguments[0] }
+
+    return asyncResource.runInAsyncScope(() => {
+      startPoolQueryCh.publish({
+        query: pgQuery
+      })
+
+      const finish = asyncResource.bind(function () {
+        finishPoolQueryCh.publish()
+      })
+
+      const cb = arguments[arguments.length - 1]
+      if (typeof cb === 'function') {
+        arguments[arguments.length - 1] = shimmer.wrap(cb, function () {
+          finish()
+          return cb.apply(this, arguments)
+        })
+      }
+
+      const retval = query.apply(this, arguments)
+
+      if (retval && retval.then) {
+        retval.then(() => {
+          finish()
+        }).catch(() => {
+          finish()
+        })
+      }
+
+      return retval
+    })
+  }
+}

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

@@ -254,7 +254,7 @@ addHook({
 addHook({
   name: '@playwright/test',
   file: 'lib/dispatcher.js',
-  versions: ['>=1.18.0  <1.30.0']
+  versions: ['>=1.18.0 <1.30.0']
 }, dispatcherHook)
 
 addHook({
@@ -266,11 +266,23 @@ addHook({
 addHook({
   name: '@playwright/test',
   file: 'lib/runner/dispatcher.js',
-  versions: ['>=1.31.0']
+  versions: ['>=1.31.0 <1.38.0']
 }, (dispatcher) => dispatcherHookNew(dispatcher, dispatcherRunWrapperNew))
 
 addHook({
   name: '@playwright/test',
   file: 'lib/runner/runner.js',
-  versions: ['>=1.31.0']
+  versions: ['>=1.31.0 <1.38.0']
 }, runnerHook)
+
+// From >=1.38.0
+addHook({
+  name: 'playwright',
+  file: 'lib/runner/runner.js',
+  versions: ['>=1.38.0']
+}, runnerHook)
+addHook({
+  name: 'playwright',
+  file: 'lib/runner/dispatcher.js',
+  versions: ['>=1.38.0']
+}, (dispatcher) => dispatcherHookNew(dispatcher, dispatcherRunWrapperNew))

package/packages/datadog-plugin-cucumber/src/index.js

@@ -25,12 +25,24 @@ class CucumberPlugin extends CiPlugin {
 
     this.sourceRoot = process.cwd()
 
-    this.addSub('ci:cucumber:session:finish', ({ status, isSuitesSkipped, testCodeCoverageLinesTotal }) => {
+    this.addSub('ci:cucumber:session:finish', ({
+      status,
+      isSuitesSkipped,
+      numSkippedSuites,
+      testCodeCoverageLinesTotal
+    }) => {
       const { isSuitesSkippingEnabled, isCodeCoverageEnabled } = this.itrConfig || {}
       addIntelligentTestRunnerSpanTags(
         this.testSessionSpan,
         this.testModuleSpan,
-        { isSuitesSkipped, isSuitesSkippingEnabled, isCodeCoverageEnabled, testCodeCoverageLinesTotal }
+        {
+          isSuitesSkipped,
+          isSuitesSkippingEnabled,
+          isCodeCoverageEnabled,
+          testCodeCoverageLinesTotal,
+          skippingCount: numSkippedSuites,
+          skippingType: 'suite'
+        }
       )
 
       this.testSessionSpan.setTag(TEST_STATUS, status)