dd-trace 5.92.0 → 5.94.0

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

@@ -1,8 +1,6 @@
 'use strict'
 
 const { EventEmitter } = require('events')
-const { promisify } = require('util')
-const zlib = require('zlib')
 const dc = require('dc-polyfill')
 const crashtracker = require('../crashtracking')
 const log = require('../log')
@@ -34,6 +32,14 @@ function findWebSpan (startedSpans, spanId) {
   return false
 }
 
+const MISSING_SOURCE_MAPS_TOKEN = 'dd:has-missing-map-files'
+
+function profileHasMissingSourceMaps (profile) {
+  const strings = profile?.stringTable?.strings
+  if (!strings) return false
+  return profile.comment?.some(idx => strings[idx] === MISSING_SOURCE_MAPS_TOKEN) ?? false
+}
+
 function processInfo (infos, info, type) {
   if (Object.keys(info).length > 0) {
     infos[type] = info
@@ -42,6 +48,7 @@ function processInfo (infos, info, type) {
 
 class Profiler extends EventEmitter {
   #compressionFn
+  #compressionFnInitialized = false
   #compressionOptions
   #config
   #enabled = false
@@ -50,7 +57,6 @@ class Profiler extends EventEmitter {
   #logger
   #profileSeq = 0
   #spanFinishListener
-  #sourceMapCount = 0
   #timer
 
   constructor () {
@@ -116,11 +122,13 @@ class Profiler extends EventEmitter {
       reportHostname,
     }
 
-    return this._start(options).catch((err) => {
+    try {
+      return this._start(options)
+    } catch (err) {
       logError(logger, 'Error starting profiler. For troubleshooting tips, see ' +
         '<https://dtdg.co/nodejs-profiler-troubleshooting>', err)
       return false
-    })
+    }
   }
 
   get enabled () {
@@ -131,7 +139,50 @@ class Profiler extends EventEmitter {
     logError(this.#logger, err)
   }
 
-  async _start (options) {
+  #getCompressionFn () {
+    if (!this.#compressionFnInitialized) {
+      this.#compressionFnInitialized = true
+      try {
+        const { promisify } = require('util')
+        const zlib = require('zlib')
+        const { method, level: clevel } = this.#config.uploadCompression
+        switch (method) {
+          case 'gzip':
+            this.#compressionFn = promisify(zlib.gzip)
+            if (clevel !== undefined) {
+              this.#compressionOptions = {
+                level: clevel,
+              }
+            }
+            break
+          case 'zstd':
+            // eslint-disable-next-line n/no-unsupported-features/node-builtins
+            if (typeof zlib.zstdCompress === 'function') {
+              // eslint-disable-next-line n/no-unsupported-features/node-builtins
+              this.#compressionFn = promisify(zlib.zstdCompress)
+              if (clevel !== undefined) {
+                this.#compressionOptions = {
+                  params: {
+                    // eslint-disable-next-line n/no-unsupported-features/node-builtins
+                    [zlib.constants.ZSTD_c_compressionLevel]: clevel,
+                  },
+                }
+              }
+            } else {
+              const zstdCompress = require('@datadog/libdatadog').load('datadog-js-zstd').zstd_compress
+              const level = clevel ?? 0 // 0 is zstd default compression level
+              this.#compressionFn = (buffer) => Promise.resolve(Buffer.from(zstdCompress(buffer, level)))
+            }
+            break
+        }
+      } catch (err) {
+        this.#logError(err)
+      }
+    }
+    return this.#compressionFn
+  }
+
+  _start (options) {
     if (this.enabled) return true
 
     const config = this.#config = new Config(options)
@@ -148,45 +199,21 @@ class Profiler extends EventEmitter {
       setLogger(config.logger)
 
       if (config.sourceMap) {
-        mapper = await SourceMapper.create([process.cwd()], config.debugSourceMaps)
-        this.#sourceMapCount = mapper.infoMap.size
-        if (config.debugSourceMaps) {
-          this.#logger.debug(() => {
-            return this.#sourceMapCount === 0
-              ? 'Found no source maps'
-              : `Found source maps for following files: [${[...mapper.infoMap.keys()].join(', ')}]`
-          })
-        }
-      }
-
-      const clevel = config.uploadCompression.level
-      switch (config.uploadCompression.method) {
-        case 'gzip':
-          this.#compressionFn = promisify(zlib.gzip)
-          if (clevel !== undefined) {
-            this.#compressionOptions = {
-              level: clevel,
-            }
-          }
-          break
-        case 'zstd':
-          if (typeof zlib.zstdCompress === 'function') { // eslint-disable-line n/no-unsupported-features/node-builtins
-            // eslint-disable-next-line n/no-unsupported-features/node-builtins
-            this.#compressionFn = promisify(zlib.zstdCompress)
-            if (clevel !== undefined) {
-              this.#compressionOptions = {
-                params: {
-                  // eslint-disable-next-line n/no-unsupported-features/node-builtins
-                  [zlib.constants.ZSTD_c_compressionLevel]: clevel,
-                },
-              }
+        mapper = new SourceMapper(config.debugSourceMaps)
+        mapper.loadDirectory(process.cwd())
+          .then(() => {
+            if (config.debugSourceMaps) {
+              const count = mapper.infoMap.size
+              this.#logger.debug(() => {
+                return count === 0
+                  ? 'Found no source maps'
+                  : `Found source maps for following files: [${[...mapper.infoMap.keys()].join(', ')}]`
+              })
             }
-          } else {
-            const zstdCompress = require('@datadog/libdatadog').load('datadog-js-zstd').zstd_compress
-            const level = clevel ?? 0 // 0 is zstd default compression level
-            this.#compressionFn = (buffer) => Promise.resolve(Buffer.from(zstdCompress(buffer, level)))
-          }
-          break
+          })
+          .catch((err) => {
+            this.#logError(err)
+          })
       }
     } catch (err) {
       this.#logError(err)
@@ -295,7 +322,7 @@ class Profiler extends EventEmitter {
     return {
       serverless: this.serverless,
       settings: this.#config.systemInfoReport,
-      sourceMapCount: this.#sourceMapCount,
+      hasMissingSourceMaps: false,
     }
   }
 
@@ -332,15 +359,19 @@ class Profiler extends EventEmitter {
 
       const encodedProfiles = {}
       const infos = this.#createInitialInfos()
+      const compressionFn = this.#getCompressionFn()
 
       // encode and export asynchronously
       await Promise.all(profiles.map(async ({ profiler, profile, info }) => {
         try {
           const encoded = await profiler.encode(profile)
-          const compressed = encoded instanceof Buffer && this.#compressionFn !== undefined
-            ? await this.#compressionFn(encoded, this.#compressionOptions)
+          const compressed = encoded instanceof Buffer && compressionFn !== undefined
+            ? await compressionFn(encoded, this.#compressionOptions)
             : encoded
           encodedProfiles[profiler.type] = compressed
+          if (profileHasMissingSourceMaps(profile)) {
+            infos.hasMissingSourceMaps = true
+          }
           processInfo(infos, info, profiler.type)
           this.#logger.debug(() => {
             const profileJson = JSON.stringify(profile, (_, value) => {

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

@@ -20,6 +20,7 @@ const TRACE_ENDPOINT_LABEL = 'trace endpoint'
 let beforeCh
 const enterCh = dc.channel('dd-trace:storage:enter')
 const spanFinishCh = dc.channel('dd-trace:span:finish')
+const tagsUpdateCh = dc.channel('dd-trace:span:tags:update')
 const profilerTelemetryMetrics = telemetryMetrics.manager.namespace('profilers')
 
 const ProfilingContext = Symbol('NativeWallProfiler.ProfilingContext')
@@ -58,33 +59,30 @@ function ensureChannelsActivated (asyncContextFrameEnabled) {
   if (channelsActivated) return
 
   const shimmer = require('../../../../datadog-shimmer')
-  const asyncHooks = require('async_hooks')
 
-  // When using AsyncContextFrame to store sample context, we do not need to use
-  // async_hooks.createHook to create a "before" callback anymore.
-  if (!asyncContextFrameEnabled) {
-    const { createHook } = asyncHooks
-    beforeCh = dc.channel('dd-trace:storage:before')
-    createHook({ before: () => beforeCh.publish() }).enable()
-  }
-
-  const { AsyncLocalStorage } = asyncHooks
-
-  // We need to instrument AsyncLocalStorage.enterWith() both with and without AsyncContextFrame.
+  // We need to instrument enterWith() on the legacy storage — that's the storage
+  // carrying span data and the only one the profiler cares about.
+  const legacyStorage = storage('legacy')
   let inRun = false
-  shimmer.wrap(AsyncLocalStorage.prototype, 'enterWith', function (original) {
-    return function (...args) {
-      const retVal = original.apply(this, args)
+  shimmer.wrap(legacyStorage, 'enterWith', function (original) {
+    return function (store) {
+      const retVal = original.call(this, store)
       if (!inRun) enterCh.publish()
       return retVal
     }
   })
 
-  // We only need to instrument AsyncLocalStorage.run() when not using AsyncContextFrame.
-  // AsyncContextFrame-based implementation of AsyncLocalStorage.run() delegates
-  // to AsyncLocalStorage.enterWith() so it doesn't need to be separately instrumented.
+  // When not using AsyncContextFrame, we need additional instrumentation.
   if (!asyncContextFrameEnabled) {
-    shimmer.wrap(AsyncLocalStorage.prototype, 'run', function (original) {
+    // We need async_hooks.createHook to create a "before" callback.
+    const { createHook } = require('async_hooks')
+    beforeCh = dc.channel('dd-trace:storage:before')
+    createHook({ before: () => beforeCh.publish() }).enable()
+
+    // In ACF-based implementation run() delegates to enterWith()  so it doesn't
+    // need to be separately instrumented. in non-ACF implementation run()
+    // doesn't delegate to enterWith(), so separate instrumentation is necessary.
+    shimmer.wrap(legacyStorage, 'run', function (original) {
       return function (store, callback, ...args) {
         const wrappedCb = shimmer.wrapFunction(callback, cb => function (...args) {
           inRun = false
@@ -125,6 +123,7 @@ class NativeWallProfiler {
   // Bind these to this so they can be used as callbacks
   #boundEnter = this.#enter.bind(this)
   #boundSpanFinished = this.#spanFinished.bind(this)
+  #boundSpanTagsUpdated = this.#spanTagsUpdated.bind(this)
   #boundGenerateLabels = this._generateLabels.bind(this)
 
   get type () { return 'wall' }
@@ -204,6 +203,9 @@ class NativeWallProfiler {
         }
         enterCh.subscribe(this.#boundEnter)
         spanFinishCh.subscribe(this.#boundSpanFinished)
+        if (this.#endpointCollectionEnabled) {
+          tagsUpdateCh.subscribe(this.#boundSpanTagsUpdated)
+        }
       }
     }
 
@@ -290,15 +292,7 @@ class NativeWallProfiler {
       }
 
       profilingContext = { spanId, rootSpanId, webTags }
-      // Don't cache if endpoint collection is enabled and webTags is undefined but
-      // the span's type hasn't been set yet. TracingPlugin.startSpan() calls
-      // enterWith() before the plugin sets span.type='web' via addRequestTags(),
-      // so the first enterCh event fires before the type is known. Without this
-      // guard we'd cache webTags=undefined and then serve that stale value on the
-      // subsequent activation (when span.type='web' is already set).
-      if (!this.#endpointCollectionEnabled || webTags !== undefined || context._tags['span.type']) {
-        span[ProfilingContext] = profilingContext
-      }
+      span[ProfilingContext] = profilingContext
     }
     return profilingContext
   }
@@ -317,6 +311,16 @@ class NativeWallProfiler {
     }
   }
 
+  #spanTagsUpdated (span) {
+    if (!this.#started) return
+    const profilingContext = span[ProfilingContext]
+    if (profilingContext === undefined || profilingContext.webTags !== undefined) return
+    const tags = span.context()._tags
+    if (isWebServerSpan(tags)) {
+      profilingContext.webTags = tags
+    }
+  }
+
   #reportV8bug (maybeBug) {
     const tag = `v8_profiler_bug_workaround_enabled:${this.#v8ProfilerBugWorkaroundEnabled}`
     const metric = `v8_cpu_profiler${maybeBug ? '_maybe' : ''}_stuck_event_loop`
@@ -355,6 +359,9 @@ class NativeWallProfiler {
         }
         enterCh.unsubscribe(this.#boundEnter)
         spanFinishCh.unsubscribe(this.#boundSpanFinished)
+        if (this.#endpointCollectionEnabled) {
+          tagsUpdateCh.unsubscribe(this.#boundSpanTagsUpdated)
+        }
         this._profilerState = undefined
       }
       this.#started = false

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

@@ -180,7 +180,7 @@ class Tracer extends NoopProxy {
       if (config.profiling.enabled === 'true') {
         this._profilerStarted = this._startProfiler(config)
       } else {
-        this._profilerStarted = Promise.resolve(false)
+        this._profilerStarted = false
         if (config.profiling.enabled === 'auto') {
           const { SSIHeuristics } = require('./profiling/ssi-heuristics')
           const ssiHeuristics = new SSIHeuristics(config)
@@ -252,6 +252,7 @@ class Tracer extends NoopProxy {
         'Error starting profiler. For troubleshooting tips, see <https://dtdg.co/nodejs-profiler-troubleshooting>',
         e
       )
+      return false
     }
   }
 
@@ -329,11 +330,11 @@ class Tracer extends NoopProxy {
    * @override
    */
   profilerStarted () {
-    if (!this._profilerStarted) {
+    if (this._profilerStarted === undefined) {
       // injection hardening: this is only ever invoked from tests.
       throw new Error('profilerStarted() must be called after init()')
     }
-    return this._profilerStarted
+    return Promise.resolve(this._profilerStarted)
   }
 
   /**

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

@@ -11,13 +11,22 @@ function storeConfig (config) {
       return
     }
 
+    const { containerId } = require('./exporters/common/docker')
+    const processTags = require('./process-tags')
+
+    const processTagsSerialized = config.propagateProcessTags?.enabled
+      ? (processTags.serialized || null)
+      : null
+
     const metadata = new processDiscovery.TracerMetadata(
       config.tags['runtime-id'],
       tracerVersion,
       config.hostname,
       config.service || null,
       config.env || null,
-      config.version || null
+      config.version || null,
+      processTagsSerialized,
+      containerId || null
     )
 
     return processDiscovery.storeMetadata(metadata)

package/webpack.js

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = require('./packages/datadog-webpack/index.js')