dd-trace 6.12.0 → 6.14.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/index.js

@@ -13,6 +13,7 @@ const noop = runtimeMetrics = {
   gauge () {},
   increment () {},
   decrement () {},
+  flush (done) { done?.() },
 }
 
 module.exports = {
@@ -42,6 +43,10 @@ module.exports = {
     runtimeMetrics = noop
     Object.setPrototypeOf(module.exports, noop)
   },
+
+  flush (done) {
+    runtimeMetrics.flush(done)
+  },
 }
 
 Object.setPrototypeOf(module.exports, noop)

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
   },
 
@@ -245,6 +249,11 @@ module.exports = {
   decrement (name, tag) {
     this.count(name, -1, tag)
   },
+
+  flush (done) {
+    if (client) return client.flush(done)
+    done?.()
+  },
 }
 
 /**

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 ||
@@ -27,6 +27,8 @@ let client = null
 let lastTime = 0
 let lastCpuUsage = null
 let eventLoopDelayObserver = null
+let capture = null
+let unsubscribeIdentityRefresh = null
 
 // !!!!!!!!!!!
 //  IMPORTANT
@@ -48,6 +50,7 @@ module.exports = {
     const trackGc = config.runtimeMetrics.gc !== false
 
     client = createMetricsClient(config)
+    unsubscribeIdentityRefresh = subscribeToIdentityRefresh(client, config)
 
     if (trackGc) {
       startGCObserver()
@@ -76,11 +79,10 @@ module.exports = {
     lastTime = performance.now()
 
     if (nativeMetrics) {
-      interval = setInterval(() => {
+      capture = () => {
         captureNativeMetrics(trackEventLoop, trackGc)
         captureCommonMetrics(trackEventLoop)
-        client.flush()
-      }, flushIntervalMs)
+      }
     } else {
       lastCpuUsage = process.cpuUsage()
 
@@ -92,17 +94,21 @@ module.exports = {
         eventLoopDelayObserver.enable()
       }
 
-      interval = setInterval(() => {
+      capture = () => {
         captureCpuUsage()
         captureCommonMetrics(trackEventLoop)
         captureHeapSpace()
         if (trackEventLoop) {
           captureEventLoopDelay()
         }
-        client.flush()
-      }, flushIntervalMs)
+      }
     }
 
+    interval = setInterval(() => {
+      capture()
+      client.flush()
+    }, flushIntervalMs)
+
     interval.unref?.()
   },
 
@@ -113,7 +119,10 @@ module.exports = {
     clearInterval(interval)
     interval = null
 
+    unsubscribeIdentityRefresh?.()
+    unsubscribeIdentityRefresh = null
     client = null
+    capture = null
     lastCpuUsage = null
 
     gcObserver?.disconnect()
@@ -158,6 +167,12 @@ module.exports = {
   decrement (name, tag) {
     this.count(name, -1, tag)
   },
+
+  flush (done) {
+    if (!client) return done?.()
+    capture?.()
+    client.flush(done)
+  },
 }
 
 function captureCpuUsage () {

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()
 }
 
 /**
@@ -171,13 +198,13 @@ class SamplingRule {
   constructor ({ name, service, resource, tags, sampleRate = 1, provenance, maxPerSecond } = {}) {
     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) {

package/packages/dd-trace/src/serverless/telemetry-delivery-tracker.js

@@ -0,0 +1,51 @@
+'use strict'
+
+/**
+ * Tracks transport deliveries that must outlive a serverless request.
+ *
+ * The tracker is created only for platforms with an invocation-retention
+ * boundary. Exporters keep their normal callback path when it is absent.
+ */
+class TelemetryDeliveryTracker {
+  #deliveries = new Set()
+
+  /**
+   * Tracks one asynchronous transport delivery until its callback runs.
+   * @param {(done: () => void) => void} deliver
+   * @param {(() => void)|undefined} done
+   */
+  track (deliver, done) {
+    const delivery = { callbacks: done ? [done] : [] }
+    this.#deliveries.add(delivery)
+
+    const complete = () => {
+      if (!this.#deliveries.delete(delivery)) return
+      for (const callback of delivery.callbacks) callback()
+    }
+
+    try {
+      deliver(complete)
+    } catch (error) {
+      complete()
+      throw error
+    }
+  }
+
+  /**
+   * Calls back after every delivery active at this boundary has completed.
+   * @param {(() => void)|undefined} done
+   */
+  waitForIdle (done) {
+    if (!done) return
+
+    let pending = this.#deliveries.size
+    if (pending === 0) return done()
+
+    const complete = () => {
+      if (--pending === 0) done()
+    }
+    for (const delivery of this.#deliveries) delivery.callbacks.push(complete)
+  }
+}
+
+module.exports = TelemetryDeliveryTracker

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

@@ -0,0 +1,155 @@
+'use strict'
+
+const { channel } = require('dc-polyfill')
+
+const { getEnvironmentVariable } = require('../config/helper')
+const log = require('../log')
+
+const httpRequestFinishChannel = channel('apm:http:server:request:finish')
+const http2RequestStartChannel = channel('apm:http2:server:request:start')
+const http2ResponseEmitChannel = channel('apm:http2:server:response:emit')
+const VERCEL_REQUEST_CONTEXT = Symbol.for('@vercel/request-context')
+const VERCEL_FLUSH_TIMEOUT = 2000
+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
+ * @returns {void}
+ */
+function flushVercelTelemetry (tracer, done) {
+  setImmediate(() => {
+    try {
+      tracer.flushAll(done, { timeout: VERCEL_FLUSH_TIMEOUT })
+    } catch (error) {
+      log.warn('Unable to flush Vercel telemetry:', error)
+      done()
+    }
+  })
+}
+
+function getVercelRequestContext () {
+  return globalThis[VERCEL_REQUEST_CONTEXT]?.get?.()
+}
+
+// HTTP/2 binds response lifecycle events while handling its request-start channel.
+function activateHttp2Lifecycle () {}
+
+/**
+ * Retains a Vercel Node Function until configured telemetry exporters complete.
+ *
+ * @param {TelemetryFlusher} tracer
+ * @returns {(() => void)|undefined}
+ */
+function registerVercelTelemetryRetention (tracer) {
+  const existing = vercelRetentionHandlers.get(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 flushHttp2Response = ({ eventName }) => {
+    if (eventName === 'close') flushRequest()
+  }
+  httpRequestFinishChannel.subscribe(flushRequest)
+  http2RequestStartChannel.subscribe(activateHttp2Lifecycle)
+  http2ResponseEmitChannel.subscribe(flushHttp2Response)
+
+  const unregister = () => {
+    httpRequestFinishChannel.unsubscribe(flushRequest)
+    http2RequestStartChannel.unsubscribe(activateHttp2Lifecycle)
+    http2ResponseEmitChannel.unsubscribe(flushHttp2Response)
+    vercelRetentionHandlers.delete(tracer)
+  }
+  vercelRetentionHandlers.set(tracer, unregister)
+  return unregister
+}
+
+/**
+ * Gets Vercel deployment tags to attach to spans.
+ *
+ * @returns {string[]|undefined}
+ */
+function getVercelPlatformTags () {
+  let tags
+  const projectId = getEnvironmentVariable('VERCEL_PROJECT_ID')
+  if (projectId) {
+    tags = ['vercel.project_id', projectId]
+  }
+
+  const environment = getEnvironmentVariable('VERCEL_ENV')
+  if (environment) {
+    tags ??= []
+    tags.push('vercel.environment', environment)
+  }
+
+  const region = getEnvironmentVariable('VERCEL_REGION')
+  if (region) {
+    tags ??= []
+    tags.push('vercel.region', region)
+  }
+
+  return tags
+}
+
+module.exports = {
+  getVercelPlatformTags,
+  registerVercelTelemetryRetention,
+}

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,50 +42,71 @@ function isInServerlessEnvironment () {
   const isGCPFunction = getIsGCPFunction()
   const isAzureFunction = getIsAzureFunction()
 
-  return inAWSLambda || isGCPFunction || isAzureFunction
+  return IS_AWS_LAMBDA_MICROVM || inAWSLambda || isGCPFunction || isAzureFunction
 }
 
 /**
  * Gets tags describing the serverless platform where the tracer is running.
  *
+ * @param {{ isVercel: boolean }} [platform] Detected serverless platform.
  * @returns {string[]|undefined}
  */
-function getServerlessPlatformTags () {
-  if (getEnvironmentVariable('VERCEL') === '1') {
-    return getVercelPlatformTags()
+function getServerlessPlatformTags (platform = getServerlessPlatform()) {
+  if (platform.isVercel) {
+    return require('./serverless/vercel').getVercelPlatformTags()
   }
 }
 
 /**
- * @returns {string[]|undefined}
+ * Detects the serverless platform once while configuration is built.
+ * @returns {{ isVercel: boolean }}
  */
-function getVercelPlatformTags () {
-  let tags
-  const projectId = getEnvironmentVariable('VERCEL_PROJECT_ID')
-  if (projectId) {
-    tags = ['vercel.project_id', projectId]
-  }
+function getServerlessPlatform () {
+  return { isVercel: supportsServerlessTelemetryRetention() }
+}
 
-  const environment = getEnvironmentVariable('VERCEL_ENV')
-  if (environment) {
-    tags ??= []
-    tags.push('vercel.environment', environment)
-  }
+/**
+ * Whether the current platform can retain an invocation for telemetry delivery.
+ *
+ * Add future serverless platforms here as they gain an equivalent retention hook.
+ * @returns {boolean}
+ */
+function supportsServerlessTelemetryRetention () {
+  return isVercelAtStartup
+}
 
-  const region = getEnvironmentVariable('VERCEL_REGION')
-  if (region) {
-    tags ??= []
-    tags.push('vercel.region', region)
+/**
+ * Creates delivery tracking for platforms with an invocation retention hook.
+ */
+function createServerlessDeliveryTracker () {
+  if (supportsServerlessTelemetryRetention()) {
+    return new (require('./serverless/telemetry-delivery-tracker'))()
   }
+}
 
-  return tags
+/**
+ * Registers the lifecycle adapter selected by the detected serverless platform.
+ * @param {{ flushAll?: (done: () => void) => void }} tracer
+ */
+function initializeServerlessTelemetry (tracer) {
+  if (supportsServerlessTelemetryRetention()) {
+    return require('./serverless/vercel').registerVercelTelemetryRetention(tracer)
+  }
 }
 
 module.exports = {
   getServerlessPlatformTags,
+  getServerlessPlatform,
+  supportsServerlessTelemetryRetention,
+  createServerlessDeliveryTracker,
   getIsGCPFunction,
   getIsAzureFunction,
   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 }) {