dd-trace 6.3.0 → 6.5.0

package/index.d.ts

@@ -156,12 +156,12 @@ interface Tracer extends opentracing.Tracer {
   llmobs: tracer.llmobs.LLMObs;
 
   /**
-   * OpenFeature Provider with Remote Config integration.
+   * OpenFeature Provider with agentless and Agent Remote Config delivery.
    *
-   * Extends DatadogNodeServerProvider with Remote Config integration for dynamic flag configuration.
-   * Enable with DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED=true.
+   * Agentless delivery is enabled by default and starts when the provider is first accessed.
    *
-   * @env DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED
+   * @env DD_FEATURE_FLAGS_ENABLED
+   * @env DD_FEATURE_FLAGS_CONFIGURATION_SOURCE
    * @beta This feature is in preview and not ready for production use
    */
   openfeature: tracer.OpenFeatureProvider;
@@ -799,9 +799,9 @@ declare namespace tracer {
        */
       flaggingProvider?: {
         /**
-         * Whether to enable the feature flagging provider.
-         * Requires Remote Config to be properly configured.
-         * Can be configured via DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED environment variable.
+         * Legacy feature flagging provider switch.
+         * When the stable Feature Flags configuration is unset, true selects Agent Remote Config and false disables
+         * the provider.
          *
          * @default false
          * @env DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED
@@ -1620,7 +1620,7 @@ declare namespace tracer {
   /**
    * Flagging Provider (OpenFeature-compatible).
    *
-   * Wraps @datadog/openfeature-node-server with Remote Config integration for dynamic flag configuration.
+   * Wraps @datadog/openfeature-node-server with agentless and Agent Remote Config delivery.
    * Implements the OpenFeature Provider interface for flag evaluation.
    *
    * @beta This feature is in preview and not ready for production use
@@ -3568,6 +3568,12 @@ declare namespace tracer {
        */
       enabled: boolean,
 
+      /**
+       * Datasets & Experiments API. Requires LLM Observability to be enabled and
+       * `DD_API_KEY` / `DD_APP_KEY` to be set.
+       */
+      experiments: Experiments,
+
       /**
        * Enable LLM Observability tracing.
        *
@@ -3721,6 +3727,93 @@ declare namespace tracer {
       flush (): void
     }
 
+    /**
+     * A task run over each dataset record during an experiment.
+     */
+    type ExperimentTask = (input: any, config: Record<string, any>) => any | Promise<any>
+
+    /**
+     * Scores a single task output. The return type selects the metric:
+     * `boolean` -> boolean, `number` -> score, anything else -> categorical.
+     */
+    type ExperimentEvaluator = (input: any, output: any, expectedOutput: any) => any | Promise<any>
+
+    interface ExperimentOptions {
+      name: string
+      dataset: Dataset
+      task: ExperimentTask
+      /** Evaluators keyed by metric label. */
+      evaluators?: Record<string, ExperimentEvaluator>
+      description?: string
+      config?: Record<string, any>
+      tags?: Record<string, string>
+    }
+
+    interface PullDatasetOptions {
+      /** Wait until at least this many records are readable (absorbs write lag). */
+      expectedRecordCount?: number
+      /** Maximum total time to wait, in ms. Default 30000. */
+      maxWaitMs?: number
+    }
+
+    interface ExperimentResultRow {
+      index: number
+      spanId: string
+      traceId: string
+      startNs: number
+      durationNs: number
+      input: any
+      output: any
+      expectedOutput: any
+      readonly isError: boolean
+      errorType: string | null
+      errorMessage: string | null
+      evaluations: Record<string, any>
+      evaluationErrors: Record<string, string>
+    }
+
+    interface ExperimentResult {
+      experimentId: string
+      rows: ExperimentResultRow[]
+      /** Dashboard URL for the experiment. */
+      url: string
+    }
+
+    interface DatasetPushResult {
+      /** Number of records from this push that were confirmed with a record id. */
+      pushedCount: number
+      /** Number of records attempted in this push. */
+      totalCount: number
+    }
+
+    interface Dataset {
+      addRecord (input: any, expectedOutput?: any, metadata?: Record<string, any>): Dataset
+      /** Creates the dataset remotely if needed and pushes any unpushed records. */
+      push (): Promise<DatasetPushResult>
+      name (): string
+      id (): string | null
+      projectId (): string | null
+      records (): Array<{ input: any, expectedOutput: any, metadata: Record<string, any> }>
+      /** Dashboard URL for the dataset, or null until pushed. */
+      url (): string | null
+    }
+
+    interface Experiment {
+      name (): string
+      experimentId (): string | null
+      url (): string | null
+      run (): Promise<ExperimentResult>
+    }
+
+    interface Experiments {
+      /** Create a local dataset buffer; pushed on the first experiment run. */
+      createDataset (name: string, description?: string): Dataset
+      /** Pull an existing dataset (with records) by name. */
+      pullDataset (name: string, options?: PullDatasetOptions): Promise<Dataset>
+      /** Build an experiment to run over a dataset. */
+      experiment (options: ExperimentOptions): Experiment
+    }
+
     interface LLMObservabilitySpan {
       /**
        * The span kind
@@ -3833,6 +3926,26 @@ declare namespace tracer {
        * Tool calls of the message
        */
       toolCalls?: ToolCall[],
+
+      /**
+       * Audio segments attached to the message (e.g. speech input/output)
+       */
+      audioParts?: AudioPart[],
+    }
+
+    /**
+     * Represents an audio segment attached to an LLM chat model message.
+     */
+    interface AudioPart {
+      /**
+       * The MIME type of the audio (e.g. "audio/wav", "audio/mpeg")
+       */
+      mimeType: string,
+
+      /**
+       * The audio content as a base64-encoded string
+       */
+      content: string,
     }
 
     /**

package/index.electron.js

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = require('./packages/dd-trace/index.electron')

package/init.js

@@ -1,5 +1,23 @@
 'use strict'
 
+// In PM2 cluster mode, per-app env vars arrive as a `pm2_env`
+// JSON string after --require has already run so we extract them
+// manually if present.
+var pm2EnvStr = process.env.pm2_env
+if (typeof pm2EnvStr === 'string') {
+  try {
+    var pm2Config = JSON.parse(pm2EnvStr)
+    var pm2Keys = Object.keys(pm2Config)
+    for (var i = 0; i < pm2Keys.length; i++) {
+      var k = pm2Keys[i]
+      var v = pm2Config[k]
+      if (v != null) {
+        process.env[k] = String(v)
+      }
+    }
+  } catch (e) {}
+}
+
 var guard = require('./packages/dd-trace/src/guardrails')
 
 module.exports = guard(function () {

package/initialize.mjs

@@ -22,7 +22,7 @@ import {
   iitmExclusionRegExp,
   load as hookLoad,
   resolve as hookResolve,
-} from './loader-hook.mjs'
+} from './loader-hook.mjs?initialize'
 
 let hasInsertedInit = false
 const initJsUrl = new URL('init.js', import.meta.url).href

package/loader-hook.mjs

@@ -2,24 +2,22 @@
 
 import * as Module from 'node:module'
 import { pathToFileURL } from 'node:url'
+import { isMainThread } from 'node:worker_threads'
 
 import { createHook, supportsSyncHooks } from 'import-in-the-middle/create-hook.mjs'
-import { initialize as origInitialize, load as origLoad, resolve } from 'import-in-the-middle/hook.mjs'
-import regexpEscapeModule from './vendor/dist/escape-string-regexp/index.js'
-import hooks from './packages/datadog-instrumentations/src/helpers/hooks.js'
-import configHelper from './packages/dd-trace/src/config/helper.js'
+import { initialize as origInitialize, load as origLoad } from 'import-in-the-middle/hook.mjs'
 import * as rewriterLoader from './packages/datadog-instrumentations/src/helpers/rewriter/loader.mjs'
-import { isRelativeRequire } from './packages/datadog-instrumentations/src/helpers/shared-utils.js'
 
 // This file must support Node.js 12.0.0 syntax
 
 const { builtinModules } = Module
-const regexpEscape = regexpEscapeModule.default
 const require = Module.createRequire(import.meta.url)
+// The query marks initialize.mjs's application-thread preload; loader workers use the full graph.
+const isInitializeMainThread = isMainThread && import.meta.url.endsWith('?initialize')
 let syncImportInTheMiddleHook
 
-// The config helper's named exports aren't visible to ESM; destructure the default.
-const { getValueFromEnvSources } = configHelper
+let getValueFromEnvSources
+let regexpEscape
 
 // Substrings of resolved URLs that import-in-the-middle must never wrap: re-export
 // shims and internal helper graphs that break when proxied, plus iitm's own files
@@ -32,15 +30,26 @@ export const iitmExclusionRegExp = /middle|langsmith|openai\/_shims|openai\/reso
 // against a regex metacharacter entering a package name.
 const includeModuleNames = new Set()
 let moduleNameAlternation = ''
-for (const moduleName of Object.keys(hooks)) {
-  // Relative hooks resolve outside node_modules and are not instrumented here.
-  if (isRelativeRequire(moduleName)) continue
-  includeModuleNames.add(moduleName)
-  // iitm matches a built-in by its node: specifier too, so mirror that and
-  // wrap `import 'node:crypto'` as well as `import 'crypto'`.
-  if (builtinModules.includes(moduleName)) includeModuleNames.add(`node:${moduleName}`)
-  if (moduleNameAlternation !== '') moduleNameAlternation += '|'
-  moduleNameAlternation += regexpEscape(moduleName)
+
+if (!isInitializeMainThread) {
+  const regexpEscapeModule = require('./vendor/dist/escape-string-regexp/index.js')
+  const hooks = require('./packages/datadog-instrumentations/src/helpers/hooks.js')
+  const configHelper = require('./packages/dd-trace/src/config/helper.js')
+  const { isRelativeRequire } = require('./packages/datadog-instrumentations/src/helpers/shared-utils.js')
+
+  regexpEscape = regexpEscapeModule.default
+  getValueFromEnvSources = configHelper.getValueFromEnvSources
+
+  for (const moduleName of Object.keys(hooks)) {
+    // Relative hooks resolve outside node_modules and are not instrumented here.
+    if (isRelativeRequire(moduleName)) continue
+    includeModuleNames.add(moduleName)
+    // iitm matches a built-in by its node: specifier too, so mirror that and
+    // wrap `import 'node:crypto'` as well as `import 'crypto'`.
+    if (builtinModules.includes(moduleName)) includeModuleNames.add(`node:${moduleName}`)
+    if (moduleNameAlternation !== '') moduleNameAlternation += '|'
+    moduleNameAlternation += regexpEscape(moduleName)
+  }
 }
 
 const nodeModulesIncludeSource = `node_modules/(?:${moduleNameAlternation})/(?!node_modules).+`
@@ -181,4 +190,5 @@ function registerSyncLoaderHooks (data = {}) {
   return true
 }
 
-export { initialize, load, registerSyncLoaderHooks, resolve }
+export { resolve } from 'import-in-the-middle/hook.mjs'
+export { initialize, load, registerSyncLoaderHooks }

package/openfeature.d.ts

@@ -0,0 +1 @@
+export {};

package/openfeature.js

@@ -0,0 +1,4 @@
+'use strict'
+
+// Static fallback for file tracers that do not recognize the optional-peer wrapper.
+require('@datadog/openfeature-node-server')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "6.3.0",
+  "version": "6.5.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -12,7 +12,9 @@
     "bench:e2e:test-optimization": "node benchmark/e2e-test-optimization/benchmark-run.js",
     "dependencies:dedupe": "yarn-deduplicate yarn.lock",
     "generate:config:types": "node scripts/generate-config-types.js",
+    "generate:electron-package": "node scripts/generate-electron-package.js",
     "verify:config:types": "node scripts/generate-config-types.js --check",
+    "verify:electron-package": "node scripts/generate-electron-package.js --check",
     "generate:supported-integrations": "node scripts/generate-supported-integrations.js",
     "verify:supported-integrations": "node scripts/generate-supported-integrations.js --check",
     "type:check": "tsc --noEmit -p tsconfig.dev.json",
@@ -142,6 +144,7 @@
     "webpack.js",
     "ext/**/*",
     "index.d.ts",
+    "index.electron.js",
     "index.js",
     "init.js",
     "initialize.mjs",
@@ -150,7 +153,10 @@
     "LICENSE.Apache",
     "LICENSE.BSD3",
     "loader-hook.mjs",
+    "openfeature.d.ts",
+    "openfeature.js",
     "packages/*/index.js",
+    "packages/*/index.electron.js",
     "packages/*/lib/**/*",
     "packages/*/src/**/*",
     "packages/datadog-instrumentations/orchestrion.yml",
@@ -164,7 +170,7 @@
   ],
   "dependencies": {
     "dc-polyfill": "^0.1.11",
-    "import-in-the-middle": "^3.3.1",
+    "import-in-the-middle": "^3.3.2",
     "opentracing": ">=0.14.7"
   },
   "optionalDependencies": {
@@ -184,7 +190,7 @@
     "@actions/github": "^9.1.1",
     "@babel/helpers": "^8.0.0",
     "@eslint/eslintrc": "^3.3.5",
-    "@eslint/js": "^9.39.2",
+    "@eslint/js": "^10.0.1",
     "@msgpack/msgpack": "^3.1.3",
     "@openfeature/core": "^1.11.0",
     "@openfeature/server-sdk": "~1.22.0",
@@ -192,21 +198,22 @@
     "@types/mocha": "^10.0.10",
     "@types/node": "^18.19.106",
     "@types/sinon": "^22.0.0",
+    "@vercel/nft": "^0.29.4",
     "axios": "^1.18.1",
     "benchmark": "^2.1.4",
     "body-parser": "^2.3.0",
     "bun": "1.3.14",
-    "c8": "^11.0.0",
+    "c8": "^12.0.0",
     "codeowners-audit": "^2.9.0",
-    "eslint": "^9.39.2",
+    "eslint": "^10.5.0",
     "eslint-plugin-cypress": "^6.4.2",
-    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-import-x": "^4.16.2",
     "eslint-plugin-jsdoc": "^63.0.12",
     "eslint-plugin-mocha": "^11.3.0",
     "eslint-plugin-n": "^18.2.1",
     "eslint-plugin-promise": "^7.3.0",
-    "eslint-plugin-sonarjs": "^4.1.0",
-    "eslint-plugin-unicorn": "^64.0.0",
+    "eslint-plugin-sonarjs": "^4.2.0",
+    "eslint-plugin-unicorn": "^68.0.0",
     "express": "^5.1.0",
     "glob": "^10.4.5",
     "globals": "^17.7.0",

package/packages/datadog-instrumentations/src/ai.js

@@ -127,7 +127,7 @@ function wrapTracer (tracer) {
     return function (...args) {
       const name = args[0]
       const options = args.length > 2 ? (args[1] ?? {}) : {} // startActiveSpan(name, fn)
-      const cb = args[args.length - 1]
+      const cb = args.at(-1)
 
       const ctx = {
         name,
@@ -136,33 +136,38 @@ function wrapTracer (tracer) {
 
       args[args.length - 1] = shimmer.wrapFunction(cb, function (originalCb) {
         return function (span) {
-          // the below is necessary in the case that the span is vercel ai's noopSpan.
-          // while we don't want to patch the noopSpan more than once, we do want to treat each as a
-          // fresh instance. However, this is really not necessary for non-noop spans, but not sure
-          // how to differentiate.
-          const freshSpan = Object.create(span) // TODO: does this cause memory leaks?
-
-          shimmer.wrap(freshSpan, 'end', function (spanEnd) {
-            return function (...args) {
-              vercelAiTracingChannel.asyncEnd.publish(ctx)
-              return spanEnd.apply(this, args)
-            }
-          })
-
-          shimmer.wrap(freshSpan, 'setAttributes', function (setAttributes) {
-            return function (attributes) {
+          // A plain delegating wrapper is used instead of Object.create(span) because
+          // Object.create (and Proxy) cannot cross private-field brand checks — any span
+          // method that reads a private field (e.g. BridgeSpanBase#statusCode) would throw
+          // "Cannot read private member" on a prototype clone. Every method here calls
+          // through to the real span instance so private fields always resolve correctly.
+          const freshSpan = {
+            spanContext () { return span.spanContext() },
+            setAttribute (key, value) { span.setAttribute(key, value); return freshSpan },
+            setAttributes (attributes) {
               vercelAiSpanSetAttributesChannel.publish({ ctx, attributes })
-              return setAttributes.apply(this, arguments)
-            }
-          })
-
-          shimmer.wrap(freshSpan, 'recordException', function (recordException) {
-            return function (exception) {
+              span.setAttributes(attributes)
+              return freshSpan
+            },
+            addEvent (name, attributesOrStartTime, startTime) {
+              span.addEvent(name, attributesOrStartTime, startTime)
+              return freshSpan
+            },
+            addLink (link, attrs) { span.addLink(link, attrs); return freshSpan },
+            addLinks (links) { span.addLinks(links); return freshSpan },
+            setStatus (status) { span.setStatus(status); return freshSpan },
+            updateName (spanName) { span.updateName(spanName); return freshSpan },
+            isRecording () { return span.isRecording() },
+            recordException (exception, timeInput) {
               ctx.error = exception
               vercelAiTracingChannel.error.publish(ctx)
-              return recordException.apply(this, arguments)
-            }
-          })
+              span.recordException(exception, timeInput)
+            },
+            end (...endArgs) {
+              vercelAiTracingChannel.asyncEnd.publish(ctx)
+              span.end(...endArgs)
+            },
+          }
 
           return originalCb.call(this, freshSpan)
         }
@@ -225,7 +230,13 @@ for (const hook of getHooks('ai')) {
     // generateObject, streamObject)
     tracingChannel('orchestrion:ai:resolveLanguageModel').subscribe({
       end (ctx) {
-        wrapModelWithLifecycle(ctx.result)
+        const model = ctx.arguments[0]
+        if (typeof model !== 'string' && model !== ctx.result) {
+          wrapModelWithLifecycle(model)
+          wrappedModels.add(ctx.result)
+        } else {
+          wrapModelWithLifecycle(ctx.result)
+        }
       },
     })
 

package/packages/datadog-instrumentations/src/child_process.js

@@ -190,7 +190,7 @@ function wrapChildProcessAsyncMethod (ChildProcess, shell = false) {
             const error = context.abortController.signal.reason || new Error('Aborted')
             childProcess.emit('error', error)
 
-            const cb = context.callArgs[context.callArgs.length - 1]
+            const cb = context.callArgs.at(-1)
             if (typeof cb === 'function') {
               cb(error)
             }

package/packages/datadog-instrumentations/src/claude-agent-sdk.js

@@ -496,7 +496,7 @@ function finishStream (chunks, ctx, error) {
 
   let processError
   if (chunks.length > 0) {
-    const lastChunk = chunks[chunks.length - 1]
+    const lastChunk = chunks.at(-1)
     if (lastChunk?.type === 'result') ctx.output = lastChunk.result
 
     try {

package/packages/datadog-instrumentations/src/cucumber-worker-threads.js

@@ -9,11 +9,17 @@ const appRequire = createRequire(path.join(process.cwd(), 'package.json'))
 
 try {
   // Cucumber v13 parallel workers start from an ESM worker.mjs entrypoint, which
-  // statically imports the internal runtime Worker before it runs support-code
+  // statically imports the internal runtime Worker/Executor before it runs support-code
   // requireModules. The regular module hook does not patch that internal worker
-  // import, so this preload is injected into requireModules to patch the cached Worker
+  // import, so this preload is injected into requireModules to patch the cached class
   // prototype before Cucumber constructs the worker instance.
-  patchCucumberWorkerRunTestCase(appRequire('@cucumber/cucumber/lib/runtime/worker'), true)
+  let runtimeExecutorPackage
+  try {
+    runtimeExecutorPackage = appRequire('@cucumber/cucumber/lib/runtime/executor')
+  } catch {
+    runtimeExecutorPackage = appRequire('@cucumber/cucumber/lib/runtime/worker')
+  }
+  patchCucumberWorkerRunTestCase(runtimeExecutorPackage, true)
 } catch {
   // Ignore preload failures so cucumber can keep running if its internals change.
 }

package/packages/datadog-instrumentations/src/cucumber.js

@@ -180,7 +180,7 @@ function getSuiteStatusFromTestStatuses (testStatuses) {
 
 function getConfiguredEfdRetryCount () {
   const maxSlowTestRetryCount = getMaxEfdRetryCount(earlyFlakeDetectionSlowTestRetries)
-  return maxSlowTestRetryCount || earlyFlakeDetectionNumRetries
+  return maxSlowTestRetryCount ?? earlyFlakeDetectionNumRetries
 }
 
 function publishWorkerEfdRetryCount (pickle, retryCount) {
@@ -1036,7 +1036,9 @@ function testCaseHook (TestCaseRunner, version) {
 // Valid for old and new cucumber versions
 function getCucumberOptions (adapterOrCoordinator) {
   if (adapterOrCoordinator.adapter) {
-    return adapterOrCoordinator.adapter.worker?.options || adapterOrCoordinator.adapter.options
+    return adapterOrCoordinator.adapter.worker?.options ||
+      adapterOrCoordinator.adapter.executor?.options ||
+      adapterOrCoordinator.adapter.options
   }
   return adapterOrCoordinator.options
 }
@@ -1178,7 +1180,8 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
       itrSkippedSuitesCh.publish({ skippedSuites, frameworkVersion })
     }
 
-    const success = await start.apply(this, arguments)
+    const result = await start.apply(this, arguments)
+    const success = satisfies(frameworkVersion, '>=13.1.0') ? result.success : result
 
     let untestedCoverage
     if (getCodeCoverageCh.hasSubscribers) {
@@ -1228,7 +1231,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
     logTestOptimizationSummary({ attemptToFixExecutions })
     loggedAttemptToFixTests.clear()
     eventDataCollector = null
-    return success
+    return result
   }
 }
 
@@ -1433,13 +1436,14 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
   }
 }
 
-function patchCucumberWorkerRunTestCase (workerPackage, isWorker) {
-  const workerPrototype = workerPackage?.Worker?.prototype
-  if (!workerPrototype || patchedCucumberWorkers.has(workerPrototype)) return
+function patchCucumberWorkerRunTestCase (runtimeExecutorPackage, isWorker) {
+  const runtimeExecutorPrototype =
+    runtimeExecutorPackage?.Worker?.prototype || runtimeExecutorPackage?.Executor?.prototype
+  if (!runtimeExecutorPrototype || patchedCucumberWorkers.has(runtimeExecutorPrototype)) return
 
-  patchedCucumberWorkers.add(workerPrototype)
+  patchedCucumberWorkers.add(runtimeExecutorPrototype)
   shimmer.wrap(
-    workerPrototype,
+    runtimeExecutorPrototype,
     'runTestCase',
     runTestCase => getWrappedRunTestCase(runTestCase, true, isWorker)
   )
@@ -1571,15 +1575,25 @@ addHook({
 // `getWrappedRunTestCase` does two things:
 // - generates suite start and finish events in the main process,
 // - handles EFD in both the main process and the worker process.
+// Shimmer is required because this wrapper may invoke the original test case multiple times and mutate runtime options.
 addHook({
   name: '@cucumber/cucumber',
-  versions: ['>=11.0.0'],
+  versions: ['>=11.0.0 <13.2.0'],
   file: 'lib/runtime/worker.js',
 }, (workerPackage) => {
   patchCucumberWorkerRunTestCase(workerPackage, !!getEnvironmentVariable('CUCUMBER_WORKER_ID'))
   return workerPackage
 })
 
+addHook({
+  name: '@cucumber/cucumber',
+  versions: ['>=13.2.0'],
+  file: 'lib/runtime/executor.js',
+}, (executorPackage) => {
+  patchCucumberWorkerRunTestCase(executorPackage, !!getEnvironmentVariable('CUCUMBER_WORKER_ID'))
+  return executorPackage
+})
+
 // `getWrappedStart` generates session start and finish events
 addHook({
   name: '@cucumber/cucumber',