dd-trace 6.8.0 → 6.9.0

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

@@ -579,6 +579,7 @@ export interface GeneratedConfig {
     DD_TEST_LOCAL_CONFIG_PATH: string | undefined;
     DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES: number;
     DD_TEST_MANAGEMENT_ENABLED: boolean;
+    DD_TEST_MANAGEMENT_REPORT_ENABLED: boolean | undefined;
   };
   traceId128BitGenerationEnabled: boolean;
   traceId128BitLoggingEnabled: boolean;
@@ -821,6 +822,7 @@ export interface GeneratedEnvVarConfig {
   DD_TEST_LOCAL_CONFIG_PATH: string | undefined;
   DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES: number;
   DD_TEST_MANAGEMENT_ENABLED: boolean;
+  DD_TEST_MANAGEMENT_REPORT_ENABLED: boolean | undefined;
   DD_TEST_SESSION_NAME: string | undefined;
   DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED: boolean;
   DD_TRACE_128_BIT_TRACEID_LOGGING_ENABLED: boolean;

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

@@ -307,6 +307,8 @@ module.exports = {
    *
    * This should only be called once in config.js to avoid copying the object frequently.
    *
+   * @param {typeof process.env} [source] The environment to read from
+   * @param {boolean} [internalOnly] Only return configurations marked as internal
    * @returns {TracerEnv} The environment variables
    */
   getEnvironmentVariables (source = process.env, internalOnly = false) {

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

@@ -4,6 +4,7 @@ const fs = require('node:fs')
 const os = require('node:os')
 const { URL, format } = require('node:url')
 
+const exporters = require('../../../../ext/exporters')
 const rfdc = require('../../../../vendor/dist/rfdc')({ proto: false, circles: false })
 const uuid = require('../../../../vendor/dist/crypto-randomuuid') // we need to keep the old uuid dep because of cypress
 const set = require('../../../datadog-core/src/utils/src/set')
@@ -41,6 +42,13 @@ const { normalizeService } = require('./normalize-service')
 const { programmaticTypeCoercions, transformers } = require('./parsers')
 
 const RUNTIME_ID = uuid()
+const TEST_OPTIMIZATION_WORKER_EXPORTERS = new Set([
+  exporters.CUCUMBER_WORKER,
+  exporters.JEST_WORKER,
+  exporters.MOCHA_WORKER,
+  exporters.PLAYWRIGHT_WORKER,
+  exporters.VITEST_WORKER,
+])
 
 const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
 
@@ -194,8 +202,11 @@ class Config extends ConfigBase {
     this.debug = log.configure(options)
 
     // Process stable config warnings, if any
-    for (const warning of this.stableConfig?.warnings ?? []) {
-      log.warn(warning)
+    const stableConfigWarnings = this.stableConfig?.warnings
+    if (stableConfigWarnings) {
+      for (const warning of stableConfigWarnings) {
+        log.warn(warning)
+      }
     }
 
     this.#applyDefaults()
@@ -593,9 +604,9 @@ class Config extends ConfigBase {
       setAndTrack(this, 'remoteConfig.DD_REMOTE_CONFIGURATION_ENABLED', false)
     }
 
-    // TODO: Should this unconditionally be disabled?
-    if (getEnvironmentVariable('JEST_WORKER_ID') &&
-        !trackedConfigOrigins.has('telemetry.DD_INSTRUMENTATION_TELEMETRY_ENABLED')) {
+    const isTestOptimizationWorker = this.isCiVisibility &&
+      TEST_OPTIMIZATION_WORKER_EXPORTERS.has(this.experimental.exporter)
+    if (isTestOptimizationWorker) {
       setAndTrack(this, 'telemetry.DD_INSTRUMENTATION_TELEMETRY_ENABLED', false)
     }
 

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

@@ -236,7 +236,7 @@ const optionLookupTable = {
 
 const transformers = {
   tracing_sampling_rules (samplingRules) {
-    for (const rule of (samplingRules || [])) {
+    for (const rule of samplingRules) {
       if (rule.tags) {
         const reformattedTags = {}
         for (const tag of rule.tags) {

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

@@ -1941,6 +1941,14 @@
         "namespace": "testOptimization"
       }
     ],
+    "DD_TEST_MANAGEMENT_REPORT_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": null,
+        "namespace": "testOptimization"
+      }
+    ],
     "DD_TEST_SESSION_NAME": [
       {
         "implementation": "A",

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

@@ -32,7 +32,7 @@ const STATUSES = {
   INSTALLED: 'INSTALLED',
   EMITTING: 'EMITTING',
   ERROR: 'ERROR',
-  BLOCKED: 'BLOCKED', // TODO: Implement once support for allow list, deny list or max probe limit has been added
+  // TODO: Add BLOCKED once support for allow list, deny list or max probe limit has been added
 }
 
 function ackReceived ({ id: probeId, version }) {

package/packages/dd-trace/src/encode/coverage-ci-visibility.js

@@ -110,7 +110,6 @@ class CoverageCIVisibilityEncoder extends AgentEncoder {
   _encodePayloadStart (bytes) {
     const payload = {
       version: COVERAGE_PAYLOAD_VERSION,
-      coverages: [],
     }
     bytes.writeMapPrefix(COVERAGE_KEYS_LENGTH)
     this._encodeString(bytes, 'version')

package/packages/dd-trace/src/guardrails/apply-pm2-env.js

@@ -0,0 +1,16 @@
+'use strict'
+
+// In PM2 cluster mode, per-app env vars arrive as a `pm2_env`
+// JSON string after preloads have run, so extract them first.
+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 key = pm2Keys[i]
+      var value = pm2Config[key]
+      process.env[key] = String(value)
+    }
+  } catch (error) {}
+}

package/packages/dd-trace/src/guardrails/log.js

@@ -2,21 +2,12 @@
 
 /* eslint-disable no-console */
 
+var logLevels = require('../log/levels')
 var isTrue = require('./util').isTrue
 
 var DD_TRACE_DEBUG = process.env.DD_TRACE_DEBUG
 var DD_TRACE_LOG_LEVEL = process.env.DD_TRACE_LOG_LEVEL
 
-var logLevels = {
-  trace: 20,
-  debug: 20,
-  info: 30,
-  warn: 40,
-  error: 50,
-  critical: 50,
-  off: 100
-}
-
 var logLevel = isTrue(DD_TRACE_DEBUG)
   ? Number(DD_TRACE_LOG_LEVEL) || logLevels.debug
   : logLevels.off

package/packages/dd-trace/src/llmobs/eval-metric.js

@@ -0,0 +1,249 @@
+'use strict'
+
+const tracerVersion = require('../../../../package.json').version
+
+/**
+ * Kind of event submitted through the evaluation metrics intake. Both kinds share the
+ * writer, the endpoint and most of their validation, and are told apart on the wire by
+ * the `event_kind` field.
+ * @typedef {'evaluation' | 'feedback'} MetricEventKind
+ */
+
+/**
+ * Tag value the intake accepts: a string, a nullish value, or anything the SDK can coerce
+ * through `toString()`.
+ * @typedef {string | null | undefined | { toString?: unknown }} MetricTagValue
+ */
+
+/** @type {string[]} */
+const EVALUATION_METRIC_TYPES = ['categorical', 'score', 'boolean', 'json']
+
+/**
+ * End-user feedback additionally accepts free-form text values.
+ * @type {string[]}
+ */
+const FEEDBACK_METRIC_TYPES = [...EVALUATION_METRIC_TYPES, 'text']
+
+/** @type {Record<MetricEventKind, string[]>} */
+const METRIC_TYPES = {
+  evaluation: EVALUATION_METRIC_TYPES,
+  feedback: FEEDBACK_METRIC_TYPES,
+}
+
+/**
+ * Feedback target option accepted by the SDK, mapped to the payload key it is sent as. `span` and
+ * `spanId` are two ways of naming the same target.
+ * @type {Record<string, string>}
+ */
+const FEEDBACK_TARGET_KEYS = {
+  span: 'span_id',
+  spanId: 'span_id',
+  traceId: 'trace_id',
+  sessionId: 'session_id',
+  feedbackJoinKey: 'feedback_join_key',
+}
+
+// The validation is shared but the user-facing wording is per-kind. Keeping the terms in one
+// table avoids threading three near-identical strings through every validator.
+/** @type {Record<MetricEventKind, { metric: string, metrics: string, data: string }>} */
+const TERMS = {
+  evaluation: {
+    metric: 'evaluation metric',
+    metrics: 'evaluation metrics',
+    data: 'Evaluation metric data',
+  },
+  feedback: {
+    metric: 'feedback metric',
+    metrics: 'feedback metrics',
+    data: 'Feedback data',
+  },
+}
+
+/**
+ * @param {string[]} metricTypes
+ * @returns {string} the quoted list, e.g. `"categorical", "score" or "json"`
+ */
+function formatMetricTypes (metricTypes) {
+  const quoted = metricTypes.map(metricType => `"${metricType}"`)
+  return `${quoted.slice(0, -1).join(', ')} or ${quoted.at(-1)}`
+}
+
+// Built once at load time: only ever used to build an error message.
+/** @type {Record<MetricEventKind, string>} */
+const METRIC_TYPES_MESSAGE = {
+  evaluation: formatMetricTypes(EVALUATION_METRIC_TYPES),
+  feedback: formatMetricTypes(FEEDBACK_METRIC_TYPES),
+}
+
+/**
+ * Builds an error carrying the telemetry error tag the SDK reports for the failed submission.
+ * @param {string} errorTag - Telemetry `error_type` tag value.
+ * @param {string} message - User-facing message.
+ * @returns {Error} the tagged error, to be thrown by the caller.
+ */
+function taggedError (errorTag, message) {
+  const error = new Error(message)
+  // Same shape as the tagger's failures, which the SDK already reads back as `e.ddErrorTag`.
+  Object.defineProperty(error, 'ddErrorTag', { get () { return errorTag } })
+  return error
+}
+
+/**
+ * @param {MetricEventKind} kind
+ * @returns {Error} the tagged error, to be thrown by the caller.
+ */
+function invalidTagsError (kind) {
+  return taggedError('invalid_tags', `Failed to parse tags. Tags for ${TERMS[kind].metrics} must be strings`)
+}
+
+/**
+ * @param {unknown} timestampMs
+ * @param {MetricEventKind} kind
+ * @returns {void}
+ */
+function validateTimestamp (timestampMs, kind) {
+  if (typeof timestampMs !== 'number' || timestampMs < 0) {
+    throw taggedError(
+      'invalid_timestamp',
+      `timestampMs must be a non-negative integer. ${TERMS[kind].data} will not be sent`
+    )
+  }
+}
+
+/**
+ * Validates the label and returns it as sent on the wire.
+ * @param {unknown} label
+ * @param {MetricEventKind} kind
+ * @returns {unknown} the label, coerced to a string for feedback and left untouched for evaluations.
+ */
+function validateLabel (label, kind) {
+  if (!label) {
+    throw taggedError('invalid_metric_label', `label must be the specified name of the ${TERMS[kind].metric}`)
+  }
+
+  // Evaluations keep the looser check they shipped with: a dotted or non-string label reaches the
+  // intake as-is. Aligning them with feedback rejects calls that succeed today, so it is deferred.
+  if (kind === 'evaluation') return label
+
+  // A dot makes the label unusable as a facet key.
+  const labelValue = String(label)
+  if (labelValue.includes('.')) {
+    throw taggedError('invalid_label_value', 'label value must not contain a "."')
+  }
+
+  return labelValue
+}
+
+/**
+ * @param {string | undefined} metricType - Already lower-cased metric type.
+ * @param {MetricEventKind} kind
+ * @returns {void}
+ */
+function validateMetricType (metricType, kind) {
+  if (!metricType || !METRIC_TYPES[kind].includes(metricType)) {
+    throw taggedError('invalid_metric_type', `metricType must be one of ${METRIC_TYPES_MESSAGE[kind]}`)
+  }
+}
+
+/**
+ * @param {string | undefined} metricType - Metric type already validated for the submitted kind.
+ * @param {unknown} value
+ * @returns {void}
+ */
+function validateMetricValue (metricType, value) {
+  if (metricType === 'categorical' && typeof value !== 'string') {
+    throw taggedError('invalid_metric_value', 'value must be a string for a categorical metric.')
+  }
+  if (metricType === 'score' && typeof value !== 'number') {
+    throw taggedError('invalid_metric_value', 'value must be a number for a score metric.')
+  }
+  if (metricType === 'boolean' && typeof value !== 'boolean') {
+    throw taggedError('invalid_metric_value', 'value must be a boolean for a boolean metric')
+  }
+  if (metricType === 'json' && (typeof value !== 'object' || value == null || Array.isArray(value))) {
+    throw taggedError('invalid_metric_value', 'value must be a JSON object for a json metric')
+  }
+  if (metricType === 'text' && typeof value !== 'string') {
+    throw taggedError('invalid_metric_value', 'value must be a string for a text metric')
+  }
+}
+
+/**
+ * @param {unknown} assessment
+ * @returns {void}
+ */
+function validateAssessment (assessment) {
+  if (assessment != null && assessment !== 'pass' && assessment !== 'fail') {
+    throw taggedError('invalid_assessment', 'assessment must be pass or fail')
+  }
+}
+
+/**
+ * @param {unknown} reasoning
+ * @returns {void}
+ */
+function validateReasoning (reasoning) {
+  if (reasoning != null && typeof reasoning !== 'string') {
+    throw taggedError('invalid_reasoning', 'reasoning must be a string')
+  }
+}
+
+/**
+ * Serializes the user-provided tags into the `key:value` list expected by the intake, along
+ * with the tags every submission carries.
+ * @param {Record<string, MetricTagValue> | undefined} tags - User-provided tags, coerced when not strings.
+ * @param {string} mlApp - Resolved ML app name.
+ * @param {MetricEventKind} kind
+ * @param {boolean} [otelEnabled] - Adds `source:otel` so the backend waits for OTel span conversion.
+ * @returns {string[]} the serialized tag list.
+ */
+function buildMetricTags (tags, mlApp, kind, otelEnabled = false) {
+  // An array or a string would otherwise be walked by index and produce tags named after
+  // their offsets, which the intake would happily store.
+  if (tags != null && (typeof tags !== 'object' || Array.isArray(tags))) {
+    throw invalidTagsError(kind)
+  }
+
+  const metricTags = {
+    'ddtrace.version': tracerVersion,
+    ml_app: mlApp,
+  }
+
+  if (tags) {
+    for (const key of Object.keys(tags)) {
+      const tag = tags[key]
+      if (typeof tag === 'string') {
+        metricTags[key] = tag
+      } else if (tag == null) {
+        // A nullish value can be intentional, so it is serialized rather than rejected. Checked
+        // before the `toString` lookup below, which would throw a raw TypeError on it.
+        metricTags[key] = String(tag)
+      } else if (typeof tag.toString === 'function') {
+        metricTags[key] = tag.toString()
+      } else {
+        // Every other value carries a `toString`, either its own or the one inherited from
+        // `Object.prototype`, so this is only reached for a null-prototype object.
+        throw invalidTagsError(kind)
+      }
+    }
+  }
+
+  if (otelEnabled) {
+    metricTags.source = 'otel'
+  }
+
+  return Object.entries(metricTags).map(([key, value]) => `${key}:${value}`)
+}
+
+module.exports = {
+  EVALUATION_METRIC_TYPES,
+  FEEDBACK_METRIC_TYPES,
+  FEEDBACK_TARGET_KEYS,
+  buildMetricTags,
+  validateAssessment,
+  validateLabel,
+  validateMetricType,
+  validateMetricValue,
+  validateReasoning,
+  validateTimestamp,
+}

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

@@ -47,15 +47,17 @@ class Experiments {
       : (descriptionOrOptions ?? {})
     const dataset = new Dataset(this.#client, name, options.description ?? '')
     const recordIds = new Set()
-    for (const record of options.records ?? []) {
-      if (record.id !== undefined && (typeof record.id !== 'string' || record.id.length === 0)) {
-        throw new Error('record id must be a non-empty string')
-      }
-      if (record.id !== undefined) {
-        if (recordIds.has(record.id)) throw new Error(`Duplicate record id '${record.id}'`)
-        recordIds.add(record.id)
+    if ((options.records) != null) {
+      for (const record of options.records) {
+        if (record.id !== undefined && (typeof record.id !== 'string' || record.id.length === 0)) {
+          throw new Error('record id must be a non-empty string')
+        }
+        if (record.id !== undefined) {
+          if (recordIds.has(record.id)) throw new Error(`Duplicate record id '${record.id}'`)
+          recordIds.add(record.id)
+        }
+        dataset.addRecord(new DatasetRecord(record.inputData, record.expectedOutput, record.metadata, record.id))
       }
-      dataset.addRecord(new DatasetRecord(record.inputData, record.expectedOutput, record.metadata, record.id))
     }
     return dataset
   }
@@ -82,13 +84,16 @@ class Experiments {
             'GET',
             `${API_BASE_PATH}/${projectId}/datasets?filter[name]=${encodeURIComponent(name)}`
           )
-          for (const item of listed?.data ?? []) {
-            if (item?.attributes?.name === name) {
-              datasetId = String(item?.id ?? '')
-              description = String(item?.attributes?.description ?? '')
-              latestVersion = item?.attributes?.current_version ?? null
-              datasetVersion = version ?? latestVersion
-              break
+          const datasets = listed?.data
+          if (datasets) {
+            for (const item of datasets) {
+              if (item?.attributes?.name === name) {
+                datasetId = String(item?.id ?? '')
+                description = String(item?.attributes?.description ?? '')
+                latestVersion = item?.attributes?.current_version ?? null
+                datasetVersion = version ?? latestVersion
+                break
+              }
             }
           }
           if (datasetId === null) return false
@@ -107,16 +112,19 @@ class Experiments {
             'GET',
             `${API_BASE_PATH}/${projectId}/datasets/${datasetId}/records?${query.toString()}`
           )
-          for (const item of resp?.data ?? []) {
-            const attrs = item?.attributes ?? item
-            const recordId = String(item?.id ?? attrs?.id ?? '')
-            recs.push(new DatasetRecord(
-              attrs?.input ?? null,
-              attrs?.expected_output ?? null,
-              attrs?.metadata ?? {},
-              recordId === '' ? null : recordId
-            ))
-            ids.push(recordId)
+          const recordData = resp?.data
+          if (recordData) {
+            for (const item of recordData) {
+              const attrs = item?.attributes ?? item
+              const recordId = String(item?.id ?? attrs?.id ?? '')
+              recs.push(new DatasetRecord(
+                attrs?.input ?? null,
+                attrs?.expected_output ?? null,
+                attrs?.metadata ?? {},
+                recordId === '' ? null : recordId
+              ))
+              ids.push(recordId)
+            }
           }
           cursor = resp?.meta?.after ?? ''
           if (!cursor) break

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

@@ -166,8 +166,10 @@ function stringify (value) {
  */
 function buildTags (userTags, autoTags) {
   const tags = new Map()
-  for (const [key, value] of Object.entries(userTags ?? {})) {
-    tags.set(key, `${key}:${value}`)
+  if ((userTags) != null) {
+    for (const [key, value] of Object.entries(userTags)) {
+      tags.set(key, `${key}:${value}`)
+    }
   }
   for (const [key, value] of Object.entries(autoTags)) {
     if (value !== undefined && value !== null && value !== '') tags.set(key, `${key}:${value}`)

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

@@ -80,6 +80,8 @@ class NoopLLMObs {
 
   submitEvaluation (llmobsSpanContext, options) {}
 
+  submitFeedback (options) {}
+
   flush () {}
 
   registerProcessor (processor) {}

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

@@ -118,7 +118,7 @@ class DdTelemetryPlugin extends BaseLLMObsPlugin {
    * @returns {string | undefined}
    */
   findToolName (toolName, toolDescription) {
-    if (Number.isNaN(Number.parseInt(toolName))) return toolName
+    if (Number.isNaN(Number.parseInt(toolName, 10))) return toolName
 
     for (const availableTool of this.#availableTools) {
       const description = availableTool.description

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

@@ -322,7 +322,7 @@ function getToolNameFromTags (tags) {
   const toolName = tags['ai.toolCall.name']
   if (!toolName) return null
 
-  const parsedToolName = Number.parseInt(toolName)
+  const parsedToolName = Number.parseInt(toolName, 10)
   if (!Number.isNaN(parsedToolName)) return null
 
   return toolName

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

@@ -72,10 +72,10 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
       const cacheWriteTokenCount = headers['x-amzn-bedrock-cache-write-input-token-count']
 
       pendingTokenHeaders.set(requestId, {
-        inputTokensFromHeaders: inputTokenCount && Number.parseInt(inputTokenCount),
-        outputTokensFromHeaders: outputTokenCount && Number.parseInt(outputTokenCount),
-        cacheReadTokensFromHeaders: cacheReadTokenCount && Number.parseInt(cacheReadTokenCount),
-        cacheWriteTokensFromHeaders: cacheWriteTokenCount && Number.parseInt(cacheWriteTokenCount),
+        inputTokensFromHeaders: inputTokenCount && Number.parseInt(inputTokenCount, 10),
+        outputTokensFromHeaders: outputTokenCount && Number.parseInt(outputTokenCount, 10),
+        cacheReadTokensFromHeaders: cacheReadTokenCount && Number.parseInt(cacheReadTokenCount, 10),
+        cacheWriteTokensFromHeaders: cacheWriteTokenCount && Number.parseInt(cacheWriteTokenCount, 10),
       })
     })
 
@@ -138,7 +138,7 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
   #tagCommon ({ span, requestParams, textAndResponseReason, tokensFromHeaders }) {
     this._tagger.tagMetadata(span, {
       temperature: Number.parseFloat(requestParams.temperature) || 0,
-      max_tokens: Number.parseInt(requestParams.maxTokens) || 0,
+      max_tokens: Number.parseInt(requestParams.maxTokens, 10) || 0,
     })
     this._tagger.tagLLMIO(span, requestParams.prompt, textAndResponseReason.messages)
     this._tagger.tagMetrics(span, extractTokens({

package/packages/dd-trace/src/llmobs/plugins/langchain/index.js

@@ -113,7 +113,7 @@ class BaseLangChainLLMObsPlugin extends LLMObsPlugin {
     }
 
     if (maxTokens) {
-      metadata.maxTokens = Number.parseInt(maxTokens)
+      metadata.maxTokens = Number.parseInt(maxTokens, 10)
     }
 
     this._tagger.tagMetadata(span, metadata)