dd-trace 5.98.0 → 5.99.0

package/packages/datadog-instrumentations/src/helpers/callback-instrumentor.js

@@ -0,0 +1,74 @@
+'use strict'
+
+const shimmer = require('../../../datadog-shimmer')
+const { channel } = require('./instrument')
+
+/**
+ * Create a shimmer-compatible instrumentor for callback-style APIs whose work is offloaded to the
+ * libuv worker thread pool (e.g. zlib.gzip, crypto.pbkdf2, dns.lookup). Builds a set of three
+ * diagnostic channels at the given prefix (`<prefix>:start`, `:finish`, `:error`) and returns a
+ * factory that produces shimmer wrappers driven by a caller-supplied `buildContext` function.
+ *
+ * The returned wrapper:
+ *  - calls through unmodified when there are no subscribers or the last argument is not a callback;
+ *  - invokes `buildContext(thisArg, args)` to construct the context object; a return of `undefined`
+ *    also causes a bypass, letting callers enforce additional guards (e.g. minimum argument count);
+ *  - publishes `:start` via `runStores`, wraps the callback to publish `:error` (on truthy error),
+ *    optionally set `ctx.result` to the callback's first non-error argument, and publish `:finish`
+ *    via `runStores`; publishes `:error` if the original call throws synchronously.
+ *
+ * @param {string} prefix
+ * @param {object} [options]
+ * @param {boolean} [options.captureResult=false] set `ctx.result` to the callback's first
+ *   non-error argument before publishing `:finish`. Plugins that tag spans from the call's
+ *   return value (e.g. the DNS lookup plugin) rely on this.
+ * @returns {(buildContext: (thisArg: unknown, args: IArguments) => object | undefined) =>
+ *   (fn: Function) => Function}
+ */
+function createCallbackInstrumentor (prefix, { captureResult = false } = {}) {
+  const startCh = channel(prefix + ':start')
+  const finishCh = channel(prefix + ':finish')
+  const errorCh = channel(prefix + ':error')
+
+  return function instrument (buildContext) {
+    return function wrap (fn) {
+      return function () {
+        const lastIndex = arguments.length - 1
+        const cb = arguments[lastIndex]
+        if (!startCh.hasSubscribers || typeof cb !== 'function') {
+          return fn.apply(this, arguments)
+        }
+
+        const ctx = buildContext(this, arguments)
+        if (ctx === undefined) {
+          return fn.apply(this, arguments)
+        }
+
+        return startCh.runStores(ctx, () => {
+          arguments[lastIndex] = shimmer.wrapFunction(cb, cb => function (error, ...rest) {
+            if (error) {
+              ctx.error = error
+              errorCh.publish(ctx)
+            }
+            if (captureResult) {
+              ctx.result = rest[0]
+            }
+            return finishCh.runStores(ctx, cb, this, error, ...rest)
+          })
+
+          try {
+            return fn.apply(this, arguments)
+          } catch (error) {
+            void error.stack // trigger getting the stack at the original throwing point
+            ctx.error = error
+            errorCh.publish(ctx)
+
+            throw error
+          }
+        })
+      }
+    }
+  }
+}
+
+module.exports = { createCallbackInstrumentor }

package/packages/datadog-instrumentations/src/helpers/check-require-cache.js

@@ -97,7 +97,10 @@ module.exports.checkForPotentialConflicts = function () {
 }
 
 module.exports.flushStartupLogs = function (log) {
+  // Some callers pass `./log/writer` (simple pass-through) while others pass the main `./log`
+  // module (which supports lazy delegate functions). Invoke closures here so both work.
   while (warnings.length) {
-    log.warn(warnings.shift())
+    const entry = warnings.shift()
+    log.warn(typeof entry === 'function' ? entry() : entry)
   }
 }

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -12,11 +12,13 @@ module.exports = {
   net: () => require('../net'),
   url: () => require('../url'),
   vm: () => require('../vm'),
+  zlib: () => require('../zlib'),
   // Non Node.js modules
   '@anthropic-ai/sdk': { esmFirst: true, fn: () => require('../anthropic') },
   '@apollo/server': () => require('../apollo-server'),
   '@apollo/gateway': () => require('../apollo'),
   '@langchain/langgraph': { esmFirst: true, fn: () => require('../langgraph') },
+  '@modelcontextprotocol/sdk': () => require('../modelcontextprotocol-sdk'),
   'apollo-server-core': () => require('../apollo-server-core'),
   '@aws-sdk/smithy-client': () => require('../aws-sdk'),
   '@azure/event-hubs': () => require('../azure-event-hubs'),

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

@@ -1,5 +1,13 @@
 'use strict'
 
+/**
+ * This file is meant to be only thin wrappers over core
+ * parsing/traversing/generating functionality with the goal to eventually move
+ * them out of the project. No other code should be added to this file such as
+ * helpers etc, and the API should be kept exactly as an external API would be
+ * expected to be.
+ */
+
 const log = require('../../../../dd-trace/src/log')
 
 // eslint-disable-next-line camelcase, no-undef
@@ -24,14 +32,13 @@ const compiler = {
     } catch (e) {
       log.error(e)
 
-      // Fallback for when OXC is not available.
       const meriyah = require('../../../../../vendor/dist/meriyah')
 
-      compiler.parse = (sourceText, { range, sourceType } = {}) => {
+      compiler.parse = (sourceText, { range, isModule } = {}) => {
         return meriyah.parse(sourceText.toString(), {
           loc: range,
           ranges: range,
-          module: sourceType === 'module',
+          module: isModule,
         })
       }
     }

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

@@ -5,4 +5,5 @@ module.exports = [
   ...require('./bullmq'),
   ...require('./langchain'),
   ...require('./langgraph'),
+  ...require('./modelcontextprotocol-sdk'),
 ]

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/modelcontextprotocol-sdk.js

@@ -0,0 +1,59 @@
+'use strict'
+
+// NOTE: Protocol.request (dist/esm|cjs/shared/protocol.js) is intentionally not instrumented here.
+// It will be used for distributed tracing header injection when server-side coverage is added.
+
+module.exports = [
+  {
+    module: {
+      name: '@modelcontextprotocol/sdk',
+      versionRange: '>=1.27.1',
+      filePath: 'dist/esm/client/index.js',
+    },
+    functionQuery: {
+      methodName: 'callTool',
+      className: 'Client',
+      kind: 'Async',
+    },
+    channelName: 'Client_callTool',
+  },
+  {
+    module: {
+      name: '@modelcontextprotocol/sdk',
+      versionRange: '>=1.27.1',
+      filePath: 'dist/cjs/client/index.js',
+    },
+    functionQuery: {
+      methodName: 'callTool',
+      className: 'Client',
+      kind: 'Async',
+    },
+    channelName: 'Client_callTool',
+  },
+  {
+    module: {
+      name: '@modelcontextprotocol/sdk',
+      versionRange: '>=1.27.1',
+      filePath: 'dist/esm/client/index.js',
+    },
+    functionQuery: {
+      methodName: 'listTools',
+      className: 'Client',
+      kind: 'Async',
+    },
+    channelName: 'Client_listTools',
+  },
+  {
+    module: {
+      name: '@modelcontextprotocol/sdk',
+      versionRange: '>=1.27.1',
+      filePath: 'dist/cjs/client/index.js',
+    },
+    functionQuery: {
+      methodName: 'listTools',
+      className: 'Client',
+      kind: 'Async',
+    },
+    channelName: 'Client_listTools',
+  },
+]

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

@@ -14,11 +14,13 @@ const transforms = module.exports = {
     if (node.body.some(tracingChannelPredicate)) return
 
     const index = node.body.findIndex(child => child.directive === 'use strict')
-    const code = sourceType === 'module'
+    const code = isModuleSourceType(sourceType)
       ? `import { tracingChannel as tr_ch_apm_tracingChannel } from "${dcModule}"`
       : `const {tracingChannel: tr_ch_apm_tracingChannel} = require("${dcModule}")`
 
-    node.body.splice(index + 1, 0, parse(code, { sourceType }).body[0])
+    node.body.splice(index + 1, 0, parse(code, {
+      isModule: isModuleSourceType(sourceType),
+    }).body[0])
   },
 
   tracingChannelDeclaration (state, node) {
@@ -51,6 +53,13 @@ function traceAny (state, node, _parent, ancestry) {
   }
 }
 
+/**
+ * @param {string} sourceType
+ */
+function isModuleSourceType (sourceType) {
+  return sourceType === 'module' || sourceType === 'esm'
+}
+
 function traceFunction (state, node, program) {
   transforms.tracingChannelDeclaration(state, program)
 

package/packages/datadog-instrumentations/src/modelcontextprotocol-sdk.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const { addHook, getHooks } = require('./helpers/instrument')
+
+for (const hook of getHooks('@modelcontextprotocol/sdk')) {
+  addHook(hook, exports => exports)
+}

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

@@ -34,22 +34,6 @@ function wrapAsJson (asJson) {
   }
 }
 
-function wrapMixin (mixin) {
-  const ch = channel('apm:pino:log')
-  return function mixinWithTrace () {
-    let obj = {}
-
-    if (mixin) {
-      obj = mixin.apply(this, arguments)
-    }
-
-    const payload = { message: obj }
-    ch.publish(payload)
-
-    return payload.message
-  }
-}
-
 function wrapPrettifyObject (prettifyObject) {
   const ch = channel('apm:pino:log')
   return function prettifyObjectWithTrace (input) {
@@ -81,26 +65,18 @@ addHook({ name: 'pino', versions: ['2 - 3', '4'], patchDefault: true }, (pino) =
   return wrapped
 })
 
-addHook({ name: 'pino', versions: ['>=5 <5.14.0'], patchDefault: true }, (pino) => {
+addHook({ name: 'pino', versions: ['>=5 <6.8.0'], patchDefault: true }, (pino) => {
   const asJsonSym = ((pino.default || pino)?.symbols.asJsonSym) || 'asJson'
 
-  const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(asJsonSym, wrapAsJson, pino))
-
-  return wrapped
-})
-
-addHook({ name: 'pino', versions: ['>=5.14.0 <6.8.0'] }, (pino) => {
-  const mixinSym = (pino.default || pino).symbols.mixinSym
-
-  const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(mixinSym, wrapMixin, pino.default || pino))
+  const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(asJsonSym, wrapAsJson, pino.default || pino))
 
   return wrapped
 })
 
 addHook({ name: 'pino', versions: ['>=6.8.0'], patchDefault: false }, (pino) => {
-  const mixinSym = pino.symbols.mixinSym
+  const asJsonSym = pino.symbols.asJsonSym
 
-  const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(mixinSym, wrapMixin, pino))
+  const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(asJsonSym, wrapAsJson, pino))
   wrapped.pino = wrapped
   wrapped.default = wrapped
 

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

@@ -0,0 +1,27 @@
+'use strict'
+
+// Serialized into chromium via Playwright's `page.evaluate`. Excluded from coverage by filename.
+// Rename only if you update that glob too.
+
+/** @returns {{ isRumInstrumented: boolean, isRumActive: boolean, rumSamplingRate: number | null }} */
+function detectRum () {
+  const isRumInstrumented = !!window.DD_RUM
+  const isRumActive = window.DD_RUM && window.DD_RUM.getInternalContext
+    ? !!window.DD_RUM.getInternalContext()
+    : false
+  const rumSamplingRate = window.DD_RUM && window.DD_RUM.getInitConfiguration
+    ? window.DD_RUM.getInitConfiguration().sessionSampleRate
+    : null
+  return { isRumInstrumented, isRumActive, rumSamplingRate }
+}
+
+/** @returns {boolean} */
+function stopRumSession () {
+  if (window.DD_RUM && window.DD_RUM.stopSession) {
+    window.DD_RUM.stopSession()
+    return true
+  }
+  return false
+}
+
+module.exports = { detectRum, stopRumSession }

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

@@ -52,6 +52,9 @@ let applyRepeatEachIndex = null
 
 let startedSuites = []
 
+// Browser-side callbacks live in a coverage-excluded file so coverage counters can't reach chromium.
+const { detectRum, stopRumSession } = require('./playwright-browser-scripts')
+
 const STATUS_TO_TEST_STATUS = {
   passed: 'pass',
   failed: 'fail',
@@ -1117,16 +1120,7 @@ addHook({
 
     try {
       if (page) {
-        const { isRumInstrumented, isRumActive, rumSamplingRate } = await page.evaluate(() => {
-          const isRumInstrumented = !!window.DD_RUM
-          const isRumActive = window.DD_RUM && window.DD_RUM.getInternalContext
-            ? !!window.DD_RUM.getInternalContext()
-            : false
-          const rumSamplingRate = window.DD_RUM && window.DD_RUM.getInitConfiguration
-            ? window.DD_RUM.getInitConfiguration().sessionSampleRate
-            : null
-          return { isRumInstrumented, isRumActive, rumSamplingRate }
-        })
+        const { isRumInstrumented, isRumActive, rumSamplingRate } = await page.evaluate(detectRum)
         if (isRumInstrumented && rumSamplingRate < 100 && !isRumActive) {
           log.debug("RUM was detected on the page, but it isn't active because the sampling rate is below 100%")
         }
@@ -1209,13 +1203,7 @@ addHook({
           fn: async function ({ page }) {
             try {
               if (page) {
-                const isRumActive = await page.evaluate(() => {
-                  if (window.DD_RUM && window.DD_RUM.stopSession) {
-                    window.DD_RUM.stopSession()
-                    return true
-                  }
-                  return false
-                })
+                const isRumActive = await page.evaluate(stopRumSession)
 
                 if (isRumActive) {
                   // Give some time RUM to flush data, similar to what we do in selenium

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

@@ -58,35 +58,49 @@ function wrapConstructEventAsync (constructEventAsync) {
   }
 }
 
-function wrapStripe (Stripe) {
+function instrumentStripeInstance (stripe) {
+  if (typeof stripe.checkout?.sessions?.create === 'function') {
+    shimmer.wrap(stripe.checkout.sessions, 'create', wrapSessionCreate)
+  }
+  if (typeof stripe.paymentIntents?.create === 'function') {
+    shimmer.wrap(stripe.paymentIntents, 'create', wrapPaymentIntentCreate)
+  }
+  if (typeof stripe.webhooks?.constructEvent === 'function') {
+    shimmer.wrap(stripe.webhooks, 'constructEvent', wrapConstructEvent)
+  }
+  if (typeof stripe.webhooks?.constructEventAsync === 'function') {
+    shimmer.wrap(stripe.webhooks, 'constructEventAsync', wrapConstructEventAsync)
+  }
+}
+
+// stripe <22: the constructor mutates this (when invoked with 'new') and
+// returns nothing; without 'new' it delegates to 'new Stripe(...)' and returns
+// that result. We need to instrument whichever object actually got populated
+function wrapLegacyStripe (Stripe) {
   return function wrappedStripe () {
-    let stripe = Stripe.apply(this, arguments)
-
-    // to support both with and without "new" operator syntax
-    if (this instanceof Stripe) {
-      stripe = this
-    }
-
-    if (typeof stripe.checkout?.sessions?.create === 'function') {
-      shimmer.wrap(stripe.checkout.sessions, 'create', wrapSessionCreate)
-    }
-    if (typeof stripe.paymentIntents?.create === 'function') {
-      shimmer.wrap(stripe.paymentIntents, 'create', wrapPaymentIntentCreate)
-    }
-    if (typeof stripe.webhooks?.constructEvent === 'function') {
-      shimmer.wrap(stripe.webhooks, 'constructEvent', wrapConstructEvent)
-    }
-    if (typeof stripe.webhooks?.constructEventAsync === 'function') {
-      shimmer.wrap(stripe.webhooks, 'constructEventAsync', wrapConstructEventAsync)
-    }
+    const result = Stripe.apply(this, arguments)
+    const stripe = this instanceof Stripe ? this : result
+    instrumentStripeInstance(stripe)
+    return stripe
+  }
+}
 
+// stripe >=22: the constructor is a factory that always returns a fresh Stripe
+// instance regardless of 'new', so we just instrument and forward the result
+function wrapStripe (Stripe) {
+  return function wrappedStripe () {
+    const stripe = Stripe.apply(this, arguments)
+    instrumentStripeInstance(stripe)
     return stripe
   }
 }
 
 addHook({
   name: 'stripe',
-  versions: ['9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '>=20.0.0'],
-}, Stripe => {
-  return shimmer.wrapFunction(Stripe, wrapStripe)
-})
+  versions: ['9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '>=20.0.0 <22'],
+}, Stripe => shimmer.wrapFunction(Stripe, wrapLegacyStripe))
+
+addHook({
+  name: 'stripe',
+  versions: ['>=22'],
+}, Stripe => shimmer.wrapFunction(Stripe, wrapStripe))

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

@@ -866,6 +866,9 @@ function wrapVitestTestRunner (VitestTestRunner) {
       } else {
         testPassCh.publish({ task, ...ctx.currentStore })
       }
+      if (shouldFlipStatus) {
+        task.result.state = 'pass'
+      }
     }
 
     const isRetryReasonAtr = numAttempt > 0 &&
@@ -1174,7 +1177,12 @@ addHook({
           })
         } else if (state === 'pass' && !isSwitchedStatus) {
           if (testCtx) {
-            testPassCh.publish({ task, ...testCtx.currentStore })
+            testPassCh.publish({
+              task,
+              finalStatus:
+                disabledTasks.has(task) || quarantinedTasks.has(task) ? 'skip' : 'pass',
+              ...testCtx.currentStore,
+            })
           }
         } else if (state === 'fail' || isSwitchedStatus) {
           let testError
@@ -1197,7 +1205,9 @@ addHook({
 
           // Check if all EFD retries failed
           const providedContext = getProvidedContext()
-          if (providedContext.isEarlyFlakeDetectionEnabled && (newTasks.has(task) || modifiedTasks.has(task))) {
+          const isEfdRetry =
+            providedContext.isEarlyFlakeDetectionEnabled && (newTasks.has(task) || modifiedTasks.has(task))
+          if (isEfdRetry) {
             const statuses = taskToStatuses.get(task)
             // statuses only includes repetitions (not the initial run), so we check against numRepeats (not +1)
             if (statuses && statuses.length === providedContext.numRepeats &&
@@ -1207,8 +1217,9 @@ addHook({
           }
 
           // ATR: set hasFailedAllRetries when all auto test retries were exhausted and every attempt failed
-          if (providedContext.isFlakyTestRetriesEnabled && !attemptToFixTasks.has(task) &&
-            !newTasks.has(task) && !modifiedTasks.has(task)) {
+          const isAtrRetry = providedContext.isFlakyTestRetriesEnabled && !attemptToFixTasks.has(task) &&
+            !newTasks.has(task) && !modifiedTasks.has(task)
+          if (isAtrRetry) {
             const maxRetries = providedContext.flakyTestRetriesCount ?? 0
             if (maxRetries > 0 && task.result?.retryCount === maxRetries) {
               hasFailedAllRetries = true
@@ -1218,11 +1229,28 @@ addHook({
           if (testCtx) {
             const isRetry = task.result?.retryCount > 0
             // `duration` is the duration of all the retries, so it can't be used if there are retries
+
+            let finalStatus
+            if (isSwitchedStatus) {
+              if (disabledTasks.has(task) || quarantinedTasks.has(task)) {
+                finalStatus = 'skip'
+              } else if (isAtrRetry || isEfdRetry) {
+                finalStatus = hasFailedAllRetries ? 'fail' : 'pass'
+              } else if (attemptToFixTasks.has(task)) {
+                finalStatus = attemptToFixFailed ? 'fail' : 'pass'
+              } else {
+                finalStatus = undefined
+              }
+            } else {
+              finalStatus = 'fail'
+            }
+
             testErrorCh.publish({
               duration: isRetry ? undefined : duration,
               error: testError,
               hasFailedAllRetries,
               attemptToFixFailed,
+              finalStatus,
               ...testCtx.currentStore,
             })
           }

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

@@ -0,0 +1,29 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook } = require('./helpers/instrument')
+const { createCallbackInstrumentor } = require('./helpers/callback-instrumentor')
+
+const asyncMethods = [
+  'brotliCompress',
+  'brotliDecompress',
+  'deflate',
+  'deflateRaw',
+  'gunzip',
+  'gzip',
+  'inflate',
+  'inflateRaw',
+  'unzip',
+  'zstdCompress', // Node 22.15+ / 23.8+ / 24+
+  'zstdDecompress', // Node 22.15+ / 23.8+ / 24+
+]
+
+addHook({ name: 'zlib' }, zlib => {
+  const instrument = createCallbackInstrumentor('apm:zlib:operation')
+  for (const method of asyncMethods) {
+    if (typeof zlib[method] === 'function') {
+      shimmer.wrap(zlib, method, instrument(() => ({ operation: method })))
+    }
+  }
+  return zlib
+})

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

@@ -197,8 +197,7 @@ class BaseAwsSdkPlugin extends ClientPlugin {
 
   isEnabled (request) {
     const serviceId = this.serviceIdentifier.toUpperCase()
-    const envVarValue = getValueFromEnvSources(`DD_TRACE_AWS_SDK_${serviceId}_ENABLED`)
-    return envVarValue ? isTrue(envVarValue) : true
+    return this._tracerConfig[`DD_TRACE_AWS_SDK_${serviceId}_ENABLED`] ?? true
   }
 
   addResponseTags (span, response) {

package/packages/datadog-plugin-azure-event-hubs/src/producer.js

@@ -1,6 +1,5 @@
 'use strict'
 
-const { getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
 const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
 
 const spanContexts = new WeakMap()
@@ -11,8 +10,9 @@ class AzureEventHubsProducerPlugin extends ProducerPlugin {
   static get prefix () { return 'tracing:apm:azure-event-hubs:send' }
 
   bindStart (ctx) {
+    const batchLinksEnabled = this._tracerConfig.DD_TRACE_AZURE_EVENTHUBS_BATCH_LINKS_ENABLED
     // we do not want to make these spans when batch linking is disabled.
-    if (!batchLinksAreEnabled() && ctx.functionName === 'tryAdd') {
+    if (!batchLinksEnabled && ctx.functionName === 'tryAdd') {
       return ctx.currentStore
     }
 
@@ -37,7 +37,7 @@ class AzureEventHubsProducerPlugin extends ProducerPlugin {
         span.setTag('message.id', ctx.eventData.messageID)
       }
 
-      if (batchLinksAreEnabled()) {
+      if (batchLinksEnabled) {
         const spanContext = spanContexts.get(ctx.batch)
         if (spanContext) {
           spanContext.push(span.context())
@@ -58,13 +58,11 @@ class AzureEventHubsProducerPlugin extends ProducerPlugin {
         for (const event of eventData) {
           injectTraceContext(this.tracer, span, event)
         }
-      } else {
-        if (batchLinksAreEnabled()) {
-          const contexts = spanContexts.get(eventData)
-          if (contexts) {
-            for (const spanContext of contexts) {
-              span.addLink(spanContext)
-            }
+      } else if (batchLinksEnabled) {
+        const contexts = spanContexts.get(eventData)
+        if (contexts) {
+          for (const spanContext of contexts) {
+            span.addLink(spanContext)
           }
         }
       }
@@ -88,9 +86,4 @@ function injectTraceContext (tracer, span, event) {
   tracer.inject(span, 'text_map', event.properties)
 }
 
-function batchLinksAreEnabled () {
-  const eh = getValueFromEnvSources('DD_TRACE_AZURE_EVENTHUBS_BATCH_LINKS_ENABLED')
-  return eh !== 'false'
-}
-
 module.exports = AzureEventHubsProducerPlugin

package/packages/datadog-plugin-azure-service-bus/src/producer.js

@@ -1,6 +1,5 @@
 'use strict'
 
-const { getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
 const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
 const spanContexts = new WeakMap()
 
@@ -10,8 +9,9 @@ class AzureServiceBusProducerPlugin extends ProducerPlugin {
   static get prefix () { return 'tracing:apm:azure-service-bus:send' }
 
   bindStart (ctx) {
+    const batchLinksEnabled = this._tracerConfig.DD_TRACE_AZURE_SERVICEBUS_BATCH_LINKS_ENABLED
     // we do not want to make these spans when batch linking is disabled.
-    if (!batchLinksAreEnabled() && ctx.functionName === 'tryAddMessage') {
+    if (!batchLinksEnabled && ctx.functionName === 'tryAddMessage') {
       return ctx.currentStore
     }
 
@@ -36,7 +36,7 @@ class AzureServiceBusProducerPlugin extends ProducerPlugin {
         span.setTag('message.id', ctx.msg)
       }
 
-      if (batchLinksAreEnabled()) {
+      if (batchLinksEnabled) {
         const spanContext = spanContexts.get(ctx.batch)
         if (spanContext) {
           spanContext.push(span.context())
@@ -52,7 +52,7 @@ class AzureServiceBusProducerPlugin extends ProducerPlugin {
       const isBatch = messages.constructor?.name === 'ServiceBusMessageBatchImpl'
       if (isBatch) {
         span.setTag('messaging.batch.message_count', messages.count)
-        if (batchLinksAreEnabled()) {
+        if (batchLinksEnabled) {
           const contexts = spanContexts.get(messages)
           if (contexts) {
             for (const spanContext of contexts) {
@@ -89,9 +89,4 @@ function injectTraceContext (tracer, span, msg) {
   tracer.inject(span, 'text_map', msg.applicationProperties)
 }
 
-function batchLinksAreEnabled () {
-  const sb = getValueFromEnvSources('DD_TRACE_AZURE_SERVICEBUS_BATCH_LINKS_ENABLED')
-  return sb !== 'false'
-}
-
 module.exports = AzureServiceBusProducerPlugin