dd-trace 5.104.0 → 5.106.0

package/packages/dd-trace/src/plugins/index.js

@@ -4,6 +4,7 @@ const plugins = {
   get '@anthropic-ai/sdk' () { return require('../../../datadog-plugin-anthropic/src') },
   get '@apollo/gateway' () { return require('../../../datadog-plugin-apollo/src') },
   get '@aws-sdk/smithy-client' () { return require('../../../datadog-plugin-aws-sdk/src') },
+  get '@azure/cosmos' () { return require('../../../datadog-plugin-azure-cosmos/src') },
   get '@azure/event-hubs' () { return require('../../../datadog-plugin-azure-event-hubs/src') },
   get '@azure/functions' () { return require('../../../datadog-plugin-azure-functions/src') },
   get '@modelcontextprotocol/sdk' () { return require('../../../datadog-plugin-modelcontextprotocol-sdk/src') },
@@ -30,6 +31,7 @@ const plugins = {
   get '@prisma/client' () { return require('../../../datadog-plugin-prisma/src') },
   get './runtime/library.js' () { return require('../../../datadog-plugin-prisma/src') },
   get '@redis/client' () { return require('../../../datadog-plugin-redis/src') },
+  get '@smithy/core' () { return require('../../../datadog-plugin-aws-sdk/src') },
   get '@smithy/smithy-client' () { return require('../../../datadog-plugin-aws-sdk/src') },
   get '@vitest/runner' () { return require('../../../datadog-plugin-vitest/src') },
   get '@langchain/langgraph' () { return require('../../../datadog-plugin-langgraph/src') },
@@ -90,6 +92,8 @@ const plugins = {
   get mongoose () { return require('../../../datadog-plugin-mongoose/src') },
   get mysql () { return require('../../../datadog-plugin-mysql/src') },
   get mysql2 () { return require('../../../datadog-plugin-mysql2/src') },
+  get '@nats-io/nats-core' () { return require('../../../datadog-plugin-nats/src') },
+  get '@nats-io/transport-node' () { return require('../../../datadog-plugin-nats/src') },
   get net () { return require('../../../datadog-plugin-net/src') },
   get next () { return require('../../../datadog-plugin-next/src') },
   get 'node:dns' () { return require('../../../datadog-plugin-dns/src') },

package/packages/dd-trace/src/plugins/log_injection.js

@@ -0,0 +1,56 @@
+'use strict'
+
+const { LOG } = require('../../../../ext/formats')
+const { storage } = require('../../../datadog-core')
+
+const legacyStorage = storage('legacy')
+
+/**
+ * Runs the tracer's log injector and returns the populated log holder, or
+ * `undefined` when the propagator emitted no `dd` field (no span, no
+ * service / version / env). Hot-path callers gate on the return.
+ *
+ * @param {object} tracer
+ * @returns {{ dd: object } | undefined}
+ */
+function buildLogHolder (tracer) {
+  const logHolder = {}
+  tracer.inject(legacyStorage.getStore()?.span, LOG, logHolder)
+  return logHolder.dd ? logHolder : undefined
+}
+
+/**
+ * @param {object} message Caller-owned log record; never mutated.
+ * @param {{ dd: object }} logHolder Holds the dd fields injected by the tracer.
+ */
+function messageProxy (message, logHolder) {
+  return new Proxy(message, {
+    get (target, key) {
+      if (shouldOverride(target, key)) return logHolder.dd
+      return target[key]
+    },
+    set (target, key, value) {
+      return Reflect.set(target, key, value)
+    },
+    ownKeys (target) {
+      const ownKeys = Reflect.ownKeys(target)
+      if (!Object.hasOwn(target, 'dd') && Reflect.isExtensible(target)) {
+        ownKeys.push('dd')
+      }
+      return ownKeys
+    },
+    getOwnPropertyDescriptor (target, p) {
+      return Reflect.getOwnPropertyDescriptor(shouldOverride(target, p) ? logHolder : target, p)
+    },
+  })
+}
+
+/**
+ * @param {object} target
+ * @param {string | symbol} p
+ */
+function shouldOverride (target, p) {
+  return p === 'dd' && !Object.hasOwn(target, p) && Reflect.isExtensible(target)
+}
+
+module.exports = { buildLogHolder, messageProxy }

package/packages/dd-trace/src/plugins/log_plugin.js

@@ -1,55 +1,8 @@
 'use strict'
 
-const { LOG } = require('../../../../ext/formats')
-const { storage } = require('../../../datadog-core')
 const Plugin = require('./plugin')
 
-const legacyStorage = storage('legacy')
-
-function messageProxy (message, holder) {
-  return new Proxy(message, {
-    get (target, key) {
-      if (shouldOverride(target, key)) {
-        return holder.dd
-      }
-
-      return target[key]
-    },
-    set (target, key, value) {
-      return Reflect.set(target, key, value)
-    },
-    ownKeys (target) {
-      const ownKeys = Reflect.ownKeys(target)
-      if (!Object.hasOwn(target, 'dd') && Reflect.isExtensible(target)) {
-        ownKeys.push('dd')
-      }
-      return ownKeys
-    },
-    getOwnPropertyDescriptor (target, p) {
-      return Reflect.getOwnPropertyDescriptor(shouldOverride(target, p) ? holder : target, p)
-    },
-  })
-}
-
-function shouldOverride (target, p) {
-  return p === 'dd' && !Object.hasOwn(target, p) && Reflect.isExtensible(target)
-}
-
-module.exports = class LogPlugin extends Plugin {
-  constructor (...args) {
-    super(...args)
-
-    this.addSub(`apm:${this.constructor.id}:log`, (arg) => {
-      const span = legacyStorage.getStore()?.span
-
-      // NOTE: This needs to run whether or not there is a span
-      // so service, version, and env will always get injected.
-      const holder = {}
-      this.tracer.inject(span, LOG, holder)
-      arg.message = messageProxy(arg.message, holder)
-    })
-  }
-
+class LogPlugin extends Plugin {
   configure (config) {
     return super.configure({
       ...config,
@@ -57,3 +10,5 @@ module.exports = class LogPlugin extends Plugin {
     })
   }
 }
+
+module.exports = LogPlugin

package/packages/dd-trace/src/plugins/outbound.js

@@ -125,7 +125,7 @@ class OutboundPlugin extends TracingPlugin {
    */
   tagPeerService (span) {
     if (this._tracerConfig.spanComputePeerService) {
-      const peerData = this.getPeerService(span.context()._tags)
+      const peerData = this.getPeerService(span.context().getTags())
       if (peerData !== undefined) {
         span.addTags(this.getPeerServiceRemap(peerData))
       }

package/packages/dd-trace/src/plugins/plugin.js

@@ -6,6 +6,8 @@ const dc = require('dc-polyfill')
 const logger = require('../log')
 const { storage } = require('../../../datadog-core')
 
+const legacyStorage = storage('legacy')
+
 /**
  * Base class for all Datadog plugins.
  *
@@ -28,8 +30,7 @@ class Subscription {
   constructor (event, handler) {
     this._channel = dc.channel(event)
     this._handler = (message, name) => {
-      const store = storage('legacy').getStore()
-      if (!store || !store.noop) {
+      if (!legacyStorage.getHandle()?.noop) {
         handler(message, name)
       }
     }
@@ -50,20 +51,20 @@ class StoreBinding {
   constructor (event, transform) {
     this._channel = dc.channel(event)
     this._transform = data => {
-      const store = storage('legacy').getStore()
+      const handle = legacyStorage.getHandle()
 
-      return !store || !store.noop || (data && Object.hasOwn(data, 'currentStore'))
+      return !handle?.noop || (data && Object.hasOwn(data, 'currentStore'))
         ? transform(data)
-        : store
+        : legacyStorage.getStore()
     }
   }
 
   enable () {
-    this._channel.bindStore(storage('legacy'), this._transform)
+    this._channel.bindStore(legacyStorage, this._transform)
   }
 
   disable () {
-    this._channel.unbindStore(storage('legacy'))
+    this._channel.unbindStore(legacyStorage)
   }
 }
 
@@ -102,24 +103,21 @@ module.exports = class Plugin {
    * @returns {void}
    */
   enter (span, store) {
-    store = store || storage('legacy').getStore()
-    storage('legacy').enterWith({ ...store, span })
+    store = store || legacyStorage.getStore()
+    legacyStorage.enterWith({ ...store, span })
   }
 
   /**
    * Subscribe to a diagnostic channel with automatic error handling and enable/disable lifecycle.
    *
    * @param {string} channelName Diagnostic channel name.
-   * @param {(...args: unknown[]) => unknown} handler Handler invoked on messages.
+   * @param {(message: unknown, name: string) => unknown} handler Handler invoked on messages.
    * @returns {void}
    */
   addSub (channelName, handler) {
-    /**
-     * @type {typeof handler}
-     */
-    const wrappedHandler = (...args) => {
+    const wrappedHandler = (message, name) => {
       try {
-        return handler.apply(this, args)
+        return handler.call(this, message, name)
       } catch (error) {
         logger.error('Error in plugin handler:', error)
         logger.info('Disabling plugin: %s', this.constructor.name)
@@ -147,12 +145,12 @@ module.exports = class Plugin {
    * @returns {void}
    */
   addError (error) {
-    const store = storage('legacy').getStore()
+    const store = legacyStorage.getStore()
 
     if (!store || !store.span) return
 
     const span = /** @type {import('../opentracing/span')} */ (store.span)
-    if (!span._spanContext._tags.error) {
+    if (!span.context().getTag('error')) {
       span.setTag('error', error || 1)
     }
   }

package/packages/dd-trace/src/plugins/tracing.js

@@ -3,6 +3,7 @@
 const { storage } = require('../../../datadog-core')
 const analyticsSampler = require('../analytics_sampler')
 const { COMPONENT, SVC_SRC_KEY } = require('../constants')
+const { INTEGRATION_SERVICE } = require('../service-naming/source-resolver')
 const Plugin = require('./plugin')
 
 const legacyStorage = storage('legacy')
@@ -99,13 +100,11 @@ class TracingPlugin extends Plugin {
       const bindName = `bind${event.charAt(0).toUpperCase()}${event.slice(1)}`
 
       if (this[event]) {
-        this.addTraceSub(event, message => {
-          this[event](message)
-        })
+        this.addTraceSub(event, this[event].bind(this))
       }
 
       if (this[bindName]) {
-        this.addTraceBind(event, message => this[bindName](message))
+        this.addTraceBind(event, this[bindName].bind(this))
       }
     }
   }
@@ -128,12 +127,49 @@ class TracingPlugin extends Plugin {
     this.addBind(`${prefix}:${eventName}`, transform)
   }
 
+  /**
+   * Record the integration's intended `service.name` on a span without writing the tag.
+   *
+   * Use this when the plugin has already set `service.name` directly on the span (e.g. via
+   * the `tracer.startSpan` tags object) and only needs to stamp the marker so
+   * `Span#finish` can later detect user overrides and re-attribute the source.
+   *
+   * Prefer {@link TracingPlugin#setServiceName} when the tag itself also needs to be written.
+   *
+   * No-op when there is nothing meaningful to record
+   *
+   * @param {import('../opentracing/span')} span Internal DatadogSpan instance.
+   * @param {string|undefined} name Service name the integration is claiming.
+   */
+  stampIntegrationService (span, name) {
+    if (name === undefined) return
+    span[INTEGRATION_SERVICE] = name
+  }
+
+  /**
+   * Set `service.name` on a span on behalf of this integration and stamp the marker.
+   *
+   * Use this for late-binding cases where the service is not known at startSpan time
+   * (e.g. web framework config applied after the span is already open).
+   *
+   * For spans started via {@link TracingPlugin#startSpan}, pass `service` as an option
+   * instead — it sets the tag and stamps the marker in one step.
+   *
+   * @param {import('../opentracing/span')} span Internal DatadogSpan instance.
+   * @param {string} name Service name the integration is claiming.
+   */
+  setServiceName (span, name) {
+    // eslint-disable-next-line eslint-rules/eslint-prefer-set-service-name -- this is the implementation
+    span._spanContext.setTag('service.name', name)
+    this.stampIntegrationService(span, name)
+  }
+
   /**
    * @param {unknown} error
    * @param {import('../../../..').Span} [span]
    */
   addError (error, span = this.activeSpan) {
-    if (span && !span._spanContext._tags.error) {
+    if (span && !span.context().getTag('error')) {
       // Errors may be wrapped in a context.
       span.setTag('error', error?.error || error || 1)
     }
@@ -224,6 +260,8 @@ class TracingPlugin extends Plugin {
       links: childOf?._links,
     })
 
+    this.stampIntegrationService(span, serviceName)
+
     analyticsSampler.sample(span, config.measured)
 
     // TODO: Remove this after migration to TracingChannel is done.

package/packages/dd-trace/src/plugins/util/test.js

@@ -229,11 +229,11 @@ const BASE_LIKE_BRANCH_FILTER = /^(main|master|preprod|prod|dev|development|trun
 
 /**
  * Returns request error tags from a test session span for propagation to child events.
- * @param {{ context: () => { _tags?: Record<string, string> } } | undefined} sessionSpan
+ * @param {{ context: () => { getTag?: (key: string) => string } } | undefined} sessionSpan
  * @returns {Record<string, string>}
  */
 function getSessionRequestErrorTags (sessionSpan) {
-  const tags = sessionSpan?.context()._tags
+  const tags = sessionSpan?.context()?.getTags?.()
   const sessionRequestErrorTags = {}
   if (!tags || typeof tags !== 'object') return {}
   if (tags[DD_CI_LIBRARY_CONFIGURATION_ERROR_SETTINGS] === 'true') {
@@ -253,11 +253,11 @@ function getSessionRequestErrorTags (sessionSpan) {
 
 /**
  * Returns ITR skipping-enabled tags from a test session span for propagation to child events.
- * @param {{ context: () => { _tags?: Record<string, string> } } | undefined} sessionSpan
+ * @param {{ context: () => { getTags?: () => Record<string, string> } } | undefined} sessionSpan
  * @returns {Record<string, string>}
  */
 function getSessionItrSkippingEnabledTags (sessionSpan) {
-  const tags = sessionSpan?.context()._tags
+  const tags = sessionSpan?.context()?.getTags?.()
   if (!tags || typeof tags !== 'object') return {}
   if (tags[TEST_ITR_SKIPPING_ENABLED] !== undefined) {
     return {
@@ -418,6 +418,12 @@ module.exports = {
   ITR_CORRELATION_ID,
   addIntelligentTestRunnerSpanTags,
   getCoveredFilenamesFromCoverage,
+  getCoveredFilesFromCoverage,
+  getExecutableFilesFromCoverage,
+  getRelativeCoverageFiles,
+  getLineCoverageBitmap,
+  applySkippedCoverageToCoverage,
+  getTestCoverageLinesPercentage,
   resetCoverage,
   mergeCoverage,
   fromCoverageMapToCoverage,
@@ -952,7 +958,6 @@ function getTestLevelCommonTags (command, testFrameworkVersion, testFramework) {
   return {
     [TEST_FRAMEWORK_VERSION]: testFrameworkVersion,
     [LIBRARY_VERSION]: ddTraceVersion,
-    [TEST_COMMAND]: command,
     [TEST_TYPE]: getTestTypeFromFramework(testFramework),
   }
 }
@@ -1030,15 +1035,233 @@ function addIntelligentTestRunnerSpanTags (
 }
 
 function getCoveredFilenamesFromCoverage (coverage) {
-  const coverageMap = istanbul.createCoverageMap(coverage)
+  return getCoveredFilesFromCoverage(coverage).map(({ filename }) => filename)
+}
 
-  return coverageMap
-    .files()
-    .filter(filename => {
-      const fileCoverage = coverageMap.fileCoverageFor(filename)
-      const lineCoverage = fileCoverage.getLineCoverage()
-      return Object.entries(lineCoverage).some(([, numExecutions]) => !!numExecutions)
-    })
+function getCoverageMap (coverage) {
+  if (coverage?.files && coverage?.fileCoverageFor) {
+    return coverage
+  }
+  return istanbul.createCoverageMap(coverage)
+}
+
+function getCoveredFilesFromCoverage (coverage) {
+  const coverageMap = getCoverageMap(coverage)
+  const coverageFiles = []
+
+  for (const filename of coverageMap.files()) {
+    const fileCoverage = coverageMap.fileCoverageFor(filename)
+    const bitmap = getLineCoverageBitmap(fileCoverage.getLineCoverage(), true)
+    if (bitmap) {
+      coverageFiles.push({ filename, bitmap })
+    }
+  }
+
+  return coverageFiles
+}
+
+function getExecutableFilesFromCoverage (coverage) {
+  const coverageMap = getCoverageMap(coverage)
+  const coverageFiles = []
+
+  for (const filename of coverageMap.files()) {
+    const fileCoverage = coverageMap.fileCoverageFor(filename)
+    const bitmap = getLineCoverageBitmap(fileCoverage.getLineCoverage())
+    if (bitmap) {
+      coverageFiles.push({ filename, bitmap })
+    }
+  }
+
+  return coverageFiles
+}
+
+function getRelativeCoverageFiles (coverageFiles, rootDir) {
+  return coverageFiles.map(({ filename, bitmap }) => ({
+    filename: getTestSuitePath(filename, rootDir),
+    bitmap,
+  }))
+}
+
+function getLineCoverageBitmap (lineCoverage, onlyCoveredLines = false) {
+  let maxLine = 0
+  const lines = []
+
+  for (const [line, hits] of Object.entries(lineCoverage)) {
+    if (onlyCoveredLines && !hits) continue
+
+    const lineNumber = Number(line)
+    if (!Number.isSafeInteger(lineNumber) || lineNumber <= 0) continue
+
+    lines.push(lineNumber)
+    if (lineNumber > maxLine) {
+      maxLine = lineNumber
+    }
+  }
+
+  if (maxLine === 0) return
+
+  const bitmap = Buffer.alloc(Math.ceil((maxLine + 1) / 8))
+  for (const lineNumber of lines) {
+    bitmap[lineNumber >> 3] |= 1 << (lineNumber % 8)
+  }
+
+  return bitmap
+}
+
+function mergeCoverageBitmaps (targetBitmap, bitmap) {
+  if (!targetBitmap) {
+    return Buffer.from(bitmap)
+  }
+
+  if (targetBitmap.length < bitmap.length) {
+    const biggerBitmap = Buffer.alloc(bitmap.length)
+    targetBitmap.copy(biggerBitmap)
+    targetBitmap = biggerBitmap
+  }
+
+  for (let i = 0; i < bitmap.length; i++) {
+    targetBitmap[i] |= bitmap[i]
+  }
+
+  return targetBitmap
+}
+
+function countBitmapBits (bitmap) {
+  let count = 0
+
+  for (const byte of bitmap) {
+    let value = byte
+    while (value) {
+      value &= value - 1
+      count++
+    }
+  }
+
+  return count
+}
+
+function countCoveredExecutableBits (coveredBitmap, executableBitmap) {
+  if (!coveredBitmap) return 0
+
+  let count = 0
+  const length = Math.min(coveredBitmap.length, executableBitmap.length)
+
+  for (let i = 0; i < length; i++) {
+    let value = coveredBitmap[i] & executableBitmap[i]
+    while (value) {
+      value &= value - 1
+      count++
+    }
+  }
+
+  return count
+}
+
+function getCoverageFileBitmap (bitmap) {
+  if (!bitmap) return
+  if (Buffer.isBuffer(bitmap)) return bitmap
+  if (ArrayBuffer.isView(bitmap)) {
+    return Buffer.from(bitmap.buffer, bitmap.byteOffset, bitmap.byteLength)
+  }
+  if (typeof bitmap === 'string') {
+    return Buffer.from(bitmap, 'base64')
+  }
+}
+
+function addCoverageFilesToMap (files, targetMap, rootDir) {
+  for (const file of files) {
+    const bitmap = getCoverageFileBitmap(file.bitmap)
+    if (!bitmap) continue
+
+    const filename = rootDir ? getTestSuitePath(file.filename, rootDir) : file.filename
+    targetMap.set(filename, mergeCoverageBitmaps(targetMap.get(filename), bitmap))
+  }
+}
+
+function addSkippedCoverageToMap (skippedCoverage, targetMap) {
+  if (!skippedCoverage) return
+
+  for (const [filename, bitmap] of Object.entries(skippedCoverage)) {
+    const coverageBitmap = getCoverageFileBitmap(bitmap)
+    if (!coverageBitmap) continue
+    targetMap.set(filename, mergeCoverageBitmaps(targetMap.get(filename), coverageBitmap))
+  }
+}
+
+function hasSkippedCoverage (skippedCoverage) {
+  return skippedCoverage && typeof skippedCoverage === 'object' && Object.keys(skippedCoverage).length > 0
+}
+
+function getTestCoverageLinesPercentage (coverage, skippedCoverage, rootDir) {
+  const executableLinesByFile = new Map()
+  const coveredLinesByFile = new Map()
+
+  addCoverageFilesToMap(getExecutableFilesFromCoverage(coverage), executableLinesByFile, rootDir)
+  addCoverageFilesToMap(getCoveredFilesFromCoverage(coverage), coveredLinesByFile, rootDir)
+  addSkippedCoverageToMap(skippedCoverage, coveredLinesByFile)
+
+  let totalExecutableLines = 0
+  let totalCoveredLines = 0
+
+  for (const [filename, executableLines] of executableLinesByFile) {
+    totalExecutableLines += countBitmapBits(executableLines)
+    totalCoveredLines += countCoveredExecutableBits(coveredLinesByFile.get(filename), executableLines)
+  }
+
+  return totalExecutableLines === 0 ? 0 : Math.floor((totalCoveredLines / totalExecutableLines) * 10_000) / 100
+}
+
+function isLineCoveredByBitmap (bitmap, line) {
+  if (!Number.isSafeInteger(line) || line <= 0) return false
+
+  const byteIndex = line >> 3
+  return byteIndex < bitmap.length && !!(bitmap[byteIndex] & (1 << (line % 8)))
+}
+
+function getSkippedCoverageByFilename (skippedCoverage) {
+  const skippedCoverageByFilename = new Map()
+  addSkippedCoverageToMap(skippedCoverage, skippedCoverageByFilename)
+  return skippedCoverageByFilename
+}
+
+function applySkippedCoverageToFileCoverage (fileCoverage, skippedBitmap) {
+  let updated = false
+  for (const [statementId, statementLocation] of Object.entries(fileCoverage.data.statementMap)) {
+    const startLine = statementLocation?.start?.line
+    if (!isLineCoveredByBitmap(skippedBitmap, startLine)) continue
+    if (fileCoverage.data.s[statementId] > 0) continue
+
+    fileCoverage.data.s[statementId] = 1
+    updated = true
+  }
+  return updated
+}
+
+/**
+ * Applies backend skipped-suite coverage to an Istanbul coverage map.
+ * @param {object} coverage
+ * @param {object} skippedCoverage
+ * @param {string} [rootDir]
+ * @returns {boolean}
+ */
+function applySkippedCoverageToCoverage (coverage, skippedCoverage, rootDir) {
+  if (!hasSkippedCoverage(skippedCoverage)) return false
+
+  const coverageMap = getCoverageMap(coverage)
+  const skippedCoverageByFilename = getSkippedCoverageByFilename(skippedCoverage)
+  let matched = false
+
+  for (const filename of coverageMap.files()) {
+    const relativeFilename = rootDir ? getTestSuitePath(filename, rootDir) : filename
+    const skippedBitmap = skippedCoverageByFilename.get(relativeFilename)
+    if (!skippedBitmap) continue
+
+    const fileCoverage = coverageMap.fileCoverageFor(filename)
+    applySkippedCoverageToFileCoverage(fileCoverage, skippedBitmap)
+    matched = true
+  }
+
+  return matched
 }
 
 function resetCoverage (coverage) {