dd-trace 4.16.0 → 4.18.0

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

@@ -1,7 +1,5 @@
 'use strict'
 
-// TODO: either instrument all or none of the render functions
-
 const { channel, addHook } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 const { DD_MAJOR } = require('../../../version')
@@ -10,8 +8,13 @@ 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 nodeNextRequestsToNextRequests = new WeakMap()
+
+const MIDDLEWARE_HEADER = 'x-middleware-invoke'
 
 function wrapHandleRequest (handleRequest) {
   return function (req, res, pathname, query) {
@@ -54,18 +57,6 @@ function wrapHandleApiRequestWithMatch (handleApiRequest) {
   }
 }
 
-function wrapRenderToResponse (renderToResponse) {
-  return function (ctx) {
-    return instrument(ctx.req, ctx.res, () => renderToResponse.apply(this, arguments))
-  }
-}
-
-function wrapRenderErrorToResponse (renderErrorToResponse) {
-  return function (ctx) {
-    return instrument(ctx.req, ctx.res, () => renderErrorToResponse.apply(this, arguments))
-  }
-}
-
 function wrapRenderToHTML (renderToHTML) {
   return function (req, res, pathname, query, parsedUrl) {
     return instrument(req, res, () => renderToHTML.apply(this, arguments))
@@ -78,6 +69,18 @@ function wrapRenderErrorToHTML (renderErrorToHTML) {
   }
 }
 
+function wrapRenderToResponse (renderToResponse) {
+  return function (ctx) {
+    return instrument(ctx.req, ctx.res, () => renderToResponse.apply(this, arguments))
+  }
+}
+
+function wrapRenderErrorToResponse (renderErrorToResponse) {
+  return function (ctx) {
+    return instrument(ctx.req, ctx.res, () => renderErrorToResponse.apply(this, arguments))
+  }
+}
+
 function wrapFindPageComponents (findPageComponents) {
   return function (pathname, query) {
     const result = findPageComponents.apply(this, arguments)
@@ -112,7 +115,9 @@ function instrument (req, res, handler) {
   req = req.originalRequest || req
   res = res.originalResponse || res
 
-  if (requests.has(req)) return handler()
+  // TODO support middleware properly in the future?
+  const isMiddleware = req.headers[MIDDLEWARE_HEADER]
+  if (isMiddleware || requests.has(req)) return handler()
 
   requests.add(req)
 
@@ -152,6 +157,11 @@ function finish (ctx, result, err) {
     errorChannel.publish(ctx)
   }
 
+  const maybeNextRequest = nodeNextRequestsToNextRequests.get(ctx.req)
+  if (maybeNextRequest) {
+    ctx.nextRequest = maybeNextRequest
+  }
+
   finishChannel.publish(ctx)
 
   if (err) {
@@ -161,6 +171,24 @@ function finish (ctx, result, err) {
   return result
 }
 
+// also wrapped in dist/server/future/route-handlers/app-route-route-handler.js
+// in versions below 13.3.0 that support middleware,
+// however, it is not provided as a class function or exported property
+addHook({
+  name: 'next',
+  versions: ['>=13.3.0'],
+  file: 'dist/server/web/spec-extension/adapters/next-request.js'
+}, NextRequestAdapter => {
+  shimmer.wrap(NextRequestAdapter.NextRequestAdapter, 'fromNodeNextRequest', fromNodeNextRequest => {
+    return function (nodeNextRequest) {
+      const nextRequest = fromNodeNextRequest.apply(this, arguments)
+      nodeNextRequestsToNextRequests.set(nodeNextRequest.originalRequest, nextRequest)
+      return nextRequest
+    }
+  })
+  return NextRequestAdapter
+})
+
 addHook({
   name: 'next',
   versions: ['>=11.1'],
@@ -173,27 +201,32 @@ addHook({
   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 => {
+addHook({ name: 'next', versions: ['>=11.1'], file: 'dist/server/next-server.js' }, nextServer => {
   const Server = nextServer.default
 
   shimmer.wrap(Server.prototype, 'handleRequest', wrapHandleRequest)
-  shimmer.wrap(Server.prototype, 'handleApiRequest', wrapHandleApiRequestWithMatch)
+
+  // Wrapping these makes sure any public API render methods called in a custom server
+  // are traced properly
+  // (instead of wrapping the top-level API methods, just wrapping these covers them all)
   shimmer.wrap(Server.prototype, 'renderToResponse', wrapRenderToResponse)
   shimmer.wrap(Server.prototype, 'renderErrorToResponse', wrapRenderErrorToResponse)
+
   shimmer.wrap(Server.prototype, 'findPageComponents', wrapFindPageComponents)
 
   return nextServer
 })
 
-addHook({ name: 'next', versions: ['>=11.1 <13.2'], file: 'dist/server/next-server.js' }, nextServer => {
+// `handleApiRequest` changes parameters/implementation at 13.2.0
+addHook({ name: 'next', versions: ['>=13.2'], file: 'dist/server/next-server.js' }, nextServer => {
   const Server = nextServer.default
+  shimmer.wrap(Server.prototype, 'handleApiRequest', wrapHandleApiRequestWithMatch)
+  return nextServer
+})
 
-  shimmer.wrap(Server.prototype, 'handleRequest', wrapHandleRequest)
+addHook({ name: 'next', versions: ['>=11.1 <13.2'], file: 'dist/server/next-server.js' }, nextServer => {
+  const Server = nextServer.default
   shimmer.wrap(Server.prototype, 'handleApiRequest', wrapHandleApiRequest)
-  shimmer.wrap(Server.prototype, 'renderToResponse', wrapRenderToResponse)
-  shimmer.wrap(Server.prototype, 'renderErrorToResponse', wrapRenderErrorToResponse)
-  shimmer.wrap(Server.prototype, 'findPageComponents', wrapFindPageComponents)
-
   return nextServer
 })
 
@@ -206,9 +239,51 @@ addHook({
 
   shimmer.wrap(Server.prototype, 'handleRequest', wrapHandleRequest)
   shimmer.wrap(Server.prototype, 'handleApiRequest', wrapHandleApiRequest)
+
+  // Likewise with newer versions, these correlate to public API render methods for custom servers
+  // all public ones use these methods somewhere in their code path
   shimmer.wrap(Server.prototype, 'renderToHTML', wrapRenderToHTML)
   shimmer.wrap(Server.prototype, 'renderErrorToHTML', wrapRenderErrorToHTML)
+
   shimmer.wrap(Server.prototype, 'findPageComponents', wrapFindPageComponents)
 
   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/playwright.js

@@ -1,5 +1,6 @@
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
+const { parseAnnotations } = require('../../dd-trace/src/plugins/util/test')
 
 const testStartCh = channel('ci:playwright:test:start')
 const testFinishCh = channel('ci:playwright:test:finish')
@@ -103,7 +104,11 @@ function testBeginHandler (test) {
   })
 }
 
-function testEndHandler (test, testStatus, error) {
+function testEndHandler (test, annotations, testStatus, error) {
+  let annotationTags
+  if (annotations.length) {
+    annotationTags = parseAnnotations(annotations)
+  }
   const { _requireFile: testSuiteAbsolutePath, results, _type } = test
 
   if (_type === 'beforeAll' || _type === 'afterAll') {
@@ -113,7 +118,7 @@ function testEndHandler (test, testStatus, error) {
   const testResult = results[results.length - 1]
   const testAsyncResource = testToAr.get(test)
   testAsyncResource.runInAsyncScope(() => {
-    testFinishCh.publish({ testStatus, steps: testResult.steps, error })
+    testFinishCh.publish({ testStatus, steps: testResult.steps, error, extraTags: annotationTags })
   })
 
   if (!testSuiteToTestStatuses.has(testSuiteAbsolutePath)) {
@@ -172,7 +177,7 @@ function dispatcherHook (dispatcherExport) {
         const { results } = test
         const testResult = results[results.length - 1]
 
-        testEndHandler(test, STATUS_TO_TEST_STATUS[testResult.status], testResult.error)
+        testEndHandler(test, params.annotations, STATUS_TO_TEST_STATUS[testResult.status], testResult.error)
       }
     })
 
@@ -181,6 +186,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,13 +202,13 @@ 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)
+    worker.on('testEnd', ({ testId, status, errors, annotations }) => {
+      const test = getTestByTestId(dispatcher, testId)
 
-      testEndHandler(test, STATUS_TO_TEST_STATUS[status], errors && errors[0])
+      testEndHandler(test, annotations, STATUS_TO_TEST_STATUS[status], errors && errors[0])
     })
 
     return worker
@@ -221,7 +235,7 @@ function runnerHook (runnerExport, playwrightVersion) {
       // because they were skipped
       tests.forEach(test => {
         testBeginHandler(test)
-        testEndHandler(test, 'skip')
+        testEndHandler(test, [], 'skip')
       })
     })
 

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: {

package/packages/datadog-plugin-cypress/src/plugin.js

@@ -21,11 +21,14 @@ const {
   getCoveredFilenamesFromCoverage,
   getTestSuitePath,
   addIntelligentTestRunnerSpanTags,
-  TEST_SKIPPED_BY_ITR
+  TEST_SKIPPED_BY_ITR,
+  TEST_ITR_UNSKIPPABLE,
+  TEST_ITR_FORCED_RUN
 } = require('../../dd-trace/src/plugins/util/test')
 const { ORIGIN_KEY, COMPONENT } = require('../../dd-trace/src/constants')
 const log = require('../../dd-trace/src/log')
 const NoopTracer = require('../../dd-trace/src/noop/tracer')
+const { isMarkedAsUnskippable } = require('../../datadog-plugin-jest/src/util')
 
 const TEST_FRAMEWORK_NAME = 'cypress'
 
@@ -185,8 +188,11 @@ module.exports = (on, config) => {
   let isSuitesSkippingEnabled = false
   let isCodeCoverageEnabled = false
   let testsToSkip = []
+  const unskippableSuites = []
+  let hasForcedToRunSuites = false
+  let hasUnskippableSuites = false
 
-  function getTestSpan (testName, testSuite) {
+  function getTestSpan (testName, testSuite, isUnskippable, isForcedToRun) {
     const testSuiteTags = {
       [TEST_COMMAND]: command,
       [TEST_COMMAND]: command,
@@ -212,6 +218,16 @@ module.exports = (on, config) => {
       testSpanMetadata[TEST_CODE_OWNERS] = codeOwners
     }
 
+    if (isUnskippable) {
+      hasUnskippableSuites = true
+      testSpanMetadata[TEST_ITR_UNSKIPPABLE] = 'true'
+    }
+
+    if (isForcedToRun) {
+      hasForcedToRunSuites = true
+      testSpanMetadata[TEST_ITR_FORCED_RUN] = 'true'
+    }
+
     return tracer.startSpan(`${TEST_FRAMEWORK_NAME}.test`, {
       childOf,
       tags: {
@@ -233,13 +249,21 @@ module.exports = (on, config) => {
         isCodeCoverageEnabled = itrConfig.isCodeCoverageEnabled
       }
 
-      getSkippableTests(isSuitesSkippingEnabled, tracer, testConfiguration).then(({ err, skippableTests }) => {
+      return getSkippableTests(isSuitesSkippingEnabled, tracer, testConfiguration).then(({ err, skippableTests }) => {
         if (err) {
           log.error(err)
         } else {
           testsToSkip = skippableTests || []
         }
 
+        // `details.specs` are test files
+        details.specs.forEach(({ absolute, relative }) => {
+          const isUnskippableSuite = isMarkedAsUnskippable({ path: absolute })
+          if (isUnskippableSuite) {
+            unskippableSuites.push(relative)
+          }
+        })
+
         const childOf = getTestParentSpan(tracer)
         rootDir = getRootDir(details)
 
@@ -340,7 +364,9 @@ module.exports = (on, config) => {
           isSuitesSkippingEnabled,
           isCodeCoverageEnabled,
           skippingType: 'test',
-          skippingCount: skippedTests.length
+          skippingCount: skippedTests.length,
+          hasForcedToRunSuites,
+          hasUnskippableSuites
         }
       )
 
@@ -384,17 +410,21 @@ module.exports = (on, config) => {
     },
     'dd:beforeEach': (test) => {
       const { testName, testSuite } = test
-      // skip test
-      if (testsToSkip.find(test => {
+      const shouldSkip = !!testsToSkip.find(test => {
         return testName === test.name && testSuite === test.suite
-      })) {
+      })
+      const isUnskippable = unskippableSuites.includes(testSuite)
+      const isForcedToRun = shouldSkip && isUnskippable
+
+      // skip test
+      if (shouldSkip && !isUnskippable) {
         skippedTests.push(test)
         isTestsSkipped = true
         return { shouldSkip: true }
       }
 
       if (!activeSpan) {
-        activeSpan = getTestSpan(testName, testSuite)
+        activeSpan = getTestSpan(testName, testSuite, isUnskippable, isForcedToRun)
       }
 
       return activeSpan ? { traceId: activeSpan.context().toTraceId() } : {}

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

@@ -76,6 +76,7 @@ class HttpClientPlugin extends ClientPlugin {
   }
 
   finish ({ req, res, span }) {
+    if (!span) return
     if (res) {
       const status = res.status || res.statusCode
 
@@ -98,6 +99,7 @@ class HttpClientPlugin extends ClientPlugin {
   }
 
   error ({ span, error }) {
+    if (!span) return
     if (error) {
       span.addTags({
         [ERROR_TYPE]: error.name,

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

@@ -10,7 +10,9 @@ const {
   TEST_PARAMETERS,
   TEST_COMMAND,
   TEST_FRAMEWORK_VERSION,
-  TEST_SOURCE_START
+  TEST_SOURCE_START,
+  TEST_ITR_UNSKIPPABLE,
+  TEST_ITR_FORCED_RUN
 } = require('../../dd-trace/src/plugins/util/test')
 const { COMPONENT } = require('../../dd-trace/src/constants')
 const id = require('../../dd-trace/src/id')
@@ -50,11 +52,19 @@ class JestPlugin extends CiPlugin {
       isSuitesSkippingEnabled,
       isCodeCoverageEnabled,
       testCodeCoverageLinesTotal,
-      numSkippedSuites
+      numSkippedSuites,
+      hasUnskippableSuites,
+      hasForcedToRunSuites,
+      error
     }) => {
       this.testSessionSpan.setTag(TEST_STATUS, status)
       this.testModuleSpan.setTag(TEST_STATUS, status)
 
+      if (error) {
+        this.testSessionSpan.setTag('error', error)
+        this.testModuleSpan.setTag('error', error)
+      }
+
       addIntelligentTestRunnerSpanTags(
         this.testSessionSpan,
         this.testModuleSpan,
@@ -64,7 +74,9 @@ class JestPlugin extends CiPlugin {
           isCodeCoverageEnabled,
           testCodeCoverageLinesTotal,
           skippingType: 'suite',
-          skippingCount: numSkippedSuites
+          skippingCount: numSkippedSuites,
+          hasUnskippableSuites,
+          hasForcedToRunSuites
         }
       )
 
@@ -89,7 +101,9 @@ class JestPlugin extends CiPlugin {
       const {
         _ddTestSessionId: testSessionId,
         _ddTestCommand: testCommand,
-        _ddTestModuleId: testModuleId
+        _ddTestModuleId: testModuleId,
+        _ddForcedToRun,
+        _ddUnskippable
       } = testEnvironmentOptions
 
       const testSessionSpanContext = this.tracer.extract('text_map', {
@@ -99,6 +113,13 @@ class JestPlugin extends CiPlugin {
 
       const testSuiteMetadata = getTestSuiteCommonTags(testCommand, frameworkVersion, testSuite, 'jest')
 
+      if (_ddUnskippable) {
+        testSuiteMetadata[TEST_ITR_UNSKIPPABLE] = 'true'
+        if (_ddForcedToRun) {
+          testSuiteMetadata[TEST_ITR_FORCED_RUN] = 'true'
+        }
+      }
+
       this.testSuiteSpan = this.tracer.startSpan('jest.test_suite', {
         childOf: testSessionSpanContext,
         tags: {
@@ -135,9 +156,11 @@ class JestPlugin extends CiPlugin {
       })
     })
 
-    this.addSub('ci:jest:test-suite:finish', ({ status, errorMessage }) => {
+    this.addSub('ci:jest:test-suite:finish', ({ status, errorMessage, error }) => {
       this.testSuiteSpan.setTag(TEST_STATUS, status)
-      if (errorMessage) {
+      if (error) {
+        this.testSuiteSpan.setTag('error', error)
+      } else if (errorMessage) {
         this.testSuiteSpan.setTag('error', new Error(errorMessage))
       }
       this.testSuiteSpan.finish()