@depup/dd-trace 5.90.0-depup.0

package/packages/dd-trace/src/azure_metadata.js

@@ -0,0 +1,137 @@
+'use strict'
+
+// Modeled after https://github.com/DataDog/libdatadog/blob/f3994857a59bb5679a65967138c5a3aec418a65f/ddcommon/src/azure_app_services.rs
+
+const os = require('os')
+const {
+  getEnvironmentVariable,
+  getEnvironmentVariables,
+  getValueFromEnvSources,
+} = require('./config/helper')
+const { getIsAzureFunction, getIsFlexConsumptionAzureFunction } = require('./serverless')
+
+function extractSubscriptionID (ownerName) {
+  if (ownerName !== undefined) {
+    const subId = ownerName.split('+')[0].trim()
+    if (subId.length > 0) {
+      return subId
+    }
+  }
+}
+
+function extractResourceGroup (ownerName) {
+  return /.+\+(.+)-.+webspace(-Linux)?/.exec(ownerName)?.[1]
+}
+
+function buildResourceID (subscriptionID, siteName, resourceGroup) {
+  if (subscriptionID === undefined || siteName === undefined || resourceGroup === undefined) {
+    return
+  }
+  return `/subscriptions/${subscriptionID}/resourcegroups/${resourceGroup}/providers/microsoft.web/sites/${siteName}`
+    .toLowerCase()
+}
+
+/**
+ * @param {Record<string | symbol, unknown>} obj
+ * @returns {Partial<Record<string | symbol, unknown>>}
+ */
+function trimObject (obj) {
+  const cleanedObj = {}
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== undefined) {
+      cleanedObj[key] = value
+    }
+  }
+  return cleanedObj
+}
+
+function buildMetadata () {
+  const {
+    COMPUTERNAME,
+    FUNCTIONS_EXTENSION_VERSION,
+    FUNCTIONS_WORKER_RUNTIME,
+    FUNCTIONS_WORKER_RUNTIME_VERSION,
+    WEBSITE_INSTANCE_ID,
+    WEBSITE_OWNER_NAME,
+    WEBSITE_OS,
+    WEBSITE_RESOURCE_GROUP,
+    WEBSITE_SITE_NAME,
+  } = getEnvironmentVariables()
+
+  const DD_AZURE_RESOURCE_GROUP = getValueFromEnvSources('DD_AZURE_RESOURCE_GROUP')
+
+  const subscriptionID = extractSubscriptionID(WEBSITE_OWNER_NAME)
+
+  const siteName = WEBSITE_SITE_NAME
+
+  const [siteKind, siteType] = getIsAzureFunction()
+    ? ['functionapp', 'function']
+    : ['app', 'app']
+
+  // Azure Functions on Flex Consumption plans require the `DD_AZURE_RESOURCE_GROUP` env var.
+  // If this logic ever changes, update the logic in `libdatadog`, `serverless-components/src/datadog-trace-agent`,
+  // and the serverless compat layers accordingly.
+  const resourceGroup = getIsFlexConsumptionAzureFunction()
+    ? (DD_AZURE_RESOURCE_GROUP ?? WEBSITE_RESOURCE_GROUP ?? extractResourceGroup(WEBSITE_OWNER_NAME))
+    : (WEBSITE_RESOURCE_GROUP ?? extractResourceGroup(WEBSITE_OWNER_NAME))
+
+  return trimObject({
+    functionRuntimeVersion: FUNCTIONS_EXTENSION_VERSION,
+    instanceID: WEBSITE_INSTANCE_ID,
+    instanceName: COMPUTERNAME,
+    operatingSystem: WEBSITE_OS ?? os.platform(),
+    resourceGroup,
+    resourceID: buildResourceID(subscriptionID, siteName, resourceGroup),
+    runtime: FUNCTIONS_WORKER_RUNTIME,
+    runtimeVersion: FUNCTIONS_WORKER_RUNTIME_VERSION,
+    siteKind,
+    siteName,
+    siteType,
+    subscriptionID,
+  })
+}
+
+function getAzureAppMetadata () {
+  // WEBSITE_SITE_NAME is the unique name of the website instance within Azure App Services. Its
+  // presence is used to determine if we are running in Azure App Service
+  // See equivalent in dd-trace-dotnet:
+  // https://github.com/DataDog/dd-trace-dotnet/blob/37030168b2996e549ba23231ae732874b53a37e6/tracer/src/Datadog.Trace/Util/EnvironmentHelpers.cs#L99-L155
+  if (getEnvironmentVariable('WEBSITE_SITE_NAME') !== undefined) {
+    return buildMetadata()
+  }
+}
+
+function getAzureFunctionMetadata () {
+  if (getIsAzureFunction()) {
+    return buildMetadata()
+  }
+}
+
+// Modeled after https://github.com/DataDog/libdatadog/blob/92272e90a7919f07178f3246ef8f82295513cfed/profiling/src/exporter/mod.rs#L187
+// and https://github.com/DataDog/libdatadog/blob/f3994857a59bb5679a65967138c5a3aec418a65f/trace-utils/src/trace_utils.rs#L533
+function getAzureTagsFromMetadata (metadata) {
+  if (metadata === undefined) {
+    return {}
+  }
+  return trimObject({
+    'aas.environment.extension_version': metadata.extensionVersion,
+    'aas.environment.function_runtime': metadata.functionRuntimeVersion,
+    'aas.environment.instance_id': metadata.instanceID,
+    'aas.environment.instance_name': metadata.instanceName,
+    'aas.environment.os': metadata.operatingSystem,
+    'aas.environment.runtime': metadata.runtime,
+    'aas.environment.runtime_version': metadata.runtimeVersion,
+    'aas.resource.group': metadata.resourceGroup,
+    'aas.resource.id': metadata.resourceID,
+    'aas.site.kind': metadata.siteKind,
+    'aas.site.name': metadata.siteName,
+    'aas.site.type': metadata.siteType,
+    'aas.subscription.id': metadata.subscriptionID,
+  })
+}
+
+module.exports = {
+  getAzureAppMetadata,
+  getAzureFunctionMetadata,
+  getAzureTagsFromMetadata,
+}

package/packages/dd-trace/src/baggage.js

@@ -0,0 +1,72 @@
+'use strict'
+
+const { storage } = require('../../datadog-core')
+
+/**
+ * Spec (API semantics):
+ * - OpenTelemetry Baggage API: https://opentelemetry.io/docs/specs/otel/baggage/api/
+ *
+ * In-process baggage is a string->string map stored in async local storage.
+ * @typedef {import('../../datadog-core/src/storage').Store<string>} BaggageStore
+ */
+
+/**
+ * @type {{ enterWith: (store?: BaggageStore) => void, getStore: () => (BaggageStore | undefined) }}
+ */
+const baggageStorage =
+  /** @type {{ enterWith: (store?: BaggageStore) => void, getStore: () => (BaggageStore | undefined) }} */ (
+    /** @type {unknown} */ (storage('baggage'))
+  )
+
+// TODO: Implement metadata https://opentelemetry.io/docs/specs/otel/baggage/api/#set-value
+/**
+ * @param {string} key
+ * @param {string} value
+ * @param {object} [metadata] Not used yet
+ */
+function setBaggageItem (key, value, metadata) {
+  if (typeof key !== 'string' || typeof value !== 'string' || key === '') {
+    return baggageStorage.getStore() ?? {}
+  }
+
+  const store = baggageStorage.getStore()
+  const newStore = { ...store, [key]: value }
+  baggageStorage.enterWith(newStore)
+  return newStore
+}
+
+/**
+ * @param {string} key
+ * @returns {string | undefined}
+ */
+function getBaggageItem (key) {
+  return baggageStorage.getStore()?.[key]
+}
+
+function getAllBaggageItems () {
+  return baggageStorage.getStore() ?? {}
+}
+
+/**
+ * @param {string} keyToRemove
+ */
+function removeBaggageItem (keyToRemove) {
+  const store = baggageStorage.getStore() ?? {}
+  const { [keyToRemove]: _, ...newBaggage } = store
+  baggageStorage.enterWith(newBaggage)
+  return newBaggage
+}
+
+function removeAllBaggageItems () {
+  const newContext = /** @type {BaggageStore} */ ({})
+  baggageStorage.enterWith(newContext)
+  return newContext
+}
+
+module.exports = {
+  setBaggageItem,
+  getBaggageItem,
+  getAllBaggageItems,
+  removeBaggageItem,
+  removeAllBaggageItems,
+}

package/packages/dd-trace/src/ci-visibility/coverage-report-discovery.js

@@ -0,0 +1,82 @@
+'use strict'
+
+const fs = require('node:fs')
+const path = require('node:path')
+
+const log = require('../log')
+
+/**
+ * Coverage report file patterns to search for
+ * Each entry contains the relative path from root and the format identifier
+ */
+const COVERAGE_REPORT_PATTERNS = [
+  // LCOV format
+  { path: 'coverage/lcov.info', format: 'lcov' },
+  { path: 'lcov.info', format: 'lcov' },
+
+  // Cobertura XML format
+  { path: 'coverage/cobertura-coverage.xml', format: 'cobertura' },
+  { path: 'cobertura-coverage.xml', format: 'cobertura' },
+
+  // JaCoCo XML format
+  { path: 'coverage/jacoco.xml', format: 'jacoco' },
+  { path: 'jacoco.xml', format: 'jacoco' },
+
+  // Clover XML format
+  { path: 'coverage/clover.xml', format: 'clover' },
+  { path: 'clover.xml', format: 'clover' },
+
+  // OpenCover XML format
+  { path: 'coverage/opencover.xml', format: 'opencover' },
+  { path: 'opencover.xml', format: 'opencover' },
+
+  // SimpleCov JSON format
+  { path: 'coverage/.resultset.json', format: 'simplecov' },
+  { path: '.resultset.json', format: 'simplecov' },
+]
+
+/**
+ * Discovers code coverage report files in the given root directory
+ * @param {string} rootDir - The root directory to search for coverage reports
+ * @returns {Array<{filePath: string, format: string}>} Array of discovered coverage reports
+ */
+function discoverCoverageReports (rootDir) {
+  if (!rootDir) {
+    log.debug('No root directory provided for coverage report discovery')
+    return []
+  }
+
+  const discoveredReports = []
+
+  for (const pattern of COVERAGE_REPORT_PATTERNS) {
+    const fullPath = path.join(rootDir, pattern.path)
+
+    try {
+      if (fs.existsSync(fullPath)) {
+        const stats = fs.statSync(fullPath)
+
+        // Only include regular files, not directories or symlinks
+        if (stats.isFile()) {
+          discoveredReports.push({
+            filePath: fullPath,
+            format: pattern.format,
+          })
+          log.debug('Found coverage report: %s (format: %s)', fullPath, pattern.format)
+        }
+      }
+    } catch (err) {
+      // Log but don't fail if we can't access a file
+      log.debug('Error checking coverage report path %s: %s', fullPath, err.message)
+    }
+  }
+
+  if (discoveredReports.length === 0) {
+    log.debug('No coverage reports found in %s', rootDir)
+  } else {
+    log.debug('Discovered %d coverage report(s)', discoveredReports.length)
+  }
+
+  return discoveredReports
+}
+
+module.exports = { discoverCoverageReports }

package/packages/dd-trace/src/ci-visibility/dynamic-instrumentation/index.js

@@ -0,0 +1,159 @@
+'use strict'
+
+const { join } = require('path')
+const { Worker, threadId: parentThreadId } = require('worker_threads')
+const { randomUUID } = require('crypto')
+const log = require('../../log')
+const { getEnvironmentVariables } = require('../../config/helper')
+const getDebuggerConfig = require('../../debugger/config')
+
+const probeIdToResolveBreakpointSet = new Map()
+const probeIdToResolveBreakpointRemove = new Map()
+
+class TestVisDynamicInstrumentation {
+  constructor (config) {
+    this._config = config
+    this.worker = null
+    this._readyPromise = new Promise(resolve => {
+      this._onReady = resolve
+    })
+    this.breakpointSetChannel = new MessageChannel()
+    this.breakpointHitChannel = new MessageChannel()
+    this.breakpointRemoveChannel = new MessageChannel()
+    this.onHitBreakpointByProbeId = new Map()
+  }
+
+  removeProbe (probeId) {
+    return new Promise(resolve => {
+      this.breakpointRemoveChannel.port2.postMessage(probeId)
+
+      probeIdToResolveBreakpointRemove.set(probeId, resolve)
+    })
+  }
+
+  // Return 2 elements:
+  // 1. Probe ID
+  // 2. Promise that's resolved when the breakpoint is set
+  addLineProbe ({ file, line }, onHitBreakpoint) {
+    if (!this.worker) { // not init yet
+      this.start()
+    }
+    const probeId = randomUUID()
+
+    this.breakpointSetChannel.port2.postMessage(
+      { id: probeId, file, line }
+    )
+
+    this.onHitBreakpointByProbeId.set(probeId, onHitBreakpoint)
+
+    return [
+      probeId,
+      new Promise(resolve => {
+        probeIdToResolveBreakpointSet.set(probeId, resolve)
+      }),
+    ]
+  }
+
+  isReady () {
+    return this._readyPromise
+  }
+
+  start () {
+    if (this.worker) return
+
+    log.debug('Starting Test Visibility - Dynamic Instrumentation client...')
+
+    const probeChannel = new MessageChannel() // mock channel
+    const configChannel = new MessageChannel() // mock channel
+
+    this.worker = new Worker(
+      join(__dirname, 'worker', 'index.js'),
+      {
+        execArgv: [],
+        // Not passing `NODE_OPTIONS` results in issues with yarn, which relies on NODE_OPTIONS
+        // for PnP support, hence why we deviate from the DI pattern here.
+        // To avoid infinite initialization loops, we're disabling DI and tracing in the worker.
+        env: {
+          // NOTE: We intentionally use `getEnvironmentVariables()` here (raw env)
+          // instead of stable-config resolution helpers. The DI worker is a forked
+          // process that should see exactly the parent process's environment, and
+          // we explicitly override a few DD_ vars below to disable tracing/DI there.
+          ...getEnvironmentVariables(),
+          DD_CIVISIBILITY_ENABLED: 'false',
+          DD_TRACE_ENABLED: 'false',
+          DD_TEST_FAILED_TEST_REPLAY_ENABLED: 'false',
+          DD_CIVISIBILITY_MANUAL_API_ENABLED: 'false',
+          DD_TRACING_ENABLED: 'false',
+          DD_INSTRUMENTATION_TELEMETRY_ENABLED: 'false',
+        },
+        workerData: {
+          config: getDebuggerConfig(this._config),
+          parentThreadId,
+          probePort: probeChannel.port1,
+          configPort: configChannel.port1,
+          breakpointSetChannel: this.breakpointSetChannel.port1,
+          breakpointHitChannel: this.breakpointHitChannel.port1,
+          breakpointRemoveChannel: this.breakpointRemoveChannel.port1,
+        },
+        transferList: [
+          probeChannel.port1,
+          configChannel.port1,
+          this.breakpointSetChannel.port1,
+          this.breakpointHitChannel.port1,
+          this.breakpointRemoveChannel.port1,
+        ],
+      }
+    )
+    this.worker.on('online', () => {
+      log.debug('Test Visibility - Dynamic Instrumentation client is ready')
+      this._onReady()
+    })
+
+    this.worker.on('error', (err) => {
+      log.error('Test Visibility - Dynamic Instrumentation worker error', err)
+    })
+
+    this.worker.on('messageerror', (err) => {
+      log.error('Test Visibility - Dynamic Instrumentation worker messageerror', err)
+    })
+
+    // Allow the parent to exit even if the worker is still running
+    this.worker.unref()
+
+    this.breakpointSetChannel.port2.on('message', (probeId) => {
+      const resolve = probeIdToResolveBreakpointSet.get(probeId)
+      if (resolve) {
+        resolve()
+        probeIdToResolveBreakpointSet.delete(probeId)
+      }
+    }).unref()
+
+    this.breakpointHitChannel.port2.on('message', ({ snapshot }) => {
+      const { probe: { id: probeId } } = snapshot
+      const onHit = this.onHitBreakpointByProbeId.get(probeId)
+      if (onHit) {
+        onHit({ snapshot })
+      } else {
+        log.warn('Received a breakpoint hit for an unknown probe')
+      }
+    }).unref()
+
+    this.breakpointRemoveChannel.port2.on('message', (probeId) => {
+      const resolve = probeIdToResolveBreakpointRemove.get(probeId)
+      if (resolve) {
+        resolve()
+        probeIdToResolveBreakpointRemove.delete(probeId)
+      }
+    }).unref()
+  }
+}
+
+let dynamicInstrumentation
+
+module.exports = function createAndGetTestVisDynamicInstrumentation (config) {
+  if (dynamicInstrumentation) {
+    return dynamicInstrumentation
+  }
+  dynamicInstrumentation = new TestVisDynamicInstrumentation(config)
+  return dynamicInstrumentation
+}

package/packages/dd-trace/src/ci-visibility/dynamic-instrumentation/worker/index.js

@@ -0,0 +1,156 @@
+'use strict'
+
+const {
+  workerData: {
+    config,
+    breakpointSetChannel,
+    breakpointHitChannel,
+    breakpointRemoveChannel,
+  },
+} = require('worker_threads')
+const { randomUUID } = require('crypto')
+
+// TODO: move debugger/devtools_client/session to common place
+const session = require('../../../debugger/devtools_client/session')
+// TODO: move debugger/devtools_client/source-maps to common place
+const { getGeneratedPosition } = require('../../../debugger/devtools_client/source-maps')
+// TODO: move debugger/devtools_client/snapshot to common place
+const { getLocalStateForCallFrame } = require('../../../debugger/devtools_client/snapshot')
+const {
+  DEFAULT_MAX_REFERENCE_DEPTH,
+  DEFAULT_MAX_COLLECTION_SIZE,
+  DEFAULT_MAX_FIELD_COUNT,
+  DEFAULT_MAX_LENGTH,
+} = require('../../../debugger/devtools_client/snapshot/constants')
+// TODO: move debugger/devtools_client/state to common place
+const {
+  findScriptFromPartialPath,
+  getStackFromCallFrames,
+} = require('../../../debugger/devtools_client/state')
+const log = require('../../../log')
+const processTags = require('../../../process-tags')
+
+let sessionStarted = false
+
+const breakpointIdToProbe = new Map()
+const probeIdToBreakpointId = new Map()
+
+const limits = {
+  maxReferenceDepth: DEFAULT_MAX_REFERENCE_DEPTH,
+  maxCollectionSize: DEFAULT_MAX_COLLECTION_SIZE,
+  maxFieldCount: DEFAULT_MAX_FIELD_COUNT,
+  maxLength: DEFAULT_MAX_LENGTH,
+}
+
+session.on('Debugger.paused', async ({ params: { hitBreakpoints: [hitBreakpoint], callFrames } }) => {
+  const probe = breakpointIdToProbe.get(hitBreakpoint)
+  if (!probe) {
+    log.warn('No probe found for breakpoint', hitBreakpoint)
+    return session.post('Debugger.resume')
+  }
+
+  const stack = await getStackFromCallFrames(callFrames)
+
+  const { processLocalState } = await getLocalStateForCallFrame(callFrames[0], limits)
+
+  await session.post('Debugger.resume')
+
+  const snapshot = {
+    id: randomUUID(),
+    timestamp: Date.now(),
+    probe: {
+      id: probe.id,
+      version: '0',
+      location: probe.location,
+    },
+    captures: {
+      lines: { [probe.location.lines[0]]: { locals: processLocalState() } },
+    },
+    stack,
+    language: 'javascript',
+  }
+
+  if (config.propagateProcessTags?.enabled) {
+    snapshot[processTags.DYNAMIC_INSTRUMENTATION_FIELD_NAME] = processTags.tagsObject
+  }
+
+  breakpointHitChannel.postMessage({ snapshot })
+})
+
+breakpointRemoveChannel.on('message', async (probeId) => {
+  await removeBreakpoint(probeId)
+  breakpointRemoveChannel.postMessage(probeId)
+})
+
+breakpointSetChannel.on('message', async (probe) => {
+  await addBreakpoint(probe)
+  breakpointSetChannel.postMessage(probe.id)
+})
+
+async function removeBreakpoint (probeId) {
+  if (!sessionStarted) {
+    // We should not get in this state, but abort if we do, so the code doesn't fail unexpected
+    throw new Error(`Cannot remove probe ${probeId}: Debugger not started`)
+  }
+
+  const breakpointId = probeIdToBreakpointId.get(probeId)
+  if (!breakpointId) {
+    throw new Error(`Unknown probe id: ${probeId}`)
+  }
+  await session.post('Debugger.removeBreakpoint', { breakpointId })
+  probeIdToBreakpointId.delete(probeId)
+  breakpointIdToProbe.delete(breakpointId)
+}
+
+async function addBreakpoint (probe) {
+  if (!sessionStarted) await start()
+  const { file, line } = probe
+
+  probe.location = { file, lines: [String(line)] }
+
+  const script = findScriptFromPartialPath(file)
+  if (!script) {
+    log.error('No loaded script found for', file)
+    throw new Error(`No loaded script found for ${file}`)
+  }
+
+  const { url, scriptId, sourceMapURL, source } = script
+
+  log.warn('Adding breakpoint at %s:%s', url, line)
+
+  let lineNumber = line
+  let columnNumber = 0
+
+  if (sourceMapURL) {
+    try {
+      ({ line: lineNumber, column: columnNumber } = await getGeneratedPosition(url, source, line, sourceMapURL))
+    } catch (err) {
+      log.error('Error processing script with source map', err)
+    }
+    if (lineNumber === null) {
+      log.error('Could not find generated position for %s:%s', url, line)
+      lineNumber = line
+      columnNumber = 0
+    }
+  }
+
+  try {
+    const { breakpointId } = await session.post('Debugger.setBreakpoint', {
+      location: {
+        scriptId,
+        lineNumber: lineNumber - 1,
+        columnNumber,
+      },
+    })
+
+    breakpointIdToProbe.set(breakpointId, probe)
+    probeIdToBreakpointId.set(probe.id, breakpointId)
+  } catch (e) {
+    log.error('Error setting breakpoint at %s:%s', url, line, e)
+  }
+}
+
+function start () {
+  sessionStarted = true
+  return session.post('Debugger.enable') // return instead of await to reduce number of promises created
+}