dd-trace 5.31.0 → 5.33.0

package/packages/datadog-plugin-aws-sdk/src/services/bedrockruntime/tracing.js

@@ -0,0 +1,63 @@
+'use strict'
+
+const BaseAwsSdkPlugin = require('../../base')
+const { parseModelId, extractRequestParams, extractTextAndResponseReason } = require('./utils')
+
+const enabledOperations = ['invokeModel']
+
+class BedrockRuntime extends BaseAwsSdkPlugin {
+  static get id () { return 'bedrockruntime' }
+
+  isEnabled (request) {
+    const operation = request.operation
+    if (!enabledOperations.includes(operation)) {
+      return false
+    }
+
+    return super.isEnabled(request)
+  }
+
+  generateTags (params, operation, response) {
+    const { modelProvider, modelName } = parseModelId(params.modelId)
+
+    const requestParams = extractRequestParams(params, modelProvider)
+    const textAndResponseReason = extractTextAndResponseReason(response, modelProvider, modelName)
+
+    const tags = buildTagsFromParams(requestParams, textAndResponseReason, modelProvider, modelName, operation)
+
+    return tags
+  }
+}
+
+function buildTagsFromParams (requestParams, textAndResponseReason, modelProvider, modelName, operation) {
+  const tags = {}
+
+  // add request tags
+  tags['resource.name'] = operation
+  tags['aws.bedrock.request.model'] = modelName
+  tags['aws.bedrock.request.model_provider'] = modelProvider.toLowerCase()
+  tags['aws.bedrock.request.prompt'] = requestParams.prompt
+  tags['aws.bedrock.request.temperature'] = requestParams.temperature
+  tags['aws.bedrock.request.top_p'] = requestParams.topP
+  tags['aws.bedrock.request.top_k'] = requestParams.topK
+  tags['aws.bedrock.request.max_tokens'] = requestParams.maxTokens
+  tags['aws.bedrock.request.stop_sequences'] = requestParams.stopSequences
+  tags['aws.bedrock.request.input_type'] = requestParams.inputType
+  tags['aws.bedrock.request.truncate'] = requestParams.truncate
+  tags['aws.bedrock.request.stream'] = requestParams.stream
+  tags['aws.bedrock.request.n'] = requestParams.n
+
+  // add response tags
+  if (modelName.includes('embed')) {
+    tags['aws.bedrock.response.embedding_length'] = textAndResponseReason.message.length
+  }
+  if (textAndResponseReason.choiceId) {
+    tags['aws.bedrock.response.choices.id'] = textAndResponseReason.choiceId
+  }
+  tags['aws.bedrock.response.choices.text'] = textAndResponseReason.message
+  tags['aws.bedrock.response.choices.finish_reason'] = textAndResponseReason.finishReason
+
+  return tags
+}
+
+module.exports = BedrockRuntime

package/packages/datadog-plugin-aws-sdk/src/services/bedrockruntime/utils.js

@@ -0,0 +1,287 @@
+'use strict'
+
+const log = require('../../../../dd-trace/src/log')
+
+const MODEL_TYPE_IDENTIFIERS = [
+  'foundation-model/',
+  'custom-model/',
+  'provisioned-model/',
+  'imported-module/',
+  'prompt/',
+  'endpoint/',
+  'inference-profile/',
+  'default-prompt-router/'
+]
+
+const PROVIDER = {
+  AI21: 'AI21',
+  AMAZON: 'AMAZON',
+  ANTHROPIC: 'ANTHROPIC',
+  COHERE: 'COHERE',
+  META: 'META',
+  STABILITY: 'STABILITY',
+  MISTRAL: 'MISTRAL'
+}
+
+class Generation {
+  constructor ({ message = '', finishReason = '', choiceId = '' } = {}) {
+    // stringify message as it could be a single generated message as well as a list of embeddings
+    this.message = typeof message === 'string' ? message : JSON.stringify(message) || ''
+    this.finishReason = finishReason || ''
+    this.choiceId = choiceId || undefined
+  }
+}
+
+class RequestParams {
+  constructor ({
+    prompt = '',
+    temperature = undefined,
+    topP = undefined,
+    topK = undefined,
+    maxTokens = undefined,
+    stopSequences = [],
+    inputType = '',
+    truncate = '',
+    stream = '',
+    n = undefined
+  } = {}) {
+    // stringify prompt as it could be a single prompt as well as a list of message objects
+    this.prompt = typeof prompt === 'string' ? prompt : JSON.stringify(prompt) || ''
+    this.temperature = temperature !== undefined ? temperature : undefined
+    this.topP = topP !== undefined ? topP : undefined
+    this.topK = topK !== undefined ? topK : undefined
+    this.maxTokens = maxTokens !== undefined ? maxTokens : undefined
+    this.stopSequences = stopSequences || []
+    this.inputType = inputType || ''
+    this.truncate = truncate || ''
+    this.stream = stream || ''
+    this.n = n !== undefined ? n : undefined
+  }
+}
+
+function parseModelId (modelId) {
+  // Best effort to extract the model provider and model name from the bedrock model ID.
+  // modelId can be a 1/2 period-separated string or a full AWS ARN, based on the following formats:
+  // 1. Base model: "{model_provider}.{model_name}"
+  // 2. Cross-region model: "{region}.{model_provider}.{model_name}"
+  // 3. Other: Prefixed by AWS ARN "arn:aws{+region?}:bedrock:{region}:{account-id}:"
+  //     a. Foundation model: ARN prefix + "foundation-model/{region?}.{model_provider}.{model_name}"
+  //     b. Custom model: ARN prefix + "custom-model/{model_provider}.{model_name}"
+  //     c. Provisioned model: ARN prefix + "provisioned-model/{model-id}"
+  //     d. Imported model: ARN prefix + "imported-module/{model-id}"
+  //     e. Prompt management: ARN prefix + "prompt/{prompt-id}"
+  //     f. Sagemaker: ARN prefix + "endpoint/{model-id}"
+  //     g. Inference profile: ARN prefix + "{application-?}inference-profile/{model-id}"
+  //     h. Default prompt router: ARN prefix + "default-prompt-router/{prompt-id}"
+  // If model provider cannot be inferred from the modelId formatting, then default to "custom"
+  modelId = modelId.toLowerCase()
+  if (!modelId.startsWith('arn:aws')) {
+    const modelMeta = modelId.split('.')
+    if (modelMeta.length < 2) {
+      return { modelProvider: 'custom', modelName: modelMeta[0] }
+    }
+    return { modelProvider: modelMeta[modelMeta.length - 2], modelName: modelMeta[modelMeta.length - 1] }
+  }
+
+  for (const identifier of MODEL_TYPE_IDENTIFIERS) {
+    if (!modelId.includes(identifier)) {
+      continue
+    }
+    modelId = modelId.split(identifier).pop()
+    if (['foundation-model/', 'custom-model/'].includes(identifier)) {
+      const modelMeta = modelId.split('.')
+      if (modelMeta.length < 2) {
+        return { modelProvider: 'custom', modelName: modelId }
+      }
+      return { modelProvider: modelMeta[modelMeta.length - 2], modelName: modelMeta[modelMeta.length - 1] }
+    }
+    return { modelProvider: 'custom', modelName: modelId }
+  }
+
+  return { modelProvider: 'custom', modelName: 'custom' }
+}
+
+function extractRequestParams (params, provider) {
+  const requestBody = JSON.parse(params.body)
+  const modelId = params.modelId
+
+  switch (provider.toUpperCase()) {
+    case PROVIDER.AI21: {
+      let userPrompt = requestBody.prompt
+      if (modelId.includes('jamba')) {
+        for (const message of requestBody.messages) {
+          if (message.role === 'user') {
+            userPrompt = message.content // Return the content of the most recent user message
+          }
+        }
+      }
+      return new RequestParams({
+        prompt: userPrompt,
+        temperature: requestBody.temperature,
+        topP: requestBody.top_p,
+        maxTokens: requestBody.max_tokens,
+        stopSequences: requestBody.stop_sequences
+      })
+    }
+    case PROVIDER.AMAZON: {
+      if (modelId.includes('embed')) {
+        return new RequestParams({ prompt: requestBody.inputText })
+      }
+      const textGenerationConfig = requestBody.textGenerationConfig || {}
+      return new RequestParams({
+        prompt: requestBody.inputText,
+        temperature: textGenerationConfig.temperature,
+        topP: textGenerationConfig.topP,
+        maxTokens: textGenerationConfig.maxTokenCount,
+        stopSequences: textGenerationConfig.stopSequences
+      })
+    }
+    case PROVIDER.ANTHROPIC: {
+      const prompt = requestBody.prompt || requestBody.messages
+      return new RequestParams({
+        prompt,
+        temperature: requestBody.temperature,
+        topP: requestBody.top_p,
+        maxTokens: requestBody.max_tokens_to_sample,
+        stopSequences: requestBody.stop_sequences
+      })
+    }
+    case PROVIDER.COHERE: {
+      if (modelId.includes('embed')) {
+        return new RequestParams({
+          prompt: requestBody.texts,
+          inputType: requestBody.input_type,
+          truncate: requestBody.truncate
+        })
+      }
+      return new RequestParams({
+        prompt: requestBody.prompt,
+        temperature: requestBody.temperature,
+        topP: requestBody.p,
+        maxTokens: requestBody.max_tokens,
+        stopSequences: requestBody.stop_sequences,
+        stream: requestBody.stream,
+        n: requestBody.num_generations
+      })
+    }
+    case PROVIDER.META: {
+      return new RequestParams({
+        prompt: requestBody.prompt,
+        temperature: requestBody.temperature,
+        topP: requestBody.top_p,
+        maxTokens: requestBody.max_gen_len
+      })
+    }
+    case PROVIDER.MISTRAL: {
+      return new RequestParams({
+        prompt: requestBody.prompt,
+        temperature: requestBody.temperature,
+        topP: requestBody.top_p,
+        maxTokens: requestBody.max_tokens,
+        stopSequences: requestBody.stop,
+        topK: requestBody.top_k
+      })
+    }
+    case PROVIDER.STABILITY: {
+      return new RequestParams()
+    }
+    default: {
+      return new RequestParams()
+    }
+  }
+}
+
+function extractTextAndResponseReason (response, provider, modelName) {
+  const body = JSON.parse(Buffer.from(response.body).toString('utf8'))
+  const shouldSetChoiceIds = provider.toUpperCase() === PROVIDER.COHERE && !modelName.includes('embed')
+  try {
+    switch (provider.toUpperCase()) {
+      case PROVIDER.AI21: {
+        if (modelName.includes('jamba')) {
+          const generations = body.choices || []
+          if (generations.length > 0) {
+            const generation = generations[0]
+            return new Generation({
+              message: generation.message,
+              finishReason: generation.finish_reason,
+              choiceId: shouldSetChoiceIds ? generation.id : undefined
+            })
+          }
+        }
+        const completions = body.completions || []
+        if (completions.length > 0) {
+          const completion = completions[0]
+          return new Generation({
+            message: completion.data?.text,
+            finishReason: completion?.finishReason,
+            choiceId: shouldSetChoiceIds ? completion?.id : undefined
+          })
+        }
+        return new Generation()
+      }
+      case PROVIDER.AMAZON: {
+        if (modelName.includes('embed')) {
+          return new Generation({ message: body.embedding })
+        }
+        const results = body.results || []
+        if (results.length > 0) {
+          const result = results[0]
+          return new Generation({ message: result.outputText, finishReason: result.completionReason })
+        }
+        break
+      }
+      case PROVIDER.ANTHROPIC: {
+        return new Generation({ message: body.completion || body.content, finishReason: body.stop_reason })
+      }
+      case PROVIDER.COHERE: {
+        if (modelName.includes('embed')) {
+          const embeddings = body.embeddings || [[]]
+          if (embeddings.length > 0) {
+            return new Generation({ message: embeddings[0] })
+          }
+        }
+        const generations = body.generations || []
+        if (generations.length > 0) {
+          const generation = generations[0]
+          return new Generation({
+            message: generation.text,
+            finishReason: generation.finish_reason,
+            choiceId: shouldSetChoiceIds ? generation.id : undefined
+          })
+        }
+        break
+      }
+      case PROVIDER.META: {
+        return new Generation({ message: body.generation, finishReason: body.stop_reason })
+      }
+      case PROVIDER.MISTRAL: {
+        const mistralGenerations = body.outputs || []
+        if (mistralGenerations.length > 0) {
+          const generation = mistralGenerations[0]
+          return new Generation({ message: generation.text, finishReason: generation.stop_reason })
+        }
+        break
+      }
+      case PROVIDER.STABILITY: {
+        return new Generation()
+      }
+      default: {
+        return new Generation()
+      }
+    }
+  } catch (error) {
+    log.warn('Unable to extract text/finishReason from response body. Defaulting to empty text/finishReason.')
+    return new Generation()
+  }
+
+  return new Generation()
+}
+
+module.exports = {
+  Generation,
+  RequestParams,
+  parseModelId,
+  extractRequestParams,
+  extractTextAndResponseReason,
+  PROVIDER
+}

package/packages/datadog-plugin-aws-sdk/src/services/index.js

@@ -12,4 +12,5 @@ exports.sns = require('./sns')
 exports.sqs = require('./sqs')
 exports.states = require('./states')
 exports.stepfunctions = require('./stepfunctions')
+exports.bedrockruntime = require('./bedrockruntime')
 exports.default = require('./default')

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

@@ -27,11 +27,7 @@ const {
   TEST_MODULE_ID,
   TEST_SUITE,
   CUCUMBER_IS_PARALLEL,
-  TEST_NAME,
-  DI_ERROR_DEBUG_INFO_CAPTURED,
-  DI_DEBUG_ERROR_SNAPSHOT_ID,
-  DI_DEBUG_ERROR_FILE,
-  DI_DEBUG_ERROR_LINE
+  TEST_RETRY_REASON
 } = require('../../dd-trace/src/plugins/util/test')
 const { RESOURCE_NAME } = require('../../../ext/tags')
 const { COMPONENT, ERROR_MESSAGE } = require('../../dd-trace/src/constants')
@@ -50,8 +46,8 @@ const {
 } = require('../../dd-trace/src/ci-visibility/telemetry')
 const id = require('../../dd-trace/src/id')
 
+const BREAKPOINT_HIT_GRACE_PERIOD_MS = 200
 const isCucumberWorker = !!process.env.CUCUMBER_WORKER_ID
-const debuggerParameterPerTest = new Map()
 
 function getTestSuiteTags (testSuiteSpan) {
   const suiteTags = {
@@ -210,7 +206,13 @@ class CucumberPlugin extends CiPlugin {
       this.telemetry.ciVisEvent(TELEMETRY_CODE_COVERAGE_FINISHED, 'suite', { library: 'istanbul' })
     })
 
-    this.addSub('ci:cucumber:test:start', ({ testName, testFileAbsolutePath, testSourceLine, isParallel }) => {
+    this.addSub('ci:cucumber:test:start', ({
+      testName,
+      testFileAbsolutePath,
+      testSourceLine,
+      isParallel,
+      promises
+    }) => {
       const store = storage.getStore()
       const testSuite = getTestSuitePath(testFileAbsolutePath, this.sourceRoot)
       const testSourceFile = getTestSuitePath(testFileAbsolutePath, this.repositoryRoot)
@@ -227,38 +229,30 @@ class CucumberPlugin extends CiPlugin {
 
       this.enter(testSpan, store)
 
-      const debuggerParameters = debuggerParameterPerTest.get(testName)
-
-      if (debuggerParameters) {
-        const spanContext = testSpan.context()
-
-        // TODO: handle race conditions with this.retriedTestIds
-        this.retriedTestIds = {
-          spanId: spanContext.toSpanId(),
-          traceId: spanContext.toTraceId()
-        }
-        const { snapshotId, file, line } = debuggerParameters
-
-        // TODO: should these be added on test:end if and only if the probe is hit?
-        // Sync issues: `hitProbePromise` might be resolved after the test ends
-        testSpan.setTag(DI_ERROR_DEBUG_INFO_CAPTURED, 'true')
-        testSpan.setTag(DI_DEBUG_ERROR_SNAPSHOT_ID, snapshotId)
-        testSpan.setTag(DI_DEBUG_ERROR_FILE, file)
-        testSpan.setTag(DI_DEBUG_ERROR_LINE, line)
+      this.activeTestSpan = testSpan
+      // Time we give the breakpoint to be hit
+      if (promises && this.runningTestProbeId) {
+        promises.hitBreakpointPromise = new Promise((resolve) => {
+          setTimeout(resolve, BREAKPOINT_HIT_GRACE_PERIOD_MS)
+        })
       }
     })
 
-    this.addSub('ci:cucumber:test:retry', ({ isRetry, error }) => {
+    this.addSub('ci:cucumber:test:retry', ({ isFirstAttempt, error }) => {
       const store = storage.getStore()
       const span = store.span
-      if (isRetry) {
+      if (!isFirstAttempt) {
         span.setTag(TEST_IS_RETRY, 'true')
       }
       span.setTag('error', error)
-      if (this.di && error && this.libraryConfig?.isDiEnabled) {
-        const testName = span.context()._tags[TEST_NAME]
-        const debuggerParameters = this.addDiProbe(error)
-        debuggerParameterPerTest.set(testName, debuggerParameters)
+      if (isFirstAttempt && this.di && error && this.libraryConfig?.isDiEnabled) {
+        const probeInformation = this.addDiProbe(error)
+        if (probeInformation) {
+          const { probeId, stackIndex } = probeInformation
+          this.runningTestProbeId = probeId
+          this.testErrorStackIndex = stackIndex
+          // TODO: we're not waiting for setProbePromise to be resolved, so there might be race conditions
+        }
       }
       span.setTag(TEST_STATUS, 'fail')
       span.finish()
@@ -328,6 +322,7 @@ class CucumberPlugin extends CiPlugin {
         span.setTag(TEST_IS_NEW, 'true')
         if (isEfdRetry) {
           span.setTag(TEST_IS_RETRY, 'true')
+          span.setTag(TEST_RETRY_REASON, 'efd')
         }
       }
 
@@ -363,6 +358,11 @@ class CucumberPlugin extends CiPlugin {
         if (isCucumberWorker) {
           this.tracer._exporter.flush()
         }
+        this.activeTestSpan = null
+        if (this.runningTestProbeId) {
+          this.removeDiProbe(this.runningTestProbeId)
+          this.runningTestProbeId = null
+        }
       }
     })
 

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

@@ -31,7 +31,8 @@ const {
   TEST_EARLY_FLAKE_ENABLED,
   getTestSessionName,
   TEST_SESSION_NAME,
-  TEST_LEVEL_EVENT_TYPES
+  TEST_LEVEL_EVENT_TYPES,
+  TEST_RETRY_REASON
 } = require('../../dd-trace/src/plugins/util/test')
 const { isMarkedAsUnskippable } = require('../../datadog-plugin-jest/src/util')
 const { ORIGIN_KEY, COMPONENT } = require('../../dd-trace/src/constants')
@@ -112,7 +113,7 @@ function getCypressCommand (details) {
 function getLibraryConfiguration (tracer, testConfiguration) {
   return new Promise(resolve => {
     if (!tracer._tracer._exporter?.getLibraryConfiguration) {
-      return resolve({ err: new Error('CI Visibility was not initialized correctly') })
+      return resolve({ err: new Error('Test Optimization was not initialized correctly') })
     }
 
     tracer._tracer._exporter.getLibraryConfiguration(testConfiguration, (err, libraryConfig) => {
@@ -124,7 +125,7 @@ function getLibraryConfiguration (tracer, testConfiguration) {
 function getSkippableTests (tracer, testConfiguration) {
   return new Promise(resolve => {
     if (!tracer._tracer._exporter?.getSkippableSuites) {
-      return resolve({ err: new Error('CI Visibility was not initialized correctly') })
+      return resolve({ err: new Error('Test Optimization was not initialized correctly') })
     }
     tracer._tracer._exporter.getSkippableSuites(testConfiguration, (err, skippableTests, correlationId) => {
       resolve({
@@ -139,7 +140,7 @@ function getSkippableTests (tracer, testConfiguration) {
 function getKnownTests (tracer, testConfiguration) {
   return new Promise(resolve => {
     if (!tracer._tracer._exporter?.getKnownTests) {
-      return resolve({ err: new Error('CI Visibility was not initialized correctly') })
+      return resolve({ err: new Error('Test Optimization was not initialized correctly') })
     }
     tracer._tracer._exporter.getKnownTests(testConfiguration, (err, knownTests) => {
       resolve({
@@ -203,6 +204,7 @@ class CypressPlugin {
     this.isSuitesSkippingEnabled = false
     this.isCodeCoverageEnabled = false
     this.isEarlyFlakeDetectionEnabled = false
+    this.isKnownTestsEnabled = false
     this.earlyFlakeDetectionNumRetries = 0
     this.testsToSkip = []
     this.skippedTests = []
@@ -232,13 +234,15 @@ class CypressPlugin {
               isEarlyFlakeDetectionEnabled,
               earlyFlakeDetectionNumRetries,
               isFlakyTestRetriesEnabled,
-              flakyTestRetriesCount
+              flakyTestRetriesCount,
+              isKnownTestsEnabled
             }
           } = libraryConfigurationResponse
           this.isSuitesSkippingEnabled = isSuitesSkippingEnabled
           this.isCodeCoverageEnabled = isCodeCoverageEnabled
           this.isEarlyFlakeDetectionEnabled = isEarlyFlakeDetectionEnabled
           this.earlyFlakeDetectionNumRetries = earlyFlakeDetectionNumRetries
+          this.isKnownTestsEnabled = isKnownTestsEnabled
           if (isFlakyTestRetriesEnabled) {
             this.cypressConfig.retries.runMode = flakyTestRetriesCount
           }
@@ -354,7 +358,7 @@ class CypressPlugin {
     this.frameworkVersion = getCypressVersion(details)
     this.rootDir = getRootDir(details)
 
-    if (this.isEarlyFlakeDetectionEnabled) {
+    if (this.isKnownTestsEnabled) {
       const knownTestsResponse = await getKnownTests(
         this.tracer,
         this.testConfiguration
@@ -362,6 +366,7 @@ class CypressPlugin {
       if (knownTestsResponse.err) {
         log.error('Cypress known tests response error', knownTestsResponse.err)
         this.isEarlyFlakeDetectionEnabled = false
+        this.isKnownTestsEnabled = false
       } else {
         // We use TEST_FRAMEWORK_NAME for the name of the module
         this.knownTestsByTestSuite = knownTestsResponse.knownTests[TEST_FRAMEWORK_NAME]
@@ -567,6 +572,9 @@ class CypressPlugin {
           cypressTestStatus = CYPRESS_STATUS_TO_TEST_STATUS[cypressTest.attempts[attemptIndex].state]
           if (attemptIndex > 0) {
             finishedTest.testSpan.setTag(TEST_IS_RETRY, 'true')
+            if (finishedTest.isEfdRetry) {
+              finishedTest.testSpan.setTag(TEST_RETRY_REASON, 'efd')
+            }
           }
         }
         if (cypressTest.displayError) {
@@ -618,7 +626,8 @@ class CypressPlugin {
         const suitePayload = {
           isEarlyFlakeDetectionEnabled: this.isEarlyFlakeDetectionEnabled,
           knownTestsForSuite: this.knownTestsByTestSuite?.[testSuite] || [],
-          earlyFlakeDetectionNumRetries: this.earlyFlakeDetectionNumRetries
+          earlyFlakeDetectionNumRetries: this.earlyFlakeDetectionNumRetries,
+          isKnownTestsEnabled: this.isKnownTestsEnabled
         }
 
         if (this.testSuiteSpan) {
@@ -703,13 +712,15 @@ class CypressPlugin {
           this.activeTestSpan.setTag(TEST_IS_NEW, 'true')
           if (isEfdRetry) {
             this.activeTestSpan.setTag(TEST_IS_RETRY, 'true')
+            this.activeTestSpan.setTag(TEST_RETRY_REASON, 'efd')
           }
         }
         const finishedTest = {
           testName,
           testStatus,
           finishTime: this.activeTestSpan._getTime(), // we store the finish time here
-          testSpan: this.activeTestSpan
+          testSpan: this.activeTestSpan,
+          isEfdRetry
         }
         if (this.finishedTestsByFile[testSuite]) {
           this.finishedTestsByFile[testSuite].push(finishedTest)

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

@@ -1,5 +1,6 @@
 /* eslint-disable */
 let isEarlyFlakeDetectionEnabled = false
+let isKnownTestsEnabled = false
 let knownTestsForSuite = []
 let suiteTests = []
 let earlyFlakeDetectionNumRetries = 0
@@ -33,7 +34,7 @@ function retryTest (test, suiteTests) {
 
 const oldRunTests = Cypress.mocha.getRunner().runTests
 Cypress.mocha.getRunner().runTests = function (suite, fn) {
-  if (!isEarlyFlakeDetectionEnabled) {
+  if (!isKnownTestsEnabled) {
     return oldRunTests.apply(this, arguments)
   }
   // We copy the new tests at the beginning of the suite run (runTests), so that they're run
@@ -41,7 +42,9 @@ Cypress.mocha.getRunner().runTests = function (suite, fn) {
   suite.tests.forEach(test => {
     if (!test._ddIsNew && !test.isPending() && isNewTest(test)) {
       test._ddIsNew = true
-      retryTest(test, suite.tests)
+      if (isEarlyFlakeDetectionEnabled) {
+        retryTest(test, suite.tests)
+      }
     }
   })
 
@@ -67,6 +70,7 @@ before(function () {
   }).then((suiteConfig) => {
     if (suiteConfig) {
       isEarlyFlakeDetectionEnabled = suiteConfig.isEarlyFlakeDetectionEnabled
+      isKnownTestsEnabled = suiteConfig.isKnownTestsEnabled
       knownTestsForSuite = suiteConfig.knownTestsForSuite
       earlyFlakeDetectionNumRetries = suiteConfig.earlyFlakeDetectionNumRetries
     }

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

@@ -9,7 +9,7 @@ class FetchPlugin extends HttpClientPlugin {
   bindStart (ctx) {
     const req = ctx.req
     const options = new URL(req.url)
-    const headers = options.headers = Object.fromEntries(req.headers.entries())
+    options.headers = Object.fromEntries(req.headers.entries())
 
     options.method = req.method
 
@@ -17,9 +17,9 @@ class FetchPlugin extends HttpClientPlugin {
 
     const store = super.bindStart(ctx)
 
-    for (const name in headers) {
+    for (const name in options.headers) {
       if (!req.headers.has(name)) {
-        req.headers.set(name, headers[name])
+        req.headers.set(name, options.headers[name])
       }
     }