dd-trace 5.9.0 → 5.11.0

package/index.d.ts

@@ -187,6 +187,7 @@ interface Plugins {
   "restify": tracer.plugins.restify;
   "rhea": tracer.plugins.rhea;
   "router": tracer.plugins.router;
+  "selenium": tracer.plugins.selenium;
   "sharedb": tracer.plugins.sharedb;
   "tedious": tracer.plugins.tedious;
   "winston": tracer.plugins.winston;
@@ -789,6 +790,14 @@ declare namespace tracer {
      */
     gauge(stat: string, value?: number, tags?: { [tag: string]: string|number }): void
 
+    /**
+     * Sets a histogram value, optionally specifying tags.
+     * @param {string} stat The dot-separated metric name.
+     * @param {number} value The amount to increment the stat by.
+     * @param {[tag:string]:string|number} tags Tags to pass along, such as `{ foo: 'bar' }`. Values are combined with config.tags.
+     */
+    histogram(stat: string, value?: number, tags?: { [tag: string]: string|number }): void
+
     /**
      * Forces any unsent metrics to be sent
      *
@@ -1728,6 +1737,12 @@ declare namespace tracer {
      */
     interface router extends Integration {}
 
+    /**
+    * This plugin automatically instruments the
+    * [selenium-webdriver](https://www.npmjs.com/package/selenium-webdriver) module.
+    */
+    interface selenium extends Integration {}
+
     /**
      * This plugin automatically instruments the
      * [sharedb](https://github.com/share/sharedb) module.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.9.0",
+  "version": "5.11.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -36,6 +36,7 @@
     "test:integration:cucumber": "mocha --colors --timeout 30000 \"integration-tests/cucumber/*.spec.js\"",
     "test:integration:cypress": "mocha --colors --timeout 30000 \"integration-tests/cypress/*.spec.js\"",
     "test:integration:playwright": "mocha --colors --timeout 30000 \"integration-tests/playwright/*.spec.js\"",
+    "test:integration:selenium": "mocha --colors --timeout 30000 \"integration-tests/selenium/*.spec.js\"",
     "test:integration:profiler": "mocha --colors --timeout 90000 \"integration-tests/profiler/*.spec.js\"",
     "test:integration:serverless": "mocha --colors --timeout 30000 \"integration-tests/serverless/*.spec.js\"",
     "test:integration:plugins": "mocha --colors --exit -r \"packages/dd-trace/test/setup/mocha.js\" \"packages/datadog-plugin-@($(echo $PLUGINS))/test/integration-test/**/*.spec.js\"",
@@ -69,7 +70,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@datadog/native-appsec": "7.1.0",
+    "@datadog/native-appsec": "7.1.1",
     "@datadog/native-iast-rewriter": "2.3.0",
     "@datadog/native-iast-taint-tracking": "1.7.0",
     "@datadog/native-metrics": "^2.0.0",

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

@@ -1,51 +1,12 @@
 'use strict'
 
 const shimmer = require('../../datadog-shimmer')
-const { channel } = require('./helpers/instrument')
-
-const startChannel = channel('apm:fetch:request:start')
-const finishChannel = channel('apm:fetch:request:finish')
-const errorChannel = channel('apm:fetch:request:error')
-
-function wrapFetch (fetch, Request) {
-  if (typeof fetch !== 'function') return fetch
-
-  return function (input, init) {
-    if (!startChannel.hasSubscribers) return fetch.apply(this, arguments)
-
-    const req = new Request(input, init)
-    const headers = req.headers
-    const message = { req, headers }
-
-    return startChannel.runStores(message, () => {
-      // Request object is read-only so we need new objects to change headers.
-      arguments[0] = message.req
-      arguments[1] = { headers: message.headers }
-
-      return fetch.apply(this, arguments)
-        .then(
-          res => {
-            message.res = res
-
-            finishChannel.publish(message)
-
-            return res
-          },
-          err => {
-            if (err.name !== 'AbortError') {
-              message.error = err
-              errorChannel.publish(message)
-            }
-
-            finishChannel.publish(message)
-
-            throw err
-          }
-        )
-    })
-  }
-}
+const { tracingChannel } = require('dc-polyfill')
+const { createWrapFetch } = require('./helpers/fetch')
 
 if (globalThis.fetch) {
-  globalThis.fetch = shimmer.wrap(fetch, wrapFetch(fetch, globalThis.Request))
+  const ch = tracingChannel('apm:fetch:request')
+  const wrapFetch = createWrapFetch(globalThis.Request, ch)
+
+  globalThis.fetch = shimmer.wrap(fetch, wrapFetch(fetch))
 }

package/packages/datadog-instrumentations/src/helpers/fetch.js

@@ -0,0 +1,17 @@
+'use strict'
+
+exports.createWrapFetch = function createWrapFetch (Request, ch) {
+  return function wrapFetch (fetch) {
+    if (typeof fetch !== 'function') return fetch
+
+    return function (input, init) {
+      if (!ch.start.hasSubscribers) return fetch.apply(this, arguments)
+
+      const req = new Request(input, init)
+      const headers = req.headers
+      const ctx = { req, headers }
+
+      return ch.tracePromise(() => fetch.call(this, req, { headers: ctx.headers }), ctx)
+    }
+  }
+}

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -58,6 +58,7 @@ module.exports = {
   'jest-environment-node': () => require('../jest'),
   'jest-environment-jsdom': () => require('../jest'),
   'jest-jasmine2': () => require('../jest'),
+  'jest-runtime': () => require('../jest'),
   'jest-worker': () => require('../jest'),
   knex: () => require('../knex'),
   koa: () => require('../koa'),
@@ -103,8 +104,9 @@ module.exports = {
   restify: () => require('../restify'),
   rhea: () => require('../rhea'),
   router: () => require('../router'),
-  sharedb: () => require('../sharedb'),
+  'selenium-webdriver': () => require('../selenium'),
   sequelize: () => require('../sequelize'),
+  sharedb: () => require('../sharedb'),
   tedious: () => require('../tedious'),
   when: () => require('../when'),
   winston: () => require('../winston')

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

@@ -11,7 +11,8 @@ const {
   getTestSuitePath,
   getTestParametersString,
   addEfdStringToTestName,
-  removeEfdStringFromTestName
+  removeEfdStringFromTestName,
+  getIsFaultyEarlyFlakeDetection
 } = require('../../dd-trace/src/plugins/util/test')
 const {
   getFormattedJestTestParameters,
@@ -44,11 +45,14 @@ const knownTestsCh = channel('ci:jest:known-tests')
 
 const itrSkippedSuitesCh = channel('ci:jest:itr:skipped-suites')
 
+// Message sent by jest's main process to workers to run a test suite (=test file)
+// https://github.com/jestjs/jest/blob/1d682f21c7a35da4d3ab3a1436a357b980ebd0fa/packages/jest-worker/src/types.ts#L37
+const CHILD_MESSAGE_CALL = 1
 // Maximum time we'll wait for the tracer to flush
 const FLUSH_TIMEOUT = 10000
 
 let skippableSuites = []
-let knownTests = []
+let knownTests = {}
 let isCodeCoverageEnabled = false
 let isSuitesSkippingEnabled = false
 let isUserCodeCoverageEnabled = false
@@ -58,6 +62,8 @@ let hasUnskippableSuites = false
 let hasForcedToRunSuites = false
 let isEarlyFlakeDetectionEnabled = false
 let earlyFlakeDetectionNumRetries = 0
+let earlyFlakeDetectionFaultyThreshold = 30
+let isEarlyFlakeDetectionFaulty = false
 let hasFilteredSkippableSuites = false
 
 const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
@@ -73,6 +79,7 @@ const specStatusToTestStatus = {
 const asyncResources = new WeakMap()
 const originalTestFns = new WeakMap()
 const retriedTestsToNumAttempts = new Map()
+const newTestsTestStatuses = new Map()
 
 // based on https://github.com/facebook/jest/blob/main/packages/jest-circus/src/formatNodeAssertErrors.ts#L41
 function formatJestError (errors) {
@@ -101,6 +108,13 @@ function getTestEnvironmentOptions (config) {
   return {}
 }
 
+function getEfdStats (testStatuses) {
+  return testStatuses.reduce((acc, testStatus) => {
+    acc[testStatus]++
+    return acc
+  }, { pass: 0, fail: 0 })
+}
+
 function getWrappedEnvironment (BaseEnvironment, jestVersion) {
   return class DatadogEnvironment extends BaseEnvironment {
     constructor (config, context) {
@@ -110,6 +124,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       this.testSuite = getTestSuitePath(context.testPath, rootDir)
       this.nameToParams = {}
       this.global._ddtrace = global._ddtrace
+      this.hasSnapshotTests = undefined
 
       this.displayName = config.projectConfig?.displayName?.name
       this.testEnvironmentOptions = getTestEnvironmentOptions(config)
@@ -123,9 +138,12 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       this.isEarlyFlakeDetectionEnabled = this.testEnvironmentOptions._ddIsEarlyFlakeDetectionEnabled
 
       if (this.isEarlyFlakeDetectionEnabled) {
+        const hasKnownTests = !!knownTests.jest
         earlyFlakeDetectionNumRetries = this.testEnvironmentOptions._ddEarlyFlakeDetectionNumRetries
         try {
-          this.knownTestsForThisSuite = this.getKnownTestsForSuite(this.testEnvironmentOptions._ddKnownTests)
+          this.knownTestsForThisSuite = hasKnownTests
+            ? (knownTests.jest[this.testSuite] || [])
+            : this.getKnownTestsForSuite(this.testEnvironmentOptions._ddKnownTests)
         } catch (e) {
           // If there has been an error parsing the tests, we'll disable Early Flake Deteciton
           this.isEarlyFlakeDetectionEnabled = false
@@ -133,6 +151,21 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       }
     }
 
+    getHasSnapshotTests () {
+      if (this.hasSnapshotTests !== undefined) {
+        return this.hasSnapshotTests
+      }
+      let hasSnapshotTests = true
+      try {
+        const { _snapshotData } = this.context.expect.getState().snapshotState
+        hasSnapshotTests = Object.keys(_snapshotData).length > 0
+      } catch (e) {
+        // if we can't be sure, we'll err on the side of caution and assume it has snapshots
+      }
+      this.hasSnapshotTests = hasSnapshotTests
+      return hasSnapshotTests
+    }
+
     // Function that receives a list of known tests for a test service and
     // returns the ones that belong to the current suite
     getKnownTestsForSuite (knownTests) {
@@ -145,7 +178,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       if (typeof knownTestsForSuite === 'string') {
         knownTestsForSuite = JSON.parse(knownTestsForSuite)
       }
-      return knownTestsForSuite.jest?.[this.testSuite] || []
+      return knownTestsForSuite
     }
 
     // Add the `add_test` event we don't have the test object yet, so
@@ -217,6 +250,13 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           const isSkipped = event.mode === 'todo' || event.mode === 'skip'
           if (isNew && !isSkipped && !retriedTestsToNumAttempts.has(testName)) {
             retriedTestsToNumAttempts.set(testName, 0)
+            // Retrying snapshots has proven to be problematic, so we'll skip them for now
+            // We'll still detect new tests, but we won't retry them.
+            // TODO: do not bail out of EFD with the whole test suite
+            if (this.getHasSnapshotTests()) {
+              log.warn('Early flake detection is disabled for suites with snapshots')
+              return
+            }
             for (let retryIndex = 0; retryIndex < earlyFlakeDetectionNumRetries; retryIndex++) {
               if (this.global.test) {
                 this.global.test(addEfdStringToTestName(event.testName, retryIndex), event.fn, event.timeout)
@@ -242,6 +282,19 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           })
           // restore in case it is retried
           event.test.fn = originalTestFns.get(event.test)
+          // We'll store the test statuses of the retries
+          if (this.isEarlyFlakeDetectionEnabled) {
+            const testName = getJestTestName(event.test)
+            const originalTestName = removeEfdStringFromTestName(testName)
+            const isNewTest = retriedTestsToNumAttempts.has(originalTestName)
+            if (isNewTest) {
+              if (newTestsTestStatuses.has(originalTestName)) {
+                newTestsTestStatuses.get(originalTestName).push(status)
+              } else {
+                newTestsTestStatuses.set(originalTestName, [status])
+              }
+            }
+          }
         })
       }
       if (event.name === 'test_skip' || event.name === 'test_todo') {
@@ -285,7 +338,7 @@ function applySuiteSkipping (originalTests, rootDir, frameworkVersion) {
   numSkippedSuites = jestSuitesToRun.skippedSuites.length
 
   itrSkippedSuitesCh.publish({ skippedSuites: jestSuitesToRun.skippedSuites, frameworkVersion })
-  skippableSuites = []
+
   return jestSuitesToRun.suitesToRun
 }
 
@@ -383,6 +436,7 @@ function cliWrapper (cli, jestVersion) {
         isSuitesSkippingEnabled = libraryConfig.isSuitesSkippingEnabled
         isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
         earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
+        earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
       }
     } catch (err) {
       log.error(err)
@@ -497,6 +551,7 @@ function cliWrapper (cli, jestVersion) {
         hasForcedToRunSuites,
         error,
         isEarlyFlakeDetectionEnabled,
+        isEarlyFlakeDetectionFaulty,
         onDone
       })
     })
@@ -508,6 +563,28 @@ function cliWrapper (cli, jestVersion) {
 
     numSkippedSuites = 0
 
+    /**
+     * If Early Flake Detection (EFD) is enabled the logic is as follows:
+     * - If all attempts for a test are failing, the test has failed and we will let the test process fail.
+     * - If just a single attempt passes, we will prevent the test process from failing.
+     * The rationale behind is the following: you may still be able to block your CI pipeline by gating
+     * on flakiness (the test will be considered flaky), but you may choose to unblock the pipeline too.
+     */
+
+    if (isEarlyFlakeDetectionEnabled) {
+      let numFailedTestsToIgnore = 0
+      for (const testStatuses of newTestsTestStatuses.values()) {
+        const { pass, fail } = getEfdStats(testStatuses)
+        if (pass > 0) { // as long as one passes, we'll consider the test passed
+          numFailedTestsToIgnore += fail
+        }
+      }
+      // If every test that failed was an EFD retry, we'll consider the suite passed
+      if (numFailedTestsToIgnore !== 0 && result.results.numFailedTests === numFailedTestsToIgnore) {
+        result.results.success = true
+      }
+    }
+
     return result
   })
 
@@ -619,7 +696,6 @@ function configureTestEnvironment (readConfigsResult) {
   // because `jestAdapterWrapper` runs in a different process. We have to go through `testEnvironmentOptions`
   configs.forEach(config => {
     config.testEnvironmentOptions._ddTestCodeCoverageEnabled = isCodeCoverageEnabled
-    config.testEnvironmentOptions._ddKnownTests = knownTests
   })
 
   isUserCodeCoverageEnabled = !!readConfigsResult.globalConfig.collectCoverage
@@ -712,13 +788,26 @@ addHook({
   const SearchSource = searchSourcePackage.default ? searchSourcePackage.default : searchSourcePackage
 
   shimmer.wrap(SearchSource.prototype, 'getTestPaths', getTestPaths => async function () {
-    if (!isSuitesSkippingEnabled || !skippableSuites.length) {
-      return getTestPaths.apply(this, arguments)
-    }
-
+    const testPaths = await getTestPaths.apply(this, arguments)
     const [{ rootDir, shard }] = arguments
 
-    if (shard?.shardCount > 1) {
+    if (isEarlyFlakeDetectionEnabled) {
+      const projectSuites = testPaths.tests.map(test => getTestSuitePath(test.path, test.context.config.rootDir))
+      const isFaulty =
+        getIsFaultyEarlyFlakeDetection(projectSuites, knownTests.jest || {}, earlyFlakeDetectionFaultyThreshold)
+      if (isFaulty) {
+        log.error('Early flake detection is disabled because the number of new suites is too high.')
+        isEarlyFlakeDetectionEnabled = false
+        const testEnvironmentOptions = testPaths.tests[0]?.context?.config?.testEnvironmentOptions
+        // Project config is shared among all tests, so we can modify it here
+        if (testEnvironmentOptions) {
+          testEnvironmentOptions._ddIsEarlyFlakeDetectionEnabled = false
+        }
+        isEarlyFlakeDetectionFaulty = true
+      }
+    }
+
+    if (shard?.shardCount > 1 || !isSuitesSkippingEnabled || !skippableSuites.length) {
       // If the user is using jest sharding, we want to apply the filtering of tests in the shard process.
       // The reason for this is the following:
       // The tests for different shards are likely being run in different CI jobs so
@@ -726,10 +815,8 @@ addHook({
       // If the skippable endpoint is returning different suites and we filter the list of tests here,
       // the base list of tests that is used for sharding might be different,
       // causing the shards to potentially run the same suite.
-      return getTestPaths.apply(this, arguments)
+      return testPaths
     }
-
-    const testPaths = await getTestPaths.apply(this, arguments)
     const { tests } = testPaths
 
     const suitesToRun = applySuiteSkipping(tests, rootDir, frameworkVersion)
@@ -789,12 +876,72 @@ if (DD_MAJOR < 4) {
   }, jasmineAsyncInstallWraper)
 }
 
+const LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE = [
+  'selenium-webdriver'
+]
+
+function shouldBypassJestRequireEngine (moduleName) {
+  return (
+    LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.some(library => moduleName.includes(library))
+  )
+}
+
+addHook({
+  name: 'jest-runtime',
+  versions: ['>=24.8.0']
+}, (runtimePackage) => {
+  const Runtime = runtimePackage.default ? runtimePackage.default : runtimePackage
+
+  shimmer.wrap(Runtime.prototype, 'requireModuleOrMock', requireModuleOrMock => function (from, moduleName) {
+    // TODO: do this for every library that we instrument
+    if (shouldBypassJestRequireEngine(moduleName)) {
+      // To bypass jest's own require engine
+      return this._requireCoreModule(moduleName)
+    }
+    return requireModuleOrMock.apply(this, arguments)
+  })
+
+  return runtimePackage
+})
+
 addHook({
   name: 'jest-worker',
   versions: ['>=24.9.0'],
   file: 'build/workers/ChildProcessWorker.js'
 }, (childProcessWorker) => {
   const ChildProcessWorker = childProcessWorker.default
+  shimmer.wrap(ChildProcessWorker.prototype, 'send', send => function (request) {
+    if (!isEarlyFlakeDetectionEnabled) {
+      return send.apply(this, arguments)
+    }
+    const [type] = request
+    // eslint-disable-next-line
+    // https://github.com/jestjs/jest/blob/1d682f21c7a35da4d3ab3a1436a357b980ebd0fa/packages/jest-worker/src/workers/ChildProcessWorker.ts#L424
+    if (type === CHILD_MESSAGE_CALL) {
+      // This is the message that the main process sends to the worker to run a test suite (=test file).
+      // In here we modify the config.testEnvironmentOptions to include the known tests for the suite.
+      // This way the suite only knows about the tests that are part of it.
+      const args = request[request.length - 1]
+      if (args.length > 1) {
+        return send.apply(this, arguments)
+      }
+      if (!args[0]?.config) {
+        return send.apply(this, arguments)
+      }
+      const [{ globalConfig, config, path: testSuiteAbsolutePath }] = args
+      const testSuite = getTestSuitePath(testSuiteAbsolutePath, globalConfig.rootDir || process.cwd())
+      const suiteKnownTests = knownTests.jest?.[testSuite] || []
+      args[0].config = {
+        ...config,
+        testEnvironmentOptions: {
+          ...config.testEnvironmentOptions,
+          _ddKnownTests: suiteKnownTests
+        }
+      }
+    }
+
+    return send.apply(this, arguments)
+  })
   shimmer.wrap(ChildProcessWorker.prototype, '_onMessage', _onMessage => function () {
     const [code, data] = arguments[0]
     if (code === JEST_WORKER_TRACE_PAYLOAD_CODE) { // datadog trace payload

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

@@ -68,7 +68,10 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
           const result = send.apply(this, arguments)
 
           result.then(
-            innerAsyncResource.bind(() => producerFinishCh.publish(undefined)),
+            innerAsyncResource.bind(res => {
+              producerFinishCh.publish(undefined)
+              producerCommitCh.publish(res)
+            }),
             innerAsyncResource.bind(err => {
               if (err) {
                 producerErrorCh.publish(err)
@@ -77,12 +80,6 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
             })
           )
 
-          result.then(res => {
-            if (producerCommitCh.hasSubscribers) {
-              producerCommitCh.publish(res)
-            }
-          })
-
           return result
         } catch (e) {
           producerErrorCh.publish(e)

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

@@ -21,7 +21,8 @@ addHook({
   name: 'mongoose',
   versions: ['>=4.6.4 <5', '5', '6', '>=7']
 }, mongoose => {
-  if (mongoose.Promise !== global.Promise) {
+  // As of Mongoose 7, custom promise libraries are no longer supported and mongoose.Promise may be undefined
+  if (mongoose.Promise && mongoose.Promise !== global.Promise) {
     shimmer.wrap(mongoose.Promise.prototype, 'then', wrapThen)
   }
 

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

@@ -21,7 +21,7 @@ function finish (err) {
   finishChannel.publish(undefined)
 }
 
-addHook({ name: 'oracledb', versions: ['5'] }, oracledb => {
+addHook({ name: 'oracledb', versions: ['>=5'] }, oracledb => {
   shimmer.wrap(oracledb.Connection.prototype, 'execute', execute => {
     return function wrappedExecute (dbQuery, ...args) {
       if (!startChannel.hasSubscribers) {

package/packages/datadog-instrumentations/src/otel-sdk-trace.js

@@ -4,7 +4,12 @@ const { addHook } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 const tracer = require('../../dd-trace')
 
-if (process.env.DD_TRACE_OTEL_ENABLED) {
+const otelSdkEnabled = process.env.DD_TRACE_OTEL_ENABLED ||
+process.env.OTEL_SDK_DISABLED
+  ? !process.env.OTEL_SDK_DISABLED
+  : undefined
+
+if (otelSdkEnabled) {
   addHook({
     name: '@opentelemetry/sdk-trace-node',
     file: 'build/src/NodeTracerProvider.js',

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

@@ -0,0 +1,69 @@
+const { addHook, channel } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const ciSeleniumDriverGetStartCh = channel('ci:selenium:driver:get')
+
+const RUM_STOP_SESSION_SCRIPT = `
+if (window.DD_RUM && window.DD_RUM.stopSession) {
+  window.DD_RUM.stopSession();
+  return true;
+} else {
+  return false;
+}
+`
+const IS_RUM_ACTIVE_SCRIPT = 'return !!window.DD_RUM'
+
+const DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS = 500
+const DD_CIVISIBILITY_TEST_EXECUTION_ID_COOKIE_NAME = 'datadog-ci-visibility-test-execution-id'
+
+// TODO: can we increase the supported version range?
+addHook({
+  name: 'selenium-webdriver',
+  versions: ['>=4.11.0']
+}, (seleniumPackage, seleniumVersion) => {
+  // TODO: do not turn this into async. Use promises
+  shimmer.wrap(seleniumPackage.WebDriver.prototype, 'get', get => async function () {
+    let traceId
+    const setTraceId = (inputTraceId) => {
+      traceId = inputTraceId
+    }
+    const getResult = await get.apply(this, arguments)
+
+    const isRumActive = await this.executeScript(IS_RUM_ACTIVE_SCRIPT)
+    const capabilities = await this.getCapabilities()
+
+    ciSeleniumDriverGetStartCh.publish({
+      setTraceId,
+      seleniumVersion,
+      browserName: capabilities.getBrowserName(),
+      browserVersion: capabilities.getBrowserVersion(),
+      isRumActive
+    })
+
+    await this.manage().addCookie({
+      name: DD_CIVISIBILITY_TEST_EXECUTION_ID_COOKIE_NAME,
+      value: traceId
+    })
+
+    return getResult
+  })
+
+  shimmer.wrap(seleniumPackage.WebDriver.prototype, 'quit', quit => async function () {
+    const isRumActive = await this.executeScript(RUM_STOP_SESSION_SCRIPT)
+
+    if (isRumActive) {
+      // We'll have time for RUM to flush the events (there's no callback to know when it's done)
+      await new Promise(resolve => {
+        setTimeout(() => {
+          resolve()
+        }, DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS)
+      })
+    }
+
+    await this.manage().deleteCookie(DD_CIVISIBILITY_TEST_EXECUTION_ID_COOKIE_NAME)
+
+    return quit.apply(this, arguments)
+  })
+
+  return seleniumPackage
+})

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

@@ -16,7 +16,7 @@ const {
   TEST_CODE_OWNERS,
   ITR_CORRELATION_ID,
   TEST_SOURCE_FILE,
-  TEST_EARLY_FLAKE_IS_ENABLED,
+  TEST_EARLY_FLAKE_ENABLED,
   TEST_IS_NEW,
   TEST_IS_RETRY
 } = require('../../dd-trace/src/plugins/util/test')
@@ -68,7 +68,7 @@ class CucumberPlugin extends CiPlugin {
         }
       )
       if (isEarlyFlakeDetectionEnabled) {
-        this.testSessionSpan.setTag(TEST_EARLY_FLAKE_IS_ENABLED, 'true')
+        this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ENABLED, 'true')
       }
 
       this.testSessionSpan.setTag(TEST_STATUS, status)

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

@@ -28,7 +28,7 @@ const {
   TEST_SOURCE_FILE,
   TEST_IS_NEW,
   TEST_IS_RETRY,
-  TEST_EARLY_FLAKE_IS_ENABLED
+  TEST_EARLY_FLAKE_ENABLED
 } = require('../../dd-trace/src/plugins/util/test')
 const { isMarkedAsUnskippable } = require('../../datadog-plugin-jest/src/util')
 const { ORIGIN_KEY, COMPONENT } = require('../../dd-trace/src/constants')
@@ -364,7 +364,7 @@ class CypressPlugin {
       getTestModuleCommonTags(this.command, this.frameworkVersion, TEST_FRAMEWORK_NAME)
 
     if (this.isEarlyFlakeDetectionEnabled) {
-      testSessionSpanMetadata[TEST_EARLY_FLAKE_IS_ENABLED] = 'true'
+      testSessionSpanMetadata[TEST_EARLY_FLAKE_ENABLED] = 'true'
     }
 
     this.testSessionSpan = this.tracer.startSpan(`${TEST_FRAMEWORK_NAME}.test_session`, {