dd-trace 5.81.0 → 5.83.0

package/packages/dd-trace/src/require-package-json.js

@@ -12,7 +12,7 @@ const fs = require('fs')
  * @typedef { import('module').Module } Module
  * @param {string} name
  * @param {Module} module
- * @returns {Object} The parsed package.json
+ * @returns {object} The parsed package.json
  */
 function requirePackageJson (name, module) {
   if (path.isAbsolute(name)) {

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

@@ -1,13 +1,16 @@
 'use strict'
 
 const path = require('path')
+const fs = require('fs')
 const Module = require('module')
-const parse = require('../../../vendor/dist/module-details-from-path')
+
 const dc = require('dc-polyfill')
-const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
 
-const origRequire = Module.prototype.require
+const parse = require('../../../vendor/dist/module-details-from-path')
+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
 
 module.exports = Hook
@@ -60,18 +63,19 @@ 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)
     }
-
     const core = !filename.includes(path.sep)
     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
@@ -111,38 +115,49 @@ 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
       // first case will only happen when patching an AWS Lambda Handler
       const stat = inAWSLambda && hasLambdaHandler && !filenameFromNodeModule ? { name: filename } : parse(filename)
-      if (!stat) return exports // abort if filename could not be parsed
-      name = stat.name
-      basedir = stat.basedir
-
-      hooks = moduleHooks[name]
-      if (!hooks) return exports // abort if module name isn't on whitelist
 
-      // figure out if this is the main module file, or a file inside the module
-      const paths = Module._resolveLookupPaths(name, this, true)
-      if (!paths) {
-        // abort if _resolveLookupPaths return null
-        return exports
-      }
-
-      let res
-      try {
-        res = Module._findPath(name, [basedir, ...paths])
-      } catch {
-        // case where the file specified in package.json "main" doesn't exist
-        // in this case, the file is treated as module-internal
-      }
+      if (stat) {
+        name = stat.name
+        basedir = stat.basedir
+
+        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
+          return exports
+        }
+
+        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
+          // in this case, the file is treated as module-internal
+        }
+
+        if (!res || res !== filename) {
+          // this is a module-internal file
+          // use the module-relative path to the file, prefixed by original module name
+          name = name + path.sep + path.relative(basedir, filename)
+        }
+      } else {
+        if (isRelativeRequire(request) && moduleHooks[request]) {
+          hooks = moduleHooks[request]
+          name = request
+          basedir = findProjectRoot(filename)
+        }
 
-      if (!res || res !== filename) {
-        // this is a module-internal file
-        // use the module-relative path to the file, prefixed by original module name
-        name = name + path.sep + path.relative(basedir, filename)
+        if (!hooks) return exports
       }
     }
 
@@ -167,6 +182,18 @@ Hook.reset = function () {
   moduleHooks = Object.create(null)
 }
 
+function findProjectRoot (startDir) {
+  let dir = startDir
+
+  while (!fs.existsSync(path.join(dir, 'package.json'))) {
+    const parent = path.dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+
+  return dir
+}
+
 Hook.prototype.unhook = function () {
   for (const mod of this.modules) {
     const hooks = (moduleHooks[mod] || []).filter(hook => hook !== this.onrequire)

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

@@ -5,15 +5,15 @@
 const v8 = require('v8')
 const os = require('os')
 const process = require('process')
+const { performance, PerformanceObserver, monitorEventLoopDelay } = require('perf_hooks')
 const { DogStatsDClient, MetricsAggregationClient } = require('../dogstatsd')
 const log = require('../log')
-const { performance, PerformanceObserver, monitorEventLoopDelay } = require('perf_hooks')
-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,7 @@
 'use strict'
 
-const { getEnvironmentVariable } = require('./config-helper')
+const { getEnvironmentVariable, getValueFromEnvSources } = require('./config/helper')
+const { isFalse } = require('./util')
 
 function getIsGCPFunction () {
   const isDeprecatedGCPFunction =
@@ -13,6 +14,15 @@ function getIsGCPFunction () {
   return isDeprecatedGCPFunction || isNewerGCPFunction
 }
 
+/**
+ * Enable GCP Pub/Sub PUSH subscription tracing for Cloud Run (K_SERVICE present).
+ * PUSH: GCP sends HTTP POST requests to the service with message data in headers.
+ */
+function enableGCPPubSubPushSubscription () {
+  const isGCPPubSubPushSubscriptionEnabled = getValueFromEnvSources('DD_TRACE_GCP_PUBSUB_PUSH_ENABLED')
+  return getEnvironmentVariable('K_SERVICE') !== undefined && !isFalse(isGCPPubSubPushSubscriptionEnabled)
+}
+
 function getIsAzureFunction () {
   const isAzureFunction =
     getEnvironmentVariable('FUNCTIONS_EXTENSION_VERSION') !== undefined &&
@@ -21,6 +31,10 @@ function getIsAzureFunction () {
   return isAzureFunction
 }
 
+function getIsFlexConsumptionAzureFunction () {
+  return getIsAzureFunction() && getEnvironmentVariable('WEBSITE_SKU') === 'FlexConsumption'
+}
+
 function isInServerlessEnvironment () {
   const inAWSLambda = getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME') !== undefined
   const isGCPFunction = getIsGCPFunction()
@@ -32,5 +46,7 @@ function isInServerlessEnvironment () {
 module.exports = {
   getIsGCPFunction,
   getIsAzureFunction,
+  enableGCPPubSubPushSubscription,
+  getIsFlexConsumptionAzureFunction,
   isInServerlessEnvironment
 }

package/packages/dd-trace/src/service-naming/schemas/v0/messaging.js

@@ -47,6 +47,10 @@ const messaging = {
     sns: {
       opName: () => 'aws.request',
       serviceName: awsServiceV0
+    },
+    bullmq: {
+      opName: () => 'bullmq.add',
+      serviceName: ({ tracerService }) => `${tracerService}-bullmq`
     }
   },
   consumer: {
@@ -77,6 +81,10 @@ const messaging = {
     sqs: {
       opName: () => 'aws.request',
       serviceName: awsServiceV0
+    },
+    bullmq: {
+      opName: () => 'bullmq.processJob',
+      serviceName: ({ tracerService }) => `${tracerService}-bullmq`
     }
   },
   client: {

package/packages/dd-trace/src/service-naming/schemas/v1/messaging.js

@@ -44,6 +44,10 @@ const messaging = {
     sns: {
       opName: () => 'aws.sns.send',
       serviceName: identityService
+    },
+    bullmq: {
+      opName: () => 'bullmq.add',
+      serviceName: identityService
     }
   },
   consumer: {
@@ -65,6 +69,10 @@ const messaging = {
     sqs: {
       opName: () => 'aws.sqs.process',
       serviceName: identityService
+    },
+    bullmq: {
+      opName: () => 'bullmq.processJob',
+      serviceName: identityService
     }
   },
   client: {

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

@@ -1,7 +1,7 @@
 'use strict'
 
-const constants = require('./constants')
 const tags = require('../../../ext/tags')
+const constants = require('./constants')
 const id = require('./id')
 const { isError } = require('./util')
 const { registerExtraService } = require('./service-naming/extra-services')

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 getProcessTags = require('./process-tags')
+const processTags = require('./process-tags')
+const { getValueFromEnvSources } = require('./config/helper')
 
 const startedSpans = new WeakSet()
 const finishedSpans = new WeakSet()
@@ -27,7 +27,7 @@ class SpanProcessor {
     this._gitMetadataTagger = new GitMetadataTagger(config)
 
     this._processTags = config.propagateProcessTags?.enabled
-      ? getProcessTags().serialized
+      ? processTags.serialized
       : false
   }
 
@@ -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/span_stats.js

@@ -1,11 +1,9 @@
 'use strict'
 
-const os = require('os')
-const { version } = require('./pkg')
+const os = require('node:os')
 const pkg = require('../../../package.json')
 
 const { LogCollapsingLowestDenseDDSketch } = require('../../../vendor/dist/@datadog/sketches-js')
-const { ORIGIN_KEY, TOP_LEVEL_KEY } = require('./constants')
 const {
   MEASURED,
   HTTP_STATUS_CODE,
@@ -13,6 +11,9 @@ const {
   HTTP_ROUTE,
   HTTP_METHOD
 } = require('../../../ext/tags')
+const { ORIGIN_KEY, TOP_LEVEL_KEY } = require('./constants')
+const { version } = require('./pkg')
+const processTags = require('./process-tags')
 
 const { SpanStatsExporter } = require('./exporters/span-stats')
 
@@ -176,7 +177,8 @@ class SpanStatsProcessor {
       Lang: 'javascript',
       TracerVersion: pkg.version,
       RuntimeID: this.tags['runtime-id'],
-      Sequence: ++this.sequence
+      Sequence: ++this.sequence,
+      ProcessTags: processTags.serialized
     })
   }
 

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

@@ -1,10 +1,10 @@
 'use strict'
 
 const { channel } = require('dc-polyfill')
-const TraceSourcePrioritySampler = require('./tracesource_priority_sampler')
 const { USER_KEEP } = require('../../../../ext/priority')
 const TraceState = require('../opentracing/propagation/tracestate')
 const { APM_TRACING_ENABLED_KEY } = require('../constants')
+const TraceSourcePrioritySampler = require('./tracesource_priority_sampler')
 const { hasTraceSourcePropagationTag } = require('./tracesource')
 
 const startCh = channel('dd-trace:span:start')

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

@@ -1,11 +1,10 @@
 'use strict'
 
-const { info, warn } = require('./log/writer')
-
 const os = require('os')
 const { inspect } = require('util')
-const defaults = require('./config_defaults')
 const tracerVersion = require('../../../package.json').version
+const defaults = require('./config/defaults')
+const { info, warn } = require('./log/writer')
 
 const errors = {}
 let config
@@ -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/dependencies.js

@@ -1,12 +1,12 @@
 'use strict'
 
 const path = require('path')
+const { fileURLToPath } = require('url')
+const dc = require('dc-polyfill')
 const parse = require('../../../../vendor/dist/module-details-from-path')
 const requirePackageJson = require('../require-package-json')
-const { sendData } = require('./send-data')
-const dc = require('dc-polyfill')
-const { fileURLToPath } = require('url')
 const { isTrue } = require('../../src/util')
+const { sendData } = require('./send-data')
 
 /** @type {Set<string>} */
 const savedDependenciesToSend = new Set()

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

@@ -3,60 +3,106 @@
 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 }
+ * 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()
 }
 
-function recordEndpoint (method, path) {
+/**
+ * @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
 
-  pendingEndpoints.set(key, { method: method.toUpperCase(), path })
+  pendingEndpoints.set(key, { method: method.toUpperCase(), path, operationName })
   scheduleFlush()
 }
 
+/**
+ * @param {{ routeOptions?: { path?: string, method: string | string[] } } | null | undefined} routeData
+ */
 function onFastifyRoute (routeData) {
   const routeOptions = routeData?.routeOptions
   if (!routeOptions?.path) return
 
   const methods = Array.isArray(routeOptions.method) ? routeOptions.method : [routeOptions.method]
   for (const method of methods) {
-    recordEndpoint(method, routeOptions.path)
+    recordEndpoint(method, routeOptions.path, 'fastify.request')
   }
 }
 
+/**
+ * @param {{ method?: string, path?: string }} param0
+ */
 function onExpressRoute ({ method, path }) {
   if (!method || !path) return
 
   // If wildcard already recorded for this path, skip specific methods
   if (wildcardEndpoints.has(path)) return
 
-  recordEndpoint(method, path)
+  recordEndpoint(method, path, 'express.request')
 
   // If this is a wildcard event, record it and mark path as wildcarded
   if (method === '*') {
@@ -66,22 +112,28 @@ function onExpressRoute ({ method, path }) {
 
   // Express automatically adds HEAD support for GET routes
   if (method.toUpperCase() === 'GET') {
-    recordEndpoint('HEAD', path)
+    recordEndpoint('HEAD', path, 'express.request')
   }
 }
 
+/**
+ * @param {{ method: string, path: string, operationName: string }[]} endpoints
+ */
 function buildEndpointObjects (endpoints) {
-  return endpoints.map(({ method, path }) => {
+  return endpoints.map(({ method, path, operationName }) => {
     return {
       type: 'REST',
       method,
       path,
-      operation_name: 'http.request',
+      operation_name: operationName,
       resource_name: endpointKey(method, path)
     }
   })
 }
 
+/**
+ * @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/logs/index.js

@@ -1,8 +1,8 @@
 'use strict'
 
 const dc = require('dc-polyfill')
-const logCollector = require('./log-collector')
 const { sendData } = require('../send-data')
+const logCollector = require('./log-collector')
 
 const telemetryLog = dc.channel('datadog:telemetry:log')
 const errorLog = dc.channel('datadog:log:error')