dd-trace 6.17.0 → 6.19.0

package/packages/dd-trace/src/openfeature/writers/base.js

@@ -1,9 +1,14 @@
 'use strict'
 
 const request = require('../../exporters/common/request')
-const { safeJSONStringify } = require('../../exporters/common/util')
 
 const log = require('../../log')
+const tracerVersion = require('../../../../../package.json').version
+
+const EVP_ORIGIN_HEADERS = {
+  'DD-EVP-ORIGIN': 'dd-trace-js',
+  'DD-EVP-ORIGIN-VERSION': tracerVersion,
+}
 
 /**
  * @typedef {object} BaseFFEWriterOptions
@@ -23,6 +28,8 @@ const log = require('../../log')
  * @property {string} endpoint - Route endpoint
  * @property {object} headers - Route-specific headers
  * @property {import('node:https').Agent} [agent] - Optional HTTPS proxy agent
+ * @property {Function} [onFallback] - Called after direct fallback becomes active
+ * @property {Function} [onUnavailable] - Called after the local route becomes unavailable
  */
 
 /**
@@ -30,6 +37,8 @@ const log = require('../../log')
  * @property {URL} url - Route base URL
  * @property {string} endpoint - Route endpoint
  * @property {object} requestOptions - HTTP request options
+ * @property {Function} [onFallback] - Called after direct fallback becomes active
+ * @property {Function} [onUnavailable] - Called after the local route becomes unavailable
  */
 
 /**
@@ -38,19 +47,31 @@ const log = require('../../log')
  * @param {Error | null} error - Request error
  * @param {number | undefined} statusCode - HTTP response status
  */
-function isDefinitiveRejection (error, statusCode) {
+function isSafeToReplay (error, statusCode) {
   return error?.code === 'EAI_AGAIN' || error?.code === 'ECONNREFUSED' ||
     error?.code === 'ENOENT' || error?.code === 'ENOTFOUND' ||
-    statusCode === 403 || statusCode === 404 || statusCode === 405
+    statusCode === 404 || statusCode === 405
 }
 
 /**
- * Tests whether a local route can have accepted an event batch before failing.
+ * Tests whether a local route failed without an authoritative HTTP response.
  *
  * @param {Error | null} error - Request error
+ * @param {number | undefined} statusCode - HTTP response status
+ */
+function isTransportFailure (error, statusCode) {
+  // SDK backpressure says nothing about the local receiver's health.
+  return error !== null && error !== undefined && statusCode === undefined &&
+    error.code !== 'ERR_DD_REQUEST_BUFFER_FULL'
+}
+
+/**
+ * Tests whether an HTTP response should move only future Agentless batches.
+ *
+ * @param {number | undefined} statusCode - HTTP response status
  */
-function isAmbiguousNetworkFailure (error) {
-  return error?.code === 'ECONNRESET' || error?.code === 'EPIPE' || error?.code === 'ETIMEDOUT'
+function shouldSwitchFutureRoute (statusCode) {
+  return statusCode === 403 || statusCode === 429 || statusCode >= 500 && statusCode < 600
 }
 
 /**
@@ -81,10 +102,11 @@ class BaseFFEWriter {
     this._requestOptions = {
       headers: {
         ...this._headers,
+        ...EVP_ORIGIN_HEADERS,
         'Content-Type': 'application/json',
       },
       method: 'POST',
-      retry: true,
+      retry: false,
       timeout: this._timeout,
       url: this._baseUrl,
       path: this._endpoint,
@@ -150,11 +172,10 @@ class BaseFFEWriter {
 
     const payload = this._encode(this.makePayload(events))
 
+    // Keep byte counting behind the debug callback because payloads can be several megabytes.
     // eslint-disable-next-line eslint-rules/eslint-log-printf-style
-    log.debug(() => `${this.constructor.name} flushing payload: ${safeJSONStringify(payload)}`)
-
-    const route = this.#createActiveRoute()
-    this.#sendRequest(payload, events.length, route, this._fallbackRoute)
+    log.debug(() => `${this.constructor.name} flushing ${events.length} events (${Buffer.byteLength(payload)} bytes)`)
+    this._sendPayload(payload, events.length)
   }
 
   /**
@@ -192,6 +213,18 @@ class BaseFFEWriter {
     return JSON.stringify(payload)
   }
 
+  /**
+   * Sends one encoded event batch through a snapshot of the selected routes.
+   *
+   * @protected
+   * @param {string} payload - Encoded event batch
+   * @param {number} eventCount - Event count
+   */
+  _sendPayload (payload, eventCount) {
+    const route = this.#createActiveRoute()
+    this.#sendRequest(payload, eventCount, route, this._fallbackRoute)
+  }
+
   /**
    * Applies the active route and an optional direct fallback route.
    *
@@ -213,10 +246,11 @@ class BaseFFEWriter {
     const requestOptions = {
       headers: {
         ...route.headers,
+        ...EVP_ORIGIN_HEADERS,
         'Content-Type': 'application/json',
       },
       method: 'POST',
-      retry: true,
+      retry: false,
       timeout: this._timeout,
       url: route.url,
       path: route.endpoint,
@@ -227,6 +261,8 @@ class BaseFFEWriter {
       url: route.url,
       endpoint: route.endpoint,
       requestOptions,
+      onFallback: route.onFallback,
+      onUnavailable: route.onUnavailable,
     }
   }
 
@@ -240,6 +276,8 @@ class BaseFFEWriter {
       url: this._baseUrl,
       endpoint: this._endpoint,
       requestOptions: this._requestOptions,
+      onFallback: this._onFallback,
+      onUnavailable: this._onUnavailable,
     }
   }
 
@@ -252,10 +290,12 @@ class BaseFFEWriter {
     this._baseUrl = route.url
     this._endpoint = route.endpoint
     this._requestOptions = route.requestOptions
+    this._onFallback = route.onFallback
+    this._onUnavailable = route.onUnavailable
   }
 
   /**
-   * Sends an encoded batch and retries it through direct intake after a local route failure.
+   * Sends an encoded batch once per route and applies safe local fallback semantics.
    *
    * @param {string} payload - Encoded event batch
    * @param {number} eventCount - Event count
@@ -264,7 +304,7 @@ class BaseFFEWriter {
    */
   #sendRequest (payload, eventCount, route, fallbackRoute) {
     request(payload, route.requestOptions, (error, response, statusCode) => {
-      if (fallbackRoute && isDefinitiveRejection(error, statusCode)) {
+      if (fallbackRoute && isSafeToReplay(error, statusCode)) {
         log.debug(
           '%s switching from %s%s to direct intake after definitive rejection',
           this.constructor.name,
@@ -273,20 +313,53 @@ class BaseFFEWriter {
         )
         this.#activateRoute(fallbackRoute)
         this._fallbackRoute = undefined
+        route.onFallback?.()
         this.#sendRequest(payload, eventCount, fallbackRoute)
         return
       }
 
-      if (fallbackRoute && isAmbiguousNetworkFailure(error)) {
+      if (fallbackRoute && isTransportFailure(error, statusCode)) {
         log.debug(
-          '%s retrying through direct intake and switching future batches from %s%s after ambiguous failure',
+          '%s switching future batches from %s%s to direct intake after an ambiguous failure without replay',
           this.constructor.name,
           route.url.href,
           route.endpoint
         )
         this.#activateRoute(fallbackRoute)
         this._fallbackRoute = undefined
-        this.#sendRequest(payload, eventCount, fallbackRoute)
+        route.onFallback?.()
+        log.error('Failed to send events to %s%s: %s', route.url.href, route.endpoint, error.message)
+        return
+      }
+
+      if (fallbackRoute && shouldSwitchFutureRoute(statusCode)) {
+        log.debug(
+          '%s switching future batches from %s%s to direct intake after status %d without replay',
+          this.constructor.name,
+          route.url.href,
+          route.endpoint,
+          statusCode
+        )
+        this.#activateRoute(fallbackRoute)
+        this._fallbackRoute = undefined
+        route.onFallback?.()
+        log.warn('Events request returned status %d', statusCode)
+        return
+      }
+
+      if (
+        !fallbackRoute &&
+        route.onUnavailable &&
+        (isSafeToReplay(error, statusCode) ||
+          isTransportFailure(error, statusCode) ||
+          shouldSwitchFutureRoute(statusCode))
+      ) {
+        route.onUnavailable()
+        if (error) {
+          log.error('Failed to send events to %s%s: %s', route.url.href, route.endpoint, error.message)
+        } else {
+          log.warn('Events request returned status %d', statusCode)
+        }
         return
       }
 

package/packages/dd-trace/src/openfeature/writers/exposures.js

@@ -26,6 +26,8 @@ const PENDING_MAX_EVENTS = 1000
  * @property {object} [headers] - Route-specific headers
  * @property {import('node:https').Agent} [agent] - Optional HTTPS proxy agent
  * @property {ExposureRoute} [fallback] - Optional direct fallback route
+ * @property {Function} [onFallback] - Called after direct fallback becomes active
+ * @property {Function} [onUnavailable] - Called after the local route becomes unavailable
  */
 
 /**
@@ -150,6 +152,8 @@ class ExposuresWriter extends BaseFFEWriter {
       endpoint: joinEVPProxyPath(route.basePath, EXPOSURES_ENDPOINT),
       headers,
       agent: route.agent,
+      onFallback: route.onFallback,
+      onUnavailable: route.onUnavailable,
     }, fallbackRoute)
   }
 

package/packages/dd-trace/src/openfeature/writers/util.js

@@ -2,6 +2,8 @@
 
 const {
   EVP_EVENT_PLATFORM_SUBDOMAIN,
+  EVP_ORIGIN_HEADER_NAME,
+  EVP_ORIGIN_VERSION_HEADER_NAME,
   EVP_PROXY_PATH_V2,
   EVP_PROXY_PATH_V4,
   EVP_SUBDOMAIN_HEADER_NAME,
@@ -10,6 +12,10 @@ const { createDirectEVPRoute } = require('../../evp_proxy/direct')
 const { discoverEVPProxy } = require('../../evp_proxy/discovery')
 const logger = require('../../log')
 
+const ROUTE_DISCOVERY_COOLDOWN_MS = 60_000
+const REQUIRED_LOCAL_HEADERS = [EVP_ORIGIN_HEADER_NAME, EVP_ORIGIN_VERSION_HEADER_NAME]
+const STOP_NOOP = () => {}
+
 let missingRouteWarningLogged = false
 
 /**
@@ -26,7 +32,7 @@ function warnExposureDeliveryUnavailable () {
 }
 
 /**
- * Preserves Agent exposure delivery for the Remote Configuration source.
+ * Preserves the one-time EVP v2 capability check for the Remote Configuration source.
  *
  * @param {import('../../config')} config - Tracer configuration object
  * @param {Function} setWriterEnabledValue - Callback to set the writer enabled state
@@ -49,6 +55,7 @@ function setAgentStrategy (config, setWriterEnabledValue) {
       setWriterEnabledValue(false)
     }
   })
+  return STOP_NOOP
 }
 
 /**
@@ -62,54 +69,118 @@ function setAgentStrategy (config, setWriterEnabledValue) {
  */
 function setAgentlessStrategy (config, setWriterEnabledValue) {
   const directRoute = createDirectEVPRoute(config, EVP_EVENT_PLATFORM_SUBDOMAIN)
+  let discovering = false
+  let recoveryTimer
+  let state = 'unknown'
+  let stopped = false
 
-  discoverEVPProxy(config.url, {
-    supportedPaths: [EVP_PROXY_PATH_V4, EVP_PROXY_PATH_V2],
-  }, (error, localRoute) => {
-    if (localRoute) {
-      const route = {
-        ...localRoute,
-        headers: {
-          [EVP_SUBDOMAIN_HEADER_NAME]: EVP_EVENT_PLATFORM_SUBDOMAIN,
-        },
-      }
-      if (directRoute) route.fallback = directRoute
-      logger.debug('FFE Writer enabled with local EVP route %s', route.basePath)
-      setWriterEnabledValue(true, route)
-      return
+  const stop = () => {
+    stopped = true
+    clearTimeout(recoveryTimer)
+    recoveryTimer = undefined
+  }
+
+  const scheduleRecovery = () => {
+    if (stopped || state !== 'unavailable' || recoveryTimer !== undefined) return
+
+    recoveryTimer = setTimeout(discover, ROUTE_DISCOVERY_COOLDOWN_MS)
+    recoveryTimer.unref?.()
+  }
+
+  const markUnavailable = () => {
+    if (stopped || state === 'direct') return
+    if (state !== 'unavailable') {
+      state = 'unavailable'
+      setWriterEnabledValue(false)
     }
+    scheduleRecovery()
+  }
 
+  const activateDirect = () => {
+    if (stopped || state === 'direct' || directRoute === undefined) return
+    state = 'direct'
+    clearTimeout(recoveryTimer)
+    recoveryTimer = undefined
+    setWriterEnabledValue(true, directRoute)
+  }
+
+  /**
+   * @param {{url: URL, basePath: string}} localRoute - Discovered local route
+   */
+  const activateLocal = localRoute => {
+    state = 'local'
+    const route = {
+      ...localRoute,
+      headers: {
+        [EVP_SUBDOMAIN_HEADER_NAME]: EVP_EVENT_PLATFORM_SUBDOMAIN,
+      },
+    }
     if (directRoute) {
+      route.fallback = directRoute
+      route.onFallback = activateDirect
+    } else {
+      route.onUnavailable = markUnavailable
+    }
+    logger.debug('FFE Writer enabled with local EVP route %s', route.basePath)
+    setWriterEnabledValue(true, route)
+  }
+
+  function discover () {
+    recoveryTimer = undefined
+    if (stopped || state === 'direct' || discovering) return
+    discovering = true
+
+    discoverEVPProxy(config.url, {
+      requiredHeaders: REQUIRED_LOCAL_HEADERS,
+      supportedPaths: [EVP_PROXY_PATH_V4, EVP_PROXY_PATH_V2],
+      // Agentless owns fallback and unavailable-state recovery; do not delay them with HTTP retries.
+      retry: false,
+    }, (error, localRoute) => {
+      discovering = false
+      if (stopped || state === 'direct') return
+
+      if (localRoute) {
+        activateLocal(localRoute)
+        return
+      }
+
+      if (directRoute) {
+        if (error) {
+          logger.debug('FFE Writer using direct EVP intake after local discovery failed: %s', error.message)
+        } else {
+          logger.debug('FFE Writer using direct EVP intake because no compatible local route was advertised')
+        }
+        activateDirect()
+        return
+      }
+
       if (error) {
-        logger.debug('FFE Writer using direct EVP intake after local discovery failed: %s', error.message)
-      } else {
-        logger.debug('FFE Writer using direct EVP intake because no compatible local route was advertised')
+        logger.debug('FFE Writer disabled - error getting local receiver info: %s', error.message)
       }
-      setWriterEnabledValue(true, directRoute)
-      return
-    }
+      warnExposureDeliveryUnavailable()
+      markUnavailable()
+    })
+  }
 
-    if (error) {
-      logger.debug('FFE Writer disabled - error getting local receiver info: %s', error.message)
-    }
-    warnExposureDeliveryUnavailable()
-    setWriterEnabledValue(false)
-  })
+  discover()
+  return stop
 }
 
 /**
- * Applies the exposure-delivery strategy for the configured Feature Flags source.
+ * Applies one event-delivery strategy that can be shared by all Feature Flags writers.
  *
  * @param {import('../../config')} config - Tracer configuration object
  * @param {Function} setWriterEnabledValue - Callback to set the writer enabled state
  */
-function setExposureDeliveryStrategy (config, setWriterEnabledValue) {
+function setEventDeliveryStrategy (config, setWriterEnabledValue) {
   if (config.featureFlags?.DD_FEATURE_FLAGS_CONFIGURATION_SOURCE === 'agentless') {
-    setAgentlessStrategy(config, setWriterEnabledValue)
-    return
+    return setAgentlessStrategy(config, setWriterEnabledValue)
   }
 
-  setAgentStrategy(config, setWriterEnabledValue)
+  return setAgentStrategy(config, setWriterEnabledValue)
 }
 
-module.exports = { setExposureDeliveryStrategy }
+module.exports = {
+  setEventDeliveryStrategy,
+  setExposureDeliveryStrategy: setEventDeliveryStrategy,
+}

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

@@ -1,6 +1,7 @@
 'use strict'
 
 const { VERSION } = require('../../../../../version')
+const { SDK_OTLP_EXPORT_KEY, SDK_SEMANTICS_KEY } = require('../../constants')
 const { registerResourceAttributeRefresh } = require('../resource-attributes')
 const OtlpHttpTraceExporter = require('./otlp_http_trace_exporter')
 
@@ -46,6 +47,10 @@ function buildResourceAttributes (config) {
   const { service, version, env, ...filteredTags } = config.tags
   Object.assign(resourceAttributes, filteredTags)
 
+  // Tracer-owned adoption markers; set after the global tags so a user tag can't contradict them.
+  resourceAttributes[SDK_OTLP_EXPORT_KEY] = 'true'
+  resourceAttributes[SDK_SEMANTICS_KEY] = config.DD_TRACE_OTEL_SEMANTICS_ENABLED ? 'otel' : 'datadog'
+
   if (config.OTEL_TRACES_SPAN_METRICS_ENABLED) {
     resourceAttributes['_dd.stats_computed'] = 'true'
   }

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

@@ -40,11 +40,11 @@ class DatadogTracer {
     // spans must reach the Electron SDK's IPC bridge, not an OTLP endpoint,
     // even when OTEL_* vars are set for unrelated telemetry.
     if (config.OTEL_TRACES_EXPORTER === 'otlp' && !config.isCiVisibility &&
-      config.experimental.exporter !== 'electron') {
+      config.tracing.DD_TRACE_EXPERIMENTAL_EXPORTER !== 'electron') {
       const { createOtlpTraceExporter } = require('../opentelemetry/trace')
       this._exporter = createOtlpTraceExporter(config)
     } else {
-      const Exporter = getExporter(config.experimental.exporter)
+      const Exporter = getExporter(config.tracing.DD_TRACE_EXPERIMENTAL_EXPORTER)
       this._exporter = new Exporter(config, this._prioritySampler)
     }
 
@@ -55,7 +55,7 @@ class DatadogTracer {
     }
     this._processor = new SpanProcessor(this._exporter, this._prioritySampler, config, otlpStatsExporter)
     this._url = this._exporter._url
-    this._enableGetRumData = config.experimental.enableGetRumData
+    this._enableGetRumData = config.rum.DD_TRACE_EXPERIMENTAL_GET_RUM_DATA_ENABLED
     this._traceId128BitGenerationEnabled = config.traceId128BitGenerationEnabled
     this._propagators = {
       [formats.TEXT_MAP]: new TextMapPropagator(config),

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

@@ -36,7 +36,11 @@ const pluginClasses = {}
 // during instrumentation initialization (e.g. re-requires in bundler contexts)
 // are captured and populate pluginClasses correctly.
 loadChannel.subscribe(({ name }) => {
-  maybeEnable(plugins[name])
+  try {
+    maybeEnable(plugins[name])
+  } catch (error) {
+    log.error('Error activating plugin %s', name, error)
+  }
 })
 
 // instrument everything that needs Plugin System V2 instrumentation
@@ -81,11 +85,15 @@ module.exports = class PluginManager {
     this._configsByName = {}
 
     this._loadedSubscriber = ({ name }) => {
-      const Plugin = plugins[name]
+      try {
+        const Plugin = plugins[name]
 
-      if (!Plugin || typeof Plugin !== 'function') return
+        if (!Plugin || typeof Plugin !== 'function') return
 
-      this.loadPlugin(Plugin.id)
+        this.loadPlugin(Plugin.id)
+      } catch (error) {
+        log.error('Error activating plugin %s', name, error)
+      }
     }
 
     loadChannel.subscribe(this._loadedSubscriber)
@@ -112,10 +120,21 @@ module.exports = class PluginManager {
     }
 
     // extracts predetermined configuration from tracer and combines it with plugin-specific config
-    this._pluginsByName[name].configure({
+    const config = {
       ...this.#getSharedConfig(name),
       ...pluginConfig,
-    })
+    }
+    const plugin = this._pluginsByName[name]
+    try {
+      plugin.configure(config)
+    } catch (error) {
+      try {
+        plugin.configure({ enabled: false })
+      } catch (disableError) {
+        log.error('Error disabling plugin %s after failed activation', name, disableError)
+      }
+      throw error
+    }
   }
 
   // TODO: merge config instead of replacing
@@ -189,7 +208,7 @@ module.exports = class PluginManager {
       traceWebsocketMessagesEnabled,
       traceWebsocketMessagesInheritSampling,
       traceWebsocketMessagesSeparateTraces,
-      experimental,
+      tracing,
       DD_TRACE_RESOURCE_RENAMING_ENABLED,
     } = /** @type {import('./config/config-base')} */ (this._tracerConfig)
 
@@ -212,7 +231,7 @@ module.exports = class PluginManager {
       traceWebsocketMessagesEnabled,
       traceWebsocketMessagesInheritSampling,
       traceWebsocketMessagesSeparateTraces,
-      experimental,
+      tracing,
       resourceRenamingEnabled: DD_TRACE_RESOURCE_RENAMING_ENABLED,
     }
 

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

@@ -788,7 +788,7 @@ module.exports = class CiPlugin extends Plugin {
       return
     }
 
-    const exporter = this.config.experimental?.exporter
+    const exporter = this.config.tracing.DD_TRACE_EXPERIMENTAL_EXPORTER
     const workerTestFramework = WORKER_EXPORTER_TO_TEST_FRAMEWORK[exporter]
     this.shouldSkipGitMetadataExtraction = workerTestFramework &&
       TEST_FRAMEWORKS_TO_SKIP_GIT_METADATA_EXTRACTION.has(workerTestFramework)

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

@@ -881,14 +881,19 @@ function setRumTestTags (testSpan, isRumActive, browserVersion) {
 }
 
 /**
- * Marks a successful test session that intentionally executed no tests.
+ * Marks a successful test session that did not execute any tests.
  *
  * @param {import('../../opentracing/span')} testSessionSpan
  * @param {import('../../opentracing/span')|undefined} testModuleSpan
- * @param {string} skipReason
- * @param {string} emptyReason
+ * @param {'zero_tests'|'all_tests_skipped'|'zero_test_shard'|'test_discovery'} emptyReason
  */
-function setExpectedEmptyTestSessionTags (testSessionSpan, testModuleSpan, skipReason, emptyReason) {
+function setExpectedEmptyTestSessionTags (testSessionSpan, testModuleSpan, emptyReason) {
+  const skipReason = emptyReason === 'test_discovery'
+    ? 'Test discovery only (--list)'
+    : emptyReason === 'zero_test_shard'
+      ? 'No tests were assigned to this shard'
+      : emptyReason === 'all_tests_skipped' ? 'All tests were skipped' : 'No tests were detected'
+
   for (const span of [testSessionSpan, testModuleSpan]) {
     if (!span) continue
 
@@ -2020,6 +2025,10 @@ function getModifiedFilesFromDiff (diff) {
     if (lineMatch && currentFile) {
       const start = Number(lineMatch.groups.start)
       const count = lineMatch.groups.count ? Number(lineMatch.groups.count) : 1
+      if (count === 0) {
+        // Keep the surviving line before a deletion so line-based consumers can match its scope.
+        result[currentFile].push(start)
+      }
       for (let j = 0; j < count; j++) {
         result[currentFile].push(start + j)
       }