dd-trace 5.110.0 → 5.111.0

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-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

@@ -390,6 +390,7 @@ class CypressPlugin {
   earlyFlakeDetectionFaultyThreshold = 0
   testsToSkip = []
   skippedTests = []
+  skippedTestIds = new Set()
   skippableTestsCoverage = {}
   testSessionCoverageMap = createCoverageMap()
   hasForcedToRunSuites = false
@@ -473,6 +474,7 @@ class CypressPlugin {
     this.earlyFlakeDetectionFaultyThreshold = 0
     this.testsToSkip = []
     this.skippedTests = []
+    this.skippedTestIds = new Set()
     this.skippableTestsCoverage = {}
     this.testSessionCoverageMap = createCoverageMap()
     this.hasForcedToRunSuites = false
@@ -637,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')
@@ -1148,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)
@@ -1386,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 }
         }
@@ -1398,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 }
         }

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

@@ -13,6 +13,8 @@ let testManagementTests = {}
 let isImpactedTestsEnabled = false
 let isModifiedTest = false
 let isTestIsolationEnabled = false
+let hasWarnedMissingBeforeEachTaskResult = false
+let hasWarnedMissingBeforeEachRetryResult = false
 // Array of test names that have been retried and the reason
 const retryReasonsByTestName = new Map()
 // Track test errors suppressed by test management so we can still report them to Datadog.
@@ -86,6 +88,47 @@ function getTestProperties (testName) {
   return { isAttemptToFix, isDisabled, isQuarantined }
 }
 
+/**
+ * @param {string} message
+ * @returns {void}
+ */
+function warnMissingBeforeEachTaskResult (message) {
+  // eslint-disable-next-line no-console
+  console.warn(message)
+}
+
+/**
+ * @param {object} test
+ * @returns {Cypress.Chainable<{ traceId?: string, shouldSkip?: boolean, shouldDiscard?: boolean }>}
+ */
+function runBeforeEachTask (test) {
+  return cy.task('dd:beforeEach', test).then((taskResult) => {
+    if (taskResult !== undefined && taskResult !== null) {
+      return taskResult
+    }
+
+    if (!hasWarnedMissingBeforeEachTaskResult) {
+      hasWarnedMissingBeforeEachTaskResult = true
+      warnMissingBeforeEachTaskResult('Datadog Cypress dd:beforeEach task returned no result. Retrying once.')
+    }
+
+    return cy.task('dd:beforeEach', test).then((retryTaskResult) => {
+      if (retryTaskResult !== undefined && retryTaskResult !== null) {
+        return retryTaskResult
+      }
+
+      if (!hasWarnedMissingBeforeEachRetryResult) {
+        hasWarnedMissingBeforeEachRetryResult = true
+        warnMissingBeforeEachTaskResult(
+          'Datadog Cypress dd:beforeEach task returned no result after retry. Continuing with an empty task result.'
+        )
+      }
+
+      return {}
+    })
+  })
+}
+
 // Catch test failures for quarantined tests and suppress them
 // By not re-throwing the error, Cypress marks the test as passed
 // This allows quarantined tests to run but not affect the exit code
@@ -263,7 +306,8 @@ beforeEach(function () {
     originalWindow = win
   })
 
-  cy.task('dd:beforeEach', {
+  runBeforeEachTask({
+    testId: currentTest.id,
     testName,
     testSuite: Cypress.mocha.getRootSuite().file,
     isEfdRetry: Cypress.mocha.getRunner().suite.ctx.currentTest._ddIsEfdRetry,

package/packages/datadog-plugin-express/src/code_origin.js

@@ -31,7 +31,7 @@ class ExpressCodeOriginForSpansPlugin extends Plugin {
       layerTags.set(layer, entryTags(topOfStackFunc))
     }
 
-    if (this._tracerConfig.remoteConfig?.enabled) {
+    if (this._tracerConfig.remoteConfig.DD_REMOTE_CONFIGURATION_ENABLED) {
       // When RC is enabled, use manual subscriptions (always pre-compute)
       // This allows tags to be computed even when CO is disabled, so runtime enabling works
       dc.channel('apm:express:route:added').subscribe(handleRouteAdded)

package/packages/datadog-plugin-fastify/src/code_origin.js

@@ -20,7 +20,7 @@ class FastifyCodeOriginForSpansPlugin extends Plugin {
       web.getContext(req)?.span?.addTags(tags)
     })
 
-    if (this._tracerConfig.remoteConfig?.enabled) {
+    if (this._tracerConfig.remoteConfig.DD_REMOTE_CONFIGURATION_ENABLED) {
       // When RC is enabled, use manual subscription (always pre-computes)
       // This allows tags to be computed even when CO is disabled, so runtime enabling works
       dc.channel('apm:fastify:route:added').subscribe(handleRouteAdded)