dd-trace 6.9.0 → 6.11.0

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

@@ -1,7 +1,6 @@
 'use strict'
 
 const NoopProxy = require('./noop/proxy')
-const { features } = require('./feature-registry')
 const DatadogTracer = require('./tracer')
 const getConfig = require('./config')
 const { getEnvironmentVariable } = require('./config/helper')
@@ -38,9 +37,9 @@ const OFFLINE_VALIDATION_EXPORTERS = new Set([
   'playwright_worker',
   'vitest_worker',
 ])
-const FEATURE_STATE_NOOP = 0
-const FEATURE_STATE_LAZY = 1
-const FEATURE_STATE_ACTIVE = 2
+const OPENFEATURE_STATE_NOOP = 0
+const OPENFEATURE_STATE_LAZY = 1
+const OPENFEATURE_STATE_ACTIVE = 2
 
 class LazyModule {
   constructor (provider) {
@@ -91,8 +90,7 @@ function defineLazily (obj, property, getClass, ...args) {
 }
 
 class Tracer extends NoopProxy {
-  /** @type {Record<string, number> | undefined} */
-  #featureStates
+  #openfeatureState = OPENFEATURE_STATE_NOOP
 
   constructor () {
     super()
@@ -115,12 +113,9 @@ class Tracer extends NoopProxy {
       aiguard: new LazyModule(() => require('./aiguard')),
       iast: new LazyModule(() => require('./appsec/iast')),
       llmobs: new LazyModule(() => require('./llmobs')),
+      openfeature: new LazyModule(() => require('./openfeature')),
       rewriter: new LazyModule(() => require('./appsec/iast/taint-tracking/rewriter')),
     }
-
-    for (const feature of Object.values(features)) {
-      this._modules[feature.name] = new LazyModule(feature.factory)
-    }
   }
 
   /**
@@ -213,9 +208,10 @@ class Tracer extends NoopProxy {
           DynamicInstrumentation.start(config, rc)
         }
 
-        for (const feature of Object.values(features)) {
-          feature.remoteConfig?.(rc, config, this)
-        }
+        const openfeatureRemoteConfig = require('./openfeature/remote_config')
+        const subscribeOpenfeatureToRemoteConfig = config.featureFlags.DD_FEATURE_FLAGS_ENABLED &&
+          config.featureFlags.DD_FEATURE_FLAGS_CONFIGURATION_SOURCE === 'remote_config'
+        openfeatureRemoteConfig.enable(rc, () => this.openfeature, subscribeOpenfeatureToRemoteConfig)
       }
 
       if (config.profiling.DD_PROFILING_ENABLED === 'true') {
@@ -233,6 +229,17 @@ class Tracer extends NoopProxy {
         }
       }
 
+      // Experimental: mirror the active trace ID, span ID and endpoint into
+      // an OTEP-4947 thread-local context record an out-of-process eBPF
+      // reader can consume.
+      if (config.DD_TRACE_OTEL_CTX_ENABLED) {
+        try {
+          require('./otel-thread-ctx').start()
+        } catch (e) {
+          log.error('Error starting OTEP-4947 thread context writer', e)
+        }
+      }
+
       // OTel logs/metrics pipelines must be initialized BEFORE runtimeMetrics.start so that
       // when the OTLP runtime metrics module calls metrics.getMeterProvider(), it gets the
       // real provider, otherwise instruments register on the noop provider and never export.
@@ -305,28 +312,32 @@ class Tracer extends NoopProxy {
   }
 
   /**
-   * @param {(typeof features)[string]} feature
+   * `tracer.openfeature` is only reachable through this proxy. SSI itself (auto-injecting
+   * the tracer, resolving the vendored provider regardless of the customer's own
+   * `node_modules` layout) is unaffected -- that is what this PR fixes. The remaining gap is
+   * narrower: there is no `dd-trace-api` handoff for `openfeature` yet (see
+   * `packages/datadog-plugin-dd-trace-api`), so an application that calls into the tracer
+   * exclusively through the `dd-trace-api` shim -- instead of `require('dd-trace')` -- cannot
+   * reach the flagging provider through that shim.
+   *
    * @param {import('./config/config-base')} config
    */
-  #enableFeature (feature, config) {
-    const states = this.#featureStates ??= {}
-    const state = states[feature.name] ?? FEATURE_STATE_NOOP
+  #enableOpenfeature (config) {
+    if (this.#openfeatureState !== OPENFEATURE_STATE_NOOP) return
+    this.#openfeatureState = OPENFEATURE_STATE_LAZY
 
-    if (state === FEATURE_STATE_ACTIVE || state === FEATURE_STATE_LAZY) return
-    states[feature.name] = FEATURE_STATE_LAZY
-
-    Reflect.defineProperty(this, feature.name, {
+    Reflect.defineProperty(this, 'openfeature', {
       get: () => {
-        const Provider = feature.provider()
-        const provider = new Provider(this._tracer, config)
+        const FlaggingProvider = require('./openfeature/flagging_provider')
+        const provider = new FlaggingProvider(this._tracer, config)
 
-        this._modules[feature.name].enable(config)
-        Reflect.defineProperty(this, feature.name, {
+        this._modules.openfeature.enable(config)
+        Reflect.defineProperty(this, 'openfeature', {
           value: provider,
           configurable: true,
           enumerable: true,
         })
-        states[feature.name] = FEATURE_STATE_ACTIVE
+        this.#openfeatureState = OPENFEATURE_STATE_ACTIVE
         return provider
       },
       configurable: true,
@@ -373,9 +384,7 @@ class Tracer extends NoopProxy {
       this._modules.llmobs.disable()
     }
 
-    for (const feature of Object.values(features)) {
-      if (feature.isEnabled(config)) this.#enableFeature(feature, config)
-    }
+    if (config.featureFlags.DD_FEATURE_FLAGS_ENABLED) this.#enableOpenfeature(config)
 
     if (this._tracingInitialized) {
       this._tracer.configure(config)

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

@@ -20,6 +20,7 @@ const origRequire = Module.prototype.require
 module.exports = Hook
 
 let moduleHooks = Object.create(null)
+let hookedModuleCount = 0
 let cache = Object.create(null)
 let patching = Object.create(null)
 let patchedRequire = null
@@ -64,6 +65,7 @@ function Hook (modules, options, onrequire) {
         hooks.push(onrequire)
       } else {
         moduleHooks[mod] = [onrequire]
+        hookedModuleCount++
       }
     }
   }
@@ -205,6 +207,7 @@ Hook.reset = function () {
   patching = Object.create(null)
   cache = Object.create(null)
   moduleHooks = Object.create(null)
+  hookedModuleCount = 0
 }
 
 function findProjectRoot (startDir) {
@@ -221,16 +224,20 @@ function findProjectRoot (startDir) {
 
 Hook.prototype.unhook = function () {
   for (const mod of this.modules) {
-    const hooks = (moduleHooks[mod] || []).filter(hook => hook !== this.onrequire)
+    const registeredHooks = moduleHooks[mod]
+    if (registeredHooks === undefined) continue
+
+    const hooks = registeredHooks.filter(hook => hook !== this.onrequire)
 
     if (hooks.length > 0) {
       moduleHooks[mod] = hooks
     } else {
       delete moduleHooks[mod]
+      hookedModuleCount--
     }
   }
 
-  if (Object.keys(moduleHooks).length === 0) {
+  if (hookedModuleCount === 0) {
     Hook.reset()
   }
 }

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

@@ -42,7 +42,44 @@ function isInServerlessEnvironment () {
   return inAWSLambda || isGCPFunction || isAzureFunction
 }
 
+/**
+ * Gets tags describing the serverless platform where the tracer is running.
+ *
+ * @returns {string[]|undefined}
+ */
+function getServerlessPlatformTags () {
+  if (getEnvironmentVariable('VERCEL') === '1') {
+    return getVercelPlatformTags()
+  }
+}
+
+/**
+ * @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 = {
+  getServerlessPlatformTags,
   getIsGCPFunction,
   getIsAzureFunction,
   enableGCPPubSubPushSubscription,

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

@@ -450,3 +450,4 @@ function isUrl (obj) {
 }
 
 module.exports = format
+module.exports.addError = extractError

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

@@ -14,8 +14,10 @@ const {
   GRPC_STATUS_CODE,
 } = require('../../../ext/tags')
 const { ORIGIN_KEY, TOP_LEVEL_KEY, SVC_SRC_KEY, GRPC_STATUS_NAMES } = require('./constants')
+const id = require('./id')
 
 const GRPC_STATUS_CODE_MAP = Object.fromEntries(GRPC_STATUS_NAMES.map((name, i) => [name, String(i)]))
+const ZERO_ID = id('0')
 const { version } = require('./pkg')
 const processTags = require('./process-tags')
 
@@ -150,9 +152,24 @@ class SpanAggKey {
 }
 
 class SpanBuckets extends Map {
+  #includeTraceRoot
+
+  /**
+   * @param {boolean} [includeTraceRoot]
+   */
+  constructor (includeTraceRoot = false) {
+    super()
+    this.#includeTraceRoot = includeTraceRoot
+  }
+
   forSpan (span) {
     const aggKey = new SpanAggKey(span)
-    const key = aggKey.toString()
+    const baseKey = aggKey.toString()
+    const parentId = span.parent_id
+    if (this.#includeTraceRoot && parentId !== undefined && parentId !== null) {
+      aggKey.isTraceRoot = parentId.equals(ZERO_ID)
+    }
+    const key = this.#includeTraceRoot ? `${baseKey},${aggKey.isTraceRoot}` : baseKey
 
     if (!this.has(key)) {
       this.set(key, new SpanAggStats(aggKey))
@@ -163,9 +180,19 @@ class SpanBuckets extends Map {
 }
 
 class TimeBuckets extends Map {
+  #includeTraceRoot
+
+  /**
+   * @param {boolean} [includeTraceRoot]
+   */
+  constructor (includeTraceRoot = false) {
+    super()
+    this.#includeTraceRoot = includeTraceRoot
+  }
+
   forTime (time) {
     if (!this.has(time)) {
-      this.set(time, new SpanBuckets())
+      this.set(time, new SpanBuckets(this.#includeTraceRoot))
     }
 
     return this.get(time)
@@ -192,7 +219,7 @@ class SpanStatsProcessor {
     const intervalMs = otlpExporter ? (flushIntervalMs ?? 10_000) : interval * 1e3
     this.interval = intervalMs / 1e3
     this.bucketSizeNs = intervalMs * 1e6
-    this.buckets = new TimeBuckets()
+    this.buckets = new TimeBuckets(Boolean(otlpExporter))
     this.hostname = os.hostname()
     this.enabled = enabled
     this.otlpExporter = otlpExporter || null

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

@@ -0,0 +1,86 @@
+'use strict'
+
+const dc = require('dc-polyfill')
+const { storage } = require('../../datadog-core')
+
+// 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.
+// 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.
+const enterCh = dc.channel('dd-trace:storage:enter')
+const beforeCh = dc.channel('dd-trace:storage:before')
+const spanFinishCh = dc.channel('dd-trace:span:finish')
+const tagsUpdateCh = dc.channel('dd-trace:span:tags:update')
+
+function getActiveSpan () {
+  const store = storage('legacy').getStore()
+  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
+
+  const shimmer = require('../../datadog-shimmer')
+
+  // 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()
+      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()
+
+    // 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
+          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
+      }
+    })
+  }
+
+  channelsActivated = true
+}
+
+module.exports = {
+  enterCh,
+  beforeCh,
+  spanFinishCh,
+  tagsUpdateCh,
+  getActiveSpan,
+  ensureChannelsActivated,
+}

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

@@ -59,8 +59,15 @@ class DatadogTracer extends Tracer {
 
   // todo[piochelepiotr] These two methods are not related to the tracer, but to data streams monitoring.
   // They should be moved outside of the tracer in the future.
-  setCheckpoint (edgeTags, span, payloadSize = 0) {
-    return this._dataStreamsManager.setCheckpoint(edgeTags, span, payloadSize)
+  /**
+   * @param {string[]} edgeTags
+   * @param {import('./opentracing/span')|null} span
+   * @param {number} [payloadSize]
+   * @param {number} [pathwayContextSize] See `DataStreamsProcessor#setCheckpoint`.
+   * @returns {object|undefined}
+   */
+  setCheckpoint (edgeTags, span, payloadSize = 0, pathwayContextSize) {
+    return this._dataStreamsManager.setCheckpoint(edgeTags, span, payloadSize, pathwayContextSize)
   }
 
   decodeDataStreamsContext (carrier) {

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

@@ -18,6 +18,18 @@ function storeConfig (config) {
       ? (processTags.serialized || null)
       : null
 
+    // OTEP-4947 thread-context writer metadata, published as part of the
+    // OTel process context so an out-of-process reader can decode the
+    // on-wire record: the attribute key map (libdatadog prepends the
+    // implicit `datadog.local_root_span_id` at wire index 0, so we only
+    // supply our own additional keys), the schema-version string, and
+    // the V8 layout constants the reader needs. Gated on the same config
+    // flag that activates the writer; undefined when off or when
+    // @datadog/pprof isn't installed to provide the values.
+    const threadlocalMetadata = config.DD_TRACE_OTEL_CTX_ENABLED
+      ? require('./otel-thread-ctx').getThreadLocalMetadata()
+      : undefined
+
     const metadata = new processDiscovery.TracerMetadata(
       config.tags['runtime-id'],
       tracerVersion,
@@ -26,7 +38,8 @@ function storeConfig (config) {
       config.env || null,
       config.version || null,
       processTagsSerialized,
-      containerId || null
+      containerId || null,
+      threadlocalMetadata
     )
 
     return processDiscovery.storeMetadata(metadata)

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

@@ -0,0 +1,132 @@
+'use strict'
+
+// Per-span cache of "which tag bag from the started-spans chain identifies
+// this span (or its nearest web-server ancestor) as a web-server span?"
+// Populated lazily on first `getCachedWebTags(span)`, refreshed
+// automatically when a `dd-trace:span:tags:update` event promotes a
+// previously-empty answer for that span into a real value.
+//
+// Used by the wall profiler (endpoint-collection label on samples) and by
+// the OTEP-4947 thread-context writer (endpoint attribute in the record);
+// having a single cache means the parent-chain walk happens once per span
+// no matter how many consumers ask.
+//
+// Consumers that want to react to late web-server-span discovery
+// subscribe to `resolvedCh` — a diagnostics channel we publish on once
+// per span at the moment its cached webTags transitions from undefined
+// to a real value. Doing it via a channel (rather than exposing a
+// stateful "did the transition happen?" query) means each consumer sees
+// every transition exactly once, regardless of subscription order or
+// how many other consumers are attached.
+//
+// `endpointResolvedCh` is the same idea one field over: published once per
+// web-server span at the moment its endpoint name settles (see finalEndpoint in
+// profiling/webspan-utils.js), i.e. when routing tags stop being interim
+// placeholders. Consumers that must materialize the endpoint eagerly rather
+// than read the tag bag at leisure need that moment; owning it here means the
+// one `dd-trace:span:tags:update` subscription this module already holds serves
+// them too, instead of each consumer adding its own subscriber to that hot
+// channel and re-deriving finality itself.
+//
+// The module-level `dd-trace:span:tags:update` subscription that drives
+// the transition promotion is installed lazily via `activate()` /
+// `deactivate()`, ref-counted across consumers. When no consumer has
+// activated the cache, `dd-trace:span:tags:update` stays subscriber-free
+// so `DatadogSpan#setTag` / `addTags` skip the publish path entirely.
+// Consumers MUST balance every activate() call with a matching
+// deactivate() when they stop caring.
+
+const dc = require('dc-polyfill')
+const { finalEndpoint, isWebServerSpan, getStartedSpans } = require('./profiling/webspan-utils')
+
+// Fields on the cache entry:
+//   resolved:      true once the parent-chain walk has run.
+//   webTags:       the resolved tag bag, or undefined when the walk came up
+//                  empty (no web-server span found in the started-spans chain).
+//   endpointFinal: true once this span is a web-server span whose endpoint name
+//                  has settled and endpointResolvedCh has been published for it.
+const CachedSym = Symbol('WebTagsCache')
+
+const tagsUpdateCh = dc.channel('dd-trace:span:tags:update')
+const resolvedCh = dc.channel('dd-trace:web-tags:resolved')
+const endpointResolvedCh = dc.channel('dd-trace:web-tags:endpoint-resolved')
+
+function getCache (span) {
+  let cached = span[CachedSym]
+  if (cached === undefined) {
+    cached = {}
+    span[CachedSym] = cached
+  }
+  return cached
+}
+
+// Returns the web-server tag bag for this span or its nearest web-server
+// ancestor in the started-spans chain, or undefined if none is a
+// web-server span. Lazy: walks the parent chain on the first call, caches
+// the result on the span.
+function getCachedWebTags (span) {
+  const cached = getCache(span)
+  if (cached.resolved) return cached.webTags
+  const spanContext = span.context()
+  const tags = spanContext.getTags()
+  let webTags
+  if (isWebServerSpan(tags)) {
+    webTags = tags
+  } else {
+    const parentId = spanContext._parentId
+    const startedSpans = getStartedSpans(spanContext)
+    for (let i = startedSpans.length; --i >= 0;) {
+      const ispan = startedSpans[i]
+      if (ispan.context()._spanId === parentId) {
+        webTags = getCachedWebTags(ispan)
+        break
+      }
+    }
+  }
+  cached.webTags = webTags
+  cached.resolved = true
+  return webTags
+}
+
+// Own the tagsUpdate → transition promotion here. The dc subscribe
+// happens lazily via activate(); each active consumer bumps a refcount,
+// the last deactivate() removes the subscription. When idle, this module
+// contributes no subscribers to `dd-trace:span:tags:update`, so
+// `DatadogSpan#setTag` / `addTags` never enter the publish path on our
+// behalf.
+function onTagsUpdate (span) {
+  const cached = span[CachedSym]
+  if (cached === undefined || !cached.resolved) return
+  const tags = span.context().getTags()
+  if (cached.webTags === undefined) {
+    if (!isWebServerSpan(tags)) return
+    cached.webTags = tags
+    resolvedCh.publish(span)
+  }
+  // Endpoint finality is a property of the web-server span itself: for a
+  // descendant, cached.webTags is an ancestor's bag rather than these tags, and
+  // 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
+  cached.endpointFinal = true
+  endpointResolvedCh.publish(span)
+}
+
+let activeCount = 0
+
+function activate () {
+  if (activeCount++ === 0) {
+    tagsUpdateCh.subscribe(onTagsUpdate)
+  }
+}
+
+function deactivate () {
+  if (activeCount === 0) return
+  if (--activeCount === 0) {
+    tagsUpdateCh.unsubscribe(onTagsUpdate)
+  }
+}
+
+module.exports = { getCachedWebTags, resolvedCh, endpointResolvedCh, activate, deactivate }