dd-trace 6.19.0 → 6.20.0

package/index.d.ts

@@ -3,6 +3,61 @@ import { LookupFunction } from 'net';
 import * as opentracing from "opentracing";
 import * as otel from "@opentelemetry/api";
 
+declare const baseEvaluatorBrand: unique symbol
+declare const baseSummaryEvaluatorBrand: unique symbol
+
+declare const EvaluatorContext: {
+  new (options: {
+    inputData: tracer.llmobs.JSONType
+    outputData: tracer.llmobs.JSONType
+    expectedOutput?: tracer.llmobs.JSONType
+    metadata?: Record<string, tracer.llmobs.JSONType>
+    spanId?: string
+    traceId?: string
+  }): tracer.llmobs.EvaluatorContext
+}
+
+declare const SummaryEvaluatorContext: {
+  new (options: {
+    inputs: tracer.llmobs.JSONType[]
+    outputs: tracer.llmobs.JSONType[]
+    expectedOutputs: tracer.llmobs.JSONType[]
+    evaluationResults: Record<string, tracer.llmobs.JSONType[]>
+    metadata?: Array<Record<string, tracer.llmobs.JSONType>>
+  }): tracer.llmobs.SummaryEvaluatorContext
+}
+
+declare const EvaluatorResult: {
+  new (value: tracer.llmobs.JSONType, options?: tracer.llmobs.EvaluatorResultOptions): tracer.llmobs.EvaluatorResult
+}
+
+declare const MultiEvaluatorResult: {
+  new (values: Record<string, tracer.llmobs.JSONType | tracer.llmobs.EvaluatorResult>, prefix?: boolean): tracer.llmobs.MultiEvaluatorResult
+}
+
+declare const BaseEvaluator: {
+  new (name?: string): tracer.llmobs.BaseEvaluator
+}
+
+declare const BaseSummaryEvaluator: {
+  new (name?: string): tracer.llmobs.BaseSummaryEvaluator
+}
+
+declare const RemoteEvaluatorError: {
+  new (message: string, options?: {
+    status?: string
+    backendError?: Record<string, tracer.llmobs.JSONType>
+  }): tracer.llmobs.RemoteEvaluatorError
+}
+
+declare const RemoteEvaluator: {
+  new (options: {
+    evalName: string
+    transformFn?: (context: tracer.llmobs.EvaluatorContext) => Record<string, tracer.llmobs.JSONType>
+  }): tracer.llmobs.RemoteEvaluator
+}
+
+
 /**
  * Tracer is the entry-point of the Datadog tracing implementation.
  */
@@ -162,6 +217,7 @@ interface Tracer extends opentracing.Tracer {
    *
    * @env DD_FEATURE_FLAGS_ENABLED
    * @env DD_FEATURE_FLAGS_CONFIGURATION_SOURCE
+   * @env DD_FLAGGING_EVALUATION_COUNTS_ENABLED
    * @beta This feature is in preview and not ready for production use
    */
   openfeature: tracer.OpenFeatureProvider;
@@ -1245,6 +1301,16 @@ declare namespace tracer {
        */
       captureTimeoutMs?: number
 
+      /**
+       * Time budget in milliseconds for evaluating a probe's condition, log message template and capture expressions.
+       * An evaluation that exceeds the budget is reported as an evaluation error and the probe is not evaluated again
+       * for a while.
+       * @default 50
+       * @env DD_DYNAMIC_INSTRUMENTATION_EVALUATION_TIMEOUT_MS
+       * Programmatic configuration takes precedence over the environment variables listed above.
+       */
+      evaluationTimeoutMs?: number
+
       /**
        * Interval in seconds between uploads of probe data.
        * @default 1
@@ -4052,6 +4118,74 @@ declare namespace tracer {
 
     type ReadonlyJSONType = string | number | boolean | null | ReadonlyArray<ReadonlyJSONType> | { readonly [key: string]: ReadonlyJSONType }
 
+    /** Context passed to a record-level class evaluator. */
+    interface EvaluatorContext {
+      inputData: JSONType
+      outputData: JSONType
+      expectedOutput?: JSONType
+      metadata: Record<string, JSONType>
+      spanId?: string
+      traceId?: string
+    }
+
+    /** Context passed to a summary class evaluator. */
+    interface SummaryEvaluatorContext {
+      inputs: JSONType[]
+      outputs: JSONType[]
+      expectedOutputs: JSONType[]
+      evaluationResults: Record<string, JSONType[]>
+      metadata: Array<Record<string, JSONType>>
+    }
+
+    interface EvaluatorResultOptions {
+      reasoning?: string
+      assessment?: 'pass' | 'fail'
+      metadata?: Record<string, JSONType>
+      tags?: Record<string, JSONType>
+    }
+
+    /** A metric value with optional evaluation details. */
+    interface EvaluatorResult {
+      value: JSONType
+      reasoning?: string
+      assessment?: 'pass' | 'fail'
+      metadata?: Record<string, JSONType>
+      tags?: Record<string, JSONType>
+    }
+
+    /** A result that emits several named metrics from one evaluator invocation. */
+    interface MultiEvaluatorResult {
+      values: Record<string, JSONType | EvaluatorResult>
+      prefix: boolean
+    }
+
+    /** Error returned by a managed evaluator configured in Datadog. */
+    interface RemoteEvaluatorError extends Error {
+      status: string
+      backendError: Record<string, JSONType>
+    }
+
+    /** Evaluator that references an LLM-as-a-judge evaluator configured in Datadog. */
+    interface RemoteEvaluator extends BaseEvaluator {}
+    interface ExperimentSummaryEvaluation extends EvaluatorResultOptions {
+      value: any
+      error: string | null
+    }
+
+    /** Base class for reusable synchronous or asynchronous record-level evaluators. */
+    interface BaseEvaluator {
+      readonly [baseEvaluatorBrand]: never
+      name: string
+      evaluate (context: EvaluatorContext): JSONType | EvaluatorResult | MultiEvaluatorResult | Promise<JSONType | EvaluatorResult | MultiEvaluatorResult>
+    }
+
+    /** Base class for reusable synchronous or asynchronous summary evaluators. */
+    interface BaseSummaryEvaluator {
+      readonly [baseSummaryEvaluatorBrand]: never
+      name: string
+      evaluate (context: SummaryEvaluatorContext): JSONType | EvaluatorResult | MultiEvaluatorResult | Promise<JSONType | EvaluatorResult | MultiEvaluatorResult>
+    }
+
     /**
      * A task run over each dataset record during an experiment.
      */
@@ -4061,26 +4195,25 @@ declare namespace tracer {
       metadata?: Record<string, JSONType>
     ) => JSONType | Promise<JSONType>
 
-    /**
-     * Scores a single task output. The return type selects the metric:
-     * `boolean` -> boolean, `number` -> score, `string` -> categorical, anything else -> json.
-     */
-    type ExperimentEvaluator = (
+    /** Scores a single task output. */
+    type ExperimentEvaluatorFunction = (
       input: JSONType,
       output: JSONType,
       expectedOutput: JSONType
-    ) => JSONType | Promise<JSONType>
+    ) => JSONType | EvaluatorResult | MultiEvaluatorResult | Promise<JSONType | EvaluatorResult | MultiEvaluatorResult>
 
-    /**
-     * Scores all rows in an experiment run and emits a summary metric.
-     */
-    type ExperimentSummaryEvaluator = (
-      inputs: any[],
-      outputs: any[],
-      expectedOutputs: any[],
-      evaluatorResults: Record<string, any[]>,
-      metadata?: Array<Record<string, any>>
-    ) => any | Promise<any>
+    type ExperimentEvaluator = ExperimentEvaluatorFunction | BaseEvaluator
+
+    /** Scores all rows in an experiment run and emits a summary metric. */
+    type ExperimentSummaryEvaluatorFunction = (
+      inputs: JSONType[],
+      outputs: JSONType[],
+      expectedOutputs: JSONType[],
+      evaluatorResults: Record<string, JSONType[]>,
+      metadata?: Array<Record<string, JSONType>>
+    ) => JSONType | EvaluatorResult | MultiEvaluatorResult | Promise<JSONType | EvaluatorResult | MultiEvaluatorResult>
+
+    type ExperimentSummaryEvaluator = ExperimentSummaryEvaluatorFunction | BaseSummaryEvaluator
 
     interface DatasetRecord {
       id: string | null
@@ -4111,9 +4244,9 @@ declare namespace tracer {
       task: ExperimentTask
       /** Override the configured project for this experiment. */
       projectName?: string
-      /** Evaluators keyed by metric label, or named functions. */
+      /** Evaluators keyed by metric label, or named functions or class instances. */
       evaluators?: Record<string, ExperimentEvaluator> | ExperimentEvaluator[]
-      /** Summary evaluators keyed by metric label, or named functions. */
+      /** Summary evaluators keyed by metric label, or named functions or class instances. */
       summaryEvaluators?: Record<string, ExperimentSummaryEvaluator> | ExperimentSummaryEvaluator[]
       description?: string
       config?: Record<string, JSONType>
@@ -4169,7 +4302,7 @@ declare namespace tracer {
       /** Whether this run had a task, row-evaluator, or summary-evaluator error. */
       hasError: boolean
       rows: ExperimentResultRow[]
-      summaryEvaluations: Record<string, { value: any, error: string | null }>
+      summaryEvaluations: Record<string, ExperimentSummaryEvaluation>
     }
 
     interface ExperimentResult {
@@ -4177,7 +4310,7 @@ declare namespace tracer {
       /** Rows from the first run, kept as a compatibility alias. */
       rows: ExperimentResultRow[]
       /** Summary evaluator results from the first run, kept as a compatibility alias. */
-      summaryEvaluations: Record<string, { value: any, error: string | null }>
+      summaryEvaluations: Record<string, ExperimentSummaryEvaluation>
       /** All experiment runs. */
       runs: ExperimentRun[]
       /** Dashboard URL for the experiment. */
@@ -4312,6 +4445,14 @@ declare namespace tracer {
     }
 
     interface Experiments {
+      BaseEvaluator: typeof BaseEvaluator
+      BaseSummaryEvaluator: typeof BaseSummaryEvaluator
+      EvaluatorContext: typeof EvaluatorContext
+      SummaryEvaluatorContext: typeof SummaryEvaluatorContext
+      EvaluatorResult: typeof EvaluatorResult
+      MultiEvaluatorResult: typeof MultiEvaluatorResult
+      RemoteEvaluator: typeof RemoteEvaluator
+      RemoteEvaluatorError: typeof RemoteEvaluatorError
       /** Create a local dataset buffer; pushed on the first experiment run. */
       createDataset (name: string, description?: string): Dataset
       createDataset (name: string, options?: CreateDatasetOptions): Dataset
@@ -4332,12 +4473,12 @@ declare namespace tracer {
       /**
        * The input content associated with the span.
        */
-      input: { content: string, role?: string }[]
+      input: { content: JSONType, role?: string }[]
 
       /**
        * The output content associated with the span.
        */
-      output: { content: string, role?: string }[]
+      output: { content: JSONType, role?: string }[]
 
       /**
        * Get a tag from the span.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "6.19.0",
+  "version": "6.20.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -190,7 +190,7 @@
   "optionalDependencies": {
     "@datadog/libdatadog": "^0.21.0",
     "@datadog/libdatadog-extras": "^0.21.0",
-    "@datadog/native-appsec": "11.0.2",
+    "@datadog/native-appsec": "11.0.3",
     "@datadog/native-iast-taint-tracking": "4.2.1",
     "@datadog/native-metrics": "4.0.0",
     "@datadog/pprof": "5.19.0",

package/packages/datadog-esbuild/index.js

@@ -165,8 +165,6 @@ ${build.initialOptions.banner.js}`
     log.warn('No git metadata available - skipping injection')
   }
 
-  // first time is intercepted, proxy should be created, next time the original should be loaded
-  const interceptedESMModules = new Set()
   let resolver
 
   build.onEnd(async () => {
@@ -217,11 +215,18 @@ ${build.initialOptions.banner.js}`
 
     const internal = builtins.has(args.path)
 
+    // Only the generated wrapper module, and the real module importing itself, must reach the real module unwrapped.
+    // Every other importer must get the wrapper regardless of whether it has already been loaded: onLoad runs
+    // concurrently with onResolve, so tracking loaded modules makes which importer sees the wrapper depend on timing,
+    // leaving some bindings uninstrumented. Routing a self-import to the wrapper would create a wrapper -> original ->
+    // wrapper cycle that can hit the wrapper's exports in their temporal dead zone.
+    const isInterceptedImporter = args.importer.endsWith(ESM_INTERCEPTED_SUFFIX) || args.importer === fullPathToModule
+
     if (args.namespace === 'file' && (
       modulesOfInterest.has(args.path) || modulesOfInterest.has(`${extracted.pkg}/${extracted.path}`))
     ) {
       // Internal module like http/fs is imported and the build output is ESM
-      if (internal && args.kind === 'import-statement' && esmBuild && !interceptedESMModules.has(fullPathToModule)) {
+      if (internal && args.kind === 'import-statement' && esmBuild && !isInterceptedImporter) {
         fullPathToModule = `${INTERNAL_ESM_INTERCEPTED_PREFIX}${fullPathToModule}${ESM_INTERCEPTED_SUFFIX}`
 
         return {
@@ -263,7 +268,7 @@ ${build.initialOptions.banner.js}`
         const packageJson = JSON.parse(fs.readFileSync(/** @type {string} */(pathToPackageJson)).toString())
 
         const isESM = isESMFile(fullPathToModule, pathToPackageJson, packageJson)
-        if (isESM && !interceptedESMModules.has(fullPathToModule)) {
+        if (isESM && !isInterceptedImporter) {
           fullPathToModule += ESM_INTERCEPTED_SUFFIX
         }
 
@@ -322,8 +327,6 @@ ${build.initialOptions.banner.js}`
             args.path = args.path.slice(INTERNAL_ESM_INTERCEPTED_PREFIX.length)
           }
 
-          interceptedESMModules.add(args.path)
-
           resolver ??= createEsmResolver()
           const setters = await processModule({
             path: args.path,

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

@@ -194,6 +194,32 @@ for (const hook of getHooks('ai').values()) {
       },
     })
 
+    tracingChannel('orchestrion:ai:includeRuntimeContext').subscribe({
+      start (ctx) {
+        const options = ctx.arguments[0]
+        const runtimeContext = options?.runtimeContext
+        const telemetry = options?.telemetry ?? options?.experimental_telemetry
+
+        if (!runtimeContext || typeof runtimeContext !== 'object' || telemetry?.isEnabled === false) return
+
+        const keys = Object.keys(runtimeContext)
+        if (!keys.length) return
+
+        const includeRuntimeContext = { ...telemetry?.includeRuntimeContext }
+        for (const key of keys) {
+          if (includeRuntimeContext[key] === undefined) includeRuntimeContext[key] = true
+        }
+
+        ctx.arguments[0] = {
+          ...options,
+          telemetry: {
+            ...telemetry,
+            includeRuntimeContext,
+          },
+        }
+      },
+    })
+
     // resolveLanguageModel is called by all LLM entry points (generateText, streamText,
     // generateObject, streamObject)
     tracingChannel('orchestrion:ai:resolveLanguageModel').subscribe({

package/packages/datadog-instrumentations/src/aws-sdk.js

@@ -198,11 +198,11 @@ function wrapSmithySend (send) {
     }
 
     return channels.start.runStores(ctx, () => {
-      // When the region is not set this never resolves so we can't await.
+      // Resolve region tags independently; send reports provider failures through its promise or callback.
       this.config.region().then(region => {
         ctx.region = region
         channels.region.publish(ctx)
-      })
+      }, () => {})
 
       if (cbExists) {
         args[args.length - 1] = shimmer.wrapCallback(cb, cb => function (err, result) {

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -2,12 +2,6 @@
 
 module.exports = {
   // Only list unprefixed node modules. They will automatically be instrumented as prefixed and unprefixed.
-  '@supabase/auth-js': { esmFirst: true, fn: () => require('../supabase') },
-  '@supabase/functions-js': { esmFirst: true, fn: () => require('../supabase') },
-  '@supabase/postgrest-js': { esmFirst: true, fn: () => require('../supabase') },
-  '@supabase/realtime-js': { esmFirst: true, fn: () => require('../supabase') },
-  '@supabase/storage-js': { esmFirst: true, fn: () => require('../supabase') },
-  '@supabase/supabase-js': { esmFirst: true, fn: () => require('../supabase') },
   child_process: () => require('../child_process'),
   crypto: () => require('../crypto'),
   dns: () => require('../dns'),
@@ -142,7 +136,6 @@ module.exports = {
   'pino-pretty': () => require('../pino'),
   playwright: () => require('../playwright'),
   'playwright-core': () => require('../playwright'),
-  postgres: { esmFirst: true, fn: () => require('../postgres') },
   'promise-js': () => require('../promise-js'),
   promise: () => require('../promise'),
   protobufjs: () => require('../protobufjs'),

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentation-registry.js

@@ -17,10 +17,10 @@ const registry = [
   { instrumentations: require('./instrumentations/modelcontextprotocol-sdk') },
   { instrumentations: require('./instrumentations/openai-agents') },
   { instrumentations: require('./instrumentations/playwright') },
-  { instrumentations: require('./instrumentations/postgres') },
+  { activate: true, instrumentations: require('./instrumentations/postgres') },
   { instrumentations: require('./instrumentations/webdriverio') },
   { instrumentations: require('./instrumentations/aws-durable-execution-sdk-js') },
-  { instrumentations: require('./instrumentations/supabase') },
+  { activate: true, instrumentations: require('./instrumentations/supabase') },
 ]
 
 const activatedModules = new Set()

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

@@ -88,6 +88,31 @@ module.exports = [
     },
     channelName: 'resolveLanguageModel',
   },
+  // AI SDK v7 filters runtime context from tracing channel events unless each key is included.
+  {
+    module: {
+      name: 'ai',
+      versionRange: '>=7.0.0',
+      filePath: 'dist/index.js',
+    },
+    functionQuery: {
+      functionName: 'generateText',
+      kind: 'Async',
+    },
+    channelName: 'includeRuntimeContext',
+  },
+  {
+    module: {
+      name: 'ai',
+      versionRange: '>=7.0.0',
+      filePath: 'dist/index.js',
+    },
+    functionQuery: {
+      functionName: 'streamText',
+      kind: 'Sync',
+    },
+    channelName: 'includeRuntimeContext',
+  },
   {
     module: {
       name: 'ai',

package/packages/datadog-plugin-openai/src/stream-helpers.js

@@ -17,7 +17,13 @@
  * @typedef {JsonObject & { choices: Array<StreamChoice | undefined>, usage?: unknown }} StreamResponseBody
  *
  * @typedef {JsonObject & { status?: string }} ResponsesApiResponse
- * @typedef {JsonObject & { response?: ResponsesApiResponse }} ResponsesApiChunk
+ * @typedef {JsonObject & {
+ *   type?: string,
+ *   response?: ResponsesApiResponse,
+ *   output_index?: number,
+ *   item?: JsonObject,
+ *   delta?: string
+ * }} ResponsesApiChunk
  */
 
 /**
@@ -143,12 +149,55 @@ function constructResponseResponseFromStreamedChunks (chunks) {
   // Find the last chunk with a complete response object (status: done, incomplete, or completed)
   const responseStatusSet = new Set(['done', 'incomplete', 'completed'])
 
+  let latestResponse
   for (let i = chunks.length - 1; i >= 0; i--) {
     const chunk = chunks[i]
     if (chunk.response && responseStatusSet.has(chunk.response.status)) {
       return chunk.response
     }
+    latestResponse ??= chunk.response
   }
+
+  // A stream that ends early (e.g. aborted by the caller) never sends a final response,
+  // so rebuild a partial one from the output streamed so far, as the chat helpers do.
+  if (latestResponse) {
+    return { ...latestResponse, output: constructPartialResponseOutput(chunks) }
+  }
+}
+
+/**
+ * Rebuilds the output items of a Responses API stream that ended before its final response.
+ * Items are shallow-copied so the chunks handed to the application are not mutated.
+ * @param {ResponsesApiChunk[]} chunks
+ * @returns {JsonObject[]}
+ */
+function constructPartialResponseOutput (chunks) {
+  const output = []
+
+  for (const chunk of chunks) {
+    const index = chunk.output_index
+    if (index === undefined) continue
+
+    const item = output[index]
+
+    switch (chunk.type) {
+      case 'response.output_item.added':
+      case 'response.output_item.done':
+        output[index] = { ...chunk.item }
+        break
+      case 'response.output_text.delta':
+        if (item) {
+          const text = (item.content?.[0]?.text ?? '') + (chunk.delta ?? '')
+          item.content = [{ type: 'output_text', text }]
+        }
+        break
+      case 'response.function_call_arguments.delta':
+        if (item) item.arguments = (item.arguments ?? '') + (chunk.delta ?? '')
+        break
+    }
+  }
+
+  return output.filter(Boolean)
 }
 
 module.exports = {

package/packages/dd-trace/src/config/generated-config-types.d.ts

@@ -416,6 +416,7 @@ export interface GeneratedConfig {
   dynamicInstrumentation: {
     DD_DYNAMIC_INSTRUMENTATION_CAPTURE_TIMEOUT_MS: number;
     DD_DYNAMIC_INSTRUMENTATION_ENABLED: boolean;
+    DD_DYNAMIC_INSTRUMENTATION_EVALUATION_TIMEOUT_MS: number;
     DD_DYNAMIC_INSTRUMENTATION_PROBE_FILE: string | undefined;
     DD_DYNAMIC_INSTRUMENTATION_REDACTED_IDENTIFIERS: string[];
     DD_DYNAMIC_INSTRUMENTATION_REDACTION_EXCLUDED_IDENTIFIERS: string[];
@@ -434,6 +435,7 @@ export interface GeneratedConfig {
     DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_POLL_INTERVAL_SECONDS: number;
     DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_REQUEST_TIMEOUT_SECONDS: number;
     DD_FEATURE_FLAGS_ENABLED: boolean;
+    DD_FLAGGING_EVALUATION_COUNTS_ENABLED: boolean;
   };
   flushInterval: number;
   flushMinSpans: number;
@@ -690,6 +692,7 @@ export interface GeneratedEnvVarConfig {
   DD_DURABLE_CROSS_INVOCATION_TRACING_ENABLED: boolean;
   DD_DYNAMIC_INSTRUMENTATION_CAPTURE_TIMEOUT_MS: number;
   DD_DYNAMIC_INSTRUMENTATION_ENABLED: boolean;
+  DD_DYNAMIC_INSTRUMENTATION_EVALUATION_TIMEOUT_MS: number;
   DD_DYNAMIC_INSTRUMENTATION_PROBE_FILE: string | undefined;
   DD_DYNAMIC_INSTRUMENTATION_REDACTED_IDENTIFIERS: string[];
   DD_DYNAMIC_INSTRUMENTATION_REDACTION_EXCLUDED_IDENTIFIERS: string[];
@@ -715,6 +718,7 @@ export interface GeneratedEnvVarConfig {
   DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_POLL_INTERVAL_SECONDS: number;
   DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_REQUEST_TIMEOUT_SECONDS: number;
   DD_FEATURE_FLAGS_ENABLED: boolean;
+  DD_FLAGGING_EVALUATION_COUNTS_ENABLED: boolean;
   DD_GIT_BRANCH: string | undefined;
   DD_GIT_COMMIT_AUTHOR_DATE: string | undefined;
   DD_GIT_COMMIT_AUTHOR_EMAIL: string | undefined;

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

@@ -148,6 +148,18 @@ function enable (rc, config, onConfigUpdated) {
   // APM_TRACING product (e.g. an org-level and a service-level config) and merges them by priority.
   rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_MULTICONFIG, true)
 
+  // Keep advertising the legacy per-setting capabilities while the backend and UI still use them
+  // to determine which settings are editable. Values are delivered through sdk_config below.
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_ENABLED, true)
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_SAMPLE_RATE, true)
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_SAMPLE_RULES, true)
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_CUSTOM_TAGS, true)
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_HTTP_HEADER_TAGS, true)
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_LOGS_INJECTION, true)
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_ENABLE_DYNAMIC_INSTRUMENTATION, true)
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_ENABLE_LIVE_DEBUGGING, true)
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_ENABLE_CODE_ORIGIN, true)
+
   // This tracer supports receiving the full SDK_CONFIGURATION settings map, env-var-keyed.
   rc.updateCapabilities(RemoteConfigCapabilities.SDK_CONFIGURATION, true)
 

package/packages/dd-trace/src/config/supported-configurations.json

@@ -820,6 +820,18 @@
         "default": "false"
       }
     ],
+    "DD_DYNAMIC_INSTRUMENTATION_EVALUATION_TIMEOUT_MS": [
+      {
+        "implementation": "A",
+        "type": "int",
+        "namespace": "dynamicInstrumentation",
+        "configurationNames": [
+          "dynamicInstrumentation.evaluationTimeoutMs"
+        ],
+        "default": "50",
+        "allowed": "\\d+"
+      }
+    ],
     "DD_DYNAMIC_INSTRUMENTATION_PROBE_FILE": [
       {
         "implementation": "B",
@@ -973,6 +985,15 @@
         "namespace": "featureFlags"
       }
     ],
+    "DD_FLAGGING_EVALUATION_COUNTS_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "true",
+        "description": "Enable aggregated Feature Flagging evaluation telemetry.",
+        "namespace": "featureFlags"
+      }
+    ],
     "DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED": [
       {
         "implementation": "B",

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

@@ -1,5 +1,13 @@
 'use strict'
 
+const WORKER_ERROR_REASON = Object.freeze({
+  UNEXPECTED_PAUSE_REASON: 'unexpected_pause_reason',
+  UNSUPPORTED_PROBE_TYPE: 'unsupported_probe_type',
+  UNSUPPORTED_INSERTION_POINT: 'unsupported_insertion_point',
+  CONFLICTING_CAPTURE_OPTIONS: 'conflicting_capture_options',
+  UNKNOWN_REMOTE_CONFIG_ACTION: 'unknown_remote_config_action',
+})
+
 module.exports = {
   DEFAULT_QUEUE_MAX_BYTES: 10 * 1024 * 1024,
   DIAGNOSTICS_QUEUE_MAX_BYTES: 1024 * 1024,
@@ -10,10 +18,11 @@ module.exports = {
   DEBUGGER_INPUT_V1: '/debugger/v1/input',
   DEBUGGER_INPUT_V2: '/debugger/v2/input',
 
-  // Guardrail counters are aggregated in shared memory and only converted into telemetry metrics at this interval, so
-  // the interval bounds the delay before a guardrail hit becomes visible, not the cost of recording it. Tests wait on
-  // it, so it is shared rather than duplicated.
-  GUARDRAIL_METRICS_FLUSH_INTERVAL_MS: 10_000,
+  // Guardrail counters and pause durations are aggregated in shared memory and only converted into telemetry metrics
+  // at this interval, so the interval bounds the delay before they become visible, not the cost of recording them.
+  // Tests wait on it, so it is shared rather than duplicated.
+  METRICS_FLUSH_INTERVAL_MS: 10_000,
 
   INSPECT_SEGMENT_GLOBAL_PROPERTY: 'debuggerInspectSegment',
+  WORKER_ERROR_REASON,
 }

package/packages/dd-trace/src/debugger/devtools_client/breakpoints.js

@@ -4,7 +4,13 @@ const createMutex = require('../../../../../vendor/dist/mutexify/promise')
 const mutex = createMutex()
 const { getGeneratedPosition } = require('./source-maps')
 const session = require('./session')
-const { compile, compileSegments, templateRequiresEvaluation } = require('./condition')
+const {
+  compile,
+  compileSegments,
+  getRedactionError,
+  getSegmentRedactionErrors,
+  templateRequiresEvaluation,
+} = require('./condition')
 const { MAX_SNAPSHOTS_PER_SECOND_PER_PROBE, MAX_NON_SNAPSHOTS_PER_SECOND_PER_PROBE } = require('./defaults')
 const {
   compileBreakpointCondition,
@@ -78,6 +84,7 @@ async function addBreakpoint (probe) {
   probe.templateRequiresEvaluation = templateRequiresEvaluation(probe.segments)
   if (probe.templateRequiresEvaluation) {
     probe.template = compileSegments(probe.segments)
+    probe.templateRedactionErrors = getSegmentRedactionErrors(probe.segments)
   }
   delete probe.segments
 
@@ -128,6 +135,12 @@ async function addBreakpoint (probe) {
   if (probe.captureExpressions?.length > 0) {
     probe.compiledCaptureExpressions = []
     for (const captureExpr of probe.captureExpressions) {
+      const redactionError = getRedactionError(captureExpr.name, captureExpr.expr.json)
+      if (redactionError !== undefined) {
+        probe.compiledCaptureExpressions.push({ name: captureExpr.name, redactionError })
+        continue
+      }
+
       let expression
       try {
         expression = compile(captureExpr.expr.json)