dd-trace 6.10.0 → 6.12.0

package/packages/dd-trace/src/llmobs/experiments/noop.js

@@ -1,23 +1,53 @@
 'use strict'
 
 const log = require('../../log')
+const { ExternalExperiment } = require('./experiment')
+
+const NOOP_EXPERIMENT_ID = '00000000-0000-0000-0000-000000000000'
+const NOOP_SPAN_ID = '0000000000000000'
+const NOOP_TRACE_ID = '00000000000000000000000000000000'
 
 class NoopDataset {
   #name
+  #description
   #records
+  #filterTags
 
   constructor (name = '', options = {}) {
     this.#name = name
+    this.#description = typeof options === 'string' ? options : (options.description ?? '')
+    this.#filterTags = typeof options === 'string' ? [] : [...(options.filterTags ?? [])]
     this.#records = (typeof options === 'string' ? [] : (options.records ?? [])).map(record => ({
       id: record.id ?? null,
       input: record.inputData,
       expectedOutput: record.expectedOutput ?? null,
       metadata: record.metadata ?? {},
+      tags: [...(record.tags ?? [])],
     }))
   }
 
-  addRecord (input, expectedOutput, metadata) {
-    this.#records.push({ id: null, input, expectedOutput: expectedOutput ?? null, metadata: metadata ?? {} })
+  addRecord (input, expectedOutput, metadata, tags) {
+    this.#records.push({
+      id: null,
+      input,
+      expectedOutput: expectedOutput ?? null,
+      metadata: metadata ?? {},
+      tags: [...(tags ?? [])],
+    })
+    return this
+  }
+
+  update (index, fields) {
+    const record = this.#records[index]
+    if (record == null) return this
+    if (Object.hasOwn(fields, 'input')) record.input = fields.input
+    if (Object.hasOwn(fields, 'expectedOutput')) record.expectedOutput = fields.expectedOutput ?? null
+    if (Object.hasOwn(fields, 'metadata')) record.metadata = fields.metadata ?? {}
+    return this
+  }
+
+  delete (index) {
+    this.#records.splice(index, 1)
     return this
   }
 
@@ -25,10 +55,57 @@ class NoopDataset {
     return Promise.resolve({ pushedCount: 0, totalCount: 0 })
   }
 
+  /**
+   * Add tags to a dataset record.
+   * @param {number} index Dataset record index.
+   * @param {string[]} tags Tags in key:value format.
+   * @returns {NoopDataset} This dataset for chaining.
+   */
+  addTags (index, tags) {
+    const record = this.#records[index]
+    if (!record) return this
+    const normalizedTags = tags ?? []
+    record.tags = [...new Set([...(record.tags ?? []), ...normalizedTags])].sort()
+    return this
+  }
+
+  /**
+   * Remove tags from a dataset record.
+   * @param {number} index Dataset record index.
+   * @param {string[]} tags Tags in key:value format.
+   * @returns {NoopDataset} This dataset for chaining.
+   */
+  removeTags (index, tags) {
+    const record = this.#records[index]
+    if (!record) return this
+    const normalizedTags = tags ?? []
+    const removed = new Set(normalizedTags)
+    record.tags = (record.tags ?? []).filter(tag => !removed.has(tag)).sort()
+    return this
+  }
+
+  /**
+   * Replace all tags on a dataset record.
+   * @param {number} index Dataset record index.
+   * @param {string[]} tags Tags in key:value format.
+   * @returns {NoopDataset} This dataset for chaining.
+   */
+  replaceTags (index, tags) {
+    const record = this.#records[index]
+    if (!record) return this
+    const normalizedTags = tags ?? []
+    record.tags = [...normalizedTags]
+    return this
+  }
+
   name () {
     return this.#name
   }
 
+  description () {
+    return this.#description
+  }
+
   id () {
     return null
   }
@@ -45,6 +122,14 @@ class NoopDataset {
     return null
   }
 
+  /**
+   * Return the tags used to filter this dataset.
+   * @returns {string[]} Dataset record filter tags.
+   */
+  filterTags () {
+    return [...this.#filterTags]
+  }
+
   records () {
     return [...this.#records]
   }
@@ -60,9 +145,11 @@ class NoopDataset {
 
 class NoopExperiment {
   #name
+  #external
 
-  constructor (name = '') {
+  constructor (name = '', external = false) {
     this.#name = name
+    this.#external = external
   }
 
   name () {
@@ -70,7 +157,7 @@ class NoopExperiment {
   }
 
   experimentId () {
-    return null
+    return this.#external ? NOOP_EXPERIMENT_ID : null
   }
 
   url () {
@@ -80,6 +167,32 @@ class NoopExperiment {
   run () {
     return Promise.resolve({ experimentId: null, rows: [], url: null })
   }
+
+  /**
+   * @returns {Promise<{experimentId: string, spanId: string, traceId: string, url: null}>}
+   */
+  submitSpan () {
+    return Promise.resolve({
+      experimentId: NOOP_EXPERIMENT_ID,
+      spanId: NOOP_SPAN_ID,
+      traceId: NOOP_TRACE_ID,
+      url: null,
+    })
+  }
+
+  /**
+   * @returns {Promise<void>}
+   */
+  submitEvaluationMetrics () {
+    return Promise.resolve()
+  }
+
+  /**
+   * @returns {Promise<void>}
+   */
+  close () {
+    return Promise.resolve()
+  }
 }
 
 // No-op Experiments used when LLM Observability is disabled or the API/APP keys
@@ -87,9 +200,11 @@ class NoopExperiment {
 // throwing, so intentionally disabled experiments remain graceful.
 class NoopExperiments {
   #reason
+  #startExperiment
 
-  constructor (reason) {
+  constructor (reason, options = {}) {
     this.#reason = reason || 'LLMObs experiments are not available'
+    this.#startExperiment = options.startExperiment
   }
 
   #warn () {
@@ -101,15 +216,28 @@ class NoopExperiments {
     return new NoopDataset(name, options)
   }
 
-  pullDataset (name) {
+  pullDataset (name, options = {}) {
     this.#warn()
-    return Promise.resolve(new NoopDataset(name))
+    return Promise.resolve(new NoopDataset(name, { filterTags: options.tags }))
   }
 
   experiment (options = {}) {
     this.#warn()
     return new NoopExperiment(options.name)
   }
+
+  /**
+   * @param {object} options
+   * @returns {Promise<ExternalExperiment>}
+   */
+  startExperiment (options = {}) {
+    if (this.#startExperiment !== undefined && options.projectName) {
+      return this.#startExperiment(options)
+    }
+
+    this.#warn()
+    return Promise.resolve(new ExternalExperiment(new NoopExperiment(options.name, true)))
+  }
 }
 
 module.exports = NoopExperiments

package/packages/dd-trace/src/llmobs/experiments/result.js

@@ -13,6 +13,7 @@ class Row {
     this.expectedOutput = fields.expectedOutput
     this.errorType = fields.errorType
     this.errorMessage = fields.errorMessage
+    this.errorStack = fields.errorStack
     this.evaluations = fields.evaluations
     this.evaluationErrors = fields.evaluationErrors
   }

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

@@ -22,6 +22,26 @@ function hasEntries (value) {
   return false
 }
 
+function validateTagsList (tags) {
+  if (tags == null) return []
+  if (!Array.isArray(tags)) throw new TypeError('Tags must be an array of strings')
+  for (const tag of tags) {
+    if (typeof tag !== 'string') throw new TypeError('Each tag must be a string')
+    if (tag.indexOf(':') <= 0) {
+      throw new Error(`Tag '${tag}' is malformed. Tags must be in 'key:value' format (e.g., 'env:prod').`)
+    }
+  }
+  return [...tags]
+}
+
+function tagOperationsAreEmpty (operations) {
+  return operations == null || (
+    !Object.hasOwn(operations, 'replace') &&
+    !Object.hasOwn(operations, 'add') &&
+    !Object.hasOwn(operations, 'remove')
+  )
+}
+
 /**
  * @param {string} name
  */
@@ -165,25 +185,58 @@ function stringify (value) {
  * @returns {string[]}
  */
 function buildTags (userTags, autoTags) {
-  const tags = new Map()
+  const tagsByKey = new Map()
   if ((userTags) != null) {
     for (const [key, value] of Object.entries(userTags)) {
-      tags.set(key, `${key}:${value}`)
+      const values = Array.isArray(value) ? value : [value]
+      tagsByKey.set(key, values.map(item => `${key}:${item}`))
     }
   }
   for (const [key, value] of Object.entries(autoTags)) {
-    if (value !== undefined && value !== null && value !== '') tags.set(key, `${key}:${value}`)
+    if (value !== undefined && value !== null && value !== '') tagsByKey.set(key, [`${key}:${value}`])
   }
-  return [...tags.values()]
+
+  const tags = []
+  for (const values of tagsByKey.values()) tags.push(...values)
+  return tags
 }
 
 /**
- * @param {Record<string, unknown> | undefined} userTags
- * @param {Record<string, unknown>} autoTags
+ * @param {Record<string, unknown> | undefined} baseTags
+ * @param {Record<string, unknown> | undefined} overrideTags
  * @returns {Record<string, unknown>}
  */
-function buildExperimentTagObject (userTags, autoTags) {
-  return userTags ? { ...userTags, ...autoTags } : { ...autoTags }
+function mergeTags (baseTags, overrideTags) {
+  return { ...baseTags, ...overrideTags }
+}
+
+/**
+ * @param {string[] | undefined} tags
+ * @returns {Record<string, string | string[]>}
+ */
+function recordTagsToObject (tags) {
+  const result = {}
+  if (!Array.isArray(tags)) return result
+  for (const tag of tags) {
+    const separator = tag.indexOf(':')
+    if (separator <= 0) continue
+
+    const key = tag.slice(0, separator)
+    const value = tag.slice(separator + 1)
+    if (!Object.hasOwn(result, key)) {
+      Object.defineProperty(result, key, {
+        configurable: true,
+        enumerable: true,
+        value,
+        writable: true,
+      })
+    } else if (Array.isArray(result[key])) {
+      result[key].push(value)
+    } else {
+      result[key] = [result[key], value]
+    }
+  }
+  return result
 }
 
 /**
@@ -195,6 +248,40 @@ function sleep (ms) {
   return new Promise((resolve) => setTimeout(resolve, ms))
 }
 
+/**
+ * @param {unknown} value
+ * @param {number} fallback
+ * @returns {number}
+ */
+function timestampMs (value, fallback = Date.now()) {
+  if (value === null || value === undefined) return fallback
+  if (value instanceof Date) {
+    const timestamp = value.getTime()
+    return Number.isFinite(timestamp) ? timestamp : fallback
+  }
+  if (typeof value === 'number' && Number.isFinite(value)) return value
+  const parsed = Date.parse(String(value))
+  return Number.isFinite(parsed) ? parsed : fallback
+}
+
+/**
+ * @param {{ durationMs?: unknown, completedAt?: unknown }} row
+ * @param {number} startMs
+ * @returns {number}
+ */
+function durationNs (row, startMs) {
+  if (typeof row.durationMs === 'number' && Number.isFinite(row.durationMs)) {
+    return Math.max(0, Math.round(row.durationMs * 1e6))
+  }
+
+  if (row.completedAt !== undefined) {
+    const completedMs = timestampMs(row.completedAt, startMs)
+    return Math.max(0, Math.round((completedMs - startMs) * 1e6))
+  }
+
+  return 0
+}
+
 /**
  * @param {Record<string, unknown> | undefined} recordMetadata
  * @param {Record<string, unknown>} config
@@ -207,14 +294,19 @@ function buildSpanMetadata (recordMetadata, config) {
 }
 
 module.exports = {
-  buildExperimentTagObject,
   buildSpanMetadata,
   buildTags,
+  durationNs,
   hasEntries,
   inferMetricType,
+  mergeTags,
   normalizeEvaluators,
   normalizeJsonMetricValue,
+  recordTagsToObject,
   sleep,
   stringify,
+  tagOperationsAreEmpty,
+  timestampMs,
   validateEvaluatorName,
+  validateTagsList,
 }

package/packages/dd-trace/src/llmobs/plugins/ai/util.js

@@ -228,6 +228,7 @@ function getJsonStringValue (str, defaultValue) {
 function getModelMetadata (tags) {
   /** @type {Record<string, unknown>} */
   const modelMetadata = {}
+  let hasModelMetadata = false
   for (const tag of Object.keys(tags)) {
     const isModelMetadata = tag.startsWith(VERCEL_AI_MODEL_METADATA_PREFIX)
     if (isModelMetadata) {
@@ -235,6 +236,7 @@ function getModelMetadata (tags) {
       const metadataKey = lastCommaPosition === -1 ? tag : tag.slice(lastCommaPosition + 1)
       if (metadataKey && MODEL_METADATA_KEYS.has(metadataKey)) {
         modelMetadata[metadataKey] = tags[tag]
+        hasModelMetadata = true
       }
     } else {
       const isTelemetryMetadata = tag.startsWith(VERCEL_AI_TELEMETRY_METADATA_PREFIX)
@@ -242,12 +244,13 @@ function getModelMetadata (tags) {
         const metadataKey = tag.slice(VERCEL_AI_TELEMETRY_METADATA_PREFIX.length)
         if (metadataKey) {
           modelMetadata[metadataKey] = tags[tag]
+          hasModelMetadata = true
         }
       }
     }
   }
 
-  return Object.keys(modelMetadata).length ? modelMetadata : null
+  return hasModelMetadata ? modelMetadata : null
 }
 
 /**
@@ -259,6 +262,7 @@ function getModelMetadata (tags) {
 function getGenerationMetadata (tags) {
   /** @type {Record<string, unknown>} */
   const metadata = {}
+  let hasMetadata = false
 
   for (const tag of Object.keys(tags)) {
     const isGenerationMetadata = tag.startsWith(VERCEL_AI_GENERATION_METADATA_PREFIX)
@@ -270,18 +274,20 @@ function getGenerationMetadata (tags) {
 
       const settingValue = tags[tag]
       metadata[settingKey] = settingValue
+      hasMetadata = true
     } else {
       const isTelemetryMetadata = tag.startsWith(VERCEL_AI_TELEMETRY_METADATA_PREFIX)
       if (isTelemetryMetadata) {
         const metadataKey = tag.slice(VERCEL_AI_TELEMETRY_METADATA_PREFIX.length)
         if (metadataKey) {
           metadata[metadataKey] = tags[tag]
+          hasMetadata = true
         }
       }
     }
   }
 
-  return Object.keys(metadata).length ? metadata : null
+  return hasMetadata ? metadata : null
 }
 
 /**
@@ -307,6 +313,7 @@ function getGenerationMetadataFromEvent (event) {
     metadata[transformedKey] = value
   }
 
+  // eslint-disable-next-line no-restricted-syntax -- manual tracking would duplicate Object.assign semantics
   return Object.keys(metadata).length ? metadata : null
 }
 
@@ -432,6 +439,7 @@ function getLlmObsSpanName (operation, functionId) {
  */
 function getTelemetryMetadata (tags) {
   const metadata = {}
+  let hasMetadata = false
 
   for (const tag of Object.keys(tags)) {
     if (!tag.startsWith(VERCEL_AI_TELEMETRY_METADATA_PREFIX)) continue
@@ -439,10 +447,11 @@ function getTelemetryMetadata (tags) {
     const metadataKey = tag.slice(VERCEL_AI_TELEMETRY_METADATA_PREFIX.length)
     if (metadataKey) {
       metadata[metadataKey] = tags[tag]
+      hasMetadata = true
     }
   }
 
-  return Object.keys(metadata).length ? metadata : null
+  return hasMetadata ? metadata : null
 }
 
 module.exports = {

package/packages/dd-trace/src/llmobs/plugins/base.js

@@ -84,9 +84,11 @@ class LLMObsPlugin extends TracingPlugin {
   }
 
   configure (config) {
-    // we do not want to enable any LLMObs plugins if it is disabled on the tracer
+    // we do not want to enable any LLMObs plugins if it is disabled on the tracer, or if the
+    // integration opted out via `tracer.use(<name>, { llmobs: false })`. Opting out only disables
+    // the LLMObs layer: the integration keeps emitting APM spans and propagating trace context.
     const llmobsEnabled = this._tracerConfig.llmobs.DD_LLMOBS_ENABLED
-    if (llmobsEnabled === false) {
+    if (llmobsEnabled === false || config?.llmobs === false) {
       config = typeof config === 'boolean' ? false : { ...config, enabled: false } // override to false
     }
     super.configure(config)

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

@@ -1,9 +1,9 @@
 'use strict'
 
-const { features } = require('../feature-registry')
 const NoopAppsecSdk = require('../appsec/sdk/noop')
 const NoopLLMObsSDK = require('../llmobs/noop')
 const NoopAIGuardSDK = require('../aiguard/noop')
+const NoopFlaggingProvider = require('../openfeature/noop')
 const NoopDogStatsDClient = require('./dogstatsd')
 const NoopTracer = require('./tracer')
 
@@ -12,6 +12,7 @@ const noopAppsec = new NoopAppsecSdk()
 const noopDogStatsDClient = new NoopDogStatsDClient()
 const noopLLMObs = new NoopLLMObsSDK(noop)
 const noopAIGuard = new NoopAIGuardSDK()
+const noopFlaggingProviderInstance = new NoopFlaggingProvider()
 const noopProfiling = {
   setCustomLabelKeys () {},
   runWithLabels (labels, fn) { return fn() },
@@ -25,9 +26,7 @@ class NoopProxy {
     this.dogstatsd = noopDogStatsDClient
     this.llmobs = noopLLMObs
     this.aiguard = noopAIGuard
-    for (const { name, noop } of Object.values(features)) {
-      this[name] = noop
-    }
+    this.openfeature = noopFlaggingProviderInstance
     this.setBaggageItem = (key, value) => {}
     this.getBaggageItem = (key) => {}
     this.getAllBaggageItems = () => {}

package/packages/dd-trace/src/openfeature/constants/constants.js

@@ -1,24 +1,6 @@
 'use strict'
 
 module.exports = {
-  /**
-   * @constant
-   * @type {string} Base path for EVP proxy agent endpoint
-   */
-  EVP_PROXY_AGENT_BASE_PATH: '/evp_proxy/v2/',
-
-  /**
-   * @constant
-   * @type {string} HTTP header name for EVP subdomain routing
-   */
-  EVP_SUBDOMAIN_HEADER_NAME: 'X-Datadog-EVP-Subdomain',
-
-  /**
-   * @constant
-   * @type {string} EVP subdomain value for event platform intake
-   */
-  EVP_SUBDOMAIN_VALUE: 'event-platform-intake',
-
   /**
    * @constant
    * @type {string} API endpoint for exposure events EVP track

package/packages/dd-trace/src/openfeature/flagging_provider.js

@@ -1,14 +1,14 @@
 'use strict'
 
 const { channel } = require('dc-polyfill')
+
+const { DatadogNodeServerProvider } = require('../../../../vendor/dist/@datadog/openfeature-node-server')
 const log = require('../log')
 const configurationSource = require('./configuration_source')
 const { EXPOSURE_CHANNEL } = require('./constants/constants')
 const EvalMetricsHook = require('./eval-metrics-hook')
 const SpanEnrichmentHook = require('./span-enrichment-hook')
 
-const { DatadogNodeServerProvider } = require('./require-provider')
-
 /**
  * OpenFeature provider that integrates with Datadog's feature flagging system.
  * Extends DatadogNodeServerProvider to add tracer integration and configuration management.
@@ -48,6 +48,22 @@ class FlaggingProvider extends DatadogNodeServerProvider {
     this.#configurationSource?.start()
   }
 
+  /**
+   * @param {import('@openfeature/core').EvaluationContext} [context]
+   * @returns {Promise<void>}
+   */
+  initialize (context) {
+    const promise = super.initialize(context)
+
+    // `DatadogNodeServerProvider#initialize` starts a timer that is never unref'd, which would
+    // otherwise keep an idle process (a short script, a serverless handler) alive for up to
+    // `initializationTimeoutMs` while waiting for configuration to arrive.
+    // TODO: remove once `@datadog/openfeature-node-server` unrefs this timer itself.
+    this.initController?.timeoutId?.unref?.()
+
+    return promise
+  }
+
   /**
    * Called when the provider is shut down.
    * Cleans up resources including channel subscriptions.

package/packages/dd-trace/src/openfeature/index.js

@@ -3,7 +3,7 @@
 const { channel } = require('dc-polyfill')
 const log = require('../log')
 const ExposuresWriter = require('./writers/exposures')
-const { setAgentStrategy } = require('./writers/util')
+const { setExposureDeliveryStrategy } = require('./writers/util')
 
 const exposureSubmitCh = channel('ffe:exposure:submit')
 const flushCh = channel('ffe:writers:flush')
@@ -40,12 +40,15 @@ function enable (config) {
     return
   }
 
-  exposuresWriter = new ExposuresWriter(config)
+  const writer = new ExposuresWriter(config)
+  exposuresWriter = writer
   exposureSubmitCh.subscribe(_handleExposureSubmit)
   flushCh.subscribe(_handleFlush)
 
-  setAgentStrategy(config, hasAgent => {
-    exposuresWriter?.setEnabled(hasAgent)
+  setExposureDeliveryStrategy(config, (enabled, route) => {
+    if (exposuresWriter !== writer) return
+
+    writer.setEnabled(enabled, route)
   })
 }
 

package/packages/dd-trace/src/openfeature/remote_config.js

@@ -6,7 +6,7 @@ const RemoteConfigCapabilities = require('../remote_config/capabilities')
  * Configures remote config handlers for openfeature feature flagging
  *
  * @param {import('../remote_config')} rc - RemoteConfig instance
- * @param {() => import('./flagging_provider')} getOpenfeatureProxy
+ * @param {() => InstanceType<ReturnType<typeof import('./flagging_provider')>>} getOpenfeatureProxy
  * @param {boolean} subscribe - Whether Agent Remote Config owns UFC delivery
  */
 function enable (rc, getOpenfeatureProxy, subscribe) {