dd-trace 5.86.0 → 5.88.0

package/packages/dd-trace/src/ci-visibility/requests/request.js

@@ -0,0 +1,236 @@
+'use strict'
+
+const http = require('http')
+const https = require('https')
+const zlib = require('zlib')
+
+const { storage } = require('../../../../datadog-core')
+const log = require('../../log')
+const { httpAgent, httpsAgent } = require('../../exporters/common/agents')
+const { urlToHttpOptions } = require('../../exporters/common/url-to-http-options-polyfill')
+
+const RATE_LIMIT_MAX_WAIT_MS = 30_000
+const RETRY_BASE_MS = 5000
+const RETRY_JITTER_MS = 2500
+
+/**
+ * Calculates retry delay with jitter to prevent thundering herd.
+ * Delay is RETRY_BASE_MS + random(0, RETRY_JITTER_MS) (e.g. 5–7.5 seconds).
+ *
+ * @returns {number} Delay in milliseconds
+ */
+function getRetryDelay () {
+  return RETRY_BASE_MS + (Math.random() * RETRY_JITTER_MS)
+}
+
+/**
+ * Determines if a network error is retriable (transient failures only).
+ * ECONNREFUSED is retried because it can be transient (service starting up,
+ * restarts, rolling deploys, k8s pod/readiness transitions). ENOTFOUND is
+ * excluded as it indicates DNS failure or wrong host and is usually not transient.
+ *
+ * @param {Error} err - The error to check
+ * @returns {boolean}
+ */
+function isRetriableNetworkError (err) {
+  if (!err.code) return false
+  return err.code === 'ECONNREFUSED' ||
+    err.code === 'ECONNRESET' ||
+    err.code === 'ETIMEDOUT' ||
+    err.code === 'EPIPE'
+}
+
+function parseUrl (urlObjOrString) {
+  if (urlObjOrString !== null && typeof urlObjOrString === 'object') {
+    return urlToHttpOptions(urlObjOrString)
+  }
+
+  const url = urlToHttpOptions(new URL(urlObjOrString))
+
+  if (url.protocol === 'unix:' && url.hostname === '.') {
+    const udsPath = urlObjOrString.slice(5)
+    url.path = udsPath
+    url.pathname = udsPath
+  }
+
+  return url
+}
+
+/**
+ * Simplified HTTP request for test optimization (library config). Uses common HTTP agents.
+ * Retries: 429 (with X-ratelimit-reset, max 30s wait),
+ * >=500 and transient network errors (5–7.5s delay with jitter). Max one retry.
+ * Destroys connections on errors to prevent reuse of bad connections. Preserves
+ * original status code across retries for telemetry.
+ *
+ * @param {string} data - Request body (e.g. JSON string)
+ * @param {object} options - { url, path?, method?, headers?, timeout? } (may be mutated)
+ * @param {Function} callback - (err, res, statusCode) => void
+ */
+function request (data, options, callback) {
+  const headers = options.headers ? { ...options.headers } : {}
+  headers['Content-Length'] = Buffer.byteLength(data, 'utf8')
+
+  const opts = { ...options, method: 'POST', headers }
+
+  if (opts.url) {
+    const url = parseUrl(opts.url)
+    if (url.protocol === 'unix:') {
+      opts.socketPath = url.pathname
+    } else {
+      opts.path = opts.path ?? url.path
+      opts.protocol = url.protocol
+      opts.hostname = url.hostname
+      opts.port = url.port
+    }
+  }
+
+  const timeout = opts.timeout || 2000
+  const isSecure = opts.protocol === 'https:'
+  const client = isSecure ? https : http
+
+  if (!opts.socketPath) {
+    opts.agent = isSecure ? httpsAgent : httpAgent
+  }
+
+  let hasRetried = false
+  let firstStatusCode = null
+
+  const makeRequest = () => {
+    storage('legacy').run({ noop: true }, () => {
+      const req = client.request(opts, (res) => {
+        // Capture non-2xx status code as soon as we see it so telemetry preserves it if the retry
+        // fails with a network error (no HTTP response) before 'end' fires
+        if (res.statusCode >= 400 && firstStatusCode === null) {
+          firstStatusCode = res.statusCode
+        }
+
+        const chunks = []
+
+        res.setTimeout(timeout)
+
+        res.on('data', chunk => {
+          chunks.push(chunk)
+        })
+
+        res.once('end', () => {
+          const buffer = Buffer.concat(chunks)
+
+          if (res.statusCode >= 200 && res.statusCode <= 299) {
+            const isGzip = res.headers['content-encoding'] === 'gzip'
+            if (isGzip) {
+              zlib.gunzip(buffer, (err, result) => {
+                if (err) {
+                  log.error('Could not gunzip response: %s', err.message)
+                  callback(null, '', res.statusCode)
+                } else {
+                  callback(null, result.toString(), res.statusCode)
+                }
+              })
+            } else {
+              callback(null, buffer.toString(), res.statusCode)
+            }
+            return
+          }
+
+          if (res.statusCode === 429 && !hasRetried) {
+            const resetHeader = res.headers['x-ratelimit-reset']
+            const resetTs = (resetHeader === null || resetHeader === undefined)
+              ? Number.NaN
+              : Number.parseInt(resetHeader, 10)
+            const waitMs = Number.isFinite(resetTs) ? Math.max(0, resetTs * 1000 - Date.now()) : Number.NaN
+
+            if (Number.isFinite(waitMs) && waitMs <= RATE_LIMIT_MAX_WAIT_MS) {
+              hasRetried = true
+              setTimeout(makeRequest, waitMs)
+              return
+            }
+
+            if (!Number.isFinite(waitMs) || waitMs > RATE_LIMIT_MAX_WAIT_MS) {
+              log.debug('Rate limited (429): drop payload (wait %sms > %sms or invalid header)',
+                Number.isFinite(waitMs) ? waitMs : 'N/A', RATE_LIMIT_MAX_WAIT_MS)
+            }
+          } else if (res.statusCode >= 500 && !hasRetried) {
+            try {
+              if (req.socket) req.socket.destroy()
+            } catch {
+              // ignore
+            }
+            hasRetried = true
+            setTimeout(makeRequest, getRetryDelay())
+            return
+          }
+
+          const error = buildError(res, buffer, opts)
+          // Use original status code if this is a failed retry
+          callback(error, null, firstStatusCode === null ? res.statusCode : firstStatusCode)
+        })
+      })
+
+      req.once('error', err => {
+        try {
+          if (req.socket) req.socket.destroy()
+        } catch {
+          // ignore
+        }
+
+        // Retry on retriable network errors
+        if (!hasRetried && isRetriableNetworkError(err)) {
+          hasRetried = true
+          setTimeout(makeRequest, getRetryDelay())
+          return
+        }
+
+        // Pass original status code (if any) for accurate telemetry
+        callback(err, null, firstStatusCode)
+      })
+
+      req.setTimeout(timeout, () => {
+        try {
+          if (typeof req.abort === 'function') {
+            req.abort()
+          } else {
+            req.destroy()
+          }
+        } catch {
+          // ignore
+        }
+      })
+
+      req.write(data, 'utf8')
+      req.end()
+    })
+  }
+
+  makeRequest()
+}
+
+/**
+ * @param {object} res - IncomingMessage
+ * @param {Buffer} buffer - Response body
+ * @param {object} options - Request options
+ * @returns {Error}
+ */
+function buildError (res, buffer, options) {
+  let errorMessage = ''
+  try {
+    const fullUrl = new URL(
+      options.path,
+      options.url || options.hostname || `http://localhost:${options.port}`
+    ).href
+    errorMessage = `Error from ${fullUrl}: ${res.statusCode} ${http.STATUS_CODES[res.statusCode]}.`
+  } catch {
+    // ignore
+  }
+
+  const responseData = buffer.toString()
+  if (responseData) {
+    errorMessage += ` Response from the endpoint: "${responseData}"`
+  }
+
+  const error = new log.NoTransmitError(errorMessage)
+  error.status = res.statusCode
+  return error
+}
+
+module.exports = request

package/packages/dd-trace/src/ci-visibility/test-management/get-test-management-tests.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const request = require('../../exporters/common/request')
+const request = require('../requests/request')
 const id = require('../../id')
 const { getValueFromEnvSources } = require('../../config/helper')
 const log = require('../../log')

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

@@ -1,15 +1,12 @@
 'use strict'
 
 const pkg = require('../pkg')
-const { GRPC_CLIENT_ERROR_STATUSES, GRPC_SERVER_ERROR_STATUSES } = require('../constants')
+const { isFalse, isTrue } = require('../util')
 const { getEnvironmentVariable: getEnv } = require('./helper')
 
-// eslint-disable-next-line @stylistic/max-len
-const qsRegex = String.raw`(?:p(?:ass)?w(?:or)?d|pass(?:_?phrase)?|secret|(?:api_?|private_?|public_?|access_?|secret_?)key(?:_?id)?|token|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)(?:(?:\s|%20)*(?:=|%3D)[^&]+|(?:"|%22)(?:\s|%20)*(?::|%3A)(?:\s|%20)*(?:"|%22)(?:%2[^2]|%[^2]|[^"%])+(?:"|%22))|bearer(?:\s|%20)+[a-z0-9\._\-]+|token(?::|%3A)[a-z0-9]{13}|gh[opsu]_[0-9a-zA-Z]{36}|ey[I-L](?:[\w=-]|%3D)+\.ey[I-L](?:[\w=-]|%3D)+(?:\.(?:[\w.+\/=-]|%3D|%2F|%2B)+)?|[\-]{5}BEGIN(?:[a-z\s]|%20)+PRIVATE(?:\s|%20)KEY[\-]{5}[^\-]+[\-]{5}END(?:[a-z\s]|%20)+PRIVATE(?:\s|%20)KEY|ssh-rsa(?:\s|%20)*(?:[a-z0-9\/\.+]|%2F|%5C|%2B){100,}`
-// eslint-disable-next-line @stylistic/max-len
-const defaultWafObfuscatorKeyRegex = String.raw`(?i)pass|pw(?:or)?d|secret|(?:api|private|public|access)[_-]?key|token|consumer[_-]?(?:id|key|secret)|sign(?:ed|ature)|bearer|authorization|jsessionid|phpsessid|asp\.net[_-]sessionid|sid|jwt`
-// eslint-disable-next-line @stylistic/max-len
-const defaultWafObfuscatorValueRegex = String.raw`(?i)(?:p(?:ass)?w(?:or)?d|pass(?:[_-]?phrase)?|secret(?:[_-]?key)?|(?:(?:api|private|public|access)[_-]?)key(?:[_-]?id)?|(?:(?:auth|access|id|refresh)[_-]?)?token|consumer[_-]?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?|jsessionid|phpsessid|asp\.net(?:[_-]|-)sessionid|sid|jwt)(?:\s*=([^;&]+)|"\s*:\s*("[^"]+"|\d+))|bearer\s+([a-z0-9\._\-]+)|token\s*:\s*([a-z0-9]{13})|gh[opsu]_([0-9a-zA-Z]{36})|ey[I-L][\w=-]+\.(ey[I-L][\w=-]+(?:\.[\w.+\/=-]+)?)|[\-]{5}BEGIN[a-z\s]+PRIVATE\sKEY[\-]{5}([^\-]+)[\-]{5}END[a-z\s]+PRIVATE\sKEY|ssh-rsa\s*([a-z0-9\/\.+]{100,})`
+const {
+  supportedConfigurations,
+} = /** @type {import('./helper').SupportedConfigurationsJson} */ (require('./supported-configurations.json'))
 
 const service = getEnv('AWS_LAMBDA_FUNCTION_NAME') ||
   getEnv('FUNCTION_NAME') || // Google Cloud Function Name set by deprecated runtimes
@@ -18,204 +15,160 @@ const service = getEnv('AWS_LAMBDA_FUNCTION_NAME') ||
   pkg.name ||
   'node'
 
-module.exports = {
-  apiKey: undefined,
-  appKey: undefined,
-  apmTracingEnabled: true,
-  'appsec.apiSecurity.enabled': true,
-  'appsec.apiSecurity.sampleDelay': 30,
-  'appsec.apiSecurity.endpointCollectionEnabled': true,
-  'appsec.apiSecurity.endpointCollectionMessageLimit': 300,
-  'appsec.blockedTemplateGraphql': undefined,
-  'appsec.blockedTemplateHtml': undefined,
-  'appsec.blockedTemplateJson': undefined,
-  'appsec.enabled': undefined,
-  'appsec.eventTracking.mode': 'identification',
-  // TODO appsec.extendedHeadersCollection is deprecated, to delete in a major
-  'appsec.extendedHeadersCollection.enabled': false,
-  'appsec.extendedHeadersCollection.redaction': true,
-  'appsec.extendedHeadersCollection.maxHeaders': 50,
-  'appsec.obfuscatorKeyRegex': defaultWafObfuscatorKeyRegex,
-  'appsec.obfuscatorValueRegex': defaultWafObfuscatorValueRegex,
-  'appsec.rasp.enabled': true,
-  // TODO Deprecated, to delete in a major
-  'appsec.rasp.bodyCollection': false,
-  'appsec.rateLimit': 100,
-  'appsec.rules': undefined,
-  'appsec.sca.enabled': null,
-  'appsec.stackTrace.enabled': true,
-  'appsec.stackTrace.maxDepth': 32,
-  'appsec.stackTrace.maxStackTraces': 2,
-  'appsec.wafTimeout': 5e3, // µs
-  baggageMaxBytes: 8192,
-  baggageMaxItems: 64,
-  baggageTagKeys: 'user.id,session.id,account.id',
-  clientIpEnabled: false,
-  clientIpHeader: null,
+/**
+ * @param {string|null} raw
+ * @param {string} type
+ * @returns {string|number|boolean|Record<string, string>|unknown[]|undefined}
+ */
+function parseDefaultByType (raw, type) {
+  if (raw === null) {
+    return
+  }
+
+  switch (type) {
+    case 'boolean':
+      if (isTrue(raw)) return true
+      if (isFalse(raw)) return false
+      // TODO: What should we do with these?
+      return
+    case 'int':
+    case 'decimal': {
+      return Number(raw)
+    }
+    case 'array': {
+      if (!raw || raw.length === 0) return []
+      // TODO: Make the parsing a helper that is reused.
+      return raw.split(',').map(item => {
+        const colonIndex = item.indexOf(':')
+        if (colonIndex === -1) {
+          return item.trim()
+        }
+        const key = item.slice(0, colonIndex).trim()
+        const value = item.slice(colonIndex + 1).trim()
+        return `${key}:${value}`
+      })
+    }
+    case 'map': {
+      if (!raw || raw.length === 0) return {}
+      // TODO: Make the parsing a helper that is reused.
+      /** @type {Record<string, string>} */
+      const entries = {}
+      for (const item of raw.split(',')) {
+        const colonIndex = item.indexOf(':')
+        if (colonIndex === -1) {
+          const key = item.trim()
+          if (key.length > 0) {
+            entries[key] = ''
+          }
+          continue
+        }
+        const key = item.slice(0, colonIndex).trim()
+        const value = item.slice(colonIndex + 1).trim()
+        if (key.length > 0) {
+          entries[key] = value
+        }
+      }
+      return entries
+    }
+    default:
+      return raw
+  }
+}
+
+/** @type {Record<string, unknown>} */
+const metadataDefaults = {}
+for (const entries of Object.values(supportedConfigurations)) {
+  for (const entry of entries) {
+    // TODO: Replace $dynamic with method names that would be called and that
+    // are also called when the user passes through the value. That way the
+    // handling is unified and methods can be declared as default.
+    // The name of that method should be expressive for users.
+    // TODO: Add handling for all environment variable names. They should not
+    // need a configuration name for being listed with their default.
+    if (!Array.isArray(entry.configurationNames)) {
+      continue
+    }
+
+    const parsedValue = parseDefaultByType(entry.default, entry.type)
+    for (const configurationName of entry.configurationNames) {
+      metadataDefaults[configurationName] = entry.default === null ? undefined : parsedValue
+    }
+  }
+}
+
+// Defaults required by JS config merge/applyCalculated that are not represented in supported-configurations.
+const defaultsWithoutSupportedConfigurationEntry = {
+  'cloudPayloadTagging.rules': [],
   'cloudPayloadTagging.requestsEnabled': false,
   'cloudPayloadTagging.responsesEnabled': false,
-  'cloudPayloadTagging.maxDepth': 10,
-  'cloudPayloadTagging.rules': [],
-  'crashtracking.enabled': true,
-  'codeOriginForSpans.enabled': true,
-  'codeOriginForSpans.experimental.exit_spans.enabled': false,
-  dbmPropagationMode: 'disabled',
-  'dogstatsd.hostname': '127.0.0.1',
-  'dogstatsd.port': '8125',
-  dsmEnabled: false,
-  'dynamicInstrumentation.captureTimeoutMs': 15,
-  'dynamicInstrumentation.enabled': false,
-  'dynamicInstrumentation.probeFile': undefined,
-  'dynamicInstrumentation.redactedIdentifiers': [],
-  'dynamicInstrumentation.redactionExcludedIdentifiers': [],
-  'dynamicInstrumentation.uploadIntervalSeconds': 1,
-  env: undefined,
-  'experimental.aiguard.enabled': false,
-  'experimental.aiguard.endpoint': undefined,
-  'experimental.aiguard.maxMessagesLength': 16,
-  'experimental.aiguard.maxContentSize': 512 * 1024,
-  'experimental.aiguard.timeout': 10_000, // ms
-  'experimental.enableGetRumData': false,
-  'experimental.exporter': undefined,
-  'experimental.flaggingProvider.enabled': false,
-  'experimental.flaggingProvider.initializationTimeoutMs': 30_000,
-  flushInterval: 2000,
-  flushMinSpans: 1000,
-  gitMetadataEnabled: true,
-  graphqlErrorExtensions: [],
-  'grpc.client.error.statuses': GRPC_CLIENT_ERROR_STATUSES,
-  'grpc.server.error.statuses': GRPC_SERVER_ERROR_STATUSES,
-  headerTags: [],
-  'heapSnapshot.count': 0,
-  'heapSnapshot.destination': '',
-  'heapSnapshot.interval': 3600,
-  hostname: '127.0.0.1',
-  'iast.dbRowsToTaint': 1,
-  'iast.deduplicationEnabled': true,
-  'iast.enabled': false,
-  'iast.maxConcurrentRequests': 2,
-  'iast.maxContextOperations': 2,
-  'iast.redactionEnabled': true,
-  'iast.redactionNamePattern': null,
-  'iast.redactionValuePattern': null,
-  'iast.requestSampling': 30,
-  'iast.securityControlsConfiguration': null,
-  'iast.telemetryVerbosity': 'INFORMATION',
-  'iast.stackTrace.enabled': true,
-  injectionEnabled: [],
-  'installSignature.id': null,
-  'installSignature.time': null,
-  'installSignature.type': null,
-  instrumentationSource: 'manual',
-  injectForce: null,
   isAzureFunction: false,
   isCiVisibility: false,
-  isEarlyFlakeDetectionEnabled: false,
-  isFlakyTestRetriesEnabled: false,
-  flakyTestRetriesCount: 5,
   isGCPFunction: false,
-  isGCPPubSubPushSubscriptionEnabled: true,
+  instrumentationSource: 'manual',
+  isServiceUserProvided: false,
+  lookup: undefined,
+  plugins: true,
+}
+
+// These values are documented in supported-configurations as CI Visibility
+// defaults. Keep startup baseline false and let #applyCalculated() switch them
+// when CI Visibility is active.
+// TODO: These entries should be removed. They are off by default
+// because they rely on other configs.
+const defaultsWithConditionalRuntimeBehavior = {
   isGitUploadEnabled: false,
+  isImpactedTestsEnabled: false,
   isIntelligentTestRunnerEnabled: false,
   isManualApiEnabled: false,
-  'langchain.spanCharLimit': 128,
-  'langchain.spanPromptCompletionSampleRate': 1,
-  'llmobs.agentlessEnabled': undefined,
-  'llmobs.enabled': false,
-  'llmobs.mlApp': undefined,
-  ciVisibilityTestSessionName: '',
-  ciVisAgentlessLogSubmissionEnabled: false,
-  legacyBaggageEnabled: true,
-  isTestDynamicInstrumentationEnabled: false,
-  isServiceUserProvided: false,
-  testManagementAttemptToFixRetries: 20,
   isTestManagementEnabled: false,
-  isImpactedTestsEnabled: false,
-  logInjection: true,
-  otelLogsEnabled: false,
-  otelUrl: undefined,
-  otelLogsUrl: undefined, // Will be computed using agent host
-  otelHeaders: undefined,
-  otelLogsHeaders: '',
-  otelProtocol: 'http/protobuf',
-  otelLogsProtocol: 'http/protobuf',
-  otelLogsTimeout: 10_000,
-  otelTimeout: 10_000,
-  otelBatchTimeout: 5000,
-  otelMaxExportBatchSize: 512,
-  otelMaxQueueSize: 2048,
-  otelMetricsEnabled: false,
-  otelMetricsUrl: undefined, // Will be computed using agent host
-  otelMetricsHeaders: '',
-  otelMetricsProtocol: 'http/protobuf',
-  otelMetricsTimeout: 10_000,
-  otelMetricsExportTimeout: 7500,
-  otelMetricsExportInterval: 10_000,
-  otelMetricsTemporalityPreference: 'DELTA', // DELTA, CUMULATIVE, or LOWMEMORY
-  lookup: undefined,
-  inferredProxyServicesEnabled: false,
-  memcachedCommandEnabled: false,
-  middlewareTracingEnabled: true,
-  openAiLogsEnabled: false,
-  'openai.spanCharLimit': 128,
-  peerServiceMapping: {},
-  plugins: true,
+  // TODO: These are not conditional, they would just be of type number.
+  'dogstatsd.port': '8125',
   port: '8126',
-  'profiling.enabled': undefined,
-  'propagateProcessTags.enabled': undefined,
-  'profiling.exporters': 'agent',
-  'profiling.sourceMap': true,
-  'profiling.longLivedThreshold': undefined,
-  protocolVersion: '0.4',
-  queryStringObfuscation: qsRegex,
-  'remoteConfig.enabled': true,
-  'remoteConfig.pollInterval': 5, // seconds
-  reportHostname: false,
-  resourceRenamingEnabled: false,
-  'runtimeMetrics.enabled': false,
-  'runtimeMetrics.eventLoop': true,
-  'runtimeMetrics.gc': true,
-  runtimeMetricsRuntimeId: false,
-  sampleRate: undefined,
-  'sampler.rateLimit': 100,
-  'sampler.rules': [],
-  'sampler.spanSamplingRules': [],
-  scope: undefined,
+  // Override due to expecting numbers, not strings. TODO: Replace later.
+  'grpc.client.error.statuses': [
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+  ],
+  'grpc.server.error.statuses': [
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+  ],
+}
+
+/** @type {Record<string, unknown>} */
+const defaults = {
+  ...defaultsWithoutSupportedConfigurationEntry,
+  ...metadataDefaults,
+  ...defaultsWithConditionalRuntimeBehavior,
   service,
-  serviceMapping: {},
-  site: 'datadoghq.com',
-  spanAttributeSchema: 'v0',
-  spanComputePeerService: false,
-  spanLeakDebug: 0,
-  spanRemoveIntegrationFromService: false,
-  startupLogs: false,
-  'stats.enabled': false,
-  tags: {},
-  tagsHeaderMaxLength: 512,
-  'telemetry.debug': false,
-  'telemetry.dependencyCollection': true,
-  'telemetry.enabled': true,
-  'telemetry.heartbeatInterval': 60_000,
-  'telemetry.logCollection': true,
-  'telemetry.metrics': true,
-  traceEnabled: true,
-  traceId128BitGenerationEnabled: true,
-  traceId128BitLoggingEnabled: true,
-  tracePropagationExtractFirst: false,
-  tracePropagationBehaviorExtract: 'continue',
-  'tracePropagationStyle.inject': ['datadog', 'tracecontext', 'baggage'],
-  'tracePropagationStyle.extract': ['datadog', 'tracecontext', 'baggage'],
-  'tracePropagationStyle.otelPropagators': false,
-  traceWebsocketMessagesEnabled: true,
-  traceWebsocketMessagesInheritSampling: true,
-  traceWebsocketMessagesSeparateTraces: true,
-  tracing: true,
-  url: undefined,
   version: pkg.version,
-  instrumentation_config_id: undefined,
-  'vertexai.spanCharLimit': 128,
-  'vertexai.spanPromptCompletionSampleRate': 1,
-  'trace.aws.addSpanPointers': true,
-  'trace.dynamoDb.tablePrimaryKeys': undefined,
-  'trace.nativeSpanEvents': false,
 }
+
+module.exports = defaults

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

@@ -2,8 +2,25 @@
 
 /* eslint-disable eslint-rules/eslint-process-env */
 
+/**
+ * @typedef {object} SupportedConfigurationEntry
+ * @property {string} implementation
+ * @property {string} type
+ * @property {string|number|boolean|null|object|unknown[]} default
+ * @property {string[]} [aliases]
+ * @property {string[]} [configurationNames]
+ * @property {string|boolean} [deprecated]
+ */
+
+/**
+ * @typedef {object} SupportedConfigurationsJson
+ * @property {Record<`DD_${string}` | `OTEL_${string}`, SupportedConfigurationEntry[]>} supportedConfigurations
+ */
+
 const { deprecate } = require('util')
-const { supportedConfigurations, aliases, deprecations } = require('./supported-configurations.json')
+const {
+  supportedConfigurations,
+} = /** @type {SupportedConfigurationsJson} */ (require('./supported-configurations.json'))
 
 /**
  * Types for environment variable handling.
@@ -12,6 +29,31 @@ const { supportedConfigurations, aliases, deprecations } = require('./supported-
  * @typedef {Partial<typeof process.env> & Partial<Record<SupportedEnvKey, string|undefined>>} TracerEnv
  */
 
+// Backwards-compatible views for old helper logic:
+// - `aliases`: Record<canonicalEnvVar, string[]>
+// - `deprecations`: Record<deprecatedEnvVar, string> (message suffix)
+const aliases = {}
+const deprecations = {}
+
+for (const [canonical, configuration] of Object.entries(supportedConfigurations)) {
+  for (const implementation of configuration) {
+    if (implementation.deprecated) {
+      deprecations[canonical] = implementation.deprecated
+      // Deprecated entries with an alias may not be listed in the supported configurations map
+      if (implementation.aliases) {
+        delete supportedConfigurations[canonical]
+        continue
+      }
+    }
+    if (Array.isArray(implementation.aliases)) {
+      for (const alias of implementation.aliases) {
+        aliases[canonical] ??= new Set()
+        aliases[canonical].add(alias)
+      }
+    }
+  }
+}
+
 const aliasToCanonical = {}
 for (const canonical of Object.keys(aliases)) {
   for (const alias of aliases[canonical]) {