dd-trace 5.10.0 → 5.12.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.10.0",
+  "version": "5.12.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\"",

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,22 @@
+'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)
+
+      if (input instanceof Request) {
+        const ctx = { req: input }
+
+        return ch.tracePromise(() => fetch.call(this, input, init), ctx)
+      } else {
+        const req = new Request(input, init)
+        const ctx = { req }
+
+        return ch.tracePromise(() => fetch.call(this, req), 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,
@@ -61,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')
@@ -121,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)
@@ -147,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) {
@@ -231,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)
@@ -312,7 +338,7 @@ function applySuiteSkipping (originalTests, rootDir, frameworkVersion) {
   numSkippedSuites = jestSuitesToRun.skippedSuites.length
 
   itrSkippedSuitesCh.publish({ skippedSuites: jestSuitesToRun.skippedSuites, frameworkVersion })
-  skippableSuites = []
+
   return jestSuitesToRun.suitesToRun
 }
 
@@ -410,6 +436,7 @@ function cliWrapper (cli, jestVersion) {
         isSuitesSkippingEnabled = libraryConfig.isSuitesSkippingEnabled
         isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
         earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
+        earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
       }
     } catch (err) {
       log.error(err)
@@ -524,6 +551,7 @@ function cliWrapper (cli, jestVersion) {
         hasForcedToRunSuites,
         error,
         isEarlyFlakeDetectionEnabled,
+        isEarlyFlakeDetectionFaulty,
         onDone
       })
     })
@@ -760,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
@@ -774,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)
@@ -837,6 +876,34 @@ 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'],

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/openai.js

@@ -10,6 +10,98 @@ const startCh = channel('apm:openai:request:start')
 const finishCh = channel('apm:openai:request:finish')
 const errorCh = channel('apm:openai:request:error')
 
+const V4_PACKAGE_SHIMS = [
+  {
+    file: 'resources/chat/completions.js',
+    targetClass: 'Completions',
+    baseResource: 'chat.completions',
+    methods: ['create']
+  },
+  {
+    file: 'resources/completions.js',
+    targetClass: 'Completions',
+    baseResource: 'completions',
+    methods: ['create']
+  },
+  {
+    file: 'resources/embeddings.js',
+    targetClass: 'Embeddings',
+    baseResource: 'embeddings',
+    methods: ['create']
+  },
+  {
+    file: 'resources/files.js',
+    targetClass: 'Files',
+    baseResource: 'files',
+    methods: ['create', 'del', 'list', 'retrieve']
+  },
+  {
+    file: 'resources/files.js',
+    targetClass: 'Files',
+    baseResource: 'files',
+    methods: ['retrieveContent'],
+    versions: ['>=4.0.0 <4.17.1']
+  },
+  {
+    file: 'resources/files.js',
+    targetClass: 'Files',
+    baseResource: 'files',
+    methods: ['content'], // replaced `retrieveContent` in v4.17.1
+    versions: ['>=4.17.1']
+  },
+  {
+    file: 'resources/images.js',
+    targetClass: 'Images',
+    baseResource: 'images',
+    methods: ['createVariation', 'edit', 'generate']
+  },
+  {
+    file: 'resources/fine-tuning/jobs/jobs.js',
+    targetClass: 'Jobs',
+    baseResource: 'fine_tuning.jobs',
+    methods: ['cancel', 'create', 'list', 'listEvents', 'retrieve'],
+    versions: ['>=4.34.0'] // file location changed in 4.34.0
+  },
+  {
+    file: 'resources/fine-tuning/jobs.js',
+    targetClass: 'Jobs',
+    baseResource: 'fine_tuning.jobs',
+    methods: ['cancel', 'create', 'list', 'listEvents', 'retrieve'],
+    versions: ['>=4.1.0 <4.34.0']
+  },
+  {
+    file: 'resources/fine-tunes.js', // deprecated after 4.1.0
+    targetClass: 'FineTunes',
+    baseResource: 'fine-tune',
+    methods: ['cancel', 'create', 'list', 'listEvents', 'retrieve'],
+    versions: ['>=4.0.0 <4.1.0']
+  },
+  {
+    file: 'resources/models.js',
+    targetClass: 'Models',
+    baseResource: 'models',
+    methods: ['del', 'list', 'retrieve']
+  },
+  {
+    file: 'resources/moderations.js',
+    targetClass: 'Moderations',
+    baseResource: 'moderations',
+    methods: ['create']
+  },
+  {
+    file: 'resources/audio/transcriptions.js',
+    targetClass: 'Transcriptions',
+    baseResource: 'audio.transcriptions',
+    methods: ['create']
+  },
+  {
+    file: 'resources/audio/translations.js',
+    targetClass: 'Translations',
+    baseResource: 'audio.translations',
+    methods: ['create']
+  }
+]
+
 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
@@ -48,3 +140,60 @@ addHook({ name: 'openai', file: 'dist/api.js', versions: ['>=3.0.0 <4'] }, expor
 
   return exports
 })
+
+for (const shim of V4_PACKAGE_SHIMS) {
+  const { file, targetClass, baseResource, methods } = shim
+  addHook({ name: 'openai', file, versions: shim.versions || ['>=4'] }, exports => {
+    const targetPrototype = exports[targetClass].prototype
+
+    for (const methodName of methods) {
+      shimmer.wrap(targetPrototype, methodName, methodFn => function () {
+        if (!startCh.hasSubscribers) {
+          return methodFn.apply(this, arguments)
+        }
+
+        const client = this._client || this.client
+
+        startCh.publish({
+          methodName: `${baseResource}.${methodName}`,
+          args: arguments,
+          basePath: client.baseURL,
+          apiKey: client.apiKey
+        })
+
+        const apiProm = methodFn.apply(this, arguments)
+
+        // wrapping `parse` avoids problematic wrapping of `then` when trying to call
+        // `withResponse` in userland code after. This way, we can return the whole `APIPromise`
+        shimmer.wrap(apiProm, 'parse', origApiPromParse => function () {
+          return origApiPromParse.apply(this, arguments)
+            // the original response is wrapped in a promise, so we need to unwrap it
+            .then(body => Promise.all([this.responsePromise, body]))
+            .then(([{ response, options }, body]) => {
+              finishCh.publish({
+                headers: response.headers,
+                body,
+                path: response.url,
+                method: options.method
+              })
+
+              return body
+            })
+            .catch(err => {
+              errorCh.publish({ err })
+
+              throw err
+            })
+            .finally(() => {
+              // maybe we don't want to unwrap here in case the promise is re-used?
+              // other hand: we want to avoid resource leakage
+              shimmer.unwrap(apiProm, 'parse')
+            })
+        })
+
+        return apiProm
+      })
+    }
+    return exports
+  })
+}

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`, {

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

@@ -4,6 +4,16 @@ let knownTestsForSuite = []
 let suiteTests = []
 let earlyFlakeDetectionNumRetries = 0
 
+// If the test is using multi domain with cy.origin, trying to access
+// window properties will result in a cross origin error.
+function safeGetRum (window) {
+  try {
+    return window.DD_RUM
+  } catch (e) {
+    return null
+  }
+}
+
 function isNewTest (test) {
   return !knownTestsForSuite.includes(test.fullTitle())
 }
@@ -62,7 +72,7 @@ before(function () {
 
 after(() => {
   cy.window().then(win => {
-    if (win.DD_RUM) {
+    if (safeGetRum(win)) {
       win.dispatchEvent(new Event('beforeunload'))
     }
   })
@@ -84,9 +94,15 @@ afterEach(function () {
       testInfo.testSourceLine = Cypress.mocha.getRunner().currentRunnable.invocationDetails.line
     } catch (e) {}
 
-    if (win.DD_RUM) {
+    if (safeGetRum(win)) {
       testInfo.isRUMActive = true
     }
-    cy.task('dd:afterEach', { test: testInfo, coverage: win.__coverage__ })
+    let coverage
+    try {
+      coverage = win.__coverage__
+    } catch (e) {
+      // ignore error and continue
+    }
+    cy.task('dd:afterEach', { test: testInfo, coverage })
   })
 })