dd-trace 5.80.0 → 5.81.0

package/packages/datadog-instrumentations/src/helpers/rewriter/loader.mjs

@@ -0,0 +1,11 @@
+import { rewrite } from './index.js'
+
+async function load (url, context, nextLoad) {
+  const result = await nextLoad(url, context)
+
+  result.source = rewrite(result.source, url, context.format)
+
+  return result
+}
+
+export { load }

package/packages/datadog-instrumentations/src/helpers/rewriter/transforms.js

@@ -0,0 +1,139 @@
+'use strict'
+
+const { parse } = require('./compiler')
+
+const tracingChannelPredicate = (node) => (
+  node.specifiers?.[0]?.local?.name === 'tr_ch_apm_tracingChannel' ||
+    node.declarations?.[0]?.id?.properties?.[0]?.value?.name === 'tr_ch_apm_tracingChannel'
+)
+
+const transforms = module.exports = {
+  tracingChannelImport ({ format }, node) {
+    if (node.body.some(tracingChannelPredicate)) return
+
+    const index = node.body.findIndex(child => child.directive === 'use strict')
+    const code = format === 'module'
+      ? 'import { tracingChannel as tr_ch_apm_tracingChannel } from "diagnostics_channel"'
+      : 'const {tracingChannel: tr_ch_apm_tracingChannel} = require("diagnostics_channel")'
+
+    node.body.splice(index + 1, 0, parse(code, { module: format === 'module' }).body[0])
+  },
+
+  tracingChannelDeclaration (state, node) {
+    const { channelName, module: { name } } = state
+    const channelVariable = 'tr_ch_apm$' + channelName.replaceAll(':', '_')
+
+    if (node.body.some(child => child.declarations?.[0]?.id?.name === channelVariable)) return
+
+    transforms.tracingChannelImport(state, node)
+
+    const index = node.body.findIndex(tracingChannelPredicate)
+    const code = `
+      const ${channelVariable} = tr_ch_apm_tracingChannel("orchestrion:${name}:${channelName}")
+    `
+
+    node.body.splice(index + 1, 0, parse(code).body[0])
+  },
+
+  traceCallback: traceAny,
+  tracePromise: traceAny,
+  traceSync: traceAny,
+}
+
+function traceAny (state, node, _parent, ancestry) {
+  const program = ancestry[ancestry.length - 1]
+
+  if (node.type === 'ClassDeclaration' || node.type === 'ClassExpression') {
+    traceInstanceMethod(state, node, program)
+  } else {
+    traceFunction(state, node, program)
+  }
+}
+
+function traceFunction (state, node, program) {
+  const { operator } = state
+
+  transforms.tracingChannelDeclaration(state, program)
+
+  node.body = wrap(state, {
+    type: 'ArrowFunctionExpression',
+    params: node.params,
+    body: node.body,
+    async: operator === 'tracePromise',
+    expression: false,
+    generator: false
+  })
+}
+
+function traceInstanceMethod (state, node, program) {
+  const { functionQuery, operator } = state
+  const { methodName } = functionQuery
+
+  const classBody = node.body
+
+  // If the method exists on the class, we return as it will be patched later
+  // while traversing child nodes later on.
+  if (classBody.body.some(({ key }) => key.name === methodName)) return
+
+  // Method doesn't exist on the class so we assume an instance method and
+  // wrap it in the constructor instead.
+  let ctor = classBody.body.find(({ kind }) => kind === 'constructor')
+
+  transforms.tracingChannelDeclaration(state, program)
+
+  if (!ctor) {
+    ctor = parse(
+      node.superClass
+        ? 'class A { constructor (...args) { super(...args) } }'
+        : 'class A { constructor () {} }'
+    ).body[0].body.body[0] // Extract constructor from dummy class body.
+
+    classBody.body.unshift(ctor)
+  }
+
+  const ctorBody = parse(`
+    const __apm$${methodName} = this["${methodName}"]
+    this["${methodName}"] = function () {}
+  `).body
+
+  // Extract only right-hand side function of line 2.
+  const fn = ctorBody[1].expression.right
+
+  fn.async = operator === 'tracePromise'
+  fn.body = wrap(state, { type: 'Identifier', name: `__apm$${methodName}` })
+
+  ctor.value.body.body.push(...ctorBody)
+}
+
+function wrap (state, node) {
+  const { channelName, operator, functionQuery: { index = -1 } } = state
+  const async = operator === 'tracePromise' ? 'async' : ''
+  const channelVariable = 'tr_ch_apm$' + channelName.replaceAll(':', '_')
+  const tracedArgs = operator === 'traceCallback'
+    ? `__apm$original_args.splice(${index}, 1, arguments[${index >= 0 ? index : `arguments.length + ${index}`}])`
+    : '__apm$original_args'
+  const traceParams = operator === 'traceCallback'
+    ? `__apm$traced, ${index}`
+    : '__apm$traced'
+  const wrapper = parse(`
+    function wrapper () {
+      const __apm$original_args = arguments;
+      const __apm$traced = ${async} function () {
+        const __apm$wrapped = () => {};
+        const __apm$traced_args = ${tracedArgs};
+        return __apm$wrapped.apply(this, __apm$traced_args);
+      };
+      if (!${channelVariable}.hasSubscribers) return __apm$traced.apply(this, arguments);
+      return ${channelVariable}.${operator}(${traceParams}, {
+        arguments,
+        self: this,
+        moduleVersion: "1.0.0"
+      }, this, ...arguments);
+    }
+  `).body[0].body // Extract only block statement of function body.
+
+  // Replace the right-hand side assignment of `const __apm$wrapped = () => {}`.
+  wrapper.body[1].declarations[0].init.body.body[0].declarations[0].init = node
+
+  return wrapper
+}

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

@@ -1,113 +1,7 @@
 'use strict'
-const { addHook } = require('./helpers/instrument')
 
-const shimmer = require('../../datadog-shimmer')
+const { addHook, getHooks } = require('./helpers/instrument')
 
-const tracingChannel = require('dc-polyfill').tracingChannel
-
-function wrap (obj, name, channelName, namespace) {
-  const channel = tracingChannel(channelName)
-  shimmer.wrap(obj, name, function (original) {
-    return function () {
-      if (!channel.start.hasSubscribers) {
-        return original.apply(this, arguments)
-      }
-      const ctx = { self: this, arguments }
-      if (namespace) {
-        ctx.namespace = namespace
-      }
-      return channel.tracePromise(original, ctx, this, ...arguments)
-    }
-  })
-}
-
-// langchain compiles into ESM and CommonJS, with ESM being the default and landing in the `.js` files
-// however, CommonJS ends up in `cjs` files, and are required under the hood with `.cjs` files
-// we patch each separately and explicitly to match against exports only once, and not rely on file regex matching
-const extensions = ['js', 'cjs']
-
-for (const extension of extensions) {
-  addHook({ name: '@langchain/core', file: `dist/runnables/base.${extension}`, versions: ['>=0.1'] }, exports => {
-    if (extension === 'cjs') {
-      wrap(exports.RunnableSequence.prototype, 'invoke', 'orchestrion:@langchain/core:RunnableSequence_invoke')
-      wrap(exports.RunnableSequence.prototype, 'batch', 'orchestrion:@langchain/core:RunnableSequence_batch')
-    }
-    return exports
-  })
-
-  addHook({
-    name: '@langchain/core',
-    file: `dist/language_models/chat_models.${extension}`,
-    versions: ['>=0.1']
-  }, exports => {
-    if (extension === 'cjs') {
-      wrap(exports.BaseChatModel.prototype, 'generate', 'orchestrion:@langchain/core:BaseChatModel_generate')
-    }
-    return exports
-  })
-
-  addHook({ name: '@langchain/core', file: `dist/language_models/llms.${extension}`, versions: ['>=0.1'] }, exports => {
-    if (extension === 'cjs') {
-      wrap(exports.BaseLLM.prototype, 'generate', 'orchestrion:@langchain/core:BaseLLM_generate')
-    }
-    return exports
-  })
-
-  addHook({ name: '@langchain/core', file: `dist/tools/index.${extension}`, versions: ['>=0.1'] }, exports => {
-    if (extension === 'cjs') {
-      wrap(exports.StructuredTool.prototype, 'invoke', 'orchestrion:@langchain/core:Tool_invoke')
-    }
-    return exports
-  })
-
-  addHook({ name: '@langchain/core', file: `dist/vectorstores.${extension}`, versions: ['>=0.1'] }, exports => {
-    if (extension === 'cjs') {
-      wrap(
-        exports.VectorStore.prototype, 'similaritySearch', 'orchestrion:@langchain/core:VectorStore_similaritySearch'
-      )
-      wrap(
-        exports.VectorStore.prototype, 'similaritySearchWithScore',
-        'orchestrion:@langchain/core:VectorStore_similaritySearchWithScore'
-      )
-    }
-
-    return exports
-  })
-
-  addHook({ name: '@langchain/core', file: `dist/embeddings.${extension}`, versions: ['>=0.1'] }, exports => {
-    if (extension === 'cjs') {
-      shimmer.wrap(exports, 'Embeddings', Embeddings => {
-        return class extends Embeddings {
-          constructor (...args) {
-            super(...args)
-
-            const namespace = ['langchain', 'embeddings']
-
-            if (this.constructor.name === 'OpenAIEmbeddings') {
-              namespace.push('openai')
-            }
-
-            wrap(this, 'embedQuery', 'apm:@langchain/core:Embeddings_embedQuery', namespace)
-            wrap(this, 'embedDocuments', 'apm:@langchain/core:Embeddings_embedDocuments', namespace)
-          }
-        }
-      })
-    } else {
-      const channel = tracingChannel('orchestrion:@langchain/core:Embeddings_constructor')
-      channel.subscribe({
-        end (ctx) {
-          const { self } = ctx
-          const namespace = ['langchain', 'embeddings']
-
-          if (self.constructor.name === 'OpenAIEmbeddings') {
-            namespace.push('openai')
-          }
-
-          wrap(self, 'embedQuery', 'apm:@langchain/core:Embeddings_embedQuery', namespace)
-          wrap(self, 'embedDocuments', 'apm:@langchain/core:Embeddings_embedDocuments', namespace)
-        }
-      })
-    }
-    return exports
-  })
+for (const hook of getHooks('@langchain/core')) {
+  addHook(hook, exports => exports)
 }

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const { createCoverageMap } = require('istanbul-lib-coverage')
+const { createCoverageMap } = require('../../../../vendor/dist/istanbul-lib-coverage')
 const { addHook, channel } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 const { isMarkedAsUnskippable } = require('../../../datadog-plugin-jest/src/util')

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

@@ -4,7 +4,7 @@ const { errorMonitor } = require('node:events')
 
 const { channel, addHook } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
-const satisfies = require('semifies')
+const satisfies = require('../../../vendor/dist/semifies')
 
 function wrapConnection (Connection, version) {
   const startCh = channel('apm:mysql2:query:start')

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const satisfies = require('semifies')
+const satisfies = require('../../../vendor/dist/semifies')
 
 const { addHook, channel } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
@@ -11,6 +11,9 @@ const {
   getIsFaultyEarlyFlakeDetection
 } = require('../../dd-trace/src/plugins/util/test')
 const log = require('../../dd-trace/src/log')
+const {
+  getEnvironmentVariable
+} = require('../../dd-trace/src/config-helper')
 const { DD_MAJOR } = require('../../../version')
 
 const testStartCh = channel('ci:playwright:test:start')
@@ -38,7 +41,7 @@ const testSuiteToTestStatuses = new Map()
 const testSuiteToErrors = new Map()
 const testsToTestStatuses = new Map()
 
-const RUM_FLUSH_WAIT_TIME = 1000
+const RUM_FLUSH_WAIT_TIME = Number(getEnvironmentVariable('DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS')) || 1000
 
 let applyRepeatEachIndex = null
 
@@ -687,10 +690,11 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
 
     const projects = getProjectsFromRunner(this, config)
 
-    const shouldSetRetries = isFlakyTestRetriesEnabled &&
-      flakyTestRetriesCount > 0 &&
-      !isTestManagementTestsEnabled
-    if (shouldSetRetries) {
+    // ATR and `--retries` are now compatible with Test Management.
+    // Test Management tests have their retries set to 0 at the test level,
+    // preventing them from being retried by ATR or `--retries`.
+    const shouldSetATRRetries = isFlakyTestRetriesEnabled && flakyTestRetriesCount > 0
+    if (shouldSetATRRetries) {
       projects.forEach(project => {
         if (project.retries === 0) { // Only if it hasn't been set by the user
           project.retries = flakyTestRetriesCount
@@ -722,6 +726,8 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
       })
     })
 
+    let preventedToFail = false
+
     const sessionStatus = runAllTestsReturn.status || runAllTestsReturn
 
     if (isTestManagementTestsEnabled && sessionStatus === 'failed') {
@@ -730,23 +736,30 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
       let totalPureQuarantinedFailedTestCount = 0
 
       for (const [fqn, testStatuses] of testsToTestStatuses.entries()) {
-        const failedCount = testStatuses.filter(status => status === 'fail').length
-        totalFailedTestCount += failedCount
-        if (quarantinedButNotAttemptToFixFqns.has(fqn)) {
-          totalPureQuarantinedFailedTestCount += failedCount
+        // Only count as failed if the final status (after retries) is 'fail'
+        const lastStatus = testStatuses[testStatuses.length - 1]
+        if (lastStatus === 'fail') {
+          totalFailedTestCount += 1
+          if (quarantinedButNotAttemptToFixFqns.has(fqn)) {
+            totalPureQuarantinedFailedTestCount += 1
+          }
         }
       }
 
       for (const test of quarantinedOrDisabledTestsAttemptToFix) {
         const testFqn = getTestFullyQualifiedName(test)
         const testStatuses = testsToTestStatuses.get(testFqn)
-        totalAttemptToFixFailedTestCount += testStatuses.filter(status => status === 'fail').length
+        // Only count as failed if the final status (after retries) is 'fail'
+        if (testStatuses && testStatuses[testStatuses.length - 1] === 'fail') {
+          totalAttemptToFixFailedTestCount += 1
+        }
       }
 
       const totalIgnorableFailures = totalAttemptToFixFailedTestCount + totalPureQuarantinedFailedTestCount
 
       if (totalFailedTestCount > 0 && totalFailedTestCount === totalIgnorableFailures) {
         runAllTestsReturn = 'passed'
+        preventedToFail = true
       }
     }
 
@@ -754,7 +767,7 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
       onDone = resolve
     })
     testSessionFinishCh.publish({
-      status: STATUS_TO_TEST_STATUS[sessionStatus],
+      status: preventedToFail ? 'pass' : STATUS_TO_TEST_STATUS[sessionStatus],
       isEarlyFlakeDetectionEnabled,
       isEarlyFlakeDetectionFaulty,
       isTestManagementTestsEnabled,
@@ -917,6 +930,8 @@ addHook({
         }
         if (testProperties.attemptToFix) {
           test._ddIsAttemptToFix = true
+          // Prevent ATR or `--retries` from retrying attemptToFix tests
+          test.retries = 0
           const fileSuite = getSuiteType(test, 'file')
 
           if (!fileSuitesWithManagedTestsToProjects.has(fileSuite)) {
@@ -991,6 +1006,8 @@ addHook({
         newTests.forEach(newTest => {
           newTest._ddIsNew = true
           if (isEarlyFlakeDetectionEnabled && newTest.expectedStatus !== 'skipped' && !newTest._ddIsModified) {
+            // Prevent ATR or `--retries` from retrying new tests if EFD is enabled
+            newTest.retries = 0
             const fileSuite = getSuiteType(newTest, 'file')
             if (!fileSuitesWithNewTestsToProjects.has(fileSuite)) {
               fileSuitesWithNewTestsToProjects.set(fileSuite, getSuiteType(newTest, 'project'))
@@ -1064,9 +1081,19 @@ addHook({
 
     try {
       if (page) {
-        const isRumActive = await page.evaluate(() => {
-          return window.DD_RUM && window.DD_RUM.getInternalContext ? !!window.DD_RUM.getInternalContext() : false
+        const { isRumInstrumented, isRumActive, rumSamplingRate } = await page.evaluate(() => {
+          const isRumInstrumented = !!window.DD_RUM
+          const isRumActive = window.DD_RUM && window.DD_RUM.getInternalContext
+            ? !!window.DD_RUM.getInternalContext()
+            : false
+          const rumSamplingRate = window.DD_RUM && window.DD_RUM.getInitConfiguration
+            ? window.DD_RUM.getInitConfiguration().sessionSampleRate
+            : null
+          return { isRumInstrumented, isRumActive, rumSamplingRate }
         })
+        if (isRumInstrumented && rumSamplingRate < 100 && !isRumActive) {
+          log.debug("RUM was detected on the page, but it isn't active because the sampling rate is below 100%")
+        }
 
         if (isRumActive) {
           testPageGotoCh.publish({
@@ -1075,8 +1102,9 @@ addHook({
           })
         }
       }
-    } catch {
+    } catch (e) {
       // ignore errors such as redirects, context destroyed, etc
+      log.error('goto hook error', e)
     }
 
     return response
@@ -1168,8 +1196,9 @@ addHook({
                   }
                 }
               }
-            } catch {
+            } catch (e) {
               // ignore errors
+              log.error('afterEach hook error', e)
             }
           },
           title: 'afterEach hook',

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

@@ -1,7 +1,7 @@
 'use strict'
 
 const METHODS = [...require('http').METHODS.map(v => v.toLowerCase()), 'all']
-const pathToRegExp = require('path-to-regexp')
+const pathToRegExp = require('../../../vendor/dist/path-to-regexp')
 const shimmer = require('../../datadog-shimmer')
 const { addHook, channel } = require('./helpers/instrument')
 

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

@@ -2,6 +2,7 @@
 
 const { addHook, channel } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
+const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
 
 const ciSeleniumDriverGetStartCh = channel('ci:selenium:driver:get')
 
@@ -15,7 +16,8 @@ if (window.DD_RUM && window.DD_RUM.stopSession) {
 `
 const IS_RUM_ACTIVE_SCRIPT = 'return !!window.DD_RUM'
 
-const DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS = 500
+const DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS =
+Number(getEnvironmentVariable('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?

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

@@ -12,6 +12,9 @@ const producerCh = tracingChannel('ws:send')
 const receiverCh = tracingChannel('ws:receive')
 const closeCh = tracingChannel('ws:close')
 const emitCh = channel('tracing:ws:server:connect:emit')
+// TODO: Add a error channel / handle error events properly.
+
+const eventHandlerMap = new WeakMap()
 
 function wrapHandleUpgrade (handleUpgrade) {
   return function () {
@@ -67,24 +70,37 @@ function createWrapEmit (emit) {
 }
 
 function createWrappedHandler (handler) {
-  return function wrappedMessageHandler (data, binary) {
+  return shimmer.wrapFunction(handler, originalHandler => function (data, binary) {
     const byteLength = dataLength(data)
 
     const ctx = { data, binary, socket: this._sender?._socket, byteLength }
 
-    return receiverCh.traceSync(handler, ctx, this, data, binary)
-  }
+    return receiverCh.traceSync(originalHandler, ctx, this, data, binary)
+  })
 }
 
 function wrapListener (originalOn) {
   return function (eventName, handler) {
     if (eventName === 'message') {
-      return originalOn.call(this, eventName, createWrappedHandler(handler))
+      // Prevent multiple wrapping of the same handler in case the user adds the listener multiple times
+      const wrappedHandler = eventHandlerMap.get(handler) ?? createWrappedHandler(handler)
+      eventHandlerMap.set(handler, wrappedHandler)
+      return originalOn.call(this, eventName, wrappedHandler)
     }
     return originalOn.apply(this, arguments)
   }
 }
 
+function removeListener (originalOff) {
+  return function (eventName, handler) {
+    if (eventName === 'message') {
+      const wrappedHandler = eventHandlerMap.get(handler)
+      return originalOff.call(this, eventName, wrappedHandler)
+    }
+    return originalOff.apply(this, arguments)
+  }
+}
+
 function wrapClose (close) {
   return function (code, data) {
     // _closeFrameReceived is set to true when receiver receives a close frame from a peer
@@ -115,22 +131,24 @@ addHook({
   versions: ['>=8.0.0']
 }, ws => {
   shimmer.wrap(ws.prototype, 'send', wrapSend)
-  shimmer.wrap(ws.prototype, 'on', wrapListener)
   shimmer.wrap(ws.prototype, 'close', wrapClose)
+
+  // TODO: Do not wrap these methods. Instead, add a listener to the websocket instance when one is created.
+  // That way it avoids producing too many spans for the same websocket instance and less user code is impacted.
+  shimmer.wrap(ws.prototype, 'on', wrapListener)
+  shimmer.wrap(ws.prototype, 'addListener', wrapListener)
+  shimmer.wrap(ws.prototype, 'off', removeListener)
+  shimmer.wrap(ws.prototype, 'removeListener', removeListener)
+
   return ws
 })
 
-function detectType (data) {
-  if (typeof Blob !== 'undefined' && data instanceof Blob) return 'Blob'
-  if (typeof Buffer !== 'undefined' && Buffer.isBuffer(data)) return 'Buffer'
-  if (typeof data === 'string') return 'string'
-  return 'Unknown'
-}
-
 function dataLength (data) {
-  const type = detectType(data)
-  if (type === 'Blob') return data.size
-  if (type === 'Buffer') return data.length
-  if (type === 'string') return Buffer.byteLength(data)
-  return 0
+  if (typeof data === 'string') {
+    return Buffer.byteLength(data)
+  }
+  if (data instanceof Blob) {
+    return data.size
+  }
+  return data?.length ?? 0
 }

package/packages/datadog-plugin-child_process/src/scrub-cmd-params.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const shellParser = require('shell-quote/parse')
+const shellParser = require('../../../vendor/dist/shell-quote').parse
 
 const ALLOWED_ENV_VARIABLES = new Set(['LD_PRELOAD', 'LD_LIBRARY_PATH', 'PATH'])
 const PROCESS_DENYLIST = new Set(['md5'])

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

@@ -133,6 +133,14 @@ function getCypressCommand (details) {
   return `${TEST_FRAMEWORK_NAME} ${details.specPattern || ''}`
 }
 
+function getIsTestIsolationEnabled (cypressConfig) {
+  if (!cypressConfig) {
+    // If we can't read testIsolation config parameter, we default to allowing retries
+    return true
+  }
+  return cypressConfig.testIsolation === undefined ? true : cypressConfig.testIsolation
+}
+
 function getLibraryConfiguration (tracer, testConfiguration) {
   return new Promise(resolve => {
     if (!tracer._tracer._exporter?.getLibraryConfiguration) {
@@ -296,6 +304,12 @@ class CypressPlugin {
     this.tracer = tracer
     this.cypressConfig = cypressConfig
 
+    this.isTestIsolationEnabled = getIsTestIsolationEnabled(cypressConfig)
+
+    if (!this.isTestIsolationEnabled) {
+      log.warn('Test isolation is disabled, retries will not be enabled')
+    }
+
     // we have to do it here because the tracer is not initialized in the constructor
     this.testEnvironmentMetadata[DD_TEST_IS_USER_PROVIDED_SERVICE] =
       tracer._tracer._config.isServiceUserProvided ? 'true' : 'false'
@@ -324,7 +338,7 @@ class CypressPlugin {
           this.isEarlyFlakeDetectionEnabled = isEarlyFlakeDetectionEnabled
           this.earlyFlakeDetectionNumRetries = earlyFlakeDetectionNumRetries
           this.isKnownTestsEnabled = isKnownTestsEnabled
-          if (isFlakyTestRetriesEnabled) {
+          if (isFlakyTestRetriesEnabled && this.isTestIsolationEnabled) {
             this.isFlakyTestRetriesEnabled = true
             this.cypressConfig.retries.runMode = flakyTestRetriesCount
           }
@@ -467,6 +481,7 @@ class CypressPlugin {
     // We need to make sure that the plugin is initialized before running the tests
     // This is for the case where the user has not returned the promise from the init function
     await this.libraryConfigurationPromise
+
     this.command = getCypressCommand(details)
     this.frameworkVersion = getCypressVersion(details)
     this.rootDir = getRootDir(details)
@@ -801,7 +816,8 @@ class CypressPlugin {
           testManagementTests: this.getTestSuiteProperties(testSuite),
           isImpactedTestsEnabled: this.isImpactedTestsEnabled,
           isModifiedTest: this.getIsTestModified(testSuiteAbsolutePath),
-          repositoryRoot: this.repositoryRoot
+          repositoryRoot: this.repositoryRoot,
+          isTestIsolationEnabled: this.isTestIsolationEnabled
         }
 
         if (this.testSuiteSpan) {
@@ -962,6 +978,11 @@ class CypressPlugin {
           this.activeTestSpan.addTags(tags)
         }
         return null
+      },
+      'dd:log': (message) => {
+        // eslint-disable-next-line no-console
+        console.log(`[datadog] ${message}`)
+        return null
       }
     }
   }

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

@@ -2,7 +2,7 @@
 
 const NoopTracer = require('../../dd-trace/src/noop/tracer')
 const cypressPlugin = require('./cypress-plugin')
-const satisfies = require('semifies')
+const satisfies = require('../../../vendor/dist/semifies')
 const { DD_MAJOR } = require('../../../version')
 
 const noopTask = {