dd-trace 5.93.0 → 5.95.0

package/packages/dd-trace/src/opentracing/span.js

@@ -35,6 +35,7 @@ const integrationCounters = {
 
 const startCh = channel('dd-trace:span:start')
 const finishCh = channel('dd-trace:span:finish')
+const tagsUpdateCh = channel('dd-trace:span:tags:update')
 
 function getIntegrationCounter (event, integration) {
   const counters = integrationCounters[event]
@@ -399,6 +400,10 @@ class DatadogSpan {
     tagger.add(this._spanContext._tags, keyValuePairs)
 
     this._prioritySampler.sample(this, false)
+
+    if (tagsUpdateCh.hasSubscribers) {
+      tagsUpdateCh.publish(this)
+    }
   }
 }
 

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

@@ -18,13 +18,6 @@ const TEST_OPTIMIZATION_PLUGINS = new Set([
 
 const loadChannel = channel('dd-trace:instrumentation:load')
 
-// instrument everything that needs Plugin System V2 instrumentation
-require('../../datadog-instrumentations')
-if (getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME') !== undefined) {
-  // instrument lambda environment
-  require('./lambda')
-}
-
 const DD_TRACE_DISABLED_PLUGINS = getValueFromEnvSources('DD_TRACE_DISABLED_PLUGINS')
 
 const disabledPlugins = new Set(
@@ -35,10 +28,20 @@ const disabledPlugins = new Set(
 
 const pluginClasses = {}
 
+// Subscribe before requiring instrumentations so that loadChannel events fired
+// during instrumentation initialization (e.g. re-requires in bundler contexts)
+// are captured and populate pluginClasses correctly.
 loadChannel.subscribe(({ name }) => {
   maybeEnable(plugins[name])
 })
 
+// instrument everything that needs Plugin System V2 instrumentation
+require('../../datadog-instrumentations')
+if (getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME') !== undefined) {
+  // instrument lambda environment
+  require('./lambda')
+}
+
 function maybeEnable (Plugin) {
   if (!Plugin || typeof Plugin !== 'function') return
   if (!pluginClasses[Plugin.id]) {

package/packages/dd-trace/src/plugins/util/test.js

@@ -88,8 +88,24 @@ const TEST_EARLY_FLAKE_ABORT_REASON = 'test.early_flake.abort_reason'
 const TEST_RETRY_REASON = 'test.retry_reason'
 const TEST_HAS_FAILED_ALL_RETRIES = 'test.has_failed_all_retries'
 const TEST_IS_MODIFIED = 'test.is_modified'
+const TEST_HAS_DYNAMIC_NAME = '_dd.has_dynamic_name'
 const CI_APP_ORIGIN = 'ciapp-test'
 
+// Matches patterns that are almost certainly runtime-generated values in test names:
+// - Unix timestamps in ms (13 digits, years ~2020-2090) or s (10 digits)
+// - UUIDs (8-4-4-4-12 hex)
+// - ISO 8601 dates (2024-03-23) or date-times (2024-03-23T14:30)
+// - Random ports on localhost, 127.0.0.1, or 0.0.0.0
+// - Math.random() float values (10+ decimal digits after 0.)
+const DYNAMIC_NAME_RE = new RegExp(
+  String.raw`\b1[6-9]\d{8,11}\b|` +
+  String.raw`[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|` +
+  String.raw`\b\d{4}-\d{2}-\d{2}|` +
+  String.raw`(?:localhost|127\.0\.0\.1|0\.0\.0\.0):\d{4,5}\b|` +
+  String.raw`\b0\.\d{10,}`,
+  'i'
+)
+
 const JEST_TEST_RUNNER = 'test.jest.test_runner'
 const JEST_DISPLAY_NAME = 'test.jest.display_name'
 
@@ -260,6 +276,7 @@ module.exports = {
   TEST_RETRY_REASON,
   TEST_HAS_FAILED_ALL_RETRIES,
   TEST_IS_MODIFIED,
+  TEST_HAS_DYNAMIC_NAME,
   getTestEnvironmentMetadata,
   getTestParametersString,
   finishAllTraceSpans,
@@ -337,6 +354,9 @@ module.exports = {
   POSSIBLE_BASE_BRANCHES,
   GIT_COMMIT_SHA,
   GIT_REPOSITORY_URL,
+  DYNAMIC_NAME_RE,
+  collectDynamicNamesFromTraces,
+  logDynamicNamesWarning,
 }
 
 // Returns pkg manager and its version, separated by '-', e.g. npm-8.15.0 or yarn-1.22.19
@@ -1178,6 +1198,62 @@ function getModifiedFilesFromDiff (diff) {
   return result
 }
 
+/**
+ * Scans serialized worker trace payloads for tests tagged with TEST_HAS_DYNAMIC_NAME
+ * and populates the provided Set. Silently ignores parse errors.
+ *
+ * @param {string} data - JSON-serialized traces from a worker
+ * @param {Set<string>} newTestsWithDynamicNames - Set to populate with "suite › name" strings
+ */
+function collectDynamicNamesFromTraces (data, newTestsWithDynamicNames) {
+  try {
+    const traces = JSON.parse(data)
+    for (const trace of traces) {
+      for (const span of trace) {
+        if (span.meta?.[TEST_HAS_DYNAMIC_NAME] === 'true') {
+          const suite = span.meta[TEST_SUITE]
+          const name = span.meta[TEST_NAME]
+          if (suite && name) {
+            newTestsWithDynamicNames.add(`${suite} › ${name}`)
+          }
+        }
+      }
+    }
+  } catch {
+    // ignore parse errors
+  }
+}
+
+/**
+ * Logs a "Datadog Test Optimization" warning about new tests with dynamic names.
+ * Clears the Set after logging. No-op if the Set is empty.
+ *
+ * @param {Set<string>} newTestsWithDynamicNames
+ */
+function logDynamicNamesWarning (newTestsWithDynamicNames) {
+  if (newTestsWithDynamicNames.size === 0) return
+
+  const MAX_SHOWN = 10
+  const names = [...newTestsWithDynamicNames]
+  const shown = names.slice(0, MAX_SHOWN)
+  const more = names.length - shown.length
+  const moreSuffix = more > 0 ? `\n  ... and ${more} more` : ''
+  const nameList = shown.map(n => `  • ${n}`).join('\n') + moreSuffix
+
+  const line = '-'.repeat(50)
+  // eslint-disable-next-line no-console -- Intentional user-facing session summary
+  console.warn(
+    `\n${line}\nDatadog Test Optimization\n${line}\n` +
+    `${newTestsWithDynamicNames.size} test(s) detected as new but their names contain ` +
+    'dynamic data (timestamps, UUIDs, etc.).\n' +
+    'Tests with changing names are always treated as new on every run, ' +
+    'causing unnecessary Early Flake Detection retries and preventing correct new test detection.\n' +
+    'Consider using stable, deterministic test names.\n\n' +
+    `${nameList}\n`
+  )
+  newTestsWithDynamicNames.clear()
+}
+
 function isModifiedTest (testPath, testStartLine, testEndLine, modifiedFiles, testFramework) {
   if (modifiedFiles === undefined) {
     return false

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

@@ -249,7 +249,7 @@ class PrioritySampler {
     }
     const rawPriority = tags[SAMPLING_PRIORITY]
     if (rawPriority !== undefined) {
-      const priority = Number.parseInt(String(rawPriority), 10)
+      const priority = Math.trunc(rawPriority)
 
       if (priority === 1 || priority === 2) {
         return USER_KEEP

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

@@ -8,7 +8,8 @@ class RateLimiter {
    * @param {'second'|'minute'|'hour'|'day'} [interval='second'] - Time window for the limiter.
    */
   constructor (rateLimit, interval = 'second') {
-    this._rateLimit = Number.parseInt(String(rateLimit))
+    // TODO: Change rateLimit to integers. Right now these are sometimes strings, sometimes numbers.
+    this._rateLimit = Math.trunc(rateLimit)
     // The limiter constructor accepts a token count number and an interval string
     this._limiter = new limiter.RateLimiter(this._rateLimit, interval)
     this._tokensRequested = 0

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const log = require('./log')
+// TODO: Rename and move file. This is a general purpose helper for adding tags to a carrier.
 
 function addNonEmpty (carrier, key, value) {
   if (key !== '') {
@@ -11,47 +11,43 @@ function addNonEmpty (carrier, key, value) {
 function add (carrier, keyValuePairs) {
   if (!carrier) return
 
-  try {
-    if (typeof keyValuePairs === 'string') {
-      let valueStart = 0
-      let keyStart = 0
-
-      for (let i = 0; i < keyValuePairs.length; i++) {
-        const char = keyValuePairs[i]
-
-        if (char === ':') {
-          if (valueStart === 0) {
-            valueStart = i
-          }
-        } else if (char === ',') {
-          valueStart ||= i
-          addNonEmpty(
-            carrier,
-            keyValuePairs.slice(keyStart, valueStart).trim(),
-            keyValuePairs.slice(valueStart + 1, i).trim()
-          )
-          keyStart = i + 1
-          valueStart = 0
-        }
-      }
+  if (typeof keyValuePairs === 'string') {
+    let valueStart = 0
+    let keyStart = 0
 
-      if (keyValuePairs.at(-1) !== ',') {
-        valueStart ||= keyValuePairs.length
+    for (let i = 0; i < keyValuePairs.length; i++) {
+      const char = keyValuePairs[i]
+
+      if (char === ':') {
+        if (valueStart === 0) {
+          valueStart = i
+        }
+      } else if (char === ',') {
+        valueStart ||= i
         addNonEmpty(
           carrier,
           keyValuePairs.slice(keyStart, valueStart).trim(),
-          keyValuePairs.slice(valueStart + 1).trim()
+          keyValuePairs.slice(valueStart + 1, i).trim()
         )
+        keyStart = i + 1
+        valueStart = 0
       }
-    } else if (Array.isArray(keyValuePairs)) {
-      for (const tags of keyValuePairs) {
-        add(carrier, tags)
-      }
-    } else {
-      Object.assign(carrier, keyValuePairs)
     }
-  } catch (error) {
-    log.error('Error adding tags', error)
+
+    if (keyValuePairs.at(-1) !== ',') {
+      valueStart ||= keyValuePairs.length
+      addNonEmpty(
+        carrier,
+        keyValuePairs.slice(keyStart, valueStart).trim(),
+        keyValuePairs.slice(valueStart + 1).trim()
+      )
+    }
+  } else if (Array.isArray(keyValuePairs)) {
+    for (const tags of keyValuePairs) {
+      add(carrier, tags)
+    }
+  } else {
+    Object.assign(carrier, keyValuePairs)
   }
 }
 

package/vendor/dist/@apm-js-collab/code-transformer/LICENSE

@@ -0,0 +1,28 @@
+
+Copyright (c) 2009-2011, Mozilla Foundation and contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the names of the Mozilla Foundation nor the names of project
+  contributors may be used to endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.