dd-trace 6.13.0 → 6.15.0

package/packages/dd-trace/src/runtime_metrics/client.js

@@ -1,21 +1,24 @@
 'use strict'
 
-const { DogStatsDClient, MetricsAggregationClient } = require('../dogstatsd')
+const { channel } = require('dc-polyfill')
+const { DogStatsDClient, createMetricsAggregationClient } = require('../dogstatsd')
 const processTags = require('../process-tags')
 
+const identityRefreshChannel = channel('datadog:identity:refresh')
+
 /**
- * Builds the aggregating DogStatsD client used to emit DD-proprietary tracer
- * metrics (runtime.node.*, datadog.tracer.*). Shared by both runtime-metrics
- * paths (DogStatsD and OTLP) so their client construction can't drift apart.
+ * Builds the DogStatsD tags (with process tags applied) for the runtime-metrics client.
+ * Shared by `createMetricsClient()` and `subscribeToIdentityRefresh()` so their tag
+ * composition can't drift apart.
  *
  * Process tags are applied here, not via config/generateClientConfig, so they only
  * reach this bounded set of runtime metrics. Putting them on the global tags would
  * also tag user-facing custom metrics, inflating their cardinality (and billing).
  *
  * @param {import('../config/config-base')} config - Tracer configuration
- * @returns {MetricsAggregationClient}
+ * @returns {{ host: string, port: number, tags: string[], lookup: Function, metricsProxyUrl?: URL }}
  */
-function createMetricsClient (config) {
+function buildClientConfig (config) {
   const clientConfig = DogStatsDClient.generateClientConfig(config)
 
   if (config.DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED) {
@@ -24,7 +27,33 @@ function createMetricsClient (config) {
     }
   }
 
-  return new MetricsAggregationClient(new DogStatsDClient(clientConfig))
+  return clientConfig
+}
+
+/**
+ * Builds the aggregating DogStatsD client used to emit DD-proprietary tracer
+ * metrics (runtime.node.*, datadog.tracer.*). Shared by both runtime-metrics
+ * paths (DogStatsD and OTLP) so their client construction can't drift apart.
+ *
+ * @param {import('../config/config-base')} config - Tracer configuration
+ * @returns {ReturnType<typeof createMetricsAggregationClient>}
+ */
+function createMetricsClient (config) {
+  return createMetricsAggregationClient(buildClientConfig(config))
+}
+
+/**
+ * Subscribes a runtime-metrics client to the identity-refresh channel so its DogStatsD tags
+ * (runtime-id, RC client id) reflect `config.tags` after a MicroVM clone resume.
+ *
+ * @param {ReturnType<typeof createMetricsAggregationClient>} client - The client returned by `createMetricsClient()`
+ * @param {import('../config/config-base')} config - Tracer configuration
+ * @returns {() => void} Unsubscribe function; call it from the owning module's `stop()`
+ */
+function subscribeToIdentityRefresh (client, config) {
+  const onIdentityRefresh = () => client.updateTags(buildClientConfig(config).tags)
+  identityRefreshChannel.subscribe(onIdentityRefresh)
+  return () => identityRefreshChannel.unsubscribe(onIdentityRefresh)
 }
 
-module.exports = { createMetricsClient }
+module.exports = { createMetricsClient, subscribeToIdentityRefresh }

package/packages/dd-trace/src/runtime_metrics/otlp_runtime_metrics.js

@@ -5,7 +5,7 @@ const process = require('node:process')
 const { performance, monitorEventLoopDelay, PerformanceObserver, constants } = require('node:perf_hooks')
 const { metrics } = require('@opentelemetry/api')
 const log = require('../log')
-const { createMetricsClient } = require('./client')
+const { createMetricsClient, subscribeToIdentityRefresh } = require('./client')
 
 const METER_NAME = 'datadog.runtime_metrics'
 
@@ -53,6 +53,7 @@ const registeredBatchCallbacks = []
 // equivalent; keep a DogStatsD client so OTLP-path customers don't lose them.
 let client = null
 let flushInterval = null
+let unsubscribeIdentityRefresh = null
 
 module.exports = {
   /**
@@ -62,6 +63,7 @@ module.exports = {
     this.stop()
 
     client = createMetricsClient(config)
+    unsubscribeIdentityRefresh = subscribeToIdentityRefresh(client, config)
     flushInterval = setInterval(() => {
       client.flush()
     }, config.DD_RUNTIME_METRICS_FLUSH_INTERVAL ?? 10_000)
@@ -221,6 +223,8 @@ module.exports = {
       clearInterval(flushInterval)
       flushInterval = null
     }
+    unsubscribeIdentityRefresh?.()
+    unsubscribeIdentityRefresh = null
     client = null
   },
 

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

@@ -8,7 +8,7 @@ const process = require('process')
 const { performance, PerformanceObserver, monitorEventLoopDelay } = require('perf_hooks')
 const log = require('../log')
 const { NODE_MAJOR, NODE_MINOR } = require('../../../../version')
-const { createMetricsClient } = require('./client')
+const { createMetricsClient, subscribeToIdentityRefresh } = require('./client')
 
 const eventLoopDelayResolution = 4
 const EVENT_LOOP_SAMPLE_PER_ITERATION_AVAILABLE = NODE_MAJOR > 26 ||
@@ -28,6 +28,7 @@ let lastTime = 0
 let lastCpuUsage = null
 let eventLoopDelayObserver = null
 let capture = null
+let unsubscribeIdentityRefresh = null
 
 // !!!!!!!!!!!
 //  IMPORTANT
@@ -49,6 +50,7 @@ module.exports = {
     const trackGc = config.runtimeMetrics.gc !== false
 
     client = createMetricsClient(config)
+    unsubscribeIdentityRefresh = subscribeToIdentityRefresh(client, config)
 
     if (trackGc) {
       startGCObserver()
@@ -117,6 +119,8 @@ module.exports = {
     clearInterval(interval)
     interval = null
 
+    unsubscribeIdentityRefresh?.()
+    unsubscribeIdentityRefresh = null
     client = null
     capture = null
     lastCpuUsage = null

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

@@ -34,6 +34,21 @@ class AlwaysMatcher {
   }
 }
 
+/**
+ * Matcher that always returns false for unsupported patterns.
+ * Implements the minimal `RuleMatcher` interface.
+ * @implements {RuleMatcher}
+ */
+class NeverMatcher {
+  /**
+   * @param {DatadogSpan} span
+   * @returns {boolean}
+   */
+  match (span) {
+    return false
+  }
+}
+
 /**
  * Matcher that evaluates a glob pattern against a derived subject.
  */
@@ -62,6 +77,8 @@ class GlobMatcher {
  * Matcher that evaluates a regular expression against a derived subject.
  */
 class RegExpMatcher {
+  #resetLastIndex
+
   /**
    * @param {RegExp} pattern - Regular expression used to test the subject.
    * @param {Locator} locator - Function extracting the subject to test.
@@ -69,6 +86,7 @@ class RegExpMatcher {
   constructor (pattern, locator) {
     this.pattern = pattern
     this.locator = locator
+    this.#resetLastIndex = pattern.global || pattern.sticky
   }
 
   /**
@@ -77,17 +95,23 @@ class RegExpMatcher {
    */
   match (span) {
     const subject = this.locator(span)
-    if (!subject) return false
-    return this.pattern.test(subject)
+    if (subject === undefined) return false
+    if (!this.#resetLastIndex) return this.pattern.test(subject)
+
+    this.pattern.lastIndex = 0
+    const matched = this.pattern.test(subject)
+    this.pattern.lastIndex = 0
+    return matched
   }
 }
 
 /**
  * Creates a matcher for the provided pattern and locator.
  * Returns a glob matcher for non-trivial strings, a regexp matcher for RegExp,
- * or an always-true matcher for wildcard or missing patterns.
+ * an always-true matcher for wildcard patterns, or an always-false matcher for
+ * unsupported patterns.
  *
- * @param {string|RegExp|undefined} pattern
+ * @param {unknown} pattern
  * @param {Locator} locator
  * @returns {RuleMatcher}
  */
@@ -96,10 +120,13 @@ function matcher (pattern, locator) {
     return new RegExpMatcher(pattern, locator)
   }
 
-  if (typeof pattern === 'string' && pattern !== '*' && pattern !== '**' && pattern !== '***') {
+  if (typeof pattern === 'string') {
+    if (pattern === '*' || pattern === '**' || pattern === '***') {
+      return new AlwaysMatcher()
+    }
     return new GlobMatcher(pattern, locator)
   }
-  return new AlwaysMatcher()
+  return new NeverMatcher()
 }
 
 /**
@@ -158,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.
  */
 
 /**
@@ -168,16 +196,16 @@ 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) {
+    if (name !== undefined) {
       this.matchers.push(matcher(name, nameLocator))
     }
-    if (service) {
+    if (service !== undefined) {
       this.matchers.push(matcher(service, serviceLocator))
     }
-    if (resource) {
+    if (resource !== undefined) {
       this.matchers.push(matcher(resource, resourceLocator))
     }
     if (tags) {
@@ -189,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/serverless/telemetry-delivery-tracker.js

@@ -18,11 +18,8 @@ class TelemetryDeliveryTracker {
     const delivery = { callbacks: done ? [done] : [] }
     this.#deliveries.add(delivery)
 
-    let completed = false
     const complete = () => {
-      if (completed) return
-      completed = true
-      this.#deliveries.delete(delivery)
+      if (!this.#deliveries.delete(delivery)) return
       for (const callback of delivery.callbacks) callback()
     }
 
@@ -41,14 +38,13 @@ class TelemetryDeliveryTracker {
   waitForIdle (done) {
     if (!done) return
 
-    const deliveries = [...this.#deliveries]
-    if (deliveries.length === 0) return done()
+    let pending = this.#deliveries.size
+    if (pending === 0) return done()
 
-    let pending = deliveries.length
     const complete = () => {
       if (--pending === 0) done()
     }
-    for (const delivery of deliveries) delivery.callbacks.push(complete)
+    for (const delivery of this.#deliveries) delivery.callbacks.push(complete)
   }
 }
 

package/packages/dd-trace/src/serverless/vercel.js

@@ -16,6 +16,19 @@ const vercelRetentionHandlers = new WeakMap()
  * @typedef {{ flushAll?: (done: () => void, options?: { timeout?: number }) => void }} TelemetryFlusher
  */
 
+/**
+ * @typedef {{ complete: () => void, promise: Promise<void> }} VercelFlush
+ */
+
+/**
+ * @returns {VercelFlush}
+ */
+function createVercelFlush () {
+  let complete
+  const promise = new Promise(resolve => { complete = resolve })
+  return { complete, promise }
+}
+
 /**
  * @param {TelemetryFlusher} tracer
  * @param {() => void} done
@@ -32,25 +45,6 @@ function flushVercelTelemetry (tracer, done) {
   })
 }
 
-function registerVercelRequestFlush (tracer) {
-  const requestContext = getVercelRequestContext()
-  if (!requestContext) return
-
-  const { waitUntil } = requestContext
-  if (typeof waitUntil !== 'function') return
-
-  // Retain the invocation synchronously, then flush after the response completes.
-  let done
-  const pending = new Promise(resolve => { done = resolve })
-  try {
-    waitUntil(pending)
-    flushVercelTelemetry(tracer, done)
-  } catch (error) {
-    log.warn('Unable to retain Vercel telemetry:', error)
-    done()
-  }
-}
-
 function getVercelRequestContext () {
   return globalThis[VERCEL_REQUEST_CONTEXT]?.get?.()
 }
@@ -69,9 +63,48 @@ function registerVercelTelemetryRetention (tracer) {
   if (existing) return existing
 
   if (typeof tracer?.flushAll !== 'function') return
+  let flushInProgress = false
+  let queuedFlush
+
+  /**
+   * @param {VercelFlush} flush
+   */
+  const startFlush = flush => {
+    flushVercelTelemetry(tracer, () => {
+      flush.complete()
+      const nextFlush = queuedFlush
+      queuedFlush = undefined
+      if (nextFlush) {
+        startFlush(nextFlush)
+      } else {
+        flushInProgress = false
+      }
+    })
+  }
+  const flushRequest = () => {
+    const requestContext = getVercelRequestContext()
+    if (!requestContext) return
+
+    const { waitUntil } = requestContext
+    if (typeof waitUntil !== 'function') return
+
+    const shouldStart = !flushInProgress
+    const flush = queuedFlush ?? createVercelFlush()
+    if (shouldStart) {
+      flushInProgress = true
+    } else {
+      queuedFlush = flush
+    }
+
+    try {
+      waitUntil(flush.promise)
+    } catch (error) {
+      log.warn('Unable to retain Vercel telemetry:', error)
+    }
+    if (shouldStart) startFlush(flush)
+  }
   // The HTTP finish channel activates its response wrapper directly. HTTP/2 needs
   // a passive request-start subscriber before it can bind response emit events.
-  const flushRequest = () => registerVercelRequestFlush(tracer)
   const flushHttp2Response = ({ eventName }) => {
     if (eventName === 'close') flushRequest()
   }

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

@@ -2,6 +2,9 @@
 
 const { getEnvironmentVariable, getValueFromEnvSources } = require('./config/helper')
 
+const IS_AWS_LAMBDA_MICROVM = getEnvironmentVariable('AWS_LAMBDA_MICROVM_IMAGE_ARN') !== undefined
+const isVercelAtStartup = getEnvironmentVariable('VERCEL') === '1'
+
 function getIsGCPFunction () {
   const isDeprecatedGCPFunction =
     getEnvironmentVariable('FUNCTION_NAME') !== undefined &&
@@ -39,7 +42,7 @@ function isInServerlessEnvironment () {
   const isGCPFunction = getIsGCPFunction()
   const isAzureFunction = getIsAzureFunction()
 
-  return inAWSLambda || isGCPFunction || isAzureFunction
+  return IS_AWS_LAMBDA_MICROVM || inAWSLambda || isGCPFunction || isAzureFunction
 }
 
 /**
@@ -59,7 +62,7 @@ function getServerlessPlatformTags (platform = getServerlessPlatform()) {
  * @returns {{ isVercel: boolean }}
  */
 function getServerlessPlatform () {
-  return { isVercel: getEnvironmentVariable('VERCEL') === '1' }
+  return { isVercel: supportsServerlessTelemetryRetention() }
 }
 
 /**
@@ -69,7 +72,7 @@ function getServerlessPlatform () {
  * @returns {boolean}
  */
 function supportsServerlessTelemetryRetention () {
-  return getServerlessPlatform().isVercel
+  return isVercelAtStartup
 }
 
 /**
@@ -101,5 +104,9 @@ module.exports = {
   enableGCPPubSubPushSubscription,
   getIsFlexConsumptionAzureFunction,
   initializeServerlessTelemetry,
+  IS_AWS_LAMBDA_MICROVM,
+  // true only for a Node that bundles its own OpenSSL, whose CSPRNG keeps the snapshot's DRBG
+  // state across a MicroVM clone resume
+  NODE_BUNDLES_OPENSSL: process.config.variables.node_shared_openssl === false,
   IS_SERVERLESS: isInServerlessEnvironment(),
 }

package/packages/dd-trace/src/service-naming/schemas/util.js

@@ -5,7 +5,7 @@ function identityService ({ tracerService }) {
 }
 
 function getFormattedHostString ({ host, port }) {
-  return [host, port].filter(Boolean).join(':')
+  return port ? `${host}:${port}` : host
 }
 
 function httpPluginClientService ({ tracerService, pluginConfig, sessionDetails }) {

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/span_stats.js

@@ -136,19 +136,8 @@ class SpanAggKey {
   }
 
   toString () {
-    return [
-      this.name,
-      this.service,
-      this.resource,
-      this.type,
-      this.statusCode,
-      this.synthetics,
-      this.method,
-      this.endpoint,
-      this.srvSrc,
-      this.spanKind,
-      this.rpcStatusCode,
-    ].join(',')
+    return `${this.name},${this.service},${this.resource},${this.type},${this.statusCode},${this.synthetics},` +
+      `${this.method},${this.endpoint},${this.srvSrc},${this.spanKind},${this.rpcStatusCode}`
   }
 }
 
@@ -201,19 +190,26 @@ class TimeBuckets extends Map {
 }
 
 class SpanStatsProcessor {
-  constructor ({
-    stats: {
-      DD_TRACE_STATS_COMPUTATION_ENABLED: enabled = false,
-      interval = 10,
-    } = {},
-    hostname,
-    port,
-    url,
-    env,
-    tags,
-    version: appVersion,
-    _DD_TRACE_METRICS_OTEL_FLUSH_INTERVAL: flushIntervalMs,
-  } = {}, otlpExporter) {
+  #config
+
+  /**
+   * @param {import('./config/config-base')} config
+   * @param {import('./opentelemetry/metrics/otlp_span_stats_exporter').OtlpStatsExporter} [otlpExporter]
+   */
+  constructor (config, otlpExporter) {
+    const {
+      stats: {
+        DD_TRACE_STATS_COMPUTATION_ENABLED: enabled = false,
+        interval = 10,
+      } = {},
+      hostname,
+      port,
+      url,
+      env,
+      tags,
+      version: appVersion,
+      _DD_TRACE_METRICS_OTEL_FLUSH_INTERVAL: flushIntervalMs,
+    } = config
     if (!otlpExporter) {
       this.exporter = new SpanStatsExporter({ hostname, port, tags, url })
     }
@@ -225,7 +221,7 @@ class SpanStatsProcessor {
     this.enabled = enabled
     this.otlpExporter = otlpExporter || null
     this.env = env
-    this.tags = tags || {}
+    this.#config = config
     this.sequence = 0
     this.version = appVersion
 
@@ -258,7 +254,7 @@ class SpanStatsProcessor {
         Stats: this.#toV06Payload(drained),
         Lang: 'javascript',
         TracerVersion: pkg.version,
-        RuntimeID: this.tags['runtime-id'],
+        RuntimeID: this.#config.tags['runtime-id'],
         Sequence: ++this.sequence,
         ProcessTags: processTags.serialized,
       }, done)

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

@@ -78,7 +78,7 @@ function configInfo () {
   const url = config.url
   const profilingEnabled = config.profiling.DD_PROFILING_ENABLED
 
-  return {
+  const startupLog = {
     [inspect.custom] () {
       return String(this)
     },
@@ -102,7 +102,6 @@ function configInfo () {
     sample_rate: config.sampler.sampleRate,
     sampling_rules: samplingRules,
     tags: config.tags,
-    ...(config.tags && config.tags.version && { dd_version: config.tags.version }),
     log_injection_enabled: !!config.logInjection,
     runtime_metrics_enabled: !!config.runtimeMetrics,
     profiling_enabled: profilingEnabled === 'true' || profilingEnabled === 'auto',
@@ -112,6 +111,8 @@ function configInfo () {
     otlp_metrics_export_enabled: !!config.DD_METRICS_OTEL_ENABLED,
     otlp_logs_export_enabled: !!config.DD_LOGS_OTEL_ENABLED,
   }
+  if (config.tags?.version) startupLog.dd_version = config.tags.version
+  return startupLog
 }
 
 /**

package/packages/dd-trace/src/telemetry/agentless-url.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const { createSiteUrl } = require('../exporters/common/url')
+
+const STAGING_SITE = 'datad0g.com'
+
+let cachedSite
+let cachedUrl
+
+/**
+ * @param {string} site
+ * @returns {URL}
+ */
+function getAgentlessTelemetryUrl (site) {
+  if (site === cachedSite && cachedUrl !== undefined) return cachedUrl
+
+  const intake = site === STAGING_SITE
+    ? 'all-http-intake.logs'
+    : 'instrumentation-telemetry-intake'
+  const url = createSiteUrl(site, intake)
+  if (url === undefined) throw new Error(`Invalid DD_SITE for agentless telemetry: ${site}`)
+
+  cachedSite = site
+  cachedUrl = url
+  return url
+}
+
+module.exports = getAgentlessTelemetryUrl