dd-trace 5.97.0 → 5.99.0

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

@@ -78,7 +78,7 @@ export interface GeneratedConfig {
   DD_AZURE_RESOURCE_GROUP: string | undefined;
   DD_CIVISIBILITY_AGENTLESS_ENABLED: boolean;
   DD_CIVISIBILITY_AGENTLESS_URL: string | undefined;
-  DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER: boolean;
+  DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER: string | undefined;
   DD_CIVISIBILITY_DANGEROUSLY_FORCE_COVERAGE: boolean;
   DD_CIVISIBILITY_DANGEROUSLY_FORCE_TEST_SKIPPING: boolean;
   DD_CIVISIBILITY_ENABLED: boolean;
@@ -297,6 +297,7 @@ export interface GeneratedConfig {
   DD_TRACE_MIDDIE_ENABLED: boolean;
   DD_TRACE_MOCHA_EACH_ENABLED: boolean;
   DD_TRACE_MOCHA_ENABLED: boolean;
+  DD_TRACE_MODELCONTEXTPROTOCOL_SDK_ENABLED: boolean;
   DD_TRACE_MOLECULER_ENABLED: boolean;
   DD_TRACE_MONGODB_CORE_ENABLED: boolean;
   DD_TRACE_MONGODB_ENABLED: boolean;
@@ -478,30 +479,34 @@ export interface GeneratedConfig {
   };
   openAiLogsEnabled: boolean;
   OTEL_EXPORTER_OTLP_ENDPOINT: string | undefined;
+  OTEL_EXPORTER_OTLP_HEADERS: Record<string, string> | undefined;
+  OTEL_EXPORTER_OTLP_LOGS_HEADERS: Record<string, string> | undefined;
+  OTEL_EXPORTER_OTLP_METRICS_HEADERS: Record<string, string> | undefined;
+  OTEL_EXPORTER_OTLP_TRACES_ENDPOINT: string;
+  OTEL_EXPORTER_OTLP_TRACES_HEADERS: Record<string, string> | undefined;
+  OTEL_EXPORTER_OTLP_TRACES_PROTOCOL: "http/json";
+  OTEL_EXPORTER_OTLP_TRACES_TIMEOUT: number;
   OTEL_LOGS_EXPORTER: "none" | "otlp" | undefined;
   OTEL_METRICS_EXPORTER: "none" | "otlp" | undefined;
   OTEL_RESOURCE_ATTRIBUTES: Record<string, string>;
   OTEL_SDK_DISABLED: boolean;
-  OTEL_TRACES_EXPORTER: "none" | "otlp";
+  OTEL_TRACES_EXPORTER: "none" | "otlp" | undefined;
   OTEL_TRACES_SAMPLER: "always_on" | "always_off" | "traceidratio" | "parentbased_always_on" | "parentbased_always_off" | "parentbased_traceidratio";
   OTEL_TRACES_SAMPLER_ARG: number | undefined;
   otelBatchTimeout: number;
-  otelHeaders: string | undefined;
   otelLogsEnabled: boolean;
-  otelLogsHeaders: string | undefined;
   otelLogsProtocol: string;
   otelLogsTimeout: number;
-  otelLogsUrl: string | undefined;
+  otelLogsUrl: string;
   otelMaxExportBatchSize: number;
   otelMaxQueueSize: number;
   otelMetricsEnabled: boolean;
   otelMetricsExportInterval: number;
   otelMetricsExportTimeout: number;
-  otelMetricsHeaders: string | undefined;
   otelMetricsProtocol: string;
   otelMetricsTemporalityPreference: "DELTA" | "CUMULATIVE" | "LOWMEMORY";
   otelMetricsTimeout: number;
-  otelMetricsUrl: string | undefined;
+  otelMetricsUrl: string;
   otelProtocol: string;
   otelTimeout: number;
   peerServiceMapping: Record<string, string>;
@@ -526,12 +531,13 @@ export interface GeneratedConfig {
     enabled: boolean;
     eventLoop: boolean;
     gc: boolean;
+    native: boolean;
   };
   runtimeMetricsRuntimeId: boolean;
   sampleRate: number | undefined;
   samplingRules: import('../../../../index').SamplingRule[];
   scope: string | undefined;
-  service: string | undefined;
+  service: string;
   serviceMapping: Record<string, string>;
   site: string;
   spanAttributeSchema: "v0" | "v1";

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

@@ -29,7 +29,6 @@ const {
   getEnvironmentVariable,
   getEnvironmentVariables,
   getStableConfigSources,
-  getValueFromEnvSources,
 } = require('./helper')
 const {
   defaults,
@@ -132,7 +131,13 @@ function setAndTrack (config, name, value, rawValue = value, source = 'calculate
     }
     changeTracker[source].add(name)
   } else {
-    const copy = typeof value === 'object' && value !== null ? rfdc(value) : value
+    // Programmatic-only options (e.g. logger, lookup, plugins) have no row in
+    // `configurationsTable` and hold opaque user-supplied references that may
+    // carry cycles or non-plain prototypes — for example a winston Logger
+    // extends a Transform stream. Use a reference for these instead of cloning.
+    const copy = typeof value === 'object' && value !== null && name in configurationsTable
+      ? rfdc(value)
+      : value
     changeTracker.baseValuesByPath[name] = { value: copy, source }
   }
   set(config, name, value)
@@ -229,22 +234,6 @@ class Config extends ConfigBase {
   #applyEnvs (envs, source) {
     for (const [name, value] of Object.entries(envs)) {
       const entry = configurationsTable[name]
-      // TracePropagationStyle is a special case. It is a single option that is used to set both inject and extract.
-      // TODO: Consider what to do with this later
-      if (name === 'DD_TRACE_PROPAGATION_STYLE') {
-        if (
-          getValueFromEnvSources('DD_TRACE_PROPAGATION_STYLE_INJECT') !== undefined ||
-          getValueFromEnvSources('DD_TRACE_PROPAGATION_STYLE_EXTRACT') !== undefined
-        ) {
-          log.warn(
-            // eslint-disable-next-line @stylistic/max-len
-            'Use either DD_TRACE_PROPAGATION_STYLE or separate DD_TRACE_PROPAGATION_STYLE_INJECT and DD_TRACE_PROPAGATION_STYLE_EXTRACT environment variables'
-          )
-          continue
-        }
-        this.#applyEnvs({ DD_TRACE_PROPAGATION_STYLE_INJECT: value, DD_TRACE_PROPAGATION_STYLE_EXTRACT: value }, source)
-        continue
-      }
       const parsed = entry.parser(value, name, source)
       const transformed = parsed !== undefined && entry.transformer ? entry.transformer(parsed, name, source) : parsed
       const rawValue = transformed !== null && typeof transformed === 'object' ? value : parsed
@@ -293,6 +282,7 @@ class Config extends ConfigBase {
         } else {
           if (fullName === 'tracePropagationStyle') {
             // TracePropagationStyle is special. It is a single option that is used to set both inject and extract.
+            // TODO: Consider what to do with this later
             // @ts-expect-error - Difficult to type this correctly.
             this.#applyOptions({ inject: value, extract: value }, source, 'tracePropagationStyle')
           } else {
@@ -374,6 +364,11 @@ class Config extends ConfigBase {
       setAndTrack(this, 'otelMetricsEnabled', false)
     }
 
+    if (this.OTEL_TRACES_EXPORTER === 'otlp' && this.protocolVersion && this.protocolVersion !== '0.4') {
+      log.warn('DD_TRACE_AGENT_PROTOCOL_VERSION is set, disabling OTLP traces export')
+      setAndTrack(this, 'OTEL_TRACES_EXPORTER', 'none')
+    }
+
     if (this.telemetry.heartbeatInterval) {
       setAndTrack(this, 'telemetry.heartbeatInterval', Math.floor(this.telemetry.heartbeatInterval * 1000))
     }
@@ -440,8 +435,13 @@ class Config extends ConfigBase {
       setAndTrack(this, 'runtimeMetrics.enabled', false)
     }
 
-    if (!trackedConfigOrigins.has('sampleRate') && trackedConfigOrigins.has('OTEL_TRACES_SAMPLER')) {
-      setAndTrack(this, 'sampleRate', getFromOtelSamplerMap(this.OTEL_TRACES_SAMPLER, this.OTEL_TRACES_SAMPLER_ARG))
+    // Apply the OTel sampler when the user opted into OTel traces or explicitly set the sampler.
+    // OTEL_TRACES_SAMPLER has `default: parentbased_always_on` (per OTel spec), so opt-in users
+    // that don't set the sampler still get parent-based sampling.
+    if (!trackedConfigOrigins.has('sampleRate') &&
+        (trackedConfigOrigins.has('OTEL_TRACES_SAMPLER') || this.OTEL_TRACES_EXPORTER === 'otlp')) {
+      setAndTrack(this, 'sampleRate',
+        getFromOtelSamplerMap(this.OTEL_TRACES_SAMPLER, this.OTEL_TRACES_SAMPLER_ARG))
     }
 
     if (this.DD_SPAN_SAMPLING_RULES_FILE) {
@@ -541,7 +541,10 @@ class Config extends ConfigBase {
         isServiceNameInferred = true
       }
     }
-    setAndTrack(this, 'isServiceNameInferred', isServiceNameInferred)
+
+    // This should not be tracked.
+    // TODO: Consider moving this outside of the config.
+    set(this, 'isServiceNameInferred', isServiceNameInferred)
 
     // Add missing tags, in case they are defined otherwise.
     if (this.service) {
@@ -593,12 +596,18 @@ class Config extends ConfigBase {
       }
     }
 
-    const DEFAULT_OTLP_PORT = '4318'
+    // TODO: This could likely be moved to the base class and allow easier GRPC handling
+    // Default OTLP endpoints follow the configured agent host so users who point DD at a custom
+    // agent (DD_AGENT_HOST / DD_TRACE_AGENT_URL) also reach OTLP on that host.
+    const defaultOtlpBase = this.OTEL_EXPORTER_OTLP_ENDPOINT?.replace(/\/$/, '') ?? `http://${agentHostname}:4318`
     if (!this.otelLogsUrl) {
-      setAndTrack(this, 'otelLogsUrl', `http://${agentHostname}:${DEFAULT_OTLP_PORT}`)
+      setAndTrack(this, 'otelLogsUrl', `${defaultOtlpBase}/v1/logs`)
     }
     if (!this.otelMetricsUrl) {
-      setAndTrack(this, 'otelMetricsUrl', `http://${agentHostname}:${DEFAULT_OTLP_PORT}/v1/metrics`)
+      setAndTrack(this, 'otelMetricsUrl', `${defaultOtlpBase}/v1/metrics`)
+    }
+    if (!this.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT) {
+      setAndTrack(this, 'OTEL_EXPORTER_OTLP_TRACES_ENDPOINT', `${defaultOtlpBase}/v1/traces`)
     }
 
     if (process.platform === 'win32') {
@@ -691,13 +700,25 @@ function increaseCounter (event, ddVar, otelVar) {
 }
 
 function getFromOtelSamplerMap (otelTracesSampler, otelTracesSamplerArg) {
+  const NON_PARENTBASED_TO_PARENTBASED = {
+    always_on: 'parentbased_always_on',
+    always_off: 'parentbased_always_off',
+    traceidratio: 'parentbased_traceidratio',
+  }
   const OTEL_TRACES_SAMPLER_MAPPING = {
-    always_on: 1,
-    always_off: 0,
     parentbased_always_on: 1,
     parentbased_always_off: 0,
   }
 
+  const parentBasedEquivalent = NON_PARENTBASED_TO_PARENTBASED[otelTracesSampler]
+  if (parentBasedEquivalent) {
+    log.info(
+      'OTEL_TRACES_SAMPLER=%s does not respect upstream sampling decisions; using parent-based equivalent %s instead',
+      otelTracesSampler, parentBasedEquivalent
+    )
+    otelTracesSampler = parentBasedEquivalent
+  }
+
   const result = OTEL_TRACES_SAMPLER_MAPPING[otelTracesSampler] ?? otelTracesSamplerArg
   if (result === undefined) {
     increaseCounter('otel.env.invalid', 'DD_TRACE_SAMPLE_RATE', 'OTEL_TRACES_SAMPLER')
@@ -712,7 +733,7 @@ function warnWrongOtelSettings () {
     // eslint-disable-next-line eslint-rules/eslint-env-aliases
     ['OTEL_LOG_LEVEL', 'DD_TRACE_LOG_LEVEL', 'logLevel'],
     // eslint-disable-next-line eslint-rules/eslint-env-aliases
-    ['OTEL_PROPAGATORS', 'DD_TRACE_PROPAGATION_STYLE'],
+    ['OTEL_PROPAGATORS', 'DD_TRACE_PROPAGATION_STYLE', 'DD_TRACE_PROPAGATION_STYLE'],
     // eslint-disable-next-line eslint-rules/eslint-env-aliases
     ['OTEL_SERVICE_NAME', 'DD_SERVICE', 'service'],
     ['OTEL_TRACES_SAMPLER', 'DD_TRACE_SAMPLE_RATE'],
@@ -733,11 +754,7 @@ function warnWrongOtelSettings () {
         increaseCounter('otel.env.hiding', ddEnvVar, otelEnvVar)
       }
 
-      // eslint-disable-next-line eslint-rules/eslint-env-aliases
-      const invalidOtelValue = otelEnvVar === 'OTEL_PROPAGATORS'
-        ? trackedConfigOrigins.get(/** @type {ConfigPath} */ ('tracePropagationStyle.inject')) !== otelSource &&
-          !envs[ddEnvVar]
-        : !otelSource
+      const invalidOtelValue = !otelSource
       if (invalidOtelValue) {
         increaseCounter('otel.env.invalid', ddEnvVar, otelEnvVar)
       }

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

@@ -13,6 +13,15 @@ const VALID_PROPAGATION_STYLES = new Set([
   'datadog', 'tracecontext', 'b3', 'b3 single header', 'b3multi', 'baggage', 'none',
 ])
 
+const RENAMED_OTEL_TAGS = new Map(
+  [
+    ['deployment.environment.name', 'env'],
+    ['deployment.environment', 'env'],
+    ['service.name', 'service'],
+    ['service.version', 'version'],
+  ]
+)
+
 function toCase (value, methodName) {
   if (Array.isArray(value)) {
     return value.map(item => {
@@ -66,12 +75,12 @@ const transformers = {
     }
     return value
   },
-  parseOtelTags (value, optionName) {
-    return parsers.MAP(value
-      ?.replace(/(^|,)deployment\.environment=/, '$1env:')
-      .replace(/(^|,)service\.name=/, '$1service:')
-      .replace(/(^|,)service\.version=/, '$1version:')
-      .replaceAll('=', ':'), optionName)
+  parseOtelTags (object) {
+    const tags = {}
+    for (const [key, value] of Object.entries(object)) {
+      tags[RENAMED_OTEL_TAGS.get(key) ?? key] = value
+    }
+    return tags
   },
   normalizeProfilingEnabled (configValue) {
     if (configValue == null) {
@@ -225,11 +234,19 @@ const parsers = {
     if (!raw) {
       return entries
     }
-    // DD_TAGS is a special case. It may be a map of key-value pairs separated by spaces.
-    if (optionName === 'DD_TAGS' && !raw.includes(',')) {
+    let valueSeparator = ':'
+    if (optionName.startsWith('OTEL_')) {
+      // OTEL spec uses `key=value,key=value`
+      // (https://opentelemetry.io/docs/specs/otel/protocol/exporter/#specifying-headers-via-environment-variables),
+      // while DD uses `key:value,key:value`. Parse OTEL-prefixed options with `=` so downstream code
+      // receives a proper map and telemetry reports the parsed entries. The char-by-char loop
+      // avoids the allocations that `split(',')` + `indexOf('=')` do per pair.
+      valueSeparator = '='
+    } else if (optionName === 'DD_TAGS' && !raw.includes(',')) {
+      // DD_TAGS is a special case. It may be a map of key-value pairs separated by spaces.
       raw = raw.replaceAll(/\s+/g, ',')
     }
-    tagger.add(entries, raw)
+    tagger.add(entries, raw, valueSeparator)
     return entries
   },
   JSON (raw) {

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

@@ -46,12 +46,12 @@
     ],
     "DD_AI_GUARD_BLOCK": [
       {
-        "implementation": "B",
+        "implementation": "C",
         "type": "boolean",
         "configurationNames": [
           "experimental.aiguard.block"
         ],
-        "default": "false"
+        "default": "true"
       }
     ],
     "DD_AI_GUARD_ENABLED": [
@@ -179,7 +179,8 @@
       {
         "implementation": "A",
         "type": "int",
-        "default": "100"
+        "default": "100",
+        "allowed": "\\d+"
       }
     ],
     "DD_APM_TRACING_ENABLED": [
@@ -189,7 +190,10 @@
         "configurationNames": [
           "apmTracingEnabled"
         ],
-        "default": "true"
+        "default": "true",
+        "aliases": [
+          "DD_TRACING_ENABLED"
+        ]
       }
     ],
     "DD_APPSEC_AUTO_USER_INSTRUMENTATION_MODE": [
@@ -445,9 +449,9 @@
     ],
     "DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER": [
       {
-        "implementation": "B",
-        "type": "boolean",
-        "default": "false"
+        "implementation": "A",
+        "type": "string",
+        "default": null
       }
     ],
     "DD_CIVISIBILITY_DANGEROUSLY_FORCE_COVERAGE": [
@@ -1573,6 +1577,16 @@
         "default": "10000"
       }
     ],
+    "DD_RUNTIME_METRICS_NATIVE": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "configurationNames": [
+          "runtimeMetrics.native"
+        ],
+        "default": "true"
+      }
+    ],
     "DD_RUNTIME_METRICS_GC_ENABLED": [
       {
         "implementation": "A",
@@ -2499,10 +2513,7 @@
         "implementation": "A",
         "type": "boolean",
         "default": "true",
-        "internalPropertyName": "tracing",
-        "aliases": [
-          "DD_TRACING_ENABLED"
-        ]
+        "internalPropertyName": "tracing"
       }
     ],
     "DD_TRACE_ENCODING_DEBUG": [
@@ -3100,6 +3111,13 @@
         "default": "true"
       }
     ],
+    "DD_TRACE_MODELCONTEXTPROTOCOL_SDK_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "true"
+      }
+    ],
     "DD_TRACE_MOLECULER_ENABLED": [
       {
         "implementation": "A",
@@ -3442,7 +3460,10 @@
           "tracePropagationStyle.extract"
         ],
         "default": "datadog, tracecontext, baggage",
-        "transform": "toLowerCase"
+        "transform": "toLowerCase",
+        "aliases": [
+          "DD_TRACE_PROPAGATION_STYLE"
+        ]
       }
     ],
     "DD_TRACE_PROPAGATION_STYLE_INJECT": [
@@ -3453,7 +3474,10 @@
           "tracePropagationStyle.inject"
         ],
         "default": "datadog, tracecontext, baggage",
-        "transform": "toLowerCase"
+        "transform": "toLowerCase",
+        "aliases": [
+          "DD_TRACE_PROPAGATION_STYLE"
+        ]
       }
     ],
     "DD_TRACE_PROTOBUFJS_ENABLED": [
@@ -3880,29 +3904,62 @@
     ],
     "OTEL_EXPORTER_OTLP_HEADERS": [
       {
-        "implementation": "C",
-        "type": "string",
-        "default": null,
-        "internalPropertyName": "otelHeaders"
+        "implementation": "B",
+        "type": "map",
+        "default": null
       }
     ],
-    "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT": [
+    "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT": [
       {
         "implementation": "A",
         "type": "string",
+        "default": null
+      }
+    ],
+    "OTEL_EXPORTER_OTLP_TRACES_HEADERS": [
+      {
+        "implementation": "B",
+        "type": "map",
         "default": null,
-        "internalPropertyName": "otelLogsUrl",
         "aliases": [
-          "OTEL_EXPORTER_OTLP_ENDPOINT"
+          "OTEL_EXPORTER_OTLP_HEADERS"
         ]
       }
     ],
-    "OTEL_EXPORTER_OTLP_LOGS_HEADERS": [
+    "OTEL_EXPORTER_OTLP_TRACES_PROTOCOL": [
+      {
+        "implementation": "B",
+        "type": "string",
+        "default": "http/json",
+        "allowed": "http/json",
+        "aliases": [
+          "OTEL_EXPORTER_OTLP_PROTOCOL"
+        ]
+      }
+    ],
+    "OTEL_EXPORTER_OTLP_TRACES_TIMEOUT": [
+      {
+        "implementation": "B",
+        "type": "int",
+        "default": "10000",
+        "aliases": [
+          "OTEL_EXPORTER_OTLP_TIMEOUT"
+        ]
+      }
+    ],
+    "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT": [
       {
         "implementation": "A",
         "type": "string",
         "default": null,
-        "internalPropertyName": "otelLogsHeaders",
+        "internalPropertyName": "otelLogsUrl"
+      }
+    ],
+    "OTEL_EXPORTER_OTLP_LOGS_HEADERS": [
+      {
+        "implementation": "B",
+        "type": "map",
+        "default": null,
         "aliases": [
           "OTEL_EXPORTER_OTLP_HEADERS"
         ]
@@ -3936,18 +3993,14 @@
         "implementation": "A",
         "type": "string",
         "default": null,
-        "internalPropertyName": "otelMetricsUrl",
-        "aliases": [
-          "OTEL_EXPORTER_OTLP_ENDPOINT"
-        ]
+        "internalPropertyName": "otelMetricsUrl"
       }
     ],
     "OTEL_EXPORTER_OTLP_METRICS_HEADERS": [
       {
-        "implementation": "B",
-        "type": "string",
+        "implementation": "C",
+        "type": "map",
         "default": null,
-        "internalPropertyName": "otelMetricsHeaders",
         "aliases": [
           "OTEL_EXPORTER_OTLP_HEADERS"
         ]
@@ -4041,8 +4094,8 @@
     ],
     "OTEL_RESOURCE_ATTRIBUTES": [
       {
-        "implementation": "B",
-        "type": "string",
+        "implementation": "A",
+        "type": "map",
         "default": "",
         "transform": "parseOtelTags"
       }
@@ -4056,9 +4109,9 @@
     ],
     "OTEL_TRACES_EXPORTER": [
       {
-        "implementation": "F",
+        "implementation": "H",
         "type": "string",
-        "default": "otlp",
+        "default": null,
         "allowed": "none|otlp",
         "transform": "toLowerCase"
       }

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

@@ -21,6 +21,7 @@ module.exports = {
   SPAN_SAMPLING_MECHANISM: '_dd.span_sampling.mechanism',
   SPAN_SAMPLING_RULE_RATE: '_dd.span_sampling.rule_rate',
   SPAN_SAMPLING_MAX_PER_SECOND: '_dd.span_sampling.max_per_second',
+  SVC_SRC_KEY: '_dd.svc_src',
   DATADOG_LAMBDA_EXTENSION_PATH: '/opt/extensions/datadog-agent',
   DATADOG_MINI_AGENT_PATH: '/tmp/datadog/mini_agent_ready',
   DECISION_MAKER_KEY: '_dd.p.dm',

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

@@ -5,6 +5,7 @@ module.exports = function getDebuggerConfig (config, inputPath) {
     commitSHA: config.commitSHA,
     debug: config.debug,
     dynamicInstrumentation: config.dynamicInstrumentation,
+    env: config.env,
     hostname: config.hostname,
     logLevel: config.logLevel,
     port: config.port,
@@ -13,6 +14,7 @@ module.exports = function getDebuggerConfig (config, inputPath) {
     runtimeId: config.tags['runtime-id'],
     service: config.service,
     url: config.url?.toString(),
+    version: config.version,
     inputPath,
   }
 }

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

@@ -6,7 +6,6 @@ const { stringify } = require('querystring')
 const { version } = require('../../../../../package.json')
 const request = require('../../exporters/common/request')
 const { GIT_COMMIT_SHA, GIT_REPOSITORY_URL } = require('../../plugins/util/tags')
-const { getValueFromEnvSources } = require('../../config/helper')
 const { DEBUGGER_DIAGNOSTICS_V1, DEBUGGER_INPUT_V2 } = require('../constants')
 const log = require('./log')
 const JSONBuffer = require('./json-buffer')
@@ -23,14 +22,14 @@ const ddsource = 'dd_debugger'
 const hostname = getHostname()
 const service = config.service
 
-const ddtags = [
-  ['env', getValueFromEnvSources('DD_ENV')],
-  ['version', getValueFromEnvSources('DD_VERSION')],
+const ddtags = buildTags([
+  ['env', config.env],
+  ['version', config.version],
   ['debugger_version', version],
   ['host_name', hostname],
   [GIT_COMMIT_SHA, config.commitSHA],
   [GIT_REPOSITORY_URL, config.repositoryUrl],
-].filter(([, value]) => value !== undefined).map((pair) => pair.join(':')).join(',')
+])
 
 let path
 setInputPath(config.inputPath)
@@ -136,3 +135,24 @@ function setInputPath (newPath) {
   config.inputPath = newPath
   path = `${newPath}?${stringify({ ddtags })}`
 }
+
+/**
+ * @param {Array<[string, unknown]>} tags - The tags to serialize.
+ * @returns {string} The serialized tags.
+ */
+function buildTags (tags) {
+  const serializedTags = []
+
+  for (const [key, rawValue] of tags) {
+    if (rawValue === undefined) continue
+
+    if (String(rawValue).includes(',')) {
+      log.warn('[debugger:devtools_client] Skipping invalid tag value for %s', key)
+      continue
+    }
+
+    serializedTags.push(`${key}:${rawValue}`)
+  }
+
+  return serializedTags.join(',')
+}

package/packages/dd-trace/src/debugger/devtools_client/snapshot/processor.js

@@ -105,10 +105,13 @@ function getObjectValue (obj, maxLength) {
     // case 'node': // TODO: What does this subtype represent?
     case 'regexp':
       return { type: obj.className, value: obj.description }
-    case 'date':
+    case 'date': {
       // TODO: This looses millisecond resolution, as that's not retained in the `.toString()` representation contained
       // in the `description` field. Unfortunately that's all we get from the Chrome DevTools Protocol.
-      return { type: obj.className, value: `${new Date(obj.description).toISOString().slice(0, -5)}Z` }
+      const date = new Date(obj.description)
+      const value = Number.isNaN(date.getTime()) ? obj.description : `${date.toISOString().slice(0, -5)}Z`
+      return { type: obj.className, value }
+    }
     case 'map':
       return toMap(obj.className, obj.properties, maxLength, timeBudgetReached)
     case 'set':

package/packages/dd-trace/src/encode/0.4.js

@@ -1,10 +1,8 @@
 'use strict'
 
+const getConfig = require('../config')
 const { MsgpackChunk, MsgpackEncoder } = require('../msgpack')
 const log = require('../log')
-const { isTrue } = require('../util')
-const { memoize } = require('../log/utils')
-const { getValueFromEnvSources } = require('../config/helper')
 const { truncateSpan, normalizeSpan } = require('./tags-processors')
 
 const SOFT_LIMIT = 8 * 1024 * 1024 // 8MB
@@ -13,7 +11,7 @@ function formatSpan (span, config) {
   span = normalizeSpan(truncateSpan(span, false))
   if (span.span_events) {
     // ensure span events are encoded as tags if agent doesn't support native top level span events
-    if (config?.trace?.nativeSpanEvents) {
+    if (config.trace.nativeSpanEvents) {
       formatSpanEvents(span)
     } else {
       span.meta.events = JSON.stringify(span.span_events)
@@ -31,8 +29,8 @@ class AgentEncoder {
     this._stringBytes = new MsgpackChunk()
     this._writer = writer
     this._reset()
-    this._debugEncoding = isTrue(getValueFromEnvSources('DD_TRACE_ENCODING_DEBUG'))
-    this._config = this._writer?._config
+    this._config = getConfig()
+    this._debugEncoding = this._config.DD_TRACE_ENCODING_DEBUG
   }
 
   count () {
@@ -338,11 +336,13 @@ class AgentEncoder {
   }
 }
 
-const memoizedLogDebug = memoize((key, message) => {
-  log.debug(message)
-  // return something to store in memoize cache
-  return true
-})
+const seenKeys = new Set()
+const memoizedLogDebug = (key, message) => {
+  if (!seenKeys.has(key)) {
+    seenKeys.add(key)
+    log.debug(message)
+  }
+}
 
 function formatSpanEvents (span) {
   for (const spanEvent of span.span_events) {