dd-trace 5.82.0 → 5.83.0

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

@@ -7,8 +7,8 @@ const Module = require('module')
 const dc = require('dc-polyfill')
 
 const parse = require('../../../vendor/dist/module-details-from-path')
-const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
 const { isRelativeRequire } = require('../../datadog-instrumentations/src/helpers/shared-utils')
+const { getEnvironmentVariable, getValueFromEnvSources } = require('./config/helper')
 
 const origRequire = Module.prototype.require
 // derived from require-in-the-middle@3 with tweaks
@@ -63,6 +63,7 @@ function Hook (modules, options, onrequire) {
     */
     let filename
     try {
+      // @ts-expect-error Module._resolveFilename is not typed
       filename = Module._resolveFilename(request, this)
     } catch {
       return _origRequire.apply(this, arguments)
@@ -71,9 +72,10 @@ function Hook (modules, options, onrequire) {
     let name, basedir, hooks
     // return known patched modules immediately
     if (cache[filename]) {
+      const externalCacheEntry = require.cache[filename]
       // require.cache was potentially altered externally
-      if (require.cache[filename] && require.cache[filename].exports !== cache[filename].original) {
-        return require.cache[filename].exports
+      if (externalCacheEntry && externalCacheEntry.exports !== cache[filename].original) {
+        return externalCacheEntry.exports
       }
 
       return cache[filename].exports
@@ -113,7 +115,7 @@ function Hook (modules, options, onrequire) {
       name = filename
     } else {
       const inAWSLambda = getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME') !== undefined
-      const hasLambdaHandler = getEnvironmentVariable('DD_LAMBDA_HANDLER') !== undefined
+      const hasLambdaHandler = getValueFromEnvSources('DD_LAMBDA_HANDLER') !== undefined
       const segments = filename.split(path.sep)
       const filenameFromNodeModule = segments.includes('node_modules')
       // decide how to assign the stat
@@ -127,6 +129,7 @@ function Hook (modules, options, onrequire) {
         hooks = moduleHooks[name]
         if (!hooks) return exports // abort if module name isn't on whitelist
 
+        // @ts-expect-error Module._resolveLookupPaths is not typed
         const paths = Module._resolveLookupPaths(name, this, true)
         if (!paths) {
           // abort if _resolveLookupPaths return null
@@ -135,6 +138,7 @@ function Hook (modules, options, onrequire) {
 
         let res
         try {
+          // @ts-expect-error Module._findPath is not typed
           res = Module._findPath(name, [basedir, ...paths])
         } catch {
           // case where the file specified in package.json "main" doesn't exist

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

@@ -8,12 +8,12 @@ const process = require('process')
 const { performance, PerformanceObserver, monitorEventLoopDelay } = require('perf_hooks')
 const { DogStatsDClient, MetricsAggregationClient } = require('../dogstatsd')
 const log = require('../log')
-const { getEnvironmentVariable } = require('../config-helper')
+const { getValueFromEnvSources } = require('../config/helper')
 
 const { NODE_MAJOR } = require('../../../../version')
 // TODO: This environment variable may not be changed, since the agent expects a flush every ten seconds.
 // It is only a variable for testing. Think about alternatives.
-const DD_RUNTIME_METRICS_FLUSH_INTERVAL = getEnvironmentVariable('DD_RUNTIME_METRICS_FLUSH_INTERVAL') ?? '10000'
+const DD_RUNTIME_METRICS_FLUSH_INTERVAL = getValueFromEnvSources('DD_RUNTIME_METRICS_FLUSH_INTERVAL') ?? '10000'
 const INTERVAL = Number.parseInt(DD_RUNTIME_METRICS_FLUSH_INTERVAL, 10)
 
 const eventLoopDelayResolution = 4

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const { getEnvironmentVariable } = require('./config-helper')
+const { getEnvironmentVariable, getValueFromEnvSources } = require('./config/helper')
 const { isFalse } = require('./util')
 
 function getIsGCPFunction () {
@@ -19,7 +19,7 @@ function getIsGCPFunction () {
  * PUSH: GCP sends HTTP POST requests to the service with message data in headers.
  */
 function enableGCPPubSubPushSubscription () {
-  const isGCPPubSubPushSubscriptionEnabled = getEnvironmentVariable('DD_TRACE_GCP_PUBSUB_PUSH_ENABLED')
+  const isGCPPubSubPushSubscriptionEnabled = getValueFromEnvSources('DD_TRACE_GCP_PUBSUB_PUSH_ENABLED')
   return getEnvironmentVariable('K_SERVICE') !== undefined && !isFalse(isGCPPubSubPushSubscriptionEnabled)
 }
 

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

@@ -4,8 +4,8 @@ const log = require('./log')
 const spanFormat = require('./span_format')
 const SpanSampler = require('./span_sampler')
 const GitMetadataTagger = require('./git_metadata_tagger')
-const { getEnvironmentVariable } = require('./config-helper')
 const processTags = require('./process-tags')
+const { getValueFromEnvSources } = require('./config/helper')
 
 const startedSpans = new WeakSet()
 const finishedSpans = new WeakSet()
@@ -88,7 +88,7 @@ class SpanProcessor {
   }
 
   _erase (trace, active) {
-    if (getEnvironmentVariable('DD_TRACE_EXPERIMENTAL_STATE_TRACKING') === 'true') {
+    if (getValueFromEnvSources('DD_TRACE_EXPERIMENTAL_STATE_TRACKING') === 'true') {
       const started = new Set()
       const startedIds = new Set()
       const finished = new Set()

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

@@ -2,9 +2,8 @@
 
 const os = require('os')
 const { inspect } = require('util')
-
 const tracerVersion = require('../../../package.json').version
-const defaults = require('./config_defaults')
+const defaults = require('./config/defaults')
 const { info, warn } = require('./log/writer')
 
 const errors = {}
@@ -15,23 +14,15 @@ let samplingRules = []
 let alreadyRan = false
 
 /**
- * @param {{ agentError: { code: string, message: string } }} [options]
+ * @param {{ status: number, message: string } } [agentError]
  */
-function startupLog ({ agentError } = {}) {
-  if (!config || !pluginManager) {
-    return
-  }
-
-  if (alreadyRan) {
+function startupLog (agentError) {
+  if (alreadyRan || !config || !config.startupLogs || !pluginManager) {
     return
   }
 
   alreadyRan = true
 
-  if (!config.startupLogs) {
-    return
-  }
-
   const out = tracerInfo()
 
   if (agentError) {
@@ -42,8 +33,8 @@ function startupLog ({ agentError } = {}) {
   if (agentError) {
     warn('DATADOG TRACER DIAGNOSTIC - Agent Error: ' + agentError.message)
     errors.agentError = {
-      code: agentError.code ?? '',
-      message: `Agent Error:${agentError.message}`
+      code: agentError.status,
+      message: `Agent Error: ${agentError.message}`
     }
   }
 }

package/packages/dd-trace/src/telemetry/endpoints.js

@@ -3,35 +3,75 @@
 const dc = require('dc-polyfill')
 const { sendData } = require('./send-data')
 
+/**
+ * RetryData is information that `telemetry.js` keeps in-memory to be merged into the next payload.
+ *
+ * @callback GetRetryData
+ * @returns {{ payload: Record<string, unknown>, reqType: string } | null}
+ */
+/**
+ * @typedef {import('./send-data').TelemetryConfig & {
+ *   appsec?: { apiSecurity?: { endpointCollectionEnabled?: boolean, endpointCollectionMessageLimit?: number } }
+ * }} TelemetryConfig
+ */
+
 const fastifyRouteCh = dc.channel('apm:fastify:route:added')
 const expressRouteCh = dc.channel('apm:express:route:added')
 const routerRouteCh = dc.channel('apm:router:route:added')
 
+/** @type {TelemetryConfig} */
 let config
+
+/** @type {import('./send-data').TelemetryApplication} */
 let application
+
+/** @type {import('./send-data').TelemetryHost} */
 let host
+
+/** @type {GetRetryData} */
 let getRetryData
+
+/** @type {import('./send-data').SendDataCallback} */
 let updateRetryData
 
 /**
  * Keep track of endpoints that still need to be sent.
  * Map key is `${METHOD} ${PATH}`, value is { method, path, operationName }
  */
+/** @type {Map<string, { method: string, path: string, operationName: string }>} */
 const pendingEndpoints = new Map()
+
+/** @type {Set<string>} */
 const wildcardEndpoints = new Set()
 let flushScheduled = false
 let isFirstPayload = true
 
+/**
+ * @param {string} method
+ * @param {string} path
+ * @returns {string}
+ */
 function endpointKey (method, path) {
   return `${method.toUpperCase()} ${path}`
 }
 
+/**
+ * @returns {void}
+ */
 function scheduleFlush () {
   if (flushScheduled) return
   flushScheduled = true
-  setImmediate(flushAndSend).unref()
+  // this used to be setImmediate() instead, but it was making the system test flaky
+  // don't ask me why
+  setTimeout(flushAndSend).unref()
 }
 
+/**
+ * @param {string} method
+ * @param {string} path
+ * @param {string} operationName
+ * @returns {void}
+ */
 function recordEndpoint (method, path, operationName) {
   const key = endpointKey(method, path)
   if (pendingEndpoints.has(key)) return
@@ -40,6 +80,9 @@ function recordEndpoint (method, path, operationName) {
   scheduleFlush()
 }
 
+/**
+ * @param {{ routeOptions?: { path?: string, method: string | string[] } } | null | undefined} routeData
+ */
 function onFastifyRoute (routeData) {
   const routeOptions = routeData?.routeOptions
   if (!routeOptions?.path) return
@@ -50,6 +93,9 @@ function onFastifyRoute (routeData) {
   }
 }
 
+/**
+ * @param {{ method?: string, path?: string }} param0
+ */
 function onExpressRoute ({ method, path }) {
   if (!method || !path) return
 
@@ -70,6 +116,9 @@ function onExpressRoute ({ method, path }) {
   }
 }
 
+/**
+ * @param {{ method: string, path: string, operationName: string }[]} endpoints
+ */
 function buildEndpointObjects (endpoints) {
   return endpoints.map(({ method, path, operationName }) => {
     return {
@@ -82,6 +131,9 @@ function buildEndpointObjects (endpoints) {
   })
 }
 
+/**
+ * @returns {void}
+ */
 function flushAndSend () {
   flushScheduled = false
   if (pendingEndpoints.size === 0) return
@@ -90,7 +142,8 @@ function flushAndSend () {
   for (const [key, endpoint] of pendingEndpoints) {
     batchEndpoints.push(endpoint)
     pendingEndpoints.delete(key)
-    if (batchEndpoints.length >= config.appsec?.apiSecurity?.endpointCollectionMessageLimit) break
+    // Config is set when endpoint collection is enabled; message limit is optional
+    if (batchEndpoints.length >= (config.appsec?.apiSecurity?.endpointCollectionMessageLimit ?? 0)) break
   }
 
   const payloadObj = {
@@ -98,7 +151,10 @@ function flushAndSend () {
     endpoints: buildEndpointObjects(batchEndpoints)
   }
 
+  /** @type {import('./send-data').TelemetryRequestType} */
   let reqType = 'app-endpoints'
+
+  /** @type {import('./send-data').TelemetryPayload} */
   let payload = payloadObj
 
   const retryData = getRetryData()
@@ -120,8 +176,15 @@ function flushAndSend () {
   if (pendingEndpoints.size) scheduleFlush()
 }
 
-function start (_config = {}, _application, _host, getRetryDataFunction, updateRetryDataFunction) {
-  if (!_config?.appsec?.apiSecurity?.endpointCollectionEnabled) return
+/**
+ * @param {TelemetryConfig} _config
+ * @param {import('./send-data').TelemetryApplication} _application
+ * @param {import('./send-data').TelemetryHost} _host
+ * @param {GetRetryData} getRetryDataFunction
+ * @param {import('./send-data').SendDataCallback} updateRetryDataFunction
+ */
+function start (_config, _application, _host, getRetryDataFunction, updateRetryDataFunction) {
+  if (!_config.appsec?.apiSecurity?.endpointCollectionEnabled) return
 
   config = _config
   application = _application
@@ -141,7 +204,6 @@ function stop () {
 
   pendingEndpoints.clear()
   flushScheduled = false
-  config = application = host = getRetryData = updateRetryData = null
 }
 
 module.exports = {

package/packages/dd-trace/src/telemetry/send-data.js

@@ -3,10 +3,93 @@
 const request = require('../exporters/common/request')
 const log = require('../log')
 const { isTrue } = require('../util')
-const { getEnvironmentVariable } = require('../config-helper')
+const { getValueFromEnvSources } = require('../config/helper')
+
+/**
+ * @typedef {Record<string, unknown>} TelemetryPayloadObject
+ */
+/**
+ * Telemetry "request_type" values sent by this library.
+ *
+ * @typedef {'app-started'
+ *   | 'app-integrations-change'
+ *   | 'app-heartbeat'
+ *   | 'app-extended-heartbeat'
+ *   | 'app-client-configuration-change'
+ *   | 'app-closing'
+ *   | 'app-dependencies-loaded'
+ *   | 'app-endpoints'
+ *   | 'generate-metrics'
+ *   | 'distributions'
+ *   | 'logs'
+ *   | 'message-batch'} TelemetryRequestType
+ */
+/**
+ * @typedef {{ request_type: string, payload: TelemetryPayloadObject }} MessageBatchItem
+ */
+/**
+ * @typedef {MessageBatchItem[]} MessageBatchPayload
+ */
+/**
+ * Telemetry payloads are usually single objects, but some request types (e.g. `message-batch`)
+ * send arrays.
+ *
+ * @typedef {TelemetryPayloadObject | MessageBatchPayload} TelemetryPayload
+ */
+/**
+ * @typedef {{language_name: string, tracer_version: string} & Record<string, unknown>} TelemetryApplication
+ */
+/**
+ * @typedef {Exclude<TelemetryRequestType, 'message-batch'>} NonBatchTelemetryRequestType
+ */
+/**
+ * @typedef {{
+ *   payload: TelemetryPayloadObject,
+ *   reqType: NonBatchTelemetryRequestType
+ * } | {
+ *   payload: MessageBatchPayload,
+ *   reqType: 'message-batch'
+ * }} SendDataRetryObject
+ */
+/**
+ * @typedef {{
+ *   hostname: string,
+ *   os: string,
+ *   architecture: string,
+ *   os_version?: string,
+ *   kernel_version?: string,
+ *   kernel_release?: string,
+ *   kernel_name?: string
+ * } & Record<string, unknown>} TelemetryHost
+ */
+/**
+ * @typedef {{
+ *   hostname?: string,
+ *   port?: string | number,
+ *   url?: string | URL,
+ *   site?: string,
+ *   apiKey?: string,
+ *   isCiVisibility?: boolean,
+ *   spanAttributeSchema?: string,
+ *   tags: Record<string, string>,
+ *   telemetry?: { debug?: boolean }
+ * }} TelemetryConfig
+ */
+/**
+ * @callback SendDataCallback
+ * @param {Error | null | undefined} error
+ * @param {SendDataRetryObject} retryObj
+ * @returns {void}
+ */
 
 let agentTelemetry = true
 
+/**
+ * @param {TelemetryConfig} config
+ * @param {TelemetryApplication} application
+ * @param {TelemetryRequestType} reqType
+ * @returns {Record<string, string>}
+ */
 function getHeaders (config, application, reqType) {
   const headers = {
     'content-type': 'application/json',
@@ -25,6 +108,9 @@ function getHeaders (config, application, reqType) {
   return headers
 }
 
+/**
+ * @param {string | undefined} site
+ */
 function getAgentlessTelemetryEndpoint (site) {
   if (site === 'datad0g.com') { // staging
     return 'https://all-http-intake.logs.datad0g.com'
@@ -34,6 +120,10 @@ function getAgentlessTelemetryEndpoint (site) {
 
 let seqId = 0
 
+/**
+ * @param {TelemetryPayload} payload
+ * @returns {TelemetryPayload}
+ */
 function getPayload (payload) {
   // Some telemetry endpoints payloads accept collections of elements such as the 'logs' endpoint.
   // 'logs' request type payload is meant to send library logs to Datadog’s backend.
@@ -44,6 +134,15 @@ function getPayload (payload) {
   return trimmedPayload
 }
 
+// TODO(BridgeAR): Simplify this code. A lot does not need to be recalculated on every call.
+/**
+ * @param {TelemetryConfig} config
+ * @param {TelemetryApplication} application
+ * @param {TelemetryHost} host
+ * @param {TelemetryRequestType} reqType
+ * @param {TelemetryPayload} [payload]
+ * @param {SendDataCallback} [cb]
+ */
 function sendData (config, application, host, reqType, payload = {}, cb = () => {}) {
   const {
     hostname,
@@ -54,7 +153,7 @@ function sendData (config, application, host, reqType, payload = {}, cb = () =>
   let url = config.url
 
   const isCiVisibilityAgentlessMode = isCiVisibility &&
-                                      isTrue(getEnvironmentVariable('DD_CIVISIBILITY_AGENTLESS_ENABLED'))
+                                      isTrue(getValueFromEnvSources('DD_CIVISIBILITY_AGENTLESS_ENABLED'))
 
   if (isCiVisibilityAgentlessMode) {
     try {
@@ -88,14 +187,14 @@ function sendData (config, application, host, reqType, payload = {}, cb = () =>
   })
 
   request(data, options, (error) => {
-    if (error && getEnvironmentVariable('DD_API_KEY') && config.site) {
+    if (error && getValueFromEnvSources('DD_API_KEY') && config.site) {
       if (agentTelemetry) {
         log.warn('Agent telemetry failed, started agentless telemetry')
         agentTelemetry = false
       }
       // figure out which data center to send to
       const backendUrl = getAgentlessTelemetryEndpoint(config.site)
-      const backendHeader = { ...options.headers, 'DD-API-KEY': getEnvironmentVariable('DD_API_KEY') }
+      const backendHeader = { ...options.headers, 'DD-API-KEY': getValueFromEnvSources('DD_API_KEY') }
       const backendOptions = {
         ...options,
         url: backendUrl,