dd-trace 5.41.1 → 5.42.0

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

@@ -27,7 +27,10 @@ const {
   DI_DEBUG_ERROR_PREFIX,
   DI_DEBUG_ERROR_SNAPSHOT_ID_SUFFIX,
   DI_DEBUG_ERROR_FILE_SUFFIX,
-  DI_DEBUG_ERROR_LINE_SUFFIX
+  DI_DEBUG_ERROR_LINE_SUFFIX,
+  DD_CAPABILITIES_EARLY_FLAKE_DETECTION,
+  DD_CAPABILITIES_AUTO_TEST_RETRIES,
+  DD_CAPABILITIES_TEST_IMPACT_ANALYSIS
 } = require('./util/test')
 const Plugin = require('./plugin')
 const { COMPONENT } = require('../constants')
@@ -42,6 +45,19 @@ const { CI_PROVIDER_NAME, GIT_REPOSITORY_URL, GIT_COMMIT_SHA, GIT_BRANCH, CI_WOR
 const { OS_VERSION, OS_PLATFORM, OS_ARCHITECTURE, RUNTIME_NAME, RUNTIME_VERSION } = require('./util/env')
 const getDiClient = require('../ci-visibility/dynamic-instrumentation')
 
+const UNSUPPORTED_TIA_FRAMEWORKS = ['playwright', 'vitest']
+const UNSUPPORTED_TIA_FRAMEWORKS_PARALLEL_MODE = ['cucumber', 'mocha']
+
+function isTiaSupported (testFramework, isParallel) {
+  if (UNSUPPORTED_TIA_FRAMEWORKS.includes(testFramework)) {
+    return false
+  }
+  if (isParallel && UNSUPPORTED_TIA_FRAMEWORKS_PARALLEL_MODE.includes(testFramework)) {
+    return false
+  }
+  return true
+}
+
 module.exports = class CiPlugin extends Plugin {
   constructor (...args) {
     super(...args)
@@ -49,7 +65,7 @@ module.exports = class CiPlugin extends Plugin {
     this.fileLineToProbeId = new Map()
     this.rootDir = process.cwd() // fallback in case :session:start events are not emitted
 
-    this.addSub(`ci:${this.constructor.id}:library-configuration`, ({ onDone }) => {
+    this.addSub(`ci:${this.constructor.id}:library-configuration`, ({ onDone, isParallel }) => {
       if (!this.tracer._exporter || !this.tracer._exporter.getLibraryConfiguration) {
         return onDone({ err: new Error('Test optimization was not initialized correctly') })
       }
@@ -59,6 +75,18 @@ module.exports = class CiPlugin extends Plugin {
         } else {
           this.libraryConfig = libraryConfig
         }
+        const { isItrEnabled, isEarlyFlakeDetectionEnabled, isFlakyTestRetriesEnabled } = this.libraryConfig || {}
+        const metadataTags = {
+          test: {
+            [DD_CAPABILITIES_TEST_IMPACT_ANALYSIS]: isItrEnabled ? 'true' : 'false',
+            [DD_CAPABILITIES_EARLY_FLAKE_DETECTION]: isEarlyFlakeDetectionEnabled ? 'true' : 'false',
+            [DD_CAPABILITIES_AUTO_TEST_RETRIES]: isFlakyTestRetriesEnabled ? 'true' : 'false'
+          }
+        }
+        if (!isTiaSupported(this.constructor.id, isParallel)) {
+          metadataTags.test[DD_CAPABILITIES_TEST_IMPACT_ANALYSIS] = undefined
+        }
+        this.tracer._exporter.addMetadataTags(metadataTags)
         onDone({ err, libraryConfig })
       })
     })
@@ -96,8 +124,8 @@ module.exports = class CiPlugin extends Plugin {
         }
       }
       // tracer might not be initialized correctly
-      if (this.tracer._exporter.setMetadataTags) {
-        this.tracer._exporter.setMetadataTags(metadataTags)
+      if (this.tracer._exporter.addMetadataTags) {
+        this.tracer._exporter.addMetadataTags(metadataTags)
       }
 
       this.testSessionSpan = this.tracer.startSpan(`${this.constructor.id}.test_session`, {
@@ -166,16 +194,16 @@ module.exports = class CiPlugin extends Plugin {
       })
     })
 
-    this.addSub(`ci:${this.constructor.id}:quarantined-tests`, ({ onDone }) => {
-      if (!this.tracer._exporter?.getQuarantinedTests) {
+    this.addSub(`ci:${this.constructor.id}:test-management-tests`, ({ onDone }) => {
+      if (!this.tracer._exporter?.getTestManagementTests) {
         return onDone({ err: new Error('Test optimization was not initialized correctly') })
       }
-      this.tracer._exporter.getQuarantinedTests(this.testConfiguration, (err, quarantinedTests) => {
+      this.tracer._exporter.getTestManagementTests(this.testConfiguration, (err, testManagementTests) => {
         if (err) {
-          log.error('Quarantined tests could not be fetched. %s', err.message)
-          this.libraryConfig.isQuarantinedTestsEnabled = false
+          log.error('Test management tests could not be fetched. %s', err.message)
+          this.libraryConfig.isTestManagementEnabled = false
         }
-        onDone({ err, quarantinedTests })
+        onDone({ err, testManagementTests })
       })
     })
   }

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

@@ -9,6 +9,7 @@ module.exports = {
   get '@elastic/elasticsearch' () { return require('../../../datadog-plugin-elasticsearch/src') },
   get '@elastic/transport' () { return require('../../../datadog-plugin-elasticsearch/src') },
   get '@google-cloud/pubsub' () { return require('../../../datadog-plugin-google-cloud-pubsub/src') },
+  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 '@jest/core' () { return require('../../../datadog-plugin-jest/src') },

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

@@ -35,7 +35,8 @@ function sanitizedExec (
   flags,
   operationMetric,
   durationMetric,
-  errorMetric
+  errorMetric,
+  shouldTrim = true
 ) {
   const store = storage('legacy').getStore()
   storage('legacy').enterWith({ noop: true })
@@ -48,7 +49,10 @@ function sanitizedExec (
     startTime = Date.now()
   }
   try {
-    const result = cp.execFileSync(cmd, flags, { stdio: 'pipe' }).toString().replace(/(\r\n|\n|\r)/gm, '')
+    let result = cp.execFileSync(cmd, flags, { stdio: 'pipe' }).toString()
+    if (shouldTrim) {
+      result = result.replace(/(\r\n|\n|\r)/gm, '')
+    }
     if (durationMetric) {
       distributionMetric(durationMetric.name, durationMetric.tags, Date.now() - startTime)
     }
@@ -330,7 +334,7 @@ function getGitMetadata (ciMetadata) {
 
   const tags = {
     [GIT_COMMIT_MESSAGE]:
-      commitMessage || sanitizedExec('git', ['show', '-s', '--format=%s']),
+      commitMessage || sanitizedExec('git', ['show', '-s', '--format=%B'], null, null, null, false),
     [GIT_BRANCH]: branch || sanitizedExec('git', ['rev-parse', '--abbrev-ref', 'HEAD']),
     [GIT_COMMIT_SHA]: commitSHA || sanitizedExec('git', ['rev-parse', 'HEAD']),
     [CI_WORKSPACE_PATH]: ciWorkspacePath || sanitizedExec('git', ['rev-parse', '--show-toplevel'])

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

@@ -99,6 +99,11 @@ const MOCHA_WORKER_TRACE_PAYLOAD_CODE = 80
 const EFD_STRING = "Retried by Datadog's Early Flake Detection"
 const EFD_TEST_NAME_REGEX = new RegExp(EFD_STRING + ' \\(#\\d+\\): ', 'g')
 
+// Library Capabilities Tagging
+const DD_CAPABILITIES_TEST_IMPACT_ANALYSIS = '_dd.library_capabilities.test_impact_analysis'
+const DD_CAPABILITIES_EARLY_FLAKE_DETECTION = '_dd.library_capabilities.early_flake_detection'
+const DD_CAPABILITIES_AUTO_TEST_RETRIES = '_dd.library_capabilities.auto_test_retries'
+
 const TEST_LEVEL_EVENT_TYPES = [
   'test',
   'test_suite_end',
@@ -115,6 +120,7 @@ const DI_DEBUG_ERROR_SNAPSHOT_ID_SUFFIX = 'snapshot_id'
 const DI_DEBUG_ERROR_FILE_SUFFIX = 'file'
 const DI_DEBUG_ERROR_LINE_SUFFIX = 'line'
 
+const TEST_MANAGEMENT_IS_DISABLED = 'test.test_management.is_test_disabled'
 const TEST_MANAGEMENT_IS_QUARANTINED = 'test.test_management.is_quarantined'
 const TEST_MANAGEMENT_ENABLED = 'test.test_management.enabled'
 
@@ -193,6 +199,9 @@ module.exports = {
   TEST_BROWSER_NAME,
   TEST_BROWSER_VERSION,
   getTestSessionName,
+  DD_CAPABILITIES_TEST_IMPACT_ANALYSIS,
+  DD_CAPABILITIES_EARLY_FLAKE_DETECTION,
+  DD_CAPABILITIES_AUTO_TEST_RETRIES,
   TEST_LEVEL_EVENT_TYPES,
   getNumFromKnownTests,
   getFileAndLineNumberFromError,
@@ -203,6 +212,7 @@ module.exports = {
   DI_DEBUG_ERROR_LINE_SUFFIX,
   getFormattedError,
   DD_TEST_IS_USER_PROVIDED_SERVICE,
+  TEST_MANAGEMENT_IS_DISABLED,
   TEST_MANAGEMENT_IS_QUARANTINED,
   TEST_MANAGEMENT_ENABLED
 }

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

@@ -8,10 +8,11 @@ const tags = require('../../../../../ext/tags')
 const types = require('../../../../../ext/types')
 const kinds = require('../../../../../ext/kinds')
 const urlFilter = require('./urlfilter')
-const { extractIp } = require('./ip_extractor')
 const { ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK } = require('../../constants')
 const { createInferredProxySpan, finishInferredProxySpan } = require('./inferred_proxy')
 
+let extractIp
+
 const WEB = types.WEB
 const SERVER = kinds.SERVER
 const RESOURCE_NAME = tags.RESOURCE_NAME
@@ -48,6 +49,8 @@ const web = {
     const middleware = getMiddlewareSetting(config)
     const queryStringObfuscation = getQsObfuscator(config)
 
+    extractIp = config.clientIpEnabled && require('./ip_extractor').extractIp
+
     return {
       ...config,
       headers,
@@ -460,7 +463,7 @@ function addRequestTags (context, spanType) {
   })
 
   // if client ip has already been set by appsec, no need to run it again
-  if (config.clientIpEnabled && !span.context()._tags.hasOwnProperty(HTTP_CLIENT_IP)) {
+  if (extractIp && !span.context()._tags.hasOwnProperty(HTTP_CLIENT_IP)) {
     const clientIp = extractIp(config, req)
 
     if (clientIp) {

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

@@ -39,28 +39,54 @@ const DEFAULT_KEY = 'service:,env:'
 
 const defaultSampler = new Sampler(AUTO_KEEP)
 
+/**
+ * from config.js
+ * @typedef { sampleRate: number, provenance: string, rateLimit: number, rules: SamplingRule[] } SamplingConfig
+ *
+ * empirically defined
+ * @typedef {2|-1|1|0} SamplingPriority
+ */
 class PrioritySampler {
+  /**
+   * @param env {string}
+   * @param config {SamplingConfig}
+   */
   constructor (env, config) {
     this.configure(env, config)
     this.update({})
   }
 
+  /**
+   *
+   * @param env {string}
+   * @param opts {SamplingConfig}
+   */
   configure (env, opts = {}) {
     const { sampleRate, provenance = undefined, rateLimit = 100, rules = [] } = opts
     this._env = env
-    this._rules = this._normalizeRules(rules, sampleRate, rateLimit, provenance)
+    this._rules = this.#_normalizeRules(rules, sampleRate, rateLimit, provenance)
     this._limiter = new RateLimiter(rateLimit)
 
     log.trace(env, opts)
     setSamplingRules(this._rules)
   }
 
+  /**
+   * @param span {DatadogSpan}
+   * @returns {boolean}
+   */
   isSampled (span) {
     const priority = this._getPriorityFromAuto(span)
     log.trace(span)
     return priority === USER_KEEP || priority === AUTO_KEEP
   }
 
+  /**
+   *
+   * @param span {DatadogSpan}
+   * @param auto {boolean}
+   * @returns {void}
+   */
   sample (span, auto = true) {
     if (!span) return
 
@@ -84,17 +110,20 @@ class PrioritySampler {
       return
     }
 
-    this._addDecisionMaker(root)
+    this.#_addDecisionMaker(root)
   }
 
+  /**
+   *
+   * @param rates {Record<string, number>}
+   * @returns {void}
+   */
   update (rates) {
     const samplers = {}
 
     for (const key in rates) {
       const rate = rates[key]
-      const sampler = new Sampler(rate)
-
-      samplers[key] = sampler
+      samplers[key] = new Sampler(rate)
     }
 
     samplers[DEFAULT_KEY] = samplers[DEFAULT_KEY] || defaultSampler
@@ -104,6 +133,11 @@ class PrioritySampler {
     log.trace(rates)
   }
 
+  /**
+   *
+   * @param samplingPriority {SamplingPriority}
+   * @returns {boolean}
+   */
   validate (samplingPriority) {
     switch (samplingPriority) {
       case USER_REJECT:
@@ -116,6 +150,12 @@ class PrioritySampler {
     }
   }
 
+  /**
+   *
+   * @param span {DatadogSpan}
+   * @param samplingPriority {SamplingPriority}
+   * @param product {import('./standalone/product').PRODUCTS}
+   */
   setPriority (span, samplingPriority, product) {
     if (!span || !this.validate(samplingPriority)) return
 
@@ -134,23 +174,40 @@ class PrioritySampler {
 
     log.trace(span, samplingPriority, mechanism)
 
-    this._addDecisionMaker(root)
+    this.#_addDecisionMaker(root)
   }
 
+  /**
+   *
+   * @param span {DatadogSpan}
+   * @returns {DatadogSpanContext}
+   */
   _getContext (span) {
     return typeof span.context === 'function' ? span.context() : span
   }
 
+  /**
+   *
+   * @param span {DatadogSpan}
+   * @returns {SamplingPriority}
+   */
   _getPriorityFromAuto (span) {
     const context = this._getContext(span)
-    const rule = this._findRule(span)
+    const rule = this.#_findRule(span)
 
     return rule
-      ? this._getPriorityByRule(context, rule)
-      : this._getPriorityByAgent(context)
+      ? this.#_getPriorityByRule(context, rule)
+      : this.#_getPriorityByAgent(context)
   }
 
-  _getPriorityFromTags (tags) {
+  /**
+   *
+   * @param tags {Record<string, symbol | unknown>}
+   * Included for compatibility with {@link import('./standalone/tracesource_priority_sampler')._getPriorityFromTags}
+   * @param _context {DatadogSpanContext}
+   * @returns {SamplingPriority}
+   */
+  _getPriorityFromTags (tags, _context) {
     if (hasOwn(tags, MANUAL_KEEP) && tags[MANUAL_KEEP] !== false) {
       return USER_KEEP
     } else if (hasOwn(tags, MANUAL_DROP) && tags[MANUAL_DROP] !== false) {
@@ -166,7 +223,13 @@ class PrioritySampler {
     }
   }
 
-  _getPriorityByRule (context, rule) {
+  /**
+   *
+   * @param context {DatadogSpanContext}
+   * @param rule {SamplingRule}
+   * @returns {SamplingPriority}
+   */
+  #_getPriorityByRule (context, rule) {
     context._trace[SAMPLING_RULE_DECISION] = rule.sampleRate
     context._sampling.mechanism = SAMPLING_MECHANISM_RULE
     if (rule.provenance === 'customer') context._sampling.mechanism = SAMPLING_MECHANISM_REMOTE_USER
@@ -177,6 +240,12 @@ class PrioritySampler {
       : USER_REJECT
   }
 
+  /**
+   *
+   * @param context {DatadogSpanContext}
+   * @returns {boolean}
+   * @private
+   */
   _isSampledByRateLimit (context) {
     const allowed = this._limiter.isAllowed()
 
@@ -185,7 +254,13 @@ class PrioritySampler {
     return allowed
   }
 
-  _getPriorityByAgent (context) {
+  /**
+   *
+   * @param context {DatadogSpanContext}
+   * @returns {SamplingPriority}
+   * @private
+   */
+  #_getPriorityByAgent (context) {
     const key = `service:${context._tags[SERVICE_NAME]},env:${this._env}`
     const sampler = this._samplers[key] || this._samplers[DEFAULT_KEY]
 
@@ -200,7 +275,13 @@ class PrioritySampler {
     return sampler.isSampled(context) ? AUTO_KEEP : AUTO_REJECT
   }
 
-  _addDecisionMaker (span) {
+  /**
+   *
+   * @param span {DatadogSpan}
+   * @private
+   * @returns {void}
+   */
+  #_addDecisionMaker (span) {
     const context = span.context()
     const trace = context._trace
     const priority = context._sampling.priority
@@ -215,7 +296,16 @@ class PrioritySampler {
     }
   }
 
-  _normalizeRules (rules, sampleRate, rateLimit, provenance) {
+  /**
+   *
+   * @param rules {SamplingRule[]}
+   * @param sampleRate {number}
+   * @param rateLimit {number}
+   * @param provenance {string}
+   * @returns {SamplingRule[]}
+   * @private
+   */
+  #_normalizeRules (rules, sampleRate, rateLimit, provenance) {
     rules = [].concat(rules || [])
 
     return rules
@@ -225,12 +315,23 @@ class PrioritySampler {
       .map(SamplingRule.from)
   }
 
-  _findRule (span) {
+  /**
+   *
+   * @param span {DatadogSpan}
+   * @returns {SamplingRule}
+   * @private
+   */
+  #_findRule (span) {
     for (const rule of this._rules) {
       if (rule.match(span)) return rule
     }
   }
 
+  /**
+   *
+   * @param span {DatadogSpan}
+   * @param product {import('./standalone/product').PRODUCTS}
+   */
   static keepTrace (span, product) {
     span?._prioritySampler?.setPriority(span, USER_KEEP, product)
   }

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

@@ -1,14 +1,23 @@
 'use strict'
 
 class Sampler {
+  /**
+   * @param rate {number}
+   */
   constructor (rate) {
     this._rate = rate
   }
 
+  /**
+   * @returns {number}
+   */
   rate () {
     return this._rate
   }
 
+  /**
+   * @returns {boolean}
+   */
   isSampled () {
     return this._rate === 1 || Math.random() < this._rate
   }

package/packages/dd-trace/src/standalone/product.js

@@ -13,12 +13,16 @@ function getProductRateLimiter (config) {
   return dropAll
 }
 
-module.exports = {
+const PRODUCTS = {
   APM: { id: 1 << 0 },
   ASM: { id: 1 << 1, mechanism: SAMPLING_MECHANISM_APPSEC },
   DSM: { id: 1 << 2 },
   DJM: { id: 1 << 3 },
-  DBM: { id: 1 << 4 },
+  DBM: { id: 1 << 4 }
+}
+
+module.exports = {
+  ...PRODUCTS,
 
   getProductRateLimiter
 }

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

@@ -86,7 +86,8 @@ function tracerInfo () {
 
   out.log_injection_enabled = !!config.logInjection
   out.runtime_metrics_enabled = !!config.runtimeMetrics
-  out.profiling_enabled = !!(config.profiling || {}).enabled
+  const profilingEnabled = config.profiling?.enabled
+  out.profiling_enabled = profilingEnabled === 'true' || profilingEnabled === 'auto'
   Object.assign(out, getIntegrationsAndAnalytics())
 
   out.appsec_enabled = !!config.appsec.enabled

package/packages/dd-trace/src/telemetry/metrics.js

@@ -27,19 +27,11 @@ function hasPoints (metric) {
   return metric.points.length > 0
 }
 
-let versionTag
-
 class Metric {
   constructor (namespace, metric, common, tags) {
     this.namespace = namespace.toString()
     this.metric = common ? metric : `nodejs.${metric}`
     this.tags = tagArray(tags)
-    if (common) {
-      if (versionTag === undefined) {
-        versionTag = `version:${process.version}`
-      }
-      this.tags.push(versionTag)
-    }
     this.common = common
 
     this.points = []

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

@@ -7,7 +7,7 @@ const { isError } = require('./util')
 const { setStartupLogConfig } = require('./startup-log')
 const { ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK } = require('../../dd-trace/src/constants')
 const { DataStreamsCheckpointer, DataStreamsManager, DataStreamsProcessor } = require('./datastreams')
-const { flushStartupLogs } = require('../../datadog-instrumentations/src/check_require_cache')
+const { flushStartupLogs } = require('../../datadog-instrumentations/src/helpers/check-require-cache')
 const log = require('./log/writer')
 
 const SPAN_TYPE = tags.SPAN_TYPE