dd-trace 6.13.0 → 6.14.0

package/packages/dd-trace/src/profiling/profiler.js

@@ -4,7 +4,7 @@ const { EventEmitter } = require('events')
 const dc = require('dc-polyfill')
 const crashtracker = require('../crashtracking')
 const log = require('../log')
-const { buildProfilingRuntime } = require('./config')
+const { buildProfilingRuntime, getProfilingTags } = require('./config')
 const { snapshotKinds } = require('./constants')
 const { threadNamePrefix } = require('./profilers/shared')
 const { isWebServerSpan, endpointNameFromTags, getStartedSpans } = require('./webspan-utils')
@@ -54,6 +54,7 @@ class Profiler extends EventEmitter {
   #compressionFn
   #compressionFnInitialized = false
   #compressionOptions
+  #config
   #customLabelKeys = new Set()
   #enabled = false
   #endpointCounts = new Map()
@@ -64,7 +65,7 @@ class Profiler extends EventEmitter {
   #profilers
   #spanFinishListener
   #systemInfoReport
-  #tags
+  #currentSnapshotTags
   #timer
   #uploadCompression
 
@@ -156,7 +157,7 @@ class Profiler extends EventEmitter {
                 }
               }
             } else {
-              const zstdCompress = require('@datadog/libdatadog').load('datadog-js-zstd').zstd_compress
+              const { zstd_compress: zstdCompress } = require('@datadog/libdatadog')
               const level = clevel ?? 0 // 0 is zstd default compression level
               this.#compressionFn = (buffer) => Promise.resolve(Buffer.from(zstdCompress(buffer, level)))
             }
@@ -176,12 +177,13 @@ class Profiler extends EventEmitter {
     if (this.enabled) return true
     this.#enabled = true
 
-    const { tags, exporters, flushInterval, profilers, uploadCompression, systemInfoReport } =
+    const { tags: snapshotTags, exporters, flushInterval, profilers, uploadCompression, systemInfoReport } =
       buildProfilingRuntime(config)
-    this.#tags = tags
+    this.#config = config
     this.#exporters = exporters
     this.#flushInterval = flushInterval
     this.#profilers = profilers
+    this.#currentSnapshotTags = snapshotTags
     this.#uploadCompression = uploadCompression
     this.#systemInfoReport = systemInfoReport
     if (this.#customLabelKeys.size > 0) {
@@ -248,7 +250,7 @@ class Profiler extends EventEmitter {
     processInfo(infos, info, profileType)
     this.#submit({
       [profileType]: encodedProfile,
-    }, infos, start, end, snapshotKinds.ON_OUT_OF_MEMORY)
+    }, infos, start, end, this.#currentSnapshotTags, snapshotKinds.ON_OUT_OF_MEMORY)
   }
 
   _setInterval () {
@@ -332,6 +334,7 @@ class Profiler extends EventEmitter {
 
       const startDate = this.#lastStart
       const endDate = new Date()
+      const snapshotTags = this.#currentSnapshotTags
       const profiles = []
 
       crashtracker.withProfilerSerializing(() => {
@@ -348,6 +351,7 @@ class Profiler extends EventEmitter {
       })
 
       if (restart) {
+        this.#currentSnapshotTags = getProfilingTags(this.#config)
         this._capture(this._timeoutInterval, endDate)
       }
 
@@ -385,7 +389,7 @@ class Profiler extends EventEmitter {
       }))
 
       if (hasEncoded) {
-        await this.#submit(encodedProfiles, infos, startDate, endDate, snapshotKind)
+        await this.#submit(encodedProfiles, infos, startDate, endDate, snapshotTags, snapshotKind)
         profileSubmittedChannel.publish()
         log.debug('Submitted profiles')
       }
@@ -395,9 +399,15 @@ class Profiler extends EventEmitter {
     }
   }
 
-  #submit (profiles, infos, start, end, snapshotKind) {
-    const tags = this.#tags
-
+  /**
+   * @param {Record<string, Buffer|string>} profiles
+   * @param {Record<string, unknown>} infos
+   * @param {Date} start
+   * @param {Date} end
+   * @param {Record<string, string|number|boolean|undefined>} snapshotTags
+   * @param {string} snapshotKind
+   */
+  #submit (profiles, infos, start, end, snapshotTags, snapshotKind) {
     // Flatten endpoint counts
     const endpointCounts = {}
     for (const [endpoint, { count }] of this.#endpointCounts) {
@@ -405,12 +415,12 @@ class Profiler extends EventEmitter {
     }
     this.#endpointCounts.clear()
 
-    tags.snapshot = snapshotKind
-    tags.profile_seq = this.#profileSeq++
+    snapshotTags.snapshot = snapshotKind
+    snapshotTags.profile_seq = this.#profileSeq++
     const customAttributes = this.#customLabelKeys.size > 0
       ? [...this.#customLabelKeys]
       : undefined
-    const exportSpec = { profiles, infos, start, end, tags, endpointCounts, customAttributes }
+    const exportSpec = { profiles, infos, start, end, tags: snapshotTags, endpointCounts, customAttributes }
     const tasks = this.#exporters.map(exporter =>
       exporter.export(exportSpec).catch(error => {
         log.warn(error)

package/packages/dd-trace/src/profiling/profilers/space.js

@@ -1,5 +1,8 @@
 'use strict'
 
+const { channel } = require('dc-polyfill')
+
+const log = require('../../log')
 const { oomExportStrategies, ensureOOMExportStrategies, strategiesToCallbackMode, buildExportCommand } =
   require('../oom')
 const { encodeProfileAsync, getThreadLabels } = require('./shared')
@@ -11,10 +14,12 @@ const { encodeProfileAsync, getThreadLabels } = require('./shared')
  */
 
 const STACK_DEPTH = 64
+const identityRefreshChannel = channel('datadog:identity:refresh')
 
 class NativeSpaceProfiler {
   #config
   #exporters
+  #identityRefreshListener
   #mapper
   #pprof
   #samplingInterval
@@ -39,20 +44,36 @@ class NativeSpaceProfiler {
   start ({ mapper, nearOOMCallback } = {}) {
     if (this.#started) return
 
-    const config = this.#config
     this.#mapper = mapper
     this.#pprof = require('@datadog/pprof')
-    this.#pprof.heap.start(this.#samplingInterval, STACK_DEPTH, config.DD_PROFILING_ALLOCATION_ENABLED)
-    if (config.DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED) {
+    this.#pprof.heap.start(this.#samplingInterval, STACK_DEPTH, this.#config.DD_PROFILING_ALLOCATION_ENABLED)
+
+    if (this.#config.DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED) {
+      const config = this.#config
       const strategies = ensureOOMExportStrategies(config.DD_PROFILING_EXPERIMENTAL_OOM_EXPORT_STRATEGIES)
-      this.#pprof.heap.monitorOutOfMemory(
-        config.DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE,
-        config.DD_PROFILING_EXPERIMENTAL_OOM_MAX_HEAP_EXTENSION_COUNT,
-        strategies.includes(oomExportStrategies.LOGS),
-        strategies.includes(oomExportStrategies.PROCESS) ? buildExportCommand(this.#exporters, this.#tags) : [],
-        (profile) => nearOOMCallback(this.type, this.#pprof.encodeSync(profile), this.getInfo()),
-        strategiesToCallbackMode(strategies, this.#pprof.heap.CallbackMode)
-      )
+      const monitorOutOfMemory = () => {
+        this.#pprof.heap.monitorOutOfMemory(
+          config.DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE,
+          config.DD_PROFILING_EXPERIMENTAL_OOM_MAX_HEAP_EXTENSION_COUNT,
+          strategies.includes(oomExportStrategies.LOGS),
+          strategies.includes(oomExportStrategies.PROCESS) ? buildExportCommand(this.#exporters, this.#tags) : [],
+          (profile) => nearOOMCallback(this.type, this.#pprof.encodeSync(profile), this.getInfo()),
+          strategiesToCallbackMode(strategies, this.#pprof.heap.CallbackMode)
+        )
+      }
+      monitorOutOfMemory()
+
+      if (strategies.includes(oomExportStrategies.PROCESS)) {
+        this.#identityRefreshListener = () => {
+          try {
+            Object.assign(this.#tags, config.tags)
+            monitorOutOfMemory()
+          } catch (error) {
+            log.error(error)
+          }
+        }
+        identityRefreshChannel.subscribe(this.#identityRefreshListener)
+      }
     }
 
     this.#started = true
@@ -74,6 +95,12 @@ class NativeSpaceProfiler {
 
   stop () {
     if (!this.#started) return
+
+    if (this.#identityRefreshListener !== undefined) {
+      identityRefreshChannel.unsubscribe(this.#identityRefreshListener)
+      this.#identityRefreshListener = undefined
+    }
+
     this.#pprof.heap.stop()
     this.#started = false
   }

package/packages/dd-trace/src/profiling/webspan-utils.js

@@ -8,10 +8,13 @@ function isWebServerSpan (tags) {
 }
 
 function endpointNameFromTags (tags) {
-  return tags[RESOURCE_NAME] || [
-    tags[HTTP_METHOD],
-    tags[HTTP_ROUTE],
-  ].filter(Boolean).join(' ')
+  const resource = tags[RESOURCE_NAME]
+  if (resource) return resource
+
+  let endpoint = tags[HTTP_METHOD] || ''
+  const route = tags[HTTP_ROUTE]
+  if (route) endpoint += endpoint ? ` ${route}` : route
+  return endpoint
 }
 
 // The endpoint name a web-server span's tag bag yields changes over the span's

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

@@ -1,5 +1,7 @@
 'use strict'
 
+const { channel } = require('dc-polyfill')
+const uuid = require('../../../vendor/dist/crypto-randomuuid')
 const NoopProxy = require('./noop/proxy')
 const DatadogTracer = require('./tracer')
 const getConfig = require('./config')
@@ -11,7 +13,13 @@ const telemetry = require('./telemetry')
 const nomenclature = require('./service-naming')
 const PluginManager = require('./plugin_manager')
 const NoopDogStatsDClient = require('./noop/dogstatsd')
-const { IS_SERVERLESS, initializeServerlessTelemetry, supportsServerlessTelemetryRetention } = require('./serverless')
+const {
+  IS_AWS_LAMBDA_MICROVM,
+  IS_SERVERLESS,
+  NODE_BUNDLES_OPENSSL,
+  initializeServerlessTelemetry,
+  supportsServerlessTelemetryRetention,
+} = require('./serverless')
 const { flushServerlessTelemetry, registerTelemetryFlusher } = require('./flush')
 const processTags = require('./process-tags')
 const { isTrue } = require('./util')
@@ -48,6 +56,13 @@ function getDynamicInstrumentation () {
   return dynamicInstrumentation
 }
 
+const UUID_POOL_SIZE = 128
+
+const BUNDLED_OPENSSL_WARNING = 'This Node.js build bundles its own OpenSSL, so its random number ' +
+  'generator is not reseeded when a MicroVM clone resumes and trace IDs may repeat across clones. ' +
+  'Install Node.js from the Amazon Linux 2023 repositories (for example `dnf install nodejs22`) so it ' +
+  'links the base image\'s snapsafe OpenSSL.'
+
 class LazyModule {
   constructor (provider) {
     this.provider = provider
@@ -150,6 +165,10 @@ class Tracer extends NoopProxy {
     try {
       const config = getConfig(options) // TODO: support dynamic code config
 
+      if (IS_AWS_LAMBDA_MICROVM) {
+        this.#registerMicroVmRunHook(config)
+      }
+
       // Add config dependent process tags
       processTags.initialize(config)
 
@@ -171,7 +190,7 @@ class Tracer extends NoopProxy {
 
       telemetry.start(config, this._pluginManager)
 
-      if (config.dogstatsd && !isOfflineTestOptimizationValidation()) {
+      if (config.dogstatsd && !config.DD_AGENTLESS_ENABLED && !isOfflineTestOptimizationValidation()) {
         // Custom Metrics
         lazyProxy(this, 'dogstatsd', () => require('./dogstatsd').CustomMetrics, config)
       }
@@ -292,10 +311,10 @@ class Tracer extends NoopProxy {
         // are lazily configured when the library is imported.
         this._testApiManualPlugin.configure({ ...config, enabled: true }, false)
       }
-      if (config.isCiVisibility && config.DD_AGENTLESS_LOG_SUBMISSION_ENABLED) {
+      if (config.DD_AGENTLESS_LOG_SUBMISSION_ENABLED) {
         if (config.DD_API_KEY) {
-          const LogSubmissionPlugin = require('./ci-visibility/log-submission/log-submission-plugin')
-          const automaticLogPlugin = new LogSubmissionPlugin(this)
+          const LogSubmissionPlugin = require('./log-submission/log-submission-plugin')
+          const automaticLogPlugin = new LogSubmissionPlugin(this, config)
           automaticLogPlugin.configure({ ...config, enabled: true })
         } else {
           log.warn(
@@ -318,6 +337,42 @@ class Tracer extends NoopProxy {
     return this
   }
 
+  /**
+   * Listens for the MicroVM /run lifecycle event and triggers a one-time
+   * identity reset on first fire.
+   *
+   * @param {import('./config/config-base')} config
+   */
+  #registerMicroVmRunHook (config) {
+    // Node reseeds its CSPRNG from the kernel on clone resume only when it links the base image's
+    // snapsafe libcrypto; a bundled OpenSSL keeps the snapshot's DRBG state, so the refresh below
+    // cannot produce distinct IDs. Logged at registration, during the image build, where the
+    // Dockerfile can still be fixed — not once per clone.
+    if (NODE_BUNDLES_OPENSSL) {
+      log.error(BUNDLED_OPENSSL_WARNING)
+    }
+
+    const ch = channel('http.server.request.start')
+
+    const onHttpRequest = ({ request }) => {
+      if (request.method === 'POST' && request.url === '/aws/lambda-microvms/runtime/v1/run') {
+        ch.unsubscribe(onHttpRequest)
+        drainUuidPool()
+        channel('datadog:identity:update').publish(config)
+        if (this._tracingInitialized) {
+          const storeTracerMetadata = require('./tracer_metadata')
+          const metadata = storeTracerMetadata(config)
+          if (metadata === undefined) {
+            log.warn('Could not store tracer configuration for service discovery')
+          }
+        }
+        channel('datadog:identity:refresh').publish(config)
+      }
+    }
+
+    ch.subscribe(onHttpRequest)
+  }
+
   /**
    * @param {import('./config/config-base')} config - Tracer configuration
    */
@@ -515,4 +570,19 @@ function isOfflineValidationExporter (options) {
   return OFFLINE_VALIDATION_EXPORTERS.has(options?.experimental?.exporter)
 }
 
+/**
+ * Discards Node's buffered UUID entropy, so the identity subscribers draw from bytes generated
+ * after the clone resumed.
+ *
+ * `crypto.randomUUID()` serves `kBatchSize` (128, see `lib/internal/crypto/random.js`) UUIDs from one
+ * process-wide pool and refills it only when its cursor wraps back to 0. A full cycle crosses the
+ * cursor exactly once from any starting position, and the position is not observable, so the count
+ * has to be the batch size rather than the number of UUIDs we need.
+ */
+function drainUuidPool () {
+  for (let index = 0; index < UUID_POOL_SIZE; index++) {
+    uuid()
+  }
+}
+
 module.exports = Tracer