dd-trace 4.15.0 → 4.17.0

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

@@ -0,0 +1,63 @@
+'use strict'
+
+require('./mongodb-core')
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+// collection methods with filter
+const collectionMethodsWithFilter = [
+  'count',
+  'countDocuments',
+  'deleteMany',
+  'deleteOne',
+  'find',
+  'findOneAndDelete',
+  'findOneAndReplace',
+  'replaceOne'
+] // findOne is ignored because it calls to find
+
+const collectionMethodsWithTwoFilters = [
+  'findOneAndUpdate',
+  'updateMany',
+  'updateOne'
+]
+
+const startCh = channel('datadog:mongodb:collection:filter:start')
+
+addHook({ name: 'mongodb', versions: ['>=3.3 <5', '5', '>=6'] }, mongodb => {
+  [...collectionMethodsWithFilter, ...collectionMethodsWithTwoFilters].forEach(methodName => {
+    if (!(methodName in mongodb.Collection.prototype)) return
+
+    const useTwoArguments = collectionMethodsWithTwoFilters.includes(methodName)
+
+    shimmer.wrap(mongodb.Collection.prototype, methodName, method => {
+      return function () {
+        if (!startCh.hasSubscribers) {
+          return method.apply(this, arguments)
+        }
+
+        const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+        return asyncResource.runInAsyncScope(() => {
+          const filters = [arguments[0]]
+          if (useTwoArguments) {
+            filters.push(arguments[1])
+          }
+
+          startCh.publish({
+            filters,
+            methodName
+          })
+
+          return method.apply(this, arguments)
+        })
+      }
+    })
+  })
+  return mongodb
+})

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const { addHook } = require('./helpers/instrument')
+const { addHook, channel } = require('./helpers/instrument')
 const { wrapThen } = require('./helpers/promise')
 const { AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
@@ -26,5 +26,144 @@ addHook({
   }
 
   shimmer.wrap(mongoose.Collection.prototype, 'addQueue', wrapAddQueue)
+
   return mongoose
 })
+
+const startCh = channel('datadog:mongoose:model:filter:start')
+const finishCh = channel('datadog:mongoose:model:filter:finish')
+
+const collectionMethodsWithFilter = [
+  'count',
+  'countDocuments',
+  'deleteMany',
+  'deleteOne',
+  'find',
+  'findOne',
+  'findOneAndDelete',
+  'findOneAndReplace',
+  'replaceOne',
+  'remove'
+]
+
+const collectionMethodsWithTwoFilters = [
+  'findOneAndUpdate',
+  'updateMany',
+  'updateOne'
+]
+
+addHook({
+  name: 'mongoose',
+  versions: ['>=4.6.4 <5', '5', '6', '>=7'],
+  file: 'lib/model.js'
+}, Model => {
+  [...collectionMethodsWithFilter, ...collectionMethodsWithTwoFilters].forEach(methodName => {
+    const useTwoArguments = collectionMethodsWithTwoFilters.includes(methodName)
+    if (!(methodName in Model)) return
+
+    shimmer.wrap(Model, methodName, method => {
+      return function wrappedModelMethod () {
+        if (!startCh.hasSubscribers) {
+          return method.apply(this, arguments)
+        }
+
+        const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+        const filters = [arguments[0]]
+        if (useTwoArguments) {
+          filters.push(arguments[1])
+        }
+
+        const finish = asyncResource.bind(function () {
+          finishCh.publish()
+        })
+
+        let callbackWrapped = false
+        const lastArgumentIndex = arguments.length - 1
+
+        if (typeof arguments[lastArgumentIndex] === 'function') {
+          // is a callback, wrap it to execute finish()
+          shimmer.wrap(arguments, lastArgumentIndex, originalCb => {
+            return function () {
+              finish()
+
+              return originalCb.apply(this, arguments)
+            }
+          })
+
+          callbackWrapped = true
+        }
+
+        return asyncResource.runInAsyncScope(() => {
+          startCh.publish({
+            filters,
+            methodName
+          })
+
+          const res = method.apply(this, arguments)
+
+          // if it is not callback, wrap exec method and its then
+          if (!callbackWrapped) {
+            shimmer.wrap(res, 'exec', originalExec => {
+              return function wrappedExec () {
+                const execResult = originalExec.apply(this, arguments)
+
+                // wrap them method, wrap resolve and reject methods
+                shimmer.wrap(execResult, 'then', originalThen => {
+                  return function wrappedThen () {
+                    const resolve = arguments[0]
+                    const reject = arguments[1]
+
+                    // not using shimmer here because resolve/reject could be empty
+                    arguments[0] = function wrappedResolve () {
+                      finish()
+
+                      if (resolve) {
+                        return resolve.apply(this, arguments)
+                      }
+                    }
+
+                    arguments[1] = function wrappedReject () {
+                      finish()
+
+                      if (reject) {
+                        return reject.apply(this, arguments)
+                      }
+                    }
+
+                    return originalThen.apply(this, arguments)
+                  }
+                })
+
+                return execResult
+              }
+            })
+          }
+          return res
+        })
+      }
+    })
+  })
+
+  return Model
+})
+
+const sanitizeFilterFinishCh = channel('datadog:mongoose:sanitize-filter:finish')
+
+addHook({
+  name: 'mongoose',
+  versions: ['6', '>=7'],
+  file: 'lib/helpers/query/sanitizeFilter.js'
+}, sanitizeFilter => {
+  return shimmer.wrap(sanitizeFilter, function wrappedSanitizeFilter () {
+    const sanitizedObject = sanitizeFilter.apply(this, arguments)
+
+    if (sanitizeFilterFinishCh.hasSubscribers) {
+      sanitizeFilterFinishCh.publish({
+        sanitizedObject
+      })
+    }
+
+    return sanitizedObject
+  })
+})

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

@@ -10,9 +10,10 @@ const startChannel = channel('apm:next:request:start')
 const finishChannel = channel('apm:next:request:finish')
 const errorChannel = channel('apm:next:request:error')
 const pageLoadChannel = channel('apm:next:page:load')
+const bodyParsedChannel = channel('apm:next:body-parsed')
+const queryParsedChannel = channel('apm:next:query-parsed')
 
 const requests = new WeakSet()
-const requestToNextjsPagePath = new WeakMap()
 
 function wrapHandleRequest (handleRequest) {
   return function (req, res, pathname, query) {
@@ -29,9 +30,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
         })
@@ -84,15 +85,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 = []) {
@@ -133,57 +138,16 @@ function instrument (req, res, handler) {
   })
 }
 
-function wrapSetupServerWorker (setupServerWorker) {
-  return function (requestHandler) {
-    arguments[0] = shimmer.wrap(requestHandler, wrapRequestHandler(requestHandler))
-    return setupServerWorker.apply(this, arguments)
-  }
-}
-
-function wrapInitialize (initialize) {
-  return async function () {
-    const result = await initialize.apply(this, arguments)
-    if (Array.isArray(result)) {
-      const requestHandler = result[0]
-      result[0] = shimmer.wrap(requestHandler, wrapRequestHandler(requestHandler))
-    }
-    return result
-  }
-}
-
-function wrapRequestHandler (requestHandler) {
-  return function (req, res) {
-    return instrument(req, res, async () => {
-      const result = await requestHandler.apply(this, arguments) // apply here first to get page path association
-
-      const page = requestToNextjsPagePath.get(req)
-      if (page && pageLoadChannel.hasSubscribers) pageLoadChannel.publish({ page })
+function wrapServeStatic (serveStatic) {
+  return function (req, res, path) {
+    return instrument(req, res, () => {
+      if (pageLoadChannel.hasSubscribers && path) pageLoadChannel.publish({ page: path })
 
-      return result
+      return serveStatic.apply(this, arguments)
     })
   }
 }
 
-// these two functions make sure we get path groups for routes in standalone,
-// as it doesn't route through `next-server`/`base-server`
-function wrapGetResolveRoutes (getResolveRoutes) {
-  return function () {
-    const result = getResolveRoutes.apply(this, arguments)
-    return shimmer.wrap(result, wrapResolveRoutes(result))
-  }
-}
-
-function wrapResolveRoutes (resolveRoutes) {
-  return async function (req) {
-    const result = await resolveRoutes.apply(this, arguments)
-    if (result && result.matchedOutput) {
-      const path = result.matchedOutput.itemPath
-      requestToNextjsPagePath.set(req, path)
-    }
-    return result
-  }
-}
-
 function finish (ctx, result, err) {
   if (err) {
     ctx.error = err
@@ -201,25 +165,21 @@ function finish (ctx, result, err) {
 
 addHook({
   name: 'next',
-  versions: ['>=13.4.13'],
-  file: 'dist/server/lib/router-utils/resolve-routes.js'
-}, resolveRoutesModule => shimmer.wrap(resolveRoutesModule, 'getResolveRoutes', wrapGetResolveRoutes))
-
-addHook({
-  name: 'next',
-  versions: ['13.4.13'],
-  file: 'dist/server/lib/setup-server-worker.js'
-}, setupServerWorker => shimmer.wrap(setupServerWorker, 'initializeServerWorker', wrapSetupServerWorker))
+  versions: ['>=11.1'],
+  file: 'dist/server/serve-static.js'
+}, serveStatic => shimmer.wrap(serveStatic, 'serveStatic', wrapServeStatic))
 
 addHook({
   name: 'next',
-  versions: ['>=13.4.15'],
-  file: 'dist/server/lib/router-server.js'
-}, routerServer => shimmer.wrap(routerServer, 'initialize', wrapInitialize))
+  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
 
+  shimmer.wrap(Server.prototype, 'handleRequest', wrapHandleRequest)
+  shimmer.wrap(Server.prototype, 'handleApiRequest', wrapHandleApiRequestWithMatch)
   shimmer.wrap(Server.prototype, 'renderToResponse', wrapRenderToResponse)
   shimmer.wrap(Server.prototype, 'renderErrorToResponse', wrapRenderErrorToResponse)
   shimmer.wrap(Server.prototype, 'findPageComponents', wrapFindPageComponents)
@@ -227,22 +187,6 @@ addHook({ name: 'next', versions: ['>=13.2'], file: 'dist/server/next-server.js'
   return nextServer
 })
 
-// these functions wrapped in all versions above 13.2 except:
-// 13.4.13 due to tests failing when these functions are wrapped
-// 13.4.14 due to it not being in the NPM registry/officially released
-addHook({
-  name: 'next',
-  versions: ['>=13.2 <13.4.13', '>=13.4.15'],
-  file: 'dist/server/next-server.js'
-}, nextServer => {
-  const Server = nextServer.default
-
-  shimmer.wrap(Server.prototype, 'handleRequest', wrapHandleRequest)
-  shimmer.wrap(Server.prototype, 'handleApiRequest', wrapHandleApiRequestWithMatch)
-
-  return nextServer
-})
-
 addHook({ name: 'next', versions: ['>=11.1 <13.2'], file: 'dist/server/next-server.js' }, nextServer => {
   const Server = nextServer.default
 
@@ -270,3 +214,41 @@ addHook({
 
   return nextServer
 })
+
+addHook({
+  name: 'next',
+  versions: ['>=13'],
+  file: 'dist/server/web/spec-extension/request.js'
+}, request => {
+  const nextUrlDescriptor = Object.getOwnPropertyDescriptor(request.NextRequest.prototype, 'nextUrl')
+  shimmer.wrap(nextUrlDescriptor, 'get', function (originalGet) {
+    return function wrappedGet () {
+      const nextUrl = originalGet.apply(this, arguments)
+      if (queryParsedChannel.hasSubscribers) {
+        const query = {}
+        for (const key of nextUrl.searchParams.keys()) {
+          if (!query[key]) {
+            query[key] = nextUrl.searchParams.getAll(key)
+          }
+        }
+
+        queryParsedChannel.publish({ query })
+      }
+      return nextUrl
+    }
+  })
+
+  Object.defineProperty(request.NextRequest.prototype, 'nextUrl', nextUrlDescriptor)
+
+  shimmer.massWrap(request.NextRequest.prototype, ['text', 'json'], function (originalMethod) {
+    return async function wrappedJson () {
+      const body = await originalMethod.apply(this, arguments)
+      bodyParsedChannel.publish({
+        body
+      })
+      return body
+    }
+  })
+
+  return request
+})

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

@@ -39,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) {
@@ -73,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

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

@@ -181,6 +181,15 @@ function dispatcherHook (dispatcherExport) {
   return dispatcherExport
 }
 
+function getTestByTestId (dispatcher, testId) {
+  if (dispatcher._testById) {
+    return dispatcher._testById.get(testId)?.test
+  }
+  if (dispatcher._allTests) {
+    return dispatcher._allTests.find(({ id }) => id === testId)
+  }
+}
+
 function dispatcherHookNew (dispatcherExport, runWrapper) {
   shimmer.wrap(dispatcherExport.Dispatcher.prototype, 'run', runWrapper)
   shimmer.wrap(dispatcherExport.Dispatcher.prototype, '_createWorker', createWorker => function () {
@@ -188,11 +197,11 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
     const worker = createWorker.apply(this, arguments)
 
     worker.on('testBegin', ({ testId }) => {
-      const { test } = dispatcher._testById.get(testId)
+      const test = getTestByTestId(dispatcher, testId)
       testBeginHandler(test)
     })
     worker.on('testEnd', ({ testId, status, errors }) => {
-      const { test } = dispatcher._testById.get(testId)
+      const test = getTestByTestId(dispatcher, testId)
 
       testEndHandler(test, STATUS_TO_TEST_STATUS[status], errors && errors[0])
     })
@@ -254,7 +263,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 +275,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

@@ -10,7 +10,9 @@ const {
   finishAllTraceSpans,
   getTestSuitePath,
   getTestSuiteCommonTags,
-  addIntelligentTestRunnerSpanTags
+  addIntelligentTestRunnerSpanTags,
+  TEST_ITR_UNSKIPPABLE,
+  TEST_ITR_FORCED_RUN
 } = require('../../dd-trace/src/plugins/util/test')
 const { RESOURCE_NAME } = require('../../../ext/tags')
 const { COMPONENT, ERROR_MESSAGE } = require('../../dd-trace/src/constants')
@@ -29,7 +31,9 @@ class CucumberPlugin extends CiPlugin {
       status,
       isSuitesSkipped,
       numSkippedSuites,
-      testCodeCoverageLinesTotal
+      testCodeCoverageLinesTotal,
+      hasUnskippableSuites,
+      hasForcedToRunSuites
     }) => {
       const { isSuitesSkippingEnabled, isCodeCoverageEnabled } = this.itrConfig || {}
       addIntelligentTestRunnerSpanTags(
@@ -41,7 +45,9 @@ class CucumberPlugin extends CiPlugin {
           isCodeCoverageEnabled,
           testCodeCoverageLinesTotal,
           skippingCount: numSkippedSuites,
-          skippingType: 'suite'
+          skippingType: 'suite',
+          hasUnskippableSuites,
+          hasForcedToRunSuites
         }
       )
 
@@ -55,13 +61,19 @@ class CucumberPlugin extends CiPlugin {
       this.tracer._exporter.flush()
     })
 
-    this.addSub('ci:cucumber:test-suite:start', (testSuiteFullPath) => {
+    this.addSub('ci:cucumber:test-suite:start', ({ testSuitePath, isUnskippable, isForcedToRun }) => {
       const testSuiteMetadata = getTestSuiteCommonTags(
         this.command,
         this.frameworkVersion,
-        getTestSuitePath(testSuiteFullPath, this.sourceRoot),
+        testSuitePath,
         'cucumber'
       )
+      if (isUnskippable) {
+        testSuiteMetadata[TEST_ITR_UNSKIPPABLE] = 'true'
+      }
+      if (isForcedToRun) {
+        testSuiteMetadata[TEST_ITR_FORCED_RUN] = 'true'
+      }
       this.testSuiteSpan = this.tracer.startSpan('cucumber.test_suite', {
         childOf: this.testModuleSpan,
         tags: {