dd-trace 6.20.1 → 6.22.0

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

@@ -92,8 +92,10 @@ function Hook (modules, options, onrequire) {
     let name, basedir, hooks
     // return known patched modules immediately
     if (cache[moduleId]) {
-      // require.cache was potentially altered externally
-      const cacheEntry = require.cache[filename]
+      // Use Node's cache: bundlers replace require.cache with their own factory cache,
+      // whose not-yet-evaluated external modules can still have empty exports.
+      // @ts-expect-error - Module._cache is not typed
+      const cacheEntry = Module._cache[filename]
       if (cacheEntry && cacheEntry.exports !== cache[moduleId].original) {
         return cacheEntry.exports
       }

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

@@ -3,6 +3,10 @@
 const { getEnvironmentVariable, getValueFromEnvSources } = require('./config/helper')
 
 const IS_AWS_LAMBDA_MICROVM = getEnvironmentVariable('AWS_LAMBDA_MICROVM_IMAGE_ARN') !== undefined
+// Standard Lambda, whose sandbox freezes between invocations. Excludes Lambda Lite (native-http),
+// Managed Instances (lambda-managed-instances) and MicroVMs.
+const IS_STANDARD_AWS_LAMBDA = !IS_AWS_LAMBDA_MICROVM && ['on-demand', 'provisioned-concurrency', 'snap-start']
+  .includes(getEnvironmentVariable('AWS_LAMBDA_INITIALIZATION_TYPE'))
 const isVercelAtStartup = getEnvironmentVariable('VERCEL') === '1'
 
 function getIsGCPFunction () {
@@ -28,6 +32,10 @@ function enableGCPPubSubPushSubscription () {
     getValueFromEnvSources('DD_TRACE_GCP_PUBSUB_PUSH_ENABLED')
 }
 
+function getIsAzureContainerApp () {
+  return getEnvironmentVariable('CONTAINER_APP_NAME') !== undefined
+}
+
 function getIsAzureFunction () {
   return getEnvironmentVariable('FUNCTIONS_EXTENSION_VERSION') !== undefined &&
     getEnvironmentVariable('FUNCTIONS_WORKER_RUNTIME') !== undefined
@@ -99,11 +107,13 @@ module.exports = {
   supportsServerlessTelemetryRetention,
   createServerlessDeliveryTracker,
   getIsGCPFunction,
+  getIsAzureContainerApp,
   getIsAzureFunction,
   enableGCPPubSubPushSubscription,
   getIsFlexConsumptionAzureFunction,
   initializeServerlessTelemetry,
   IS_AWS_LAMBDA_MICROVM,
+  IS_STANDARD_AWS_LAMBDA,
   // 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,

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const { AUTO_REJECT } = require('../../../ext/priority')
+const { AUTO_KEEP, AUTO_REJECT } = require('../../../ext/priority')
 const log = require('./log')
 const spanFormat = require('./span_format')
 const SpanSampler = require('./span_sampler')
@@ -15,32 +15,23 @@ const finishedSpans = new WeakSet()
 
 let otelSampling
 
-/**
- * Adds first-class OTLP trace context to a DD-formatted span.
- *
- * @param {import('./opentracing/span')} span
- * @param {boolean} isFirstSpanInChunk
- * @param {string | false} processTagsValue
- */
-function formatOtlpSpan (span, isFirstSpanInChunk, processTagsValue) {
-  const formattedSpan = spanFormat(span, isFirstSpanInChunk, processTagsValue)
-  const context = span.context()
+/** @param {import('./opentracing/span_context')} context */
+function serializeOtlpTraceState (context) {
   const traceState = context._tracestate?.clone() ?? new TraceState()
   otelSampling ??= require('./otel-sampling')
   otelSampling.updateOtelTraceState(context, traceState)
-  formattedSpan.trace_state = traceState.toString()
-  return formattedSpan
+  return traceState.toString()
 }
 
 class SpanProcessor {
-  #formatSpan
+  #exportOtlpTraces
 
   constructor (exporter, prioritySampler, config, otlpStatsExporter, exportOtlpTraces) {
     this._exporter = exporter
     this._prioritySampler = prioritySampler
     this._config = config
     this._killAll = false
-    this.#formatSpan = exportOtlpTraces ? formatOtlpSpan : spanFormat
+    this.#exportOtlpTraces = exportOtlpTraces
 
     if (config.stats?.DD_TRACE_STATS_COMPUTATION_ENABLED &&
         !config.appsec?.DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED) {
@@ -95,13 +86,18 @@ class SpanProcessor {
       let isFirstSpanInChunk = true
       const stampApmDisabled = this._config.apmTracingEnabled === false
       const discard = this.#isDiscarded(spanContext)
-      const formatSpan = this.#formatSpan
+      const exportOtlpTraces = this.#exportOtlpTraces && !(spanContext._sampling.priority < AUTO_KEEP)
+      let traceState
 
       for (const span of started) {
         if (span._duration === undefined) {
           active.push(span)
         } else if (!discard) {
-          const formattedSpan = formatSpan(span, isFirstSpanInChunk, this._processTags)
+          const formattedSpan = spanFormat(span, isFirstSpanInChunk, this._processTags)
+          if (exportOtlpTraces) {
+            traceState ??= serializeOtlpTraceState(spanContext)
+            formattedSpan.trace_state = traceState
+          }
           if (stampApmDisabled) {
             formattedSpan.metrics[APM_TRACING_ENABLED_KEY] = 0
           }

package/packages/dd-trace/src/storage-channels.js

@@ -2,16 +2,17 @@
 
 const dc = require('dc-polyfill')
 const { storage } = require('../../datadog-core')
+const { isACFActive } = require('../../datadog-core/src/storage')
 
 // Channels that surface tracer-storage events to interested consumers
 // (currently the wall profiler and the OTEP-4947 thread context writer).
 //
 // dd-trace:storage:enter — fires when the active legacy-storage store
-//   changes. Published by the shimmer installed in ensureChannelsActivated().
-// dd-trace:storage:before — fires from an async_hooks "before" callback in
-//   non-AsyncContextFrame mode. Used by the wall profiler to refresh the
-//   sample context at the start of each async resource callback. Has no
-//   publisher in ACF mode.
+//   changes. Published by the shimmer installed in acquireChannels().
+// dd-trace:storage:before — fires from an async_hooks "before" callback while
+//   at least one consumer that acquired the channels needs it. Used by the
+//   wall profiler in its non-AsyncContextFrame (single holder) mode to refresh
+//   the sample context at the start of each async resource callback.
 // dd-trace:span:finish, dd-trace:span:tags:update — published by the
 //   tracer core (opentracing/span.js). Re-exported here as a convenience
 //   so consumers have a single import path for storage-related channels.
@@ -25,55 +26,119 @@ function getActiveSpan () {
   return store && store.span
 }
 
-let channelsActivated = false
-// Idempotent. The asyncContextFrameEnabled argument from the first caller
-// wins; subsequent calls are no-ops regardless of their argument. In
-// practice all callers observe the same global ACF state.
-function ensureChannelsActivated (asyncContextFrameEnabled) {
-  if (channelsActivated) return
+// The legacy storage instrumentation feeding enterCh and beforeCh is installed
+// lazily via acquireChannels() / releaseChannels(), ref-counted across
+// consumers, so that once the last consumer stops (e.g. the profiler is turned
+// off remotely), instrumentation is undone.
+// Consumers MUST balance every acquireChannels() call with a matching
+// releaseChannels() when they no longer use them.
+let refCount = 0
+// The async hook has a separate count: it's only needed by some consumers, and
+// is a per-callback cost, so it's disabled as soon as the last of them releases.
+let beforeRefCount = 0
+let inRun = false
+let beforeHook
 
-  const shimmer = require('../../datadog-shimmer')
+// Wrappers currently installed on legacy storage, keyed by method name. Each
+// entry records the method's own property descriptor from before wrapping
+// (undefined when the method was inherited from the prototype) so it can be
+// restored exactly.
+const installedWrappers = new Map()
+
+function wrapEnterWith (original) {
+  return function (store) {
+    const retVal = original.call(this, store)
+    if (!inRun && refCount !== 0) enterCh.publish()
+    return retVal
+  }
+}
 
-  // We need to instrument enterWith() on the legacy storage — that's the storage
-  // carrying span data and the only one consumers of these channels care about.
-  const legacyStorage = storage('legacy')
-  let inRun = false
-  shimmer.wrap(legacyStorage, 'enterWith', function (original) {
-    return function (store) {
-      const retVal = original.call(this, store)
-      if (!inRun) enterCh.publish()
+function wrapRun (original) {
+  const shimmer = require('../../datadog-shimmer')
+  return function (store, callback, ...args) {
+    if (refCount === 0) return original.call(this, store, callback, ...args)
+    const wrappedCb = shimmer.wrapFunction(callback, cb => function (...args) {
+      inRun = false
+      enterCh.publish()
+      const retVal = cb.apply(this, args)
+      inRun = true
       return retVal
-    }
-  })
+    })
+    inRun = true
+    const retVal = original.call(this, store, wrappedCb, ...args)
+    enterCh.publish()
+    inRun = false
+    return retVal
+  }
+}
 
-  // When not using AsyncContextFrame, we need additional instrumentation.
-  if (!asyncContextFrameEnabled) {
-    // We need async_hooks.createHook to create a "before" callback.
-    const { createHook } = require('async_hooks')
-    createHook({ before: () => beforeCh.publish() }).enable()
+function installWrapper (target, name, wrapper) {
+  if (installedWrappers.has(name)) return
+  const descriptor = Object.getOwnPropertyDescriptor(target, name)
+  require('../../datadog-shimmer').wrap(target, name, wrapper)
+  installedWrappers.set(name, { descriptor, wrapped: target[name] })
+}
 
+function uninstallWrappers (target) {
+  for (const [name, { descriptor, wrapped }] of installedWrappers) {
+    // If someone else wrapped the method on top of ours, restoring would
+    // silently drop their wrapper too. Leave ours in place instead; it
+    // short-circuits while released, and gets reused on the next acquisition.
+    if (target[name] !== wrapped) continue
+    if (descriptor === undefined) {
+      delete target[name]
+    } else {
+      Object.defineProperty(target, name, descriptor)
+    }
+    installedWrappers.delete(name)
+  }
+}
+
+/**
+ * Acquires a reference to the channel publishers. The first reference installs
+ * the legacy storage instrumentation publishing on enterCh.
+ *
+ * @param {boolean} needsBeforeHook Whether the consumer needs beforeCh events.
+ *   The same value must be passed to the matching releaseChannels() call.
+ */
+function acquireChannels (needsBeforeHook) {
+  if (refCount++ === 0) {
+    // We need to instrument enterWith() on the legacy storage — that's the storage
+    // carrying span data and the only one consumers of these channels care about.
+    const legacyStorage = storage('legacy')
+    installWrapper(legacyStorage, 'enterWith', wrapEnterWith)
     // In ACF-based implementation run() delegates to enterWith() so it doesn't
-    // need to be separately instrumented. in non-ACF implementation run()
+    // 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
-          enterCh.publish()
-          const retVal = cb.apply(this, args)
-          inRun = true
-          return retVal
-        })
-        inRun = true
-        const retVal = original.call(this, store, wrappedCb, ...args)
-        enterCh.publish()
-        inRun = false
-        return retVal
-      }
-    })
+    if (!isACFActive) {
+      installWrapper(legacyStorage, 'run', wrapRun)
+    }
   }
 
-  channelsActivated = true
+  if (needsBeforeHook && beforeRefCount++ === 0) {
+    beforeHook ??= require('async_hooks').createHook({ before: () => beforeCh.publish() })
+    beforeHook.enable()
+  }
+}
+
+/**
+ * Releases one acquireChannels() reference. The async hook is disabled when the
+ * last reference needing it is released, and the legacy storage instrumentation
+ * is removed when the last reference overall is released.
+ *
+ * @param {boolean} needsBeforeHook The value passed to the matching
+ *   acquireChannels() call.
+ */
+function releaseChannels (needsBeforeHook) {
+  if (refCount === 0) return
+
+  if (needsBeforeHook && beforeRefCount !== 0 && --beforeRefCount === 0) {
+    beforeHook.disable()
+  }
+
+  if (--refCount === 0) {
+    uninstallWrappers(storage('legacy'))
+  }
 }
 
 module.exports = {
@@ -82,5 +147,6 @@ module.exports = {
   spanFinishCh,
   tagsUpdateCh,
   getActiveSpan,
-  ensureChannelsActivated,
+  acquireChannels,
+  releaseChannels,
 }

package/packages/dd-trace/src/telemetry/endpoints.js

@@ -95,10 +95,8 @@ function onFastifyRoute (routeData) {
  * @param {{ method?: string, path?: string }} param0
  */
 function onExpressRoute ({ method, path }) {
-  if (!method || !path) return
-
   // If wildcard already recorded for this path, skip specific methods
-  if (wildcardEndpoints.has(path)) return
+  if (!method || !path || wildcardEndpoints.has(path)) return
 
   recordEndpoint(method, path, 'express.request')
 

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

@@ -1,6 +1,14 @@
 'use strict'
 
 const path = require('path')
+const { types: { isTypedArray } } = require('node:util')
+
+/**
+ * @typedef {Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array |
+ *   Float32Array | Float64Array | BigInt64Array | BigUint64Array | DataView} BinaryView
+ */
+
+const getTypedArrayLength = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), 'length').get
 
 /**
  * `for-in` with an early return is the only allocation-free shape for
@@ -12,11 +20,31 @@ const path = require('path')
  * @param {object | undefined} obj
  */
 function isEmpty (obj) {
+  if (Array.isArray(obj) || ArrayBuffer.isView(obj)) {
+    // `for-in` materializes every index key up front, which exhausts memory on large bodies, so return as soon as
+    // there are elements. Empty ones have no index keys to materialize, so check their own keys, which still detects
+    // named properties without walking a Buffer's enumerable prototype methods.
+    const length = Array.isArray(obj) ? obj.length : typedArrayLength(obj)
+    // eslint-disable-next-line no-restricted-syntax
+    return length === 0 && Object.keys(obj).length === 0
+  }
+  // `for-in` over a string also materializes every index key, so large raw string bodies need the same shortcut.
+  if (typeof obj === 'string') return obj.length === 0
   // eslint-disable-next-line no-unreachable-loop
   for (const _ in obj) return false
   return true
 }
 
+/**
+ * Reads the element count through the intrinsic getter, which, unlike `view.length`, an instance or subclass cannot
+ * shadow with application code. A `DataView` exposes no indexed elements, so it counts as zero.
+ *
+ * @param {BinaryView} view
+ */
+function typedArrayLength (view) {
+  return isTypedArray(view) ? getTypedArrayLength.call(view) : 0
+}
+
 function isTrue (str) {
   str = String(str).toLowerCase()
   return str === 'true' || str === '1'
@@ -167,4 +195,5 @@ module.exports = {
   normalizePluginEnvName,
   formatKnuthRate,
   truncateString,
+  typedArrayLength,
 }

package/packages/dd-trace/src/web-tags-cache.js

@@ -120,8 +120,12 @@ function onTagsUpdate (span) {
   // the ancestor's own update is what settles the endpoint. Skipped entirely
   // when nobody is listening, keeping this the same early return it used to be
   // for consumers that only care about web-tag discovery.
-  if (!endpointResolvedCh.hasSubscribers || cached.endpointFinal || cached.webTags !== tags) return
-  if (finalEndpoint(tags) === undefined) return
+  if (
+    !endpointResolvedCh.hasSubscribers || cached.endpointFinal || cached.webTags !== tags ||
+    finalEndpoint(tags) === undefined
+  ) {
+    return
+  }
   cached.endpointFinal = true
   endpointResolvedCh.publish(span)
 }