dd-trace 6.14.0 → 6.15.0

package/packages/dd-trace/src/debugger/devtools_client/request-options.js

@@ -1,7 +1,5 @@
 'use strict'
 
-const { getHttpsProxyAgent } = require('../../evp_proxy/direct')
-
 /**
  * @param {ReturnType<import('../config')>} config - Debugger configuration
  * @param {string} path - Request path
@@ -10,8 +8,7 @@ const { getHttpsProxyAgent } = require('../../evp_proxy/direct')
  *   method: 'POST',
  *   url: string | URL,
  *   path: string,
- *   headers: Record<string, string>,
- *   agent?: import('node:https').Agent
+ *   headers: Record<string, string>
  * }}
  */
 module.exports = function getRequestOptions (config, path, headers) {
@@ -25,8 +22,6 @@ module.exports = function getRequestOptions (config, path, headers) {
   if (config.agentless) {
     if (config.apiKey !== undefined) headers['DD-API-KEY'] = config.apiKey
     headers['DD-EVP-ORIGIN'] = 'agent-debugger'
-    const agent = getHttpsProxyAgent(config.url.href)
-    if (agent !== undefined) options.agent = agent
   }
 
   return options

package/packages/dd-trace/src/evp_proxy/direct.js

@@ -1,19 +1,13 @@
 'use strict'
 
-const { HttpsProxyAgent } = require('../../../../vendor/dist/https-proxy-agent')
-const { getProxyForUrl } = require('../../../../vendor/dist/proxy-from-env')
 const { createSiteUrl } = require('../exporters/common/url')
 const log = require('../log')
 
-/** @type {Map<string, import('node:https').Agent>} */
-const proxyAgents = new Map()
-
 /**
  * @typedef {object} DirectEVPRoute
  * @property {URL} url - Direct intake URL
  * @property {string} basePath - Direct intake base path
  * @property {object} headers - Direct intake authentication headers
- * @property {import('node:https').Agent} [agent] - Optional HTTPS proxy agent
  */
 
 /**
@@ -33,36 +27,16 @@ function createDirectEVPRoute (config, intake) {
     const url = createSiteUrl(config.site, intake)
     if (url === undefined) throw new Error('Invalid direct EVP intake URL')
 
-    const agent = getHttpsProxyAgent(url.href)
-
-    const route = {
+    return {
       url,
       basePath: '',
       headers: {
         'DD-API-KEY': apiKey,
       },
     }
-    if (agent) route.agent = agent
-    return route
   } catch (error) {
     log.debug('Unable to configure direct EVP intake: %s', error.message)
   }
 }
 
-/**
- * @param {string} url
- * @returns {import('node:https').Agent|undefined}
- */
-function getHttpsProxyAgent (url) {
-  const proxyUrl = getProxyForUrl(url)
-  if (!proxyUrl) return
-
-  let agent = proxyAgents.get(proxyUrl)
-  if (agent === undefined) {
-    agent = new HttpsProxyAgent(proxyUrl)
-    proxyAgents.set(proxyUrl, agent)
-  }
-  return agent
-}
-
-module.exports = { createDirectEVPRoute, getHttpsProxyAgent }
+module.exports = { createDirectEVPRoute }

package/packages/dd-trace/src/exporters/agentless/writer.js

@@ -8,6 +8,7 @@ const log = require('../../log')
 const tracerVersion = require('../../../../../package.json').version
 
 const { canSendApiKey } = require('../common/url')
+const { getHttpsProxyAgent } = require('../common/proxy')
 const BaseWriter = require('../common/writer')
 const { AgentEncoder } = require('../../encode/0.4')
 const { computeIntakeUrl, INTAKE_PATH } = require('./intake')
@@ -153,6 +154,7 @@ class AgentlessWriter extends BaseWriter {
 
     this.#closeExporter()
     const config = getConfig()
+    const agent = this._url.protocol === 'https:' ? getHttpsProxyAgent(this._url) : undefined
     this.#exporter = createAgentlessExporter({
       endpoint: this.#endpoint(),
       apiKey,
@@ -165,7 +167,7 @@ class AgentlessWriter extends BaseWriter {
       tracerVersion,
       languageVersion: process.version,
       languageInterpreter: process.versions.bun ? 'JavaScriptCore' : 'v8',
-    })
+    }, { agent })
     this.#exporterApiKey = apiKey
     this.#exporterEnv = env
     this.#exporterRuntimeId = runtimeID

package/packages/dd-trace/src/exporters/common/proxy.js

@@ -0,0 +1,52 @@
+'use strict'
+
+const { isIPv6 } = require('node:net')
+
+let defaultAgentKey
+let getProxyForUrl
+let proxyAgents
+
+/**
+ * Selects a proxy agent for an HTTPS target while preserving the direct agent's pool boundaries.
+ *
+ * @param {string|URL|object} url
+ * @param {import('node:http').Agent|false} [directAgent]
+ * @returns {import('node:http').Agent|false|undefined}
+ */
+function getHttpsProxyAgent (url, directAgent) {
+  getProxyForUrl ??= require('../../../../../vendor/dist/proxy-from-env').getProxyForUrl
+
+  const host = typeof url === 'string' ? undefined : url.host ?? url.hostname
+  const isUnbracketedIPv6 = typeof host === 'string' && host.includes(':') && isIPv6(host)
+  const target = typeof url === 'string'
+    ? url
+    : { protocol: url.protocol, host: isUnbracketedIPv6 ? `[${host}]` : host, port: url.port }
+  const proxyUrl = getProxyForUrl(target)
+  if (!proxyUrl) return directAgent
+
+  directAgent ??= require('node:https').globalAgent
+
+  if (proxyAgents === undefined) {
+    defaultAgentKey = {}
+    proxyAgents = new WeakMap()
+  }
+  const cacheKey = directAgent || defaultAgentKey
+  let agents = proxyAgents.get(cacheKey)
+  if (agents === undefined) {
+    agents = new Map()
+    proxyAgents.set(cacheKey, agents)
+  }
+
+  let agent = agents.get(proxyUrl)
+  if (agent === undefined) {
+    const { HttpsProxyAgent } = require('../../../../../vendor/dist/https-proxy-agent')
+    const options = directAgent
+      ? { keepAlive: directAgent.keepAlive, maxSockets: directAgent.maxSockets }
+      : undefined
+    agent = new HttpsProxyAgent(proxyUrl, options)
+    agents.set(proxyUrl, agent)
+  }
+  return agent
+}
+
+module.exports = { getHttpsProxyAgent }

package/packages/dd-trace/src/exporters/common/request.js

@@ -13,6 +13,7 @@ const log = require('../../log')
 const { canSendApiKey, parseUrl } = require('./url')
 const docker = require('./docker')
 const { httpAgent, httpsAgent } = require('./agents')
+const { getHttpsProxyAgent } = require('./proxy')
 const {
   getMaxAttempts,
   getRetryDelay,
@@ -94,11 +95,18 @@ function request (data, options, callback) {
 
   docker.inject(options.headers)
 
-  const connectionOptions = {
-    ...options,
-    agent: options.agent ?? (isSecure ? httpsAgent : httpAgent),
+  let agent = options.agent ?? (isSecure ? httpsAgent : httpAgent)
+  if (hasApiKey && isSecure) {
+    try {
+      agent = getHttpsProxyAgent(options, agent)
+    } catch (error) {
+      callback(error)
+      return
+    }
   }
 
+  const connectionOptions = { ...options, agent }
+
   /**
    * @param {import('node:http').IncomingMessage} res
    * @param {(error: Error|null, result?: string|null, statusCode?: number,

package/packages/dd-trace/src/opentelemetry/otlp/otlp_http_exporter_base.js

@@ -6,7 +6,9 @@ const { URL } = require('node:url')
 const { storage } = require('../../../../datadog-core')
 const log = require('../../log')
 const { createServerlessDeliveryTracker } = require('../../serverless')
+const { getHttpsProxyAgent } = require('../../exporters/common/proxy')
 const telemetryMetrics = require('../../telemetry/metrics')
+const { version: tracerVersion } = require('../../../../../package.json')
 
 const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
 const legacyStorage = storage('legacy')
@@ -48,8 +50,10 @@ class OtlpHttpExporterBase {
       hostname: parsedUrl.hostname,
       port: parsedUrl.port,
       path: parsedUrl.pathname + parsedUrl.search,
+      agent: parsedUrl.protocol === 'https:' ? getHttpsProxyAgent(parsedUrl) : undefined,
       headers: {
         'Content-Type': isJson ? 'application/json' : 'application/x-protobuf',
+        'User-Agent': `dd-trace-js/${tracerVersion}`,
         ...headers,
       },
     }
@@ -169,6 +173,7 @@ class OtlpHttpExporterBase {
     this.options.hostname = parsedUrl.hostname
     this.options.port = parsedUrl.port
     this.options.path = parsedUrl.pathname + parsedUrl.search
+    this.options.agent = parsedUrl.protocol === 'https:' ? getHttpsProxyAgent(parsedUrl) : undefined
     this.telemetryTags[0] = `protocol:${this.#transport === https ? 'https' : 'http'}`
   }
 

package/packages/dd-trace/src/opentracing/propagation/text_map.js

@@ -363,6 +363,11 @@ class TextMapPropagator {
    * @returns {DatadogSpanContext | null}
    */
   extract (carrier) {
+    if (!carrier || typeof carrier !== 'object') {
+      if (this.#config.DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT !== 'ignore') removeAllBaggageItems()
+      return null
+    }
+
     const spanContext = this.#extractSpanContext(carrier)
     if (spanContext === undefined) return null
 
@@ -825,7 +830,6 @@ class TextMapPropagator {
    * @returns {DatadogSpanContext | undefined}
    */
   #extractDatadogContext (carrier) {
-    if (!carrier) return
     const traceId = readDatadogTraceId(carrier)
     if (!traceId) return
     const spanContext = extractGenericContext(traceId, readDatadogParentId(carrier), 10)
@@ -860,6 +864,8 @@ class TextMapPropagator {
     } catch {
       return
     }
+    if (!parsed || typeof parsed !== 'object') return
+
     const spanContext = this.#extractDatadogContext(parsed)
     if (!spanContext) return
 
@@ -983,7 +989,7 @@ class TextMapPropagator {
    */
   #extractBaggageItems (carrier, spanContext, extractBaggage) {
     removeAllBaggageItems()
-    if (!carrier || !extractBaggage) return
+    if (!extractBaggage) return
     const header = readBaggage(carrier)
     if (!header) return
 

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

@@ -263,6 +263,10 @@ class PrioritySampler {
       context._sampling.mechanism = SAMPLING_MECHANISM_REMOTE_DYNAMIC
     }
 
+    if (rule.discard) {
+      context._sampling.discard = true
+    }
+
     return rule.sample(context) && this._isSampledByRateLimit(context)
       ? USER_KEEP
       : USER_REJECT

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

@@ -185,6 +185,7 @@ function resourceLocator (span) {
  * @property {number} [sampleRate=1] - Deterministic sampling rate in [0, 1].
  * @property {string} [provenance] - Optional provenance/metadata for this rule.
  * @property {number} [maxPerSecond] - Maximum samples per second (rate limit).
+ * @property {boolean} [discard=false] - Whether to fully drop a trace if not kept.
  */
 
 /**
@@ -195,7 +196,7 @@ class SamplingRule {
   /**
    * @param {SamplingRuleConfig} [config]
    */
-  constructor ({ name, service, resource, tags, sampleRate = 1, provenance, maxPerSecond } = {}) {
+  constructor ({ name, service, resource, tags, sampleRate = 1, provenance, maxPerSecond, discard = false } = {}) {
     this.matchers = []
 
     if (name !== undefined) {
@@ -216,6 +217,7 @@ class SamplingRule {
     this._sampler = new Sampler(sampleRate)
     this._limiter = undefined
     this.provenance = provenance
+    this.discard = !!discard
 
     if (Number.isFinite(maxPerSecond)) {
       this._limiter = new RateLimiter(maxPerSecond)

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

@@ -1,5 +1,6 @@
 'use strict'
 
+const { AUTO_REJECT } = require('../../../ext/priority')
 const log = require('./log')
 const spanFormat = require('./span_format')
 const SpanSampler = require('./span_sampler')
@@ -34,7 +35,20 @@ class SpanProcessor {
   sample (span) {
     const spanContext = span.context()
     this._prioritySampler.sample(spanContext)
-    this._spanSampler.sample(spanContext)
+    if (!this.#isDiscarded(spanContext)) {
+      this._spanSampler.sample(spanContext)
+    }
+  }
+
+  /**
+   * A rule's reject decision can later be overridden (e.g. a product force-keeping the trace via
+   * `PrioritySampler.keepTrace()`), so `discard` only applies while the priority is still a reject.
+   *
+   * @param {import('./opentracing/span_context')} spanContext
+   * @returns {boolean}
+   */
+  #isDiscarded (spanContext) {
+    return spanContext._sampling.discard && spanContext._sampling.priority <= AUTO_REJECT
   }
 
   process (span) {
@@ -56,11 +70,12 @@ class SpanProcessor {
 
       let isFirstSpanInChunk = true
       const stampApmDisabled = this._config.apmTracingEnabled === false
+      const discard = this.#isDiscarded(spanContext)
 
       for (const span of started) {
         if (span._duration === undefined) {
           active.push(span)
-        } else {
+        } else if (!discard) {
           const formattedSpan = spanFormat(span, isFirstSpanInChunk, this._processTags)
           if (stampApmDisabled) {
             formattedSpan.metrics[APM_TRACING_ENABLED_KEY] = 0
@@ -76,7 +91,7 @@ class SpanProcessor {
         }
       }
 
-      if (formatted.length !== 0 && trace.isRecording !== false) {
+      if (!discard && formatted.length !== 0 && trace.isRecording !== false) {
         this._exporter.export(formatted)
       }
 

package/packages/dd-trace/src/telemetry/send-data.js

@@ -76,9 +76,10 @@ let getTestOptimizationAgent
  * @param {import('../config/config-base')} config
  * @param {TelemetryApplication} application
  * @param {TelemetryRequestType} reqType
+ * @param {string} [apiKey]
  * @returns {Record<string, string>}
  */
-function getHeaders (config, application, reqType) {
+function getHeaders (config, application, reqType, apiKey) {
   const headers = {
     'DD-Client-Library-Language': application.language_name,
     'DD-Client-Library-Version': application.tracer_version,
@@ -94,8 +95,8 @@ function getHeaders (config, application, reqType) {
   if (debug) {
     headers['dd-telemetry-debug-enabled'] = 'true'
   }
-  if (config.DD_API_KEY) {
-    headers['dd-api-key'] = config.DD_API_KEY
+  if (apiKey) {
+    headers['dd-api-key'] = apiKey
   }
   return headers
 }
@@ -161,7 +162,7 @@ function sendData (config, application, host, reqType, payload = {}, cb = () =>
     port,
     method: 'POST',
     path: isAgentlessMode ? '/api/v2/apmtelemetry' : '/telemetry/proxy/api/v2/apmtelemetry',
-    headers: getHeaders(config, application, reqType),
+    headers: getHeaders(config, application, reqType, isAgentlessMode ? config.DD_API_KEY : undefined),
   }
   if (isCiVisibility) options.agent = getTestOptimizationAgent(url)