dd-trace 5.87.0 → 5.89.0

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

@@ -21,6 +21,7 @@ const {
   getFormattedJestTestParameters,
   getJestTestName,
   getJestSuitesToRun,
+  getEfdRetryCount,
 } = require('../../datadog-plugin-jest/src/util')
 const { addHook, channel } = require('./helpers/instrument')
 
@@ -68,7 +69,9 @@ const RETRY_TIMES = Symbol.for('RETRY_TIMES')
 let skippableSuites = []
 let knownTests = {}
 let isCodeCoverageEnabled = false
+let isCodeCoverageEnabledBecauseOfUs = false
 let isSuitesSkippingEnabled = false
+let isKeepingCoverageConfiguration = false
 let isUserCodeCoverageEnabled = false
 let isSuitesSkipped = false
 let numSkippedSuites = 0
@@ -76,6 +79,7 @@ let hasUnskippableSuites = false
 let hasForcedToRunSuites = false
 let isEarlyFlakeDetectionEnabled = false
 let earlyFlakeDetectionNumRetries = 0
+let earlyFlakeDetectionSlowTestRetries = {}
 let earlyFlakeDetectionFaultyThreshold = 30
 let isEarlyFlakeDetectionFaulty = false
 let hasFilteredSkippableSuites = false
@@ -95,6 +99,12 @@ const attemptToFixRetriedTestsStatuses = new Map()
 const wrappedWorkers = new WeakSet()
 const testSuiteMockedFiles = new Map()
 const testsToBeRetried = new Set()
+// Per-test: how many EFD retries were determined after the first execution.
+const efdDeterminedRetries = new Map()
+// Tests whose first run exceeded the 5-min threshold — tagged "slow".
+const efdSlowAbortedTests = new Set()
+// Tests added as EFD new-test candidates (not ATF, not impacted).
+const efdNewTestCandidates = new Set()
 const testSuiteAbsolutePathsWithFastCheck = new Set()
 const testSuiteJestObjects = new Map()
 
@@ -197,7 +207,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       this.isImpactedTestsEnabled = this.testEnvironmentOptions._ddIsImpactedTestsEnabled
 
       if (this.isKnownTestsEnabled) {
-        earlyFlakeDetectionNumRetries = this.testEnvironmentOptions._ddEarlyFlakeDetectionNumRetries
+        earlyFlakeDetectionSlowTestRetries = this.testEnvironmentOptions._ddEarlyFlakeDetectionSlowTestRetries ?? {}
         try {
           this.knownTestsForThisSuite = this.getKnownTestsForSuite(this.testEnvironmentOptions._ddKnownTests)
 
@@ -466,7 +476,13 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         testContexts.set(event.test, ctx)
 
         testStartCh.runStores(ctx, () => {
-          for (const hook of event.test.parent.hooks) {
+          let p = event.test.parent
+          const hooks = []
+          while (p != null) {
+            hooks.push(...p.hooks)
+            p = p.parent
+          }
+          for (const hook of hooks) {
             let hookFn = hook.fn
             if (originalHookFns.has(hook)) {
               hookFn = originalHookFns.get(hook)
@@ -537,11 +553,9 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             retriedTestsToNumAttempts.set(testFullName, 0)
             if (this.isEarlyFlakeDetectionEnabled) {
               testsToBeRetried.add(testFullName)
-              this.retryTest({
-                jestEvent: event,
-                retryCount: earlyFlakeDetectionNumRetries,
-                retryType: 'Early flake detection',
-              })
+              efdNewTestCandidates.add(testFullName)
+              // Cloning is deferred to test_done after the first execution,
+              // when we know the duration and can choose the right retry count.
             }
           }
         }
@@ -566,8 +580,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         let attemptToFixFailed = false
         let failedAllTests = false
         let isAttemptToFix = false
+        const testName = getJestTestName(event.test, this.getShouldStripSeedFromTestName())
         if (this.isTestManagementTestsEnabled) {
-          const testName = getJestTestName(event.test, this.getShouldStripSeedFromTestName())
           isAttemptToFix = this.testManagementTestsForThisSuite?.attemptToFix?.includes(testName)
           if (isAttemptToFix) {
             if (attemptToFixRetriedTestsStatuses.has(testName)) {
@@ -592,9 +606,53 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           }
         }
 
+        // EFD dynamic cloning: on first execution of a new EFD candidate,
+        // determine the retry count from the test's duration.
+        if (
+          this.isEarlyFlakeDetectionEnabled &&
+          this.isKnownTestsEnabled &&
+          efdNewTestCandidates.has(testName) &&
+          event.test.invocations === 1 &&
+          !efdDeterminedRetries.has(testName)
+        ) {
+          const durationMs = event.test.duration ?? 0
+          const retryCount = getEfdRetryCount(durationMs, earlyFlakeDetectionSlowTestRetries)
+          efdDeterminedRetries.set(testName, retryCount)
+          if (retryCount > 0) {
+            // Temporarily adjust jest-circus state so that retry tests are registered
+            // into the correct describe block and bypass the "tests have started" guard.
+            //
+            // Problem 1 (jest-circus ≤24): currentDescribeBlock points to ROOT during
+            // execution, and ROOT's tests loop already finished before children ran.
+            //
+            // Problem 2 (jest-circus ≥27): `hasStarted = true` causes `test()` to throw
+            // "Cannot add a test after tests have started running".
+            //
+            // Fix: temporarily point currentDescribeBlock to the test's parent (so retries
+            // land in the still-iterating children array) and set hasStarted = false (so the
+            // guard is bypassed). Both are restored immediately after scheduling the retries.
+            const originalDescribeBlock = state.currentDescribeBlock
+            const originalHasStarted = state.hasStarted
+            state.currentDescribeBlock = event.test.parent ?? originalDescribeBlock
+            state.hasStarted = false
+            this.retryTest({
+              jestEvent: {
+                testName: event.test.name,
+                fn: event.test.fn,
+                timeout: event.test.timeout,
+              },
+              retryCount,
+              retryType: 'Early flake detection',
+            })
+            state.currentDescribeBlock = originalDescribeBlock
+            state.hasStarted = originalHasStarted
+          } else {
+            efdSlowAbortedTests.add(testName)
+          }
+        }
+
         let isEfdRetry = false
         // We'll store the test statuses of the retries
-        const testName = getJestTestName(event.test, this.getShouldStripSeedFromTestName())
         if (this.isKnownTestsEnabled) {
           const isNewTest = retriedTestsToNumAttempts.has(testName)
           if (isNewTest) {
@@ -607,7 +665,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             const testStatuses = newTestsTestStatuses.get(testName)
             // Check if this is the last EFD retry.
             // If it is, we'll set the failedAllTests flag to true if all the tests failed
-            if (testStatuses.length === earlyFlakeDetectionNumRetries + 1 &&
+            const efdRetryCount = efdDeterminedRetries.get(testName) ?? 0
+            if (efdRetryCount > 0 && testStatuses.length === efdRetryCount + 1 &&
               testStatuses.every(status => status === 'fail')) {
               failedAllTests = true
             }
@@ -665,6 +724,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           attemptToFixFailed,
           isAtrRetry,
           finalStatus,
+          earlyFlakeAbortReason: efdSlowAbortedTests.has(testName) ? 'slow' : undefined,
         })
 
         if (promises.isProbeReady) {
@@ -676,6 +736,9 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           test.errors = errors
         }
         atrSuppressedErrors.clear()
+        efdDeterminedRetries.clear()
+        efdSlowAbortedTests.clear()
+        efdNewTestCandidates.clear()
       }
       if (event.name === 'test_skip' || event.name === 'test_todo') {
         const testName = getJestTestName(event.test, this.getShouldStripSeedFromTestName())
@@ -696,7 +759,9 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
     getEfdResult ({ testName, isNewTest, isModifiedTest, isEfdRetry, numberOfExecutedRetries }) {
       const isEfdEnabled = this.isEarlyFlakeDetectionEnabled
       const isEfdActive = isEfdEnabled && (isNewTest || isModifiedTest)
-      const isLastEfdRetry = isEfdRetry && numberOfExecutedRetries >= (earlyFlakeDetectionNumRetries + 1)
+      const retryCount = efdDeterminedRetries.get(testName) ?? 0
+      const isSlowAbort = efdSlowAbortedTests.has(testName)
+      const isLastEfdRetry = (isEfdRetry && numberOfExecutedRetries >= (retryCount + 1)) || isSlowAbort
       const isFinalEfdTestExecution = isEfdActive && isLastEfdRetry
 
       let finalStatus
@@ -931,8 +996,11 @@ function getCliWrapper (isNewJestVersion) {
         if (!err) {
           isCodeCoverageEnabled = libraryConfig.isCodeCoverageEnabled
           isSuitesSkippingEnabled = libraryConfig.isSuitesSkippingEnabled
+          isKeepingCoverageConfiguration =
+            libraryConfig.isKeepingCoverageConfiguration ?? isKeepingCoverageConfiguration
           isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
           earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
+          earlyFlakeDetectionSlowTestRetries = libraryConfig.earlyFlakeDetectionSlowTestRetries ?? {}
           earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
           isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
           isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
@@ -1263,9 +1331,10 @@ function coverageReporterWrapper (coverageReporter) {
    */
   // `_addUntestedFiles` is an async function
   shimmer.wrap(CoverageReporter.prototype, '_addUntestedFiles', addUntestedFiles => function () {
-    // If the user has added coverage manually, they're willing to pay the price of this execution, so
-    // we will not skip it.
-    if (isSuitesSkippingEnabled && !isUserCodeCoverageEnabled) {
+    if (isKeepingCoverageConfiguration) {
+      return addUntestedFiles.apply(this, arguments)
+    }
+    if (isCodeCoverageEnabledBecauseOfUs) {
       return Promise.resolve()
     }
     return addUntestedFiles.apply(this, arguments)
@@ -1445,12 +1514,13 @@ function configureTestEnvironment (readConfigsResult) {
   }
 
   isUserCodeCoverageEnabled = !!readConfigsResult.globalConfig.collectCoverage
+  isCodeCoverageEnabledBecauseOfUs = isCodeCoverageEnabled && !isUserCodeCoverageEnabled
 
   if (readConfigsResult.globalConfig.forceExit) {
     log.warn("Jest's '--forceExit' flag has been passed. This may cause loss of data.")
   }
 
-  if (isCodeCoverageEnabled) {
+  if (isCodeCoverageEnabledBecauseOfUs) {
     const globalConfig = {
       ...readConfigsResult.globalConfig,
       collectCoverage: true,
@@ -1458,14 +1528,18 @@ function configureTestEnvironment (readConfigsResult) {
     readConfigsResult.globalConfig = globalConfig
   }
   if (isSuitesSkippingEnabled) {
-    // If suite skipping is enabled, the code coverage results are not going to be relevant,
-    // so we do not show them.
-    // Also, we might skip every test, so we need to pass `passWithNoTests`
+    // If suite skipping is enabled, we pass `passWithNoTests` in case every test gets skipped.
     const globalConfig = {
       ...readConfigsResult.globalConfig,
-      coverageReporters: ['none'],
       passWithNoTests: true,
     }
+    if (isCodeCoverageEnabledBecauseOfUs && !isKeepingCoverageConfiguration) {
+      globalConfig.coverageReporters = ['none']
+      readConfigsResult.configs = configs.map(config => ({
+        ...config,
+        coverageReporters: ['none'],
+      }))
+    }
     readConfigsResult.globalConfig = globalConfig
   }
 
@@ -1488,49 +1562,97 @@ function jestConfigSyncWrapper (jestConfig) {
   })
 }
 
+const DD_TEST_ENVIRONMENT_OPTION_KEYS = [
+  '_ddTestModuleId',
+  '_ddTestSessionId',
+  '_ddTestCommand',
+  '_ddTestSessionName',
+  '_ddForcedToRun',
+  '_ddUnskippable',
+  '_ddItrCorrelationId',
+  '_ddKnownTests',
+  '_ddIsEarlyFlakeDetectionEnabled',
+  '_ddEarlyFlakeDetectionSlowTestRetries',
+  '_ddRepositoryRoot',
+  '_ddIsFlakyTestRetriesEnabled',
+  '_ddFlakyTestRetriesCount',
+  '_ddIsDiEnabled',
+  '_ddIsKnownTestsEnabled',
+  '_ddIsTestManagementTestsEnabled',
+  '_ddTestManagementTests',
+  '_ddTestManagementAttemptToFixRetries',
+  '_ddModifiedFiles',
+]
+
+function removeDatadogTestEnvironmentOptions (testEnvironmentOptions) {
+  const removedEntries = []
+
+  for (const key of DD_TEST_ENVIRONMENT_OPTION_KEYS) {
+    if (!Object.hasOwn(testEnvironmentOptions, key)) {
+      continue
+    }
+
+    removedEntries.push([key, testEnvironmentOptions[key]])
+    delete testEnvironmentOptions[key]
+  }
+
+  return function restoreDatadogTestEnvironmentOptions () {
+    for (const [key, value] of removedEntries) {
+      testEnvironmentOptions[key] = value
+    }
+  }
+}
+
+/**
+ * Wrap `createScriptTransformer` to temporarily hide Datadog-specific
+ * `testEnvironmentOptions` keys while Jest builds its transform config.
+ *
+ * @param {Function} createScriptTransformer
+ * @returns {Function}
+ */
+function wrapCreateScriptTransformer (createScriptTransformer) {
+  return function (config) {
+    const testEnvironmentOptions = config?.testEnvironmentOptions
+
+    if (!testEnvironmentOptions) {
+      return createScriptTransformer.apply(this, arguments)
+    }
+
+    const restoreTestEnvironmentOptions = removeDatadogTestEnvironmentOptions(testEnvironmentOptions)
+
+    try {
+      const result = createScriptTransformer.apply(this, arguments)
+
+      if (result?.then) {
+        return result.finally(restoreTestEnvironmentOptions)
+      }
+
+      restoreTestEnvironmentOptions()
+      return result
+    } catch (e) {
+      restoreTestEnvironmentOptions()
+      throw e
+    }
+  }
+}
+
 addHook({
   name: '@jest/transform',
-  versions: ['>=24.8.0'],
+  versions: ['>=24.8.0 <30.0.0'],
   file: 'build/ScriptTransformer.js',
 }, transformPackage => {
-  const originalCreateScriptTransformer = transformPackage.createScriptTransformer
-
-  // `createScriptTransformer` is an async function
-  transformPackage.createScriptTransformer = function (config) {
-    const { testEnvironmentOptions, ...restOfConfig } = config
-    const {
-      _ddTestModuleId,
-      _ddTestSessionId,
-      _ddTestCommand,
-      _ddTestSessionName,
-      _ddForcedToRun,
-      _ddUnskippable,
-      _ddItrCorrelationId,
-      _ddKnownTests,
-      _ddIsEarlyFlakeDetectionEnabled,
-      _ddEarlyFlakeDetectionNumRetries,
-      _ddRepositoryRoot,
-      _ddIsFlakyTestRetriesEnabled,
-      _ddFlakyTestRetriesCount,
-      _ddIsDiEnabled,
-      _ddIsKnownTestsEnabled,
-      _ddIsTestManagementTestsEnabled,
-      _ddTestManagementTests,
-      _ddTestManagementAttemptToFixRetries,
-      _ddModifiedFiles,
-      ...restOfTestEnvironmentOptions
-    } = testEnvironmentOptions
-
-    restOfConfig.testEnvironmentOptions = restOfTestEnvironmentOptions
-
-    arguments[0] = restOfConfig
-
-    return originalCreateScriptTransformer.apply(this, arguments)
-  }
+  transformPackage.createScriptTransformer = wrapCreateScriptTransformer(transformPackage.createScriptTransformer)
 
   return transformPackage
 })
 
+addHook({
+  name: '@jest/transform',
+  versions: ['>=30.0.0'],
+}, transformPackage => {
+  return shimmer.wrap(transformPackage, 'createScriptTransformer', wrapCreateScriptTransformer, { replaceGetter: true })
+})
+
 /**
  * Hook to remove the test paths (test suite) that are part of `skippableSuites`
  */

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

@@ -24,22 +24,6 @@ const batchConsumerErrorCh = channel('apm:kafkajs:consume-batch:error')
 
 const disabledHeaderWeakSet = new WeakSet()
 
-function commitsFromEvent (event) {
-  const { payload: { groupId, topics } } = event
-  const commitList = []
-  for (const { topic, partitions } of topics) {
-    for (const { partition, offset } of partitions) {
-      commitList.push({
-        groupId,
-        partition,
-        offset,
-        topic,
-      })
-    }
-  }
-  consumerCommitCh.publish(commitList)
-}
-
 addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKafka) => {
   class Kafka extends BaseKafka {
     constructor (options) {
@@ -132,6 +116,7 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
     }
 
     const kafkaClusterIdPromise = getKafkaClusterId(this)
+    let resolvedClusterId = null
 
     const eachMessageExtractor = (args, clusterId) => {
       const { topic, partition, message } = args[0]
@@ -146,13 +131,31 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
 
     const consumer = createConsumer.apply(this, arguments)
 
-    consumer.on(consumer.events.COMMIT_OFFSETS, commitsFromEvent)
+    consumer.on(consumer.events.COMMIT_OFFSETS, (event) => {
+      const { payload: { groupId: commitGroupId, topics } } = event
+      const commitList = []
+      for (const { topic, partitions } of topics) {
+        for (const { partition, offset } of partitions) {
+          commitList.push({
+            groupId: commitGroupId,
+            partition,
+            offset,
+            topic,
+            clusterId: resolvedClusterId,
+          })
+        }
+      }
+      consumerCommitCh.publish(commitList)
+    })
 
     const run = consumer.run
     const groupId = arguments[0].groupId
 
     consumer.run = function ({ eachMessage, eachBatch, ...runArgs }) {
       const wrapConsume = (clusterId) => {
+        // In kafkajs COMMIT_OFFSETS always happens in the context of one synchronous run
+        // So this will always reference a correct cluster id
+        resolvedClusterId = clusterId
         return run({
           eachMessage: wrappedCallback(
             eachMessage,

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

@@ -41,7 +41,7 @@ const testSuiteToTestStatuses = new Map()
 const testSuiteToErrors = new Map()
 const testsToTestStatuses = new Map()
 
-const RUM_FLUSH_WAIT_TIME = Number(getValueFromEnvSources('DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS')) || 1000
+const RUM_FLUSH_WAIT_TIME = Number(getValueFromEnvSources('DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS')) || 500
 
 let applyRepeatEachIndex = null
 

package/packages/datadog-plugin-amqplib/src/consumer.js

@@ -9,6 +9,19 @@ class AmqplibConsumerPlugin extends ConsumerPlugin {
   static id = 'amqplib'
   static operation = 'consume'
 
+  start (ctx) {
+    if (!this.config.dsmEnabled) return
+    const { fields = {}, message, queue } = ctx
+    if (!message?.properties?.headers) return
+
+    const { span } = ctx.currentStore
+    const queueName = queue || fields.queue || fields.routingKey
+    const payloadSize = getAmqpMessageSize({ headers: message.properties.headers, content: message.content })
+    this.tracer.decodeDataStreamsContext(message.properties.headers)
+    this.tracer
+      .setCheckpoint(['direction:in', `topic:${queueName}`, 'type:rabbitmq'], span, payloadSize)
+  }
+
   bindStart (ctx) {
     const { method, fields = {}, message, queue } = ctx
 
@@ -17,7 +30,7 @@ class AmqplibConsumerPlugin extends ConsumerPlugin {
     const childOf = extract(this.tracer, message)
 
     const queueName = queue || fields.queue || fields.routingKey
-    const span = this.startSpan({
+    this.startSpan({
       childOf,
       resource: getResourceName(method, fields),
       type: 'worker',
@@ -31,15 +44,6 @@ class AmqplibConsumerPlugin extends ConsumerPlugin {
       },
     }, ctx)
 
-    if (
-      this.config.dsmEnabled && message?.properties?.headers
-    ) {
-      const payloadSize = getAmqpMessageSize({ headers: message.properties.headers, content: message.content })
-      this.tracer.decodeDataStreamsContext(message.properties.headers)
-      this.tracer
-        .setCheckpoint(['direction:in', `topic:${queueName}`, 'type:rabbitmq'], span, payloadSize)
-    }
-
     return ctx.currentStore
   }
 }

package/packages/datadog-plugin-amqplib/src/producer.js

@@ -10,8 +10,30 @@ class AmqplibProducerPlugin extends ProducerPlugin {
   static id = 'amqplib'
   static operation = 'publish'
 
+  start (ctx) {
+    if (!this.config.dsmEnabled) return
+    const { fields, message } = ctx
+    const { span } = ctx.currentStore
+
+    const hasRoutingKey = fields.routingKey != null
+    const payloadSize = getAmqpMessageSize({ content: message, headers: fields.headers })
+
+    // there are two ways to send messages in RabbitMQ:
+    // 1. using an exchange and a routing key in which DSM connects via the exchange
+    // 2. using an unnamed exchange and a routing key in which DSM connects via the topic
+    const exchangeOrTopicTag = hasRoutingKey && !fields.exchange
+      ? `topic:${fields.routingKey}`
+      : `exchange:${fields.exchange}`
+
+    const dataStreamsContext = this.tracer.setCheckpoint(
+      ['direction:out', exchangeOrTopicTag, `has_routing_key:${hasRoutingKey}`, 'type:rabbitmq'],
+      span, payloadSize
+    )
+    DsmPathwayCodec.encode(dataStreamsContext, fields.headers)
+  }
+
   bindStart (ctx) {
-    const { channel = {}, method, fields, message } = ctx
+    const { channel = {}, method, fields } = ctx
 
     if (method !== 'basic.publish') return
 
@@ -34,24 +56,6 @@ class AmqplibProducerPlugin extends ProducerPlugin {
 
     this.tracer.inject(span, TEXT_MAP, fields.headers)
 
-    if (this.config.dsmEnabled) {
-      const hasRoutingKey = fields.routingKey != null
-      const payloadSize = getAmqpMessageSize({ content: message, headers: fields.headers })
-
-      // there are two ways to send messages in RabbitMQ:
-      // 1. using an exchange and a routing key in which DSM connects via the exchange
-      // 2. using an unnamed exchange and a routing key in which DSM connects via the topic
-      const exchangeOrTopicTag = hasRoutingKey && !fields.exchange
-        ? `topic:${fields.routingKey}`
-        : `exchange:${fields.exchange}`
-
-      const dataStreamsContext = this.tracer
-        .setCheckpoint(
-          ['direction:out', exchangeOrTopicTag, `has_routing_key:${hasRoutingKey}`, 'type:rabbitmq']
-          , span, payloadSize)
-      DsmPathwayCodec.encode(dataStreamsContext, fields.headers)
-    }
-
     return ctx.currentStore
   }
 }

package/packages/datadog-plugin-bullmq/src/consumer.js

@@ -11,17 +11,24 @@ class BullmqConsumerPlugin extends ConsumerPlugin {
     ctx.currentStore?.span?.finish()
   }
 
+  start (ctx) {
+    if (!this.config.dsmEnabled) return
+    const { span } = ctx.currentStore
+    this.setConsumerCheckpoint(span, ctx)
+  }
+
   bindStart (ctx) {
     const job = ctx.arguments?.[0]
     const queueName = job?.queueName || job?.queue?.name || 'bullmq'
 
     let childOf
-    const datadogContext = job?.data?._datadog
-    if (datadogContext) {
-      childOf = this.tracer.extract('text_map', datadogContext)
+    const ddCarrier = this._extractDatadog(job)
+    if (ddCarrier) {
+      ctx._ddCarrier = ddCarrier
+      childOf = this.tracer.extract('text_map', ddCarrier)
     }
 
-    const span = this.startSpan({
+    this.startSpan({
       childOf,
       resource: queueName,
       meta: {
@@ -33,10 +40,6 @@ class BullmqConsumerPlugin extends ConsumerPlugin {
       },
     }, ctx)
 
-    if (this.config.dsmEnabled) {
-      this.setConsumerCheckpoint(span, ctx)
-    }
-
     return ctx.currentStore
   }
 
@@ -47,14 +50,33 @@ class BullmqConsumerPlugin extends ConsumerPlugin {
     const queueName = job.queueName || job.queue?.name || 'bullmq'
     const payloadSize = job.data ? getMessageSize(job.data) : 0
 
-    const datadogContext = job.data?._datadog
-    if (datadogContext) {
-      this.tracer.decodeDataStreamsContext(datadogContext)
+    const ddCarrier = ctx._ddCarrier
+    if (ddCarrier) {
+      this.tracer.decodeDataStreamsContext(ddCarrier)
     }
 
     const edgeTags = ['direction:in', `topic:${queueName}`, 'type:bullmq']
     this.tracer.setCheckpoint(edgeTags, span, payloadSize)
   }
+
+  _extractDatadog (job) {
+    const metadataStr = job?.opts?.telemetry?.metadata
+    if (!metadataStr) return
+
+    try {
+      const metadata = JSON.parse(metadataStr)
+      const ddCarrier = metadata._datadog
+      if (!ddCarrier) return
+
+      // Clean up only our _datadog key, preserve other metadata
+      delete metadata._datadog
+      job.opts.telemetry.metadata = JSON.stringify(metadata)
+
+      return ddCarrier
+    } catch {
+      // Ignore malformed metadata
+    }
+  }
 }
 
 module.exports = BullmqConsumerPlugin