dd-trace 5.67.0 → 5.68.0

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

@@ -1,11 +1,9 @@
 'use strict'
-
-const coalesce = require('koalas')
 const { inspect } = require('util')
 const { isTrue } = require('../util')
 const { traceChannel, debugChannel, infoChannel, warnChannel, errorChannel } = require('./channels')
 const logWriter = require('./writer')
-const { Log } = require('./log')
+const { Log, LogConfig, NoTransmitError } = require('./log')
 const { memoize } = require('./utils')
 const { getEnvironmentVariable } = require('../config-helper')
 
@@ -15,7 +13,14 @@ const config = {
   logLevel: 'debug'
 }
 
+// in most places where we know we want to mute a log we use log.error() directly
+const NO_TRANSMIT = new LogConfig(false)
+
 const log = {
+  LogConfig,
+  NO_TRANSMIT,
+  NoTransmitError,
+
   /**
    * @returns Read-only version of logging config. To modify config, call `log.use` and `log.toggle`
    */
@@ -92,18 +97,26 @@ const log = {
     return this
   },
 
+  errorWithoutTelemetry (...args) {
+    args.push(NO_TRANSMIT)
+    if (errorChannel.hasSubscribers) {
+      errorChannel.publish(Log.parse(...args))
+    }
+    return this
+  },
+
   deprecate (code, message) {
     return this._deprecate(code, message)
   },
 
   isEnabled (fleetStableConfigValue, localStableConfigValue) {
-    return isTrue(coalesce(
-      fleetStableConfigValue,
-      getEnvironmentVariable('DD_TRACE_DEBUG'),
-      getEnvironmentVariable('OTEL_LOG_LEVEL') === 'debug' || undefined,
-      localStableConfigValue,
-      config.enabled
-    ))
+    return isTrue(
+      (fleetStableConfigValue ??
+      getEnvironmentVariable('DD_TRACE_DEBUG') ??
+      getEnvironmentVariable('OTEL_LOG_LEVEL') === 'debug') ||
+      (localStableConfigValue ??
+      config.enabled)
+    )
   },
 
   getLogLevel (
@@ -111,14 +124,12 @@ const log = {
     fleetStableConfigValue,
     localStableConfigValue
   ) {
-    return coalesce(
-      optionsValue,
-      fleetStableConfigValue,
-      getEnvironmentVariable('DD_TRACE_LOG_LEVEL'),
-      getEnvironmentVariable('OTEL_LOG_LEVEL'),
-      localStableConfigValue,
+    return optionsValue ??
+      fleetStableConfigValue ??
+      getEnvironmentVariable('DD_TRACE_LOG_LEVEL') ??
+      getEnvironmentVariable('OTEL_LOG_LEVEL') ??
+      localStableConfigValue ??
       config.logLevel
-    )
   }
 }
 

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

@@ -2,12 +2,16 @@
 
 const { format } = require('util')
 
+// other times we produce an Error in a central location and log it several other places
+class NoTransmitError extends Error {}
+
 class Log {
-  constructor (message, args, cause, delegate) {
+  constructor (message, args, cause, delegate, sendViaTelemetry = true) {
     this.message = message
     this.args = args
     this.cause = cause
     this.delegate = delegate
+    this.sendViaTelemetry = sendViaTelemetry
   }
 
   get formatted () {
@@ -22,10 +26,18 @@ class Log {
 
   static parse (...args) {
     let message, cause, delegate
+    let sendViaTelemetry = true
+
+    const maybeLogConfig = args.at(-1)
+    if (maybeLogConfig instanceof LogConfig) {
+      args.pop()
+      sendViaTelemetry = maybeLogConfig.transmit
+    }
 
-    const lastArg = args.at(-1)
-    if (lastArg && typeof lastArg === 'object' && lastArg.stack) { // lastArg instanceof Error?
+    const maybeError = args.at(-1)
+    if (maybeError && typeof maybeError === 'object' && maybeError.stack) { // maybeError instanceof Error?
       cause = args.pop()
+      if (cause instanceof NoTransmitError) sendViaTelemetry = false
     }
 
     const firstArg = args.shift()
@@ -43,10 +55,22 @@ class Log {
       message = String(firstArg)
     }
 
-    return new Log(message, args, cause, delegate)
+    return new Log(message, args, cause, delegate, sendViaTelemetry)
+  }
+}
+
+/**
+ * Pass instances of this class to logger methods when fine-grain control is needed
+ * @property {boolean} transmit - Whether to send the log via telemetry.
+ */
+class LogConfig {
+  constructor (transmit = true) {
+    this.transmit = transmit
   }
 }
 
 module.exports = {
-  Log
+  Log,
+  LogConfig,
+  NoTransmitError,
 }

package/packages/dd-trace/src/log/writer.js

@@ -75,12 +75,12 @@ function onError (err) {
   // TODO: replace it with Error(message, { cause }) when cause has broad support
   if (formatted) {
     withNoop(() => {
-      const l = Error.stackTraceLimit
+      const stackTraceLimitBackup = Error.stackTraceLimit
       Error.stackTraceLimit = 0
-      const e = new Error(formatted)
-      Error.stackTraceLimit = l
-      Error.captureStackTrace(e, stackTraceLimitFunction)
-      logger.error(e)
+      const newError = new Error(formatted)
+      Error.stackTraceLimit = stackTraceLimitBackup
+      Error.captureStackTrace(newError, stackTraceLimitFunction)
+      logger.error(newError)
     })
   }
   if (cause) withNoop(() => logger.error(cause))

package/packages/dd-trace/src/noop/span.js

@@ -22,6 +22,7 @@ class NoopSpan {
   setTag (key, value) { return this }
   addTags (keyValueMap) { return this }
   addLink (link) { return this }
+  addLinks (links) { return this }
   addSpanPointer (ptrKind, ptrDir, ptrHash) { return this }
   log () { return this }
   logEvent () {}

package/packages/dd-trace/src/opentelemetry/span.js

@@ -211,10 +211,21 @@ class Span {
     return this
   }
 
-  addLink (context, attributes) {
-    // extract dd context
+  addLink (link, attrs) {
+    // TODO: Remove this once we remove addLink(context, attrs) in v6.0.0
+    if (link instanceof SpanContext) {
+      link = { context: link, attributes: attrs ?? {} }
+    }
+
+    const { context, attributes } = link
+    // Extract dd context
     const ddSpanContext = context._ddContext
-    this._ddSpan.addLink(ddSpanContext, attributes)
+    this._ddSpan.addLink({ context: ddSpanContext, attributes })
+    return this
+  }
+
+  addLinks (links) {
+    links.forEach(link => this.addLink(link))
     return this
   }
 

package/packages/dd-trace/src/opentracing/span.js

@@ -86,8 +86,10 @@ class DatadogSpan {
 
     this._startTime = fields.startTime || this._getTime()
 
-    this._links = []
-    fields.links && fields.links.forEach(link => this.addLink(link.context, link.attributes))
+    this._links = fields.links?.map(link => ({
+      context: link.context._ddContext ?? link.context,
+      attributes: this._sanitizeAttributes(link.attributes)
+    })) ?? []
 
     if (DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
       runtimeMetrics.increment('runtime.node.spans.unfinished')
@@ -196,13 +198,25 @@ class DatadogSpan {
 
   logEvent () {}
 
-  addLink (context, attributes) {
+  addLink (link, attrs) {
+    // TODO: Remove this once we remove addLink(context, attrs) in v6.0.0
+    if (link instanceof SpanContext) {
+      link = { context: link, attributes: attrs ?? {} }
+    }
+
+    const { context, attributes } = link
+
     this._links.push({
       context: context._ddContext ?? context,
       attributes: this._sanitizeAttributes(attributes)
     })
   }
 
+  addLinks (links) {
+    links.forEach(link => this.addLink(link))
+    return this
+  }
+
   addSpanPointer (ptrKind, ptrDir, ptrHash) {
     const zeroContext = new SpanContext({
       traceId: id('0'),
@@ -214,7 +228,7 @@ class DatadogSpan {
       'ptr.hash': ptrHash,
       'link.kind': 'span-pointer'
     }
-    this.addLink(zeroContext, attributes)
+    this.addLink({ context: zeroContext, attributes })
   }
 
   addEvent (name, attributesOrStartTime, startTime) {

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

@@ -6,6 +6,15 @@ const plugins = require('./plugins')
 const log = require('./log')
 const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
 
+// Test optimization plugins that should only be enabled when isCiVisibility is true
+const TEST_OPTIMIZATION_PLUGINS = new Set([
+  'jest',
+  'vitest',
+  'cucumber',
+  'mocha',
+  'playwright'
+])
+
 const loadChannel = channel('dd-trace:instrumentation:load')
 
 // instrument everything that needs Plugin System V2 instrumentation
@@ -74,6 +83,13 @@ module.exports = class PluginManager {
 
     if (!Plugin) return
     if (!this._tracerConfig) return // TODO: don't wait for tracer to be initialized
+
+    // Check if this is a Test Optimization plugin and Test Optimization is not enabled
+    if (TEST_OPTIMIZATION_PLUGINS.has(name) && !this._tracerConfig.isCiVisibility) {
+      log.debug('Plugin "%s" is not initialized because Test Optimization mode is not enabled.', name)
+      return
+    }
+
     if (!this._pluginsByName[name]) {
       this._pluginsByName[name] = new Plugin(this._tracer, this._tracerConfig)
     }
@@ -148,7 +164,8 @@ module.exports = class PluginManager {
       middlewareTracingEnabled,
       traceWebsocketMessagesEnabled,
       traceWebsocketMessagesInheritSampling,
-      traceWebsocketMessagesSeparateTraces
+      traceWebsocketMessagesSeparateTraces,
+      experimental
     } = this._tracerConfig
 
     const sharedConfig = {
@@ -166,7 +183,8 @@ module.exports = class PluginManager {
       isServiceUserProvided,
       traceWebsocketMessagesEnabled,
       traceWebsocketMessagesInheritSampling,
-      traceWebsocketMessagesSeparateTraces
+      traceWebsocketMessagesSeparateTraces,
+      experimental
     }
 
     if (logInjection !== undefined) {

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

@@ -36,6 +36,7 @@ const {
   getModifiedTestsFromDiff,
   getPullRequestBaseBranch
 } = require('./util/test')
+const { getRepositoryRoot } = require('./util/git')
 const Plugin = require('./plugin')
 const { COMPONENT } = require('../constants')
 const log = require('../log')
@@ -61,6 +62,7 @@ const {
 const { OS_VERSION, OS_PLATFORM, OS_ARCHITECTURE, RUNTIME_NAME, RUNTIME_VERSION } = require('./util/env')
 const getDiClient = require('../ci-visibility/dynamic-instrumentation')
 const { DD_MAJOR } = require('../../../../version')
+const id = require('../id')
 
 const FRAMEWORK_TO_TRIMMED_COMMAND = {
   vitest: 'vitest run',
@@ -70,12 +72,44 @@ const FRAMEWORK_TO_TRIMMED_COMMAND = {
   jest: 'jest'
 }
 
+const WORKER_EXPORTER_TO_TEST_FRAMEWORK = {
+  vitest_worker: 'vitest',
+  jest_worker: 'jest',
+  cucumber_worker: 'cucumber',
+  mocha_worker: 'mocha',
+  playwright_worker: 'playwright'
+}
+
+const TEST_FRAMEWORKS_TO_SKIP_GIT_METADATA_EXTRACTION = new Set([
+  'vitest',
+  'jest',
+  'mocha',
+  'cucumber',
+])
+
+function getTestSuiteLevelVisibilityTags (testSuiteSpan, testFramework) {
+  const testSuiteSpanContext = testSuiteSpan.context()
+
+  const suiteTags = {
+    [TEST_SUITE_ID]: testSuiteSpanContext.toSpanId(),
+    [TEST_SESSION_ID]: testSuiteSpanContext.toTraceId(),
+    [TEST_COMMAND]: testSuiteSpanContext._tags[TEST_COMMAND],
+    [TEST_MODULE]: testFramework
+  }
+
+  if (testSuiteSpanContext._parentId) {
+    suiteTags[TEST_MODULE_ID] = testSuiteSpanContext._parentId.toString(10)
+  }
+  return suiteTags
+}
+
 module.exports = class CiPlugin extends Plugin {
   constructor (...args) {
     super(...args)
 
     this.fileLineToProbeId = new Map()
     this.rootDir = process.cwd() // fallback in case :session:start events are not emitted
+    this._testSuiteSpansByTestSuite = new Map()
 
     this.addSub(`ci:${this.constructor.id}:library-configuration`, (ctx) => {
       const { onDone, isParallel, frameworkVersion } = ctx
@@ -265,6 +299,53 @@ module.exports = class CiPlugin extends Plugin {
       // TODO: Add telemetry for this type of error
       return onDone({ err: new Error('No modified tests could have been retrieved') })
     })
+
+    this.addSub(`ci:${this.constructor.id}:worker-report:trace`, traces => {
+      const formattedTraces = JSON.parse(traces)
+
+      for (const trace of formattedTraces) {
+        for (const span of trace) {
+          span.span_id = id(span.span_id)
+          span.trace_id = id(span.trace_id)
+          span.parent_id = id(span.parent_id)
+
+          if (span.name?.startsWith(`${this.constructor.id}.`)) {
+            // augment with git information (since it will not be available in the worker)
+            for (const key in this.testEnvironmentMetadata) {
+              // CAREFUL: this bypasses the metadata/metrics distinction
+              // Be careful not to pass numbers in `meta`
+              if (key.startsWith('git.')) {
+                span.meta[key] = this.testEnvironmentMetadata[key]
+              }
+            }
+          }
+
+          // Only test hooks run in the cucumber worker, so the test events do not have the
+          // test session, test module and test suite ids. We have to update them here.
+          if (span.name === 'cucumber.test' || span.name === 'mocha.test') {
+            const testSuite = span.meta[TEST_SUITE]
+            const testSuiteSpan = this._testSuiteSpansByTestSuite.get(testSuite)
+            if (!testSuiteSpan) {
+              log.warn(`Test suite span not found for test span with test suite ${testSuite}`)
+              continue
+            }
+
+            const testSuiteTags = getTestSuiteLevelVisibilityTags(testSuiteSpan, this.constructor.id)
+            span.meta = {
+              ...span.meta,
+              ...testSuiteTags
+            }
+          }
+        }
+        this.tracer._exporter.export(trace)
+      }
+    })
+
+    this.addSub(`ci:${this.constructor.id}:worker-report:logs`, (logsPayloads) => {
+      JSON.parse(logsPayloads).forEach(({ logMessage }) => {
+        this.tracer._exporter.exportDiLogs(this.testEnvironmentMetadata, logMessage)
+      })
+    })
   }
 
   get telemetry () {
@@ -298,7 +379,20 @@ module.exports = class CiPlugin extends Plugin {
       this.di = getDiClient()
     }
 
-    this.testEnvironmentMetadata = getTestEnvironmentMetadata(this.constructor.id, this.config)
+    if (this.testConfiguration) { // no need to recalculate as it's constant
+      return
+    }
+
+    const exporter = this.config.experimental?.exporter
+    const workerTestFramework = WORKER_EXPORTER_TO_TEST_FRAMEWORK[exporter]
+    this.shouldSkipGitMetadataExtraction = workerTestFramework &&
+      TEST_FRAMEWORKS_TO_SKIP_GIT_METADATA_EXTRACTION.has(workerTestFramework)
+
+    this.testEnvironmentMetadata = getTestEnvironmentMetadata(
+      this.constructor.id,
+      this.config,
+      this.shouldSkipGitMetadataExtraction
+    )
 
     const {
       [GIT_REPOSITORY_URL]: repositoryUrl,
@@ -318,9 +412,9 @@ module.exports = class CiPlugin extends Plugin {
       [GIT_COMMIT_HEAD_MESSAGE]: commitHeadMessage
     } = this.testEnvironmentMetadata
 
-    this.repositoryRoot = repositoryRoot || process.cwd()
+    this.repositoryRoot = repositoryRoot || getRepositoryRoot() || process.cwd()
 
-    this.codeOwnersEntries = getCodeOwnersFileEntries(repositoryRoot)
+    this.codeOwnersEntries = getCodeOwnersFileEntries(this.repositoryRoot)
 
     this.ciProviderName = ciProviderName
 

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

@@ -13,6 +13,7 @@ module.exports = {
   get '@google-cloud/vertexai' () { return require('../../../datadog-plugin-google-cloud-vertexai/src') },
   get '@grpc/grpc-js' () { return require('../../../datadog-plugin-grpc/src') },
   get '@hapi/hapi' () { return require('../../../datadog-plugin-hapi/src') },
+  get '@happy-dom/jest-environment' () { return require('../../../datadog-plugin-jest/src') },
   get '@jest/core' () { return require('../../../datadog-plugin-jest/src') },
   get '@jest/test-sequencer' () { return require('../../../datadog-plugin-jest/src') },
   get '@jest/transform' () { return require('../../../datadog-plugin-jest/src') },
@@ -73,6 +74,7 @@ module.exports = {
   get 'mocha-each' () { return require('../../../datadog-plugin-mocha/src') },
   get vitest () { return require('../../../datadog-plugin-vitest/src') },
   get workerpool () { return require('../../../datadog-plugin-mocha/src') },
+  get tinypool () { return require('../../../datadog-plugin-vitest/src') },
   get moleculer () { return require('../../../datadog-plugin-moleculer/src') },
   get mongodb () { return require('../../../datadog-plugin-mongodb-core/src') },
   get 'mongodb-core' () { return require('../../../datadog-plugin-mongodb-core/src') },

package/packages/dd-trace/src/plugins/util/git-cache.js

@@ -0,0 +1,129 @@
+'use strict'
+
+const os = require('os')
+const path = require('path')
+const fs = require('fs')
+const crypto = require('crypto')
+const cp = require('child_process')
+
+const log = require('../../log')
+const { getEnvironmentVariable } = require('../../config-helper')
+const { isTrue } = require('../../util')
+
+let isGitEnabled = isTrue(getEnvironmentVariable('DD_EXPERIMENTAL_TEST_OPT_GIT_CACHE_ENABLED'))
+const GIT_CACHE_DIR = getEnvironmentVariable('DD_EXPERIMENTAL_TEST_OPT_GIT_CACHE_DIR') ||
+  path.join(os.tmpdir(), 'dd-trace-git-cache')
+
+function ensureCacheDir () {
+  if (!isGitEnabled) return false
+
+  try {
+    if (fs.existsSync(GIT_CACHE_DIR)) {
+      const stats = fs.statSync(GIT_CACHE_DIR)
+      if (!stats.isDirectory()) {
+        throw new Error(`Cache directory path exists but is not a directory: ${GIT_CACHE_DIR}`)
+      }
+    } else {
+      fs.mkdirSync(GIT_CACHE_DIR, { recursive: true })
+    }
+    return true
+  } catch (err) {
+    log.error('Failed to create git cache directory, disabling cache', err)
+    isGitEnabled = false
+    return false
+  }
+}
+
+// Initialize cache directory at module load time
+ensureCacheDir()
+
+function getCacheKey (cmd, flags) {
+  // Create a hash of the command and flags to use as cache key
+  const commandString = `${cmd} ${flags.join(' ')}`
+  return crypto.createHash('sha256').update(commandString).digest('hex')
+}
+
+function getCacheFilePath (cacheKey) {
+  return path.join(GIT_CACHE_DIR, `${cacheKey}.cache`)
+}
+
+function getCache (cacheKey) {
+  if (!isGitEnabled) return null
+
+  try {
+    const cacheFilePath = getCacheFilePath(cacheKey)
+    if (!fs.existsSync(cacheFilePath)) {
+      return null
+    }
+
+    const content = fs.readFileSync(cacheFilePath, 'utf8')
+    return content
+  } catch (err) {
+    log.error('Failed to read git cache', err)
+    return null
+  }
+}
+
+function setCache (cacheKey, result) {
+  if (!isGitEnabled) return
+
+  // Ensure cache directory exists
+  if (!ensureCacheDir()) return
+
+  try {
+    const cacheFilePath = getCacheFilePath(cacheKey)
+    fs.writeFileSync(cacheFilePath, result, 'utf8')
+  } catch (err) {
+    log.error('Failed to write git cache', err)
+  }
+}
+
+function cachedExec (cmd, flags, options) {
+  if (options === undefined) {
+    options = { stdio: 'pipe' }
+  }
+  if (!isGitEnabled) {
+    return cp.execFileSync(cmd, flags, options)
+  }
+  const cacheKey = getCacheKey(cmd, flags)
+  const cachedResult = getCache(cacheKey)
+  if (cachedResult !== null) {
+    if (cachedResult.startsWith('__GIT_COMMAND_FAILED__')) {
+      let error
+      try {
+        const errorData = cachedResult.replace('__GIT_COMMAND_FAILED__', '')
+        const { message, code, status, errno } = JSON.parse(errorData)
+        error = new Error(message)
+        error.code = code
+        error.status = status
+        error.errno = errno
+      } catch {
+        // we couldn't parse the error data, so we'll throw a generic error
+        throw new Error('Git command failed')
+      }
+      throw error
+    }
+    return cachedResult
+  }
+  try {
+    const result = cp.execFileSync(cmd, flags, options)
+    setCache(cacheKey, result)
+    return result
+  } catch (err) {
+    const cacheValue = '__GIT_COMMAND_FAILED__' +
+      JSON.stringify({
+        code: err.code,
+        status: err.status,
+        errno: err.errno,
+        message: err.message
+      })
+    setCache(cacheKey, cacheValue)
+    throw err
+  }
+}
+
+module.exports = {
+  getCacheKey,
+  getCacheFilePath,
+  cachedExec
+}