dd-trace 5.109.0 → 5.111.0

package/packages/datadog-plugin-avsc/src/schema_iterator.js

@@ -43,9 +43,9 @@ class SchemaExtractor {
     let type
     let format
     let enumValues
-    let description
     let ref
 
+    const description = field.doc
     const fieldType = field.type?.types ?? field.type?.typeName ?? field.type
 
     if (Array.isArray(fieldType)) {
@@ -129,7 +129,7 @@ class SchemaExtractor {
   }
 
   iterateOverSchema (builder) {
-    this.constructor.extractSchema(this.schema, builder, 0)
+    SchemaExtractor.extractSchema(this.schema, builder, 0)
   }
 
   static attachSchemaOnSpan (args, span, operation, tracer) {

package/packages/datadog-plugin-aws-durable-execution-sdk-js/src/client.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const ClientPlugin = require('../../dd-trace/src/plugins/client')
-const { addOpMeta, unwrapDurableError } = require('./util')
+const { addOpMeta, getStepDataForNext, unwrapDurableError } = require('./util')
 
 class AwsDurableExecutionSdkJsClientPlugin extends ClientPlugin {
   static id = 'aws-durable-execution-sdk-js'
@@ -29,7 +29,7 @@ class AwsDurableExecutionSdkJsClientPlugin extends ClientPlugin {
     if (operationName) {
       meta['aws.durable.operation_name'] = operationName
     }
-    addOpMeta(meta, ctx.self)
+    addOpMeta(meta, getStepDataForNext(ctx.self))
 
     this.startSpan(this.operationName(), {
       resource: operationName,

package/packages/datadog-plugin-aws-durable-execution-sdk-js/src/context.js

@@ -2,7 +2,7 @@
 
 const { storage } = require('../../datadog-core')
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
-const { addOpMeta, unwrapDurableError } = require('./util')
+const { addOpMeta, getOperationAttempt, getStepDataForNext, unwrapDurableError } = require('./util')
 
 // Span names whose direct children must keep the default resource.
 // These can have very high cardinality which is undesireable in the resource.
@@ -41,12 +41,18 @@ class BaseContextPlugin extends TracingPlugin {
     if (operationName) {
       meta['aws.durable.operation_name'] = operationName
     }
-    addOpMeta(meta, ctx.self)
+    const stepInfo = getStepDataForNext(ctx.self)
+    addOpMeta(meta, stepInfo)
+
+    const metrics = this.constructor.retryable
+      ? { 'aws.durable.operation_attempt': getOperationAttempt(stepInfo.stepData) }
+      : undefined
 
     this.startSpan(spanName, {
       resource,
       kind: this.constructor.kind,
       meta,
+      metrics,
     }, ctx)
 
     return ctx.currentStore
@@ -71,11 +77,12 @@ class BaseContextPlugin extends TracingPlugin {
   }
 }
 
-function makeContextPlugin (method, spanName) {
+function makeContextPlugin (method, spanName, { retryable }) {
   return class extends BaseContextPlugin {
     static prefix = `tracing:orchestrion:@aws/durable-execution-sdk-js:DurableContextImpl_${method}`
     static settleChannel = `apm:aws-durable-execution-sdk-js:${method}:settle`
     static spanName = spanName
+    static retryable = retryable
   }
 }
 
@@ -83,6 +90,7 @@ class RunInChildContextPlugin extends BaseContextPlugin {
   static prefix = 'tracing:orchestrion:@aws/durable-execution-sdk-js:DurableContextImpl_runInChildContext'
   static settleChannel = 'apm:aws-durable-execution-sdk-js:runInChildContext:settle'
   static spanName = 'aws.durable.child_context'
+  static retryable = false
 
   bindStart (ctx) {
     if (SUPPRESSED_CHILD_CONTEXT_SUBTYPES.has(getRunInChildContextSubType(ctx))) {
@@ -103,12 +111,12 @@ function getRunInChildContextSubType (ctx) {
 }
 
 module.exports = {
-  step: makeContextPlugin('step', 'aws.durable.step'),
-  wait: makeContextPlugin('wait', 'aws.durable.wait'),
-  waitForCondition: makeContextPlugin('waitForCondition', 'aws.durable.wait_for_condition'),
-  waitForCallback: makeContextPlugin('waitForCallback', 'aws.durable.wait_for_callback'),
-  createCallback: makeContextPlugin('createCallback', 'aws.durable.create_callback'),
-  map: makeContextPlugin('map', 'aws.durable.map'),
-  parallel: makeContextPlugin('parallel', 'aws.durable.parallel'),
+  step: makeContextPlugin('step', 'aws.durable.step', { retryable: true }),
+  wait: makeContextPlugin('wait', 'aws.durable.wait', { retryable: false }),
+  waitForCondition: makeContextPlugin('waitForCondition', 'aws.durable.wait_for_condition', { retryable: true }),
+  waitForCallback: makeContextPlugin('waitForCallback', 'aws.durable.wait_for_callback', { retryable: false }),
+  createCallback: makeContextPlugin('createCallback', 'aws.durable.create_callback', { retryable: false }),
+  map: makeContextPlugin('map', 'aws.durable.map', { retryable: false }),
+  parallel: makeContextPlugin('parallel', 'aws.durable.parallel', { retryable: false }),
   runInChildContext: RunInChildContextPlugin,
 }

package/packages/datadog-plugin-aws-durable-execution-sdk-js/src/util.js

@@ -2,27 +2,63 @@
 
 const { createHash } = require('node:crypto')
 
+// A checkpoint in one of these terminal states means the operation is served from the checkpoint
+// on a replay rather than executed: the SDK reloads a SUCCEEDED result or re-raises a FAILED error
+// without running the user function. Both also carry the 1-indexed attempt that reached the terminal
+// state, so both need the same normalization to agree with the 0-indexed live run.
+const REPLAYED_STATUSES = new Set(['SUCCEEDED', 'FAILED'])
+
 /**
- * Populates the replay and operation_id tags for the op the DurableContextImpl is about to
- * run, deriving both from a single `getNextStepId()` call. `aws.durable.replayed` is always
- * set ('true' when the next stepId already has a SUCCEEDED checkpoint entry, i.e. the op will
- * be served from the SDK's checkpoint). `aws.durable.operation_id` — the 16-hex-char MD5 of
- * the stepId, mirroring the SDK's internal calculation — is only added when a stepId exists.
- * @param {Record<string, string>} meta - The span meta/tags object to populate.
+ * Resolves the SDK's next stepId and its checkpoint entry in a single pass, so one span start can
+ * feed both addOpMeta and getOperationAttempt without traversing the SDK internals twice. `stepData`
+ * is undefined when there is no next stepId, or no checkpoint entry exists for it yet.
  * @param {object} [ctxImpl] - The DurableContextImpl about to run the op.
- * @returns {void}
+ * @returns {{ stepId: string | undefined, stepData: object | undefined }}
  */
-function addOpMeta (meta, ctxImpl) {
+function getStepDataForNext (ctxImpl) {
   const stepId = ctxImpl?.getNextStepId?.()
+  const stepData = stepId ? ctxImpl?._executionContext?.getStepData?.(stepId) : undefined
+  return { stepId, stepData }
+}
+
+/**
+ * Populates the replay and operation_id tags from a pre-resolved step lookup (see
+ * getStepDataForNext). `aws.durable.replayed` is always set ('true' when the next stepId already
+ * has a terminal checkpoint entry — SUCCEEDED or FAILED — i.e. the op will be served from the SDK's
+ * checkpoint rather than executed). `aws.durable.operation_id` — the 16-hex-char MD5 of the stepId,
+ * mirroring the SDK's internal calculation — is only added when a stepId exists.
+ * @param {Record<string, string>} meta - The span meta/tags object to populate.
+ * @param {{ stepId?: string, stepData?: object }} stepInfo - Resolved next stepId and checkpoint entry.
+ * @returns {void}
+ */
+function addOpMeta (meta, { stepId, stepData }) {
   if (!stepId) {
     meta['aws.durable.replayed'] = 'false'
     return
   }
-  const stepData = ctxImpl?._executionContext?.getStepData?.(stepId)
-  meta['aws.durable.replayed'] = String(stepData?.Status === 'SUCCEEDED')
+  meta['aws.durable.replayed'] = String(REPLAYED_STATUSES.has(stepData?.Status))
   meta['aws.durable.operation_id'] = createHash('md5').update(stepId).digest('hex').slice(0, 16)
 }
 
+/**
+ * Returns the 0-indexed attempt number for the op (0 original, 1 first retry, …) from a pre-resolved
+ * checkpoint entry (see getStepDataForNext), defaulting to 0 before any checkpoint exists.
+ *
+ * StepDetails.Attempt is indexed differently depending on checkpoint status: on a pending/retry
+ * checkpoint it's the count of prior failed attempts (already 0-indexed), but on a terminal
+ * checkpoint read on replay (SUCCEEDED or FAILED) it's the 1-indexed attempt that reached that
+ * state. We subtract 1 in the terminal case so a replay agrees with the original run, flooring at
+ * 0 since the 1-indexing is observed server behavior, not an SDK guarantee.
+ *
+ * @param {object} [stepData] - The checkpoint entry for the next stepId.
+ * @returns {number}
+ */
+function getOperationAttempt (stepData) {
+  const attempt = stepData?.StepDetails?.Attempt
+  if (!Number.isFinite(attempt)) return 0
+  return REPLAYED_STATUSES.has(stepData.Status) ? Math.max(0, attempt - 1) : attempt
+}
+
 /**
  * The SDK wraps user errors in typed classes (StepError, ChildContextError, etc.); we follow the
  * `.cause` chain to recover the user's original Error. SDK wrappers expose a string `errorType`
@@ -40,4 +76,4 @@ function unwrapDurableError (ctx) {
   return err
 }
 
-module.exports = { addOpMeta, unwrapDurableError }
+module.exports = { addOpMeta, getOperationAttempt, getStepDataForNext, unwrapDurableError }

package/packages/datadog-plugin-aws-sdk/src/base.js

@@ -108,7 +108,7 @@ class BaseAwsSdkPlugin extends ClientPlugin {
       const span = this.startSpan(this.operationFromRequest(request), {
         childOf,
         meta,
-        service: this.serviceName(),
+        service: this.serviceName(request),
         integrationName: 'aws-sdk',
       }, ctx)
 
@@ -216,14 +216,18 @@ class BaseAwsSdkPlugin extends ClientPlugin {
     })
   }
 
-  serviceName () {
-    return this.config.service ||
-      super.serviceName({
-        id: 'aws',
-        type: 'web',
-        kind: 'client',
-        awsService: this.serviceIdentifier,
-      })
+  /**
+   * @param {{ params?: object }} request
+   */
+  serviceName (request) {
+    return super.serviceName({
+      id: 'aws',
+      type: 'web',
+      kind: 'client',
+      awsService: this.serviceIdentifier,
+      pluginConfig: this.config,
+      params: request.params,
+    })
   }
 
   isEnabled (request) {

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

@@ -2,6 +2,34 @@
 const log = require('../../../dd-trace/src/log')
 const BaseAwsSdkPlugin = require('../base')
 
+// EventBridge enforces this limit over the whole PutEvents request (the sum of
+// every entry), not over a single entry. 1 MiB == 1,048,576 bytes.
+const MAX_PUT_EVENTS_BYTES = 1024 * 1024
+
+/**
+ * Size a single `PutEventsRequestEntry` the way EventBridge does server-side:
+ * the UTF-8 byte length of `Source`, `DetailType`, `Detail`, and each
+ * `Resources` ARN, plus a flat 14 bytes when `Time` is set.
+ *
+ * @param {object} entry a single PutEvents request entry
+ * @param {string} [detail] overrides `entry.Detail`, used to size the entry as
+ *   it would be sent with the injected `_datadog` context
+ * @returns {number}
+ * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-putevents.html
+ */
+function putEventEntrySize (entry, detail = entry.Detail) {
+  let size = entry.Time == null ? 0 : 14
+  if (entry.Source != null) size += Buffer.byteLength(entry.Source)
+  if (entry.DetailType != null) size += Buffer.byteLength(entry.DetailType)
+  if (detail != null) size += Buffer.byteLength(detail)
+  if (entry.Resources != null) {
+    for (const resource of entry.Resources) {
+      if (resource != null) size += Buffer.byteLength(resource)
+    }
+  }
+  return size
+}
+
 class EventBridge extends BaseAwsSdkPlugin {
   static id = 'eventbridge'
   static isPayloadReporter = true
@@ -25,7 +53,8 @@ class EventBridge extends BaseAwsSdkPlugin {
    * Docs: https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEventsRequestEntry.html
    * We cannot use the traceHeader field as that's reserved for X-Ray.
    * Detail must be a valid JSON string
-   * Max size per event is 256kb (https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-putevent-size.html)
+   * Max PutEvents request size is 1mb, summed over all entries
+   * (https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-putevent-size.html)
    */
   requestInject (span, request) {
     const operation = request.operation
@@ -34,6 +63,7 @@ class EventBridge extends BaseAwsSdkPlugin {
       request.params.Entries &&
       request.params.Entries.length > 0 &&
       request.params.Entries[0].Detail) {
+      const entries = request.params.Entries
       const injected = {}
       this.tracer.inject(span, 'text_map', injected)
 
@@ -42,19 +72,26 @@ class EventBridge extends BaseAwsSdkPlugin {
       // it so the rest of the body stays in V8's optimisable surface.
       let finalData
       try {
-        finalData = BaseAwsSdkPlugin.injectFieldIntoJsonObject(
-          request.params.Entries[0].Detail, '_datadog', injected
-        )
+        finalData = BaseAwsSdkPlugin.injectFieldIntoJsonObject(entries[0].Detail, '_datadog', injected)
       } catch (error) {
         log.error('EventBridge error injecting request', error)
         return
       }
 
-      if (Buffer.byteLength(finalData) >= 1024 * 256) {
+      // EventBridge applies the 1 MiB cap to the whole request, so size every
+      // entry as it would be sent (the first with `_datadog` injected) and skip
+      // rather than tip a request AWS would otherwise accept over the limit. The
+      // running total only needs to clear the cap, so stop summing the moment it
+      // does instead of byte-counting the rest of a batch we already know is over.
+      let requestSize = putEventEntrySize(entries[0], finalData)
+      for (let i = 1; requestSize < MAX_PUT_EVENTS_BYTES && i < entries.length; i++) {
+        requestSize += putEventEntrySize(entries[i])
+      }
+      if (requestSize >= MAX_PUT_EVENTS_BYTES) {
         log.info('Payload size too large to pass context')
         return
       }
-      request.params.Entries[0].Detail = finalData
+      entries[0].Detail = finalData
     }
   }
 }

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

@@ -72,44 +72,53 @@ class Sqs extends BaseAwsSdkPlugin {
     })
   }
 
+  /**
+   * Start the consumer (`aws.response`) span for a receive. The first message carrying trace
+   * context becomes the parent; every additional one fans in as a span link.
+   *
+   * @param {{ request: object, response: object, needsFinish?: boolean, currentStore?: object }} ctx
+   * @returns {object | undefined} The store to activate for the consumer span, else the parent store.
+   */
   #startResponseSpan (ctx) {
     const { request, response } = ctx
-    const contextExtraction = this.responseExtract(request.params, request.operation, response)
+    const carriers = this.responseExtract(request.params, request.operation, response)
 
     let store = this._parentMap.get(request)
     let span
-    let parsedMessageAttributes
-    let parsedFirstBody
-    let firstBodyChecked = false
-    if (contextExtraction !== undefined) {
-      parsedFirstBody = contextExtraction.parsedBody
-      firstBodyChecked = contextExtraction.bodyChecked === true
-      if (contextExtraction.datadogContext !== undefined) {
-        parsedMessageAttributes = contextExtraction.parsedAttributes
-        // request:start records requestTags only after the isEnabled gate, so an absent entry
-        // means this consumer is disabled — gate on it instead of paying isEnabled again here.
-        const requestTags = this.requestTags.get(request)
-        if (requestTags !== undefined) {
-          ctx.needsFinish = true
-          const options = {
-            childOf: contextExtraction.datadogContext,
-            meta: {
-              ...requestTags,
-              'span.kind': 'server',
-            },
-            integrationName: 'aws-sdk',
+
+    if (carriers !== undefined) {
+      // request:start records requestTags only after the isEnabled gate, so an absent entry
+      // means this consumer is disabled — gate on it instead of paying isEnabled again here.
+      const requestTags = this.requestTags.get(request)
+      if (requestTags !== undefined) {
+        // A receive can return messages from many producers; fanning the extra ones in as span
+        // links is the shape dd-trace-java and dd-trace-py use for batch SQS receives.
+        for (const carrier of carriers) {
+          if (carrier === undefined) continue
+          const datadogContext = this.tracer.extract('text_map', carrier)
+          // A DSM-only carrier (a non-first sendMessageBatch entry when batchPropagationEnabled
+          // is off) extracts to null; span.addLink dereferences the context and would throw on it.
+          if (datadogContext === null) continue
+          if (span === undefined) {
+            ctx.needsFinish = true
+            span = this.startSpan('aws.response', {
+              childOf: datadogContext,
+              meta: {
+                ...requestTags,
+                'span.kind': 'server',
+              },
+              integrationName: 'aws-sdk',
+            }, ctx)
+            store = ctx.currentStore
+          } else {
+            span.addLink({ context: datadogContext })
           }
-          span = this.startSpan('aws.response', options, ctx)
-          store = ctx.currentStore
         }
       }
     }
 
     // Extract DSM context after, as we might not have a parent-child but may have a DSM context.
-    this.responseExtractDSMContext(
-      request.operation, request.params, response, span ?? null,
-      { parsedAttributes: parsedMessageAttributes, parsedFirstBody, firstBodyChecked }
-    )
+    this.responseExtractDSMContext(request.operation, request.params, response, span ?? null, carriers)
 
     return store
   }
@@ -183,19 +192,39 @@ class Sqs extends BaseAwsSdkPlugin {
     return tags
   }
 
+  /**
+   * Parse the trace-context carrier of every received message, in message order.
+   * Entries are `undefined` for messages that carry no `_datadog` context.
+   *
+   * @param {{ MaxNumberOfMessages?: number }} params
+   * @param {string} operation
+   * @param {{ Messages?: object[] }} response
+   * @returns {Array<Record<string, string> | undefined> | undefined}
+   */
   responseExtract (params, operation, response) {
     if (operation !== 'receiveMessage') return
-    if (params.MaxNumberOfMessages && params.MaxNumberOfMessages !== 1) return
-    if (!response || !response.Messages || !response.Messages[0]) return
+    if (!response?.Messages?.length) return
 
-    let message = response.Messages[0]
-    let parsedBody
+    return response.Messages.map(message => this.parseMessageCarrier(message))
+  }
 
+  /**
+   * Resolve the trace-context carrier for a single received message. The
+   * `MessageAttributes._datadog` text map (direct SQS or SNS to SQS) wins;
+   * otherwise the EventBridge envelope, optionally wrapped in an SNS
+   * `Notification` (see getEventBridgeContext). Checking MessageAttributes first
+   * avoids parsing a large SNS `Message` just to rule out an EventBridge envelope.
+   *
+   * @param {object} message A single `response.Messages` entry.
+   * @returns {Record<string, string> | undefined}
+   */
+  parseMessageCarrier (message) {
+    let parsedBody
     if (message.Body) {
       try {
         parsedBody = JSON.parse(message.Body)
       } catch {
-        // SQS to SQS
+        // Opaque, non-JSON body (SQS to SQS).
       }
       // SNS to SQS
       if (parsedBody?.Type === 'Notification') {
@@ -203,34 +232,9 @@ class Sqs extends BaseAwsSdkPlugin {
       }
     }
 
-    // Check MessageAttributes first (common direct-SQS/SNS path): avoids parsing
-    // the body (e.g. a large SNS `Message`) just to rule out an EventBridge
-    // envelope. Precedence matches responseExtractDSMContext.
     const datadogAttribute = message.MessageAttributes?._datadog
-    if (datadogAttribute) {
-      const parsedAttributes = this.parseDatadogAttributes(datadogAttribute)
-      if (parsedAttributes) {
-        return {
-          datadogContext: this.tracer.extract('text_map', parsedAttributes),
-          parsedAttributes,
-          parsedBody,
-          bodyChecked: true,
-        }
-      }
-    }
-
-    // Then the EventBridge envelope (optionally via SNS); see getEventBridgeContext.
-    const eventBridgeContext = getEventBridgeContext(parsedBody)
-    if (eventBridgeContext) {
-      return {
-        datadogContext: this.tracer.extract('text_map', eventBridgeContext),
-        parsedAttributes: eventBridgeContext,
-        parsedBody,
-        bodyChecked: true,
-      }
-    }
-
-    return { parsedBody, bodyChecked: true }
+    const carrier = datadogAttribute ? this.parseDatadogAttributes(datadogAttribute) : undefined
+    return carrier ?? getEventBridgeContext(parsedBody)
   }
 
   parseDatadogAttributes (attributes) {
@@ -247,51 +251,39 @@ class Sqs extends BaseAwsSdkPlugin {
     }
   }
 
-  responseExtractDSMContext (operation, params, response, span, kwargs = {}) {
-    let { parsedAttributes } = kwargs
-    const { parsedFirstBody, firstBodyChecked } = kwargs
+  /**
+   * @param {string} operation
+   * @param {{ QueueUrl: string }} params
+   * @param {{ Messages?: object[] }} response
+   * @param {import('../../../dd-trace/src/opentracing/span') | null} span
+   * @param {Array<Record<string, string> | undefined>} [carriers] Per-message carriers already
+   *   parsed by `responseExtract`; reused so each message body is parsed once. When omitted, the
+   *   carriers are parsed here.
+   */
+  responseExtractDSMContext (operation, params, response, span, carriers) {
     if (!this.config.dsmEnabled) return
     if (operation !== 'receiveMessage') return
-    if (!response || !response.Messages || !response.Messages[0]) return
+    if (!response?.Messages?.length) return
 
+    const messages = response.Messages
     // Only attribute payloadSize to the span when there is a single message.
-    span = response.Messages.length > 1 ? null : span
+    span = messages.length > 1 ? null : span
 
     // QueueUrl is the same for the whole receive batch.
     const queue = params.QueueUrl.slice(params.QueueUrl.lastIndexOf('/') + 1)
 
-    for (let i = 0; i < response.Messages.length; i++) {
-      let message = response.Messages[i]
-      if (!parsedAttributes) {
-        let body
-        // responseExtract already parsed message[0]; reuse that result instead of re-parsing.
-        if (i === 0 && firstBodyChecked) {
-          body = parsedFirstBody
-        } else if (message.Body) {
-          try {
-            body = JSON.parse(message.Body)
-          } catch {
-            // SQS to SQS
-          }
-        }
-        // SNS to SQS
-        if (body?.Type === 'Notification') {
-          message = body
-        }
-        // MessageAttributes for direct SQS/SNS; else the EventBridge envelope.
-        parsedAttributes = message.MessageAttributes?._datadog
-          ? this.parseDatadogAttributes(message.MessageAttributes._datadog)
-          : getEventBridgeContext(body)
+    for (let i = 0; i < messages.length; i++) {
+      const message = messages[i]
+      const carrier = carriers === undefined ? this.parseMessageCarrier(message) : carriers[i]
+      if (carrier) {
+        // Inert for EventBridge until its producer emits a pathway (separate
+        // change) — no `dd-pathway-ctx-base64` to decode yet; SQS/SNS decode now.
+        this.tracer.decodeDataStreamsContext(carrier)
       }
       const payloadSize = getHeadersSize({
         Body: message.Body,
         MessageAttributes: message.MessageAttributes,
       })
-      if (parsedAttributes) {
-        // Inert for EventBridge until its producer emits a pathway (separate
-        // change) — no `dd-pathway-ctx-base64` to decode yet; SQS/SNS decode now.
-        this.tracer.decodeDataStreamsContext(parsedAttributes)
-      }
       this.tracer
         .setCheckpoint(['direction:in', `topic:${queue}`, 'type:sqs'], span, payloadSize)
     }

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

@@ -130,7 +130,7 @@ class CucumberPlugin extends CiPlugin {
       finishAllTraceSpans(this.testSessionSpan)
       this.telemetry.count(TELEMETRY_TEST_SESSION, {
         provider: this.ciProviderName,
-        autoInjected: !!this._tracerConfig.DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER,
+        autoInjected: !!this._tracerConfig.testOptimization.DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER,
       })
 
       this.libraryConfig = null

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

@@ -11,6 +11,7 @@ const {
   TEST_IS_RUM_ACTIVE,
   TEST_CODE_OWNERS,
   getTestEnvironmentMetadata,
+  getTestLevelsMetadataTags,
   CI_APP_ORIGIN,
   getTestParentSpan,
   getCodeOwnersFileEntries,
@@ -23,6 +24,7 @@ const {
   TEST_MODULE_ID,
   TEST_SESSION_ID,
   TEST_COMMAND,
+  TEST_LEVELS_METADATA,
   TEST_MODULE,
   TEST_SOURCE_START,
   finishAllTraceSpans,
@@ -388,6 +390,7 @@ class CypressPlugin {
   earlyFlakeDetectionFaultyThreshold = 0
   testsToSkip = []
   skippedTests = []
+  skippedTestIds = new Set()
   skippableTestsCoverage = {}
   testSessionCoverageMap = createCoverageMap()
   hasForcedToRunSuites = false
@@ -471,6 +474,7 @@ class CypressPlugin {
     this.earlyFlakeDetectionFaultyThreshold = 0
     this.testsToSkip = []
     this.skippedTests = []
+    this.skippedTestIds = new Set()
     this.skippableTestsCoverage = {}
     this.testSessionCoverageMap = createCoverageMap()
     this.hasForcedToRunSuites = false
@@ -635,7 +639,7 @@ class CypressPlugin {
 
     this.isTestIsolationEnabled = getIsTestIsolationEnabled(cypressConfig)
 
-    this.rumFlushWaitMillis = getConfig().DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS
+    this.rumFlushWaitMillis = getConfig().testOptimization.DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS
 
     if (!this.isTestIsolationEnabled) {
       log.warn('Test isolation is disabled, retries will not be enabled')
@@ -1043,7 +1047,13 @@ class CypressPlugin {
     )
 
     if (this.tracer._tracer._exporter?.addMetadataTags) {
-      const metadataTags = { '*': { [TEST_COMMAND]: this.command, [TEST_SESSION_NAME]: testSessionName } }
+      const metadataTags = {
+        [TEST_LEVELS_METADATA]: {
+          [TEST_COMMAND]: this.command,
+          [TEST_SESSION_NAME]: testSessionName,
+          ...getTestLevelsMetadataTags(this.testEnvironmentMetadata),
+        },
+      }
       const libraryCapabilitiesTags = getLibraryCapabilitiesTags(this.constructor.id, this.frameworkVersion)
       metadataTags.test = {
         ...libraryCapabilitiesTags,
@@ -1140,7 +1150,7 @@ class CypressPlugin {
       this.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'session')
       incrementCountMetric(TELEMETRY_TEST_SESSION, {
         provider: this.ciProviderName,
-        autoInjected: !!getConfig().DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER,
+        autoInjected: !!getConfig().testOptimization.DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER,
       })
 
       finishAllTraceSpans(this.testSessionSpan)
@@ -1378,7 +1388,7 @@ class CypressPlugin {
         return suitePayload
       },
       'dd:beforeEach': (test) => {
-        const { testName, testSuite, isEfdRetry, efdRetryIndex } = test
+        const { testId, testName, testSuite, isEfdRetry, efdRetryIndex } = test
         if (isEfdRetry && this.shouldSkipEfdRetry(testSuite, testName, efdRetryIndex)) {
           return { shouldSkip: true, shouldDiscard: true }
         }
@@ -1390,7 +1400,11 @@ class CypressPlugin {
         const { isAttemptToFix, isDisabled, isQuarantined } = this.getTestProperties(testSuite, testName)
         // skip test
         if (shouldSkip && !isUnskippable) {
-          this.skippedTests.push(test)
+          const skippedTestId = `${testSuite}:${testId || testName}`
+          if (!this.skippedTestIds.has(skippedTestId)) {
+            this.skippedTestIds.add(skippedTestId)
+            this.skippedTests.push(test)
+          }
           this.isTestsSkipped = true
           return { shouldSkip: true }
         }