dd-trace 5.87.0 → 5.88.0

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

@@ -0,0 +1,21 @@
+'use strict'
+
+const transforms = require('./transforms')
+
+function transform (state, ...args) {
+  const operator = state.operator = getOperator(state)
+
+  transforms[operator](state, ...args)
+}
+
+function getOperator ({ functionQuery: { kind } }) {
+  switch (kind) {
+    case 'Async': return 'tracePromise'
+    case 'AsyncIterator': return 'traceAsyncIterator'
+    case 'Callback': return 'traceCallback'
+    case 'Iterator': return 'traceIterator'
+    case 'Sync': return 'traceSync'
+  }
+}
+
+module.exports = { transform }

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const { parse, query } = require('./compiler')
+const { parse, query, traverse } = require('./compiler')
 
 const tracingChannelPredicate = (node) => (
   node.specifiers?.[0]?.local?.name === 'tr_ch_apm_tracingChannel' ||
@@ -8,15 +8,15 @@ const tracingChannelPredicate = (node) => (
 )
 
 const transforms = module.exports = {
-  tracingChannelImport ({ format }, node) {
+  tracingChannelImport ({ sourceType }, node) {
     if (node.body.some(tracingChannelPredicate)) return
 
     const index = node.body.findIndex(child => child.directive === 'use strict')
-    const code = format === 'module'
+    const code = sourceType === 'module'
       ? 'import { tracingChannel as tr_ch_apm_tracingChannel } from "diagnostics_channel"'
       : 'const {tracingChannel: tr_ch_apm_tracingChannel} = require("diagnostics_channel")'
 
-    node.body.splice(index + 1, 0, parse(code, { module: format === 'module' }).body[0])
+    node.body.splice(index + 1, 0, parse(code, { sourceType }).body[0])
   },
 
   tracingChannelDeclaration (state, node) {
@@ -35,7 +35,9 @@ const transforms = module.exports = {
     node.body.splice(index + 1, 0, parse(code).body[0])
   },
 
+  traceAsyncIterator: traceAny,
   traceCallback: traceAny,
+  traceIterator: traceAny,
   tracePromise: traceAny,
   traceSync: traceAny,
 }
@@ -51,18 +53,25 @@ function traceAny (state, node, _parent, ancestry) {
 }
 
 function traceFunction (state, node, program) {
-  const { operator } = state
-
   transforms.tracingChannelDeclaration(state, program)
 
   node.body = wrap(state, {
-    type: 'ArrowFunctionExpression',
+    type: 'FunctionExpression',
     params: node.params,
     body: node.body,
-    async: operator === 'tracePromise',
+    async: node.async,
     expression: false,
-    generator: false,
-  })
+    generator: node.generator,
+  }, program)
+
+  // The original function no longer contains any calls to `await` or `yield` as
+  // the function body is copied to the internal wrapped function, so we set
+  // these to false to avoid altering the return value of the wrapper. The old
+  // values are instead copied to the new AST node above.
+  node.generator = false
+  node.async = false
+
+  wrapSuper(state, node)
 }
 
 function traceInstanceMethod (state, node, program) {
@@ -100,15 +109,19 @@ function traceInstanceMethod (state, node, program) {
   const fn = ctorBody[1].expression.right
 
   fn.async = operator === 'tracePromise'
-  fn.body = wrap(state, { type: 'Identifier', name: `__apm$${methodName}` })
+  fn.body = wrap(state, { type: 'Identifier', name: `__apm$${methodName}` }, program)
+
+  wrapSuper(state, fn)
 
   ctor.value.body.body.push(...ctorBody)
 }
 
-function wrap (state, node) {
+function wrap (state, node, program) {
   const { channelName, operator } = state
 
+  if (operator === 'traceAsyncIterator') return wrapIterator(state, node, program)
   if (operator === 'traceCallback') return wrapCallback(state, node)
+  if (operator === 'traceIterator') return wrapIterator(state, node, program)
 
   const async = operator === 'tracePromise' ? 'async' : ''
   const channelVariable = 'tr_ch_apm$' + channelName.replaceAll(':', '_')
@@ -133,6 +146,55 @@ function wrap (state, node) {
   return wrapper
 }
 
+function wrapSuper (_state, node) {
+  const members = new Set()
+
+  traverse(
+    node.body,
+    '[object.type=Super]',
+    (node, parent) => {
+      const { name } = node.property
+
+      let child
+
+      if (parent.callee) {
+        // This is needed because for generator functions we have to move the
+        // original function to a nested wrapped function, but we can't use an
+        // arrow function because arrow function cannot be generator functions,
+        // and `super` cannot be called from a nested function, so we have to
+        // rewrite any `super` call to not use the keyword.
+        const { expression } = parse(`__apm$super['${name}'].call(this)`).body[0]
+
+        parent.callee = child = expression.callee
+        parent.arguments.unshift(...expression.arguments)
+      } else {
+        parent.expression = child = parse(`__apm$super['${name}']`).body[0]
+      }
+
+      child.computed = parent.callee.computed
+      child.optional = parent.callee.optional
+
+      members.add(name)
+    }
+  )
+
+  for (const name of members) {
+    const member = parse(`
+      class Wrapper {
+        wrapper () {
+          __apm$super['${name}'] = super['${name}']
+        }
+      }
+    `).body[0].body.body[0].value.body.body[0]
+
+    node.body.body.unshift(member)
+  }
+
+  if (members.size > 0) {
+    node.body.body.unshift(parse('const __apm$super = {}').body[0])
+  }
+}
+
 function wrapCallback (state, node) {
   const { channelName, functionQuery: { index = -1 } } = state
   const channelVariable = 'tr_ch_apm$' + channelName.replaceAll(':', '_')
@@ -194,3 +256,67 @@ function wrapCallback (state, node) {
 
   return wrapper
 }
+
+function wrapIterator (state, node, program) {
+  const { channelName, operator } = state
+  const baseChannel = channelName.replaceAll(':', '_')
+  const channelVariable = 'tr_ch_apm$' + baseChannel
+  const nextChannel = baseChannel + '_next'
+  const traceMethod = operator === 'traceAsyncIterator' ? 'tracePromise' : 'traceSync'
+  const traceNext = `tr_ch_apm$${nextChannel}.${traceMethod}`
+
+  transforms.tracingChannelDeclaration({ ...state, channelName: nextChannel }, program)
+
+  const wrapper = parse(`
+    function wrapper () {
+      const __apm$traced = () => {
+        const __apm$wrapped = () => {};
+        return __apm$wrapped.apply(this, arguments);
+      };
+
+      if (!${channelVariable}.start.hasSubscribers) return __apm$traced();
+
+      {
+        const wrap = iter => {
+          const { next: iterNext, return: iterReturn, throw: iterThrow } = iter;
+
+          iter.next = (...args) => ${traceNext}(iterNext, ctx, iter, ...args);
+          iter.return = (...args) => ${traceNext}(iterReturn, ctx, iter, ...args);
+          iter.throw = (...args) => ${traceNext}(iterThrow, ctx, iter, ...args);
+
+          return iter;
+        };
+        const ctx = {
+          arguments,
+          self: this,
+          moduleVersion: "1.0.0"
+        };
+        const iter = ${channelVariable}.traceSync(__apm$traced, ctx);
+
+        if (typeof iter.then !== 'function') return wrap(iter);
+
+        return iter.then(result => {
+          ctx.result = result;
+
+          ${channelVariable}.asyncStart.publish(ctx);
+          ${channelVariable}.asyncEnd.publish(ctx);
+
+          return wrap(result);
+        }, err => {
+          ctx.error = err;
+
+          ${channelVariable}.error.publish(ctx);
+          ${channelVariable}.asyncStart.publish(ctx);
+          ${channelVariable}.asyncEnd.publish(ctx);
+
+          return Promise.reject(err);
+        });
+      };
+    }
+  `).body[0].body // Extract only block statement of function body.
+
+  // Replace the right-hand side assignment of `const __apm$wrapped = () => {}`.
+  query(wrapper, '[id.name=__apm$wrapped]')[0].init = node
+
+  return wrapper
+}

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')
 
@@ -76,6 +77,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 +97,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 +205,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 +474,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 +551,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 +578,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 +604,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 +663,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 +722,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           attemptToFixFailed,
           isAtrRetry,
           finalStatus,
+          earlyFlakeAbortReason: efdSlowAbortedTests.has(testName) ? 'slow' : undefined,
         })
 
         if (promises.isProbeReady) {
@@ -676,6 +734,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 +757,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
@@ -933,6 +996,7 @@ function getCliWrapper (isNewJestVersion) {
           isSuitesSkippingEnabled = libraryConfig.isSuitesSkippingEnabled
           isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
           earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
+          earlyFlakeDetectionSlowTestRetries = libraryConfig.earlyFlakeDetectionSlowTestRetries ?? {}
           earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
           isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
           isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
@@ -1508,7 +1572,7 @@ addHook({
       _ddItrCorrelationId,
       _ddKnownTests,
       _ddIsEarlyFlakeDetectionEnabled,
-      _ddEarlyFlakeDetectionNumRetries,
+      _ddEarlyFlakeDetectionSlowTestRetries,
       _ddRepositoryRoot,
       _ddIsFlakyTestRetriesEnabled,
       _ddFlakyTestRetriesCount,

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