dd-trace 4.38.1 → 4.40.0

package/packages/dd-trace/src/profiling/{ssi-telemetry.js → ssi-heuristics.js}

@@ -2,28 +2,25 @@
 
 const telemetryMetrics = require('../telemetry/metrics')
 const profilersNamespace = telemetryMetrics.manager.namespace('profilers')
-const performance = require('perf_hooks').performance
 const dc = require('dc-polyfill')
-const { isTrue, isFalse } = require('../util')
 
-// If the process lived for less than 30 seconds, it's considered short-lived
-const DEFAULT_SHORT_LIVED_THRESHOLD = 30000
+// If the process lives for at least 30 seconds, it's considered long-lived
+const DEFAULT_LONG_LIVED_THRESHOLD = 30000
 
 const EnablementChoice = {
   MANUALLY_ENABLED: Symbol('SSITelemetry.EnablementChoice.MANUALLY_ENABLED'),
   SSI_ENABLED: Symbol('SSITelemetry.EnablementChoice.SSI_ENABLED'),
   SSI_NOT_ENABLED: Symbol('SSITelemetry.EnablementChoice.SSI_NOT_ENABLED'),
-  DISABLED: Symbol('SSITelemetry.EnablementChoice.MANUALLY_DISABLED')
+  DISABLED: Symbol('SSITelemetry.EnablementChoice.DISABLED')
 }
 Object.freeze(EnablementChoice)
 
-function getEnablementChoiceFromEnv () {
-  const { DD_PROFILING_ENABLED, DD_INJECTION_ENABLED } = process.env
-  if (DD_INJECTION_ENABLED === undefined || isFalse(DD_PROFILING_ENABLED)) {
+function getEnablementChoiceFromConfig (config) {
+  if (config.ssi === false || config.enabled === false) {
     return EnablementChoice.DISABLED
-  } else if (DD_INJECTION_ENABLED.split(',').includes('profiling')) {
+  } else if (config.heuristicsEnabled === true) {
     return EnablementChoice.SSI_ENABLED
-  } else if (isTrue(DD_PROFILING_ENABLED)) {
+  } else if (config.enabled === true) {
     return EnablementChoice.MANUALLY_ENABLED
   } else {
     return EnablementChoice.SSI_NOT_ENABLED
@@ -38,39 +35,38 @@ function enablementChoiceToTagValue (enablementChoice) {
       return 'ssi_enabled'
     case EnablementChoice.SSI_NOT_ENABLED:
       return 'not_enabled'
-    case EnablementChoice.MANUALLY_DISABLED:
+    case EnablementChoice.DISABLED:
       // Can't emit this one as a tag
       throw new Error('Invalid enablement choice')
   }
 }
 
 /**
- * This class emits telemetry metrics about the profiler behavior under SSI. It will only emit metrics
- * when the application closes, and will emit the following metrics:
+ * This class embodies the SSI profiler-triggering heuristics and also emits telemetry metrics about
+ * the profiler behavior under SSI. It emits the following metrics:
  * - `number_of_profiles`: The number of profiles that were submitted
- * - `number_of_runtime_id`: The number of runtime IDs in the app (always 1 for Node.js)
- * It will also add tags describing the state of heuristics triggers, the enablement choice, and whether
- * actual profiles were sent (as opposed to mock profiles). There is a mock profiler that is activated
- * when the profiler is not enabled, and it will emit mock profile submission events at the same cadence
- * the profiler would, providing insight into how many profiles would've been emitted if SSI enabled
- * profiling. Note that telemetry is per tracer instance, and each worker thread will have its own instance.
+ * - `number_of_runtime_id`: The number of runtime IDs in the app (always 1 for Node.js, emitted
+ *   once when the tags won't change for the remaineder of of the app's lifetime.)
+ * It will also add tags describing the state of heuristics triggers, the enablement choice, and
+ * whether actual profiles were sent (as opposed to mock profiles). There is a mock profiler that is
+ * activated when the profiler is not enabled, and it will emit mock profile submission events at
+ * the same cadence the profiler would, providing insight into how many profiles would've been
+ * emitted if SSI enabled profiling. Note that heuristics (and thus telemetry) is per tracer
+ * instance, and each worker thread will have its own instance.
  */
-class SSITelemetry {
-  constructor ({
-    enablementChoice = getEnablementChoiceFromEnv(),
-    shortLivedThreshold = DEFAULT_SHORT_LIVED_THRESHOLD
-  } = {}) {
-    if (!Object.values(EnablementChoice).includes(enablementChoice)) {
-      throw new Error('Invalid enablement choice')
-    }
-    if (typeof shortLivedThreshold !== 'number' || shortLivedThreshold <= 0) {
-      throw new Error('Short-lived threshold must be a positive number')
+class SSIHeuristics {
+  constructor (config) {
+    this.enablementChoice = getEnablementChoiceFromConfig(config)
+
+    const longLivedThreshold = config.longLivedThreshold || DEFAULT_LONG_LIVED_THRESHOLD
+    if (typeof longLivedThreshold !== 'number' || longLivedThreshold <= 0) {
+      throw new Error('Long-lived threshold must be a positive number')
     }
-    this.enablementChoice = enablementChoice
-    this.shortLivedThreshold = shortLivedThreshold
+    this.longLivedThreshold = longLivedThreshold
 
     this.hasSentProfiles = false
     this.noSpan = true
+    this.shortLived = true
   }
 
   enabled () {
@@ -83,7 +79,10 @@ class SSITelemetry {
       // reference point, but the tracer initialization point is more relevant, as we couldn't be
       // collecting profiles earlier anyway. The difference is not particularly significant if the
       // tracer is initialized early in the process lifetime.
-      this.startTime = performance.now()
+      setTimeout(() => {
+        this.shortLived = false
+        this._maybeTriggered()
+      }, this.longLivedThreshold).unref()
 
       this._onSpanCreated = this._onSpanCreated.bind(this)
       this._onProfileSubmitted = this._onProfileSubmitted.bind(this)
@@ -97,8 +96,31 @@ class SSITelemetry {
     }
   }
 
+  onTriggered (callback) {
+    switch (typeof callback) {
+      case 'undefined':
+      case 'function':
+        this.triggeredCallback = callback
+        process.nextTick(() => {
+          this._maybeTriggered()
+        })
+        break
+      default:
+        throw new TypeError('callback must be a function or undefined')
+    }
+  }
+
+  _maybeTriggered () {
+    if (!this.shortLived && !this.noSpan) {
+      if (typeof this.triggeredCallback === 'function') {
+        this.triggeredCallback.call(null)
+      }
+    }
+  }
+
   _onSpanCreated () {
     this.noSpan = false
+    this._maybeTriggered()
     dc.unsubscribe('dd-trace:span:start', this._onSpanCreated)
   }
 
@@ -121,7 +143,7 @@ class SSITelemetry {
     if (this.noSpan) {
       decision.push('no_span')
     }
-    if (performance.now() - this.startTime < this.shortLivedThreshold) {
+    if (this.shortLived) {
       decision.push('short_lived')
     }
     if (decision.length === 0) {
@@ -138,8 +160,14 @@ class SSITelemetry {
     this._profileCount = profilersNamespace.count('ssi_heuristic.number_of_profiles', tags)
     this._runtimeIdCount = profilersNamespace.count('ssi_heuristic.number_of_runtime_id', tags)
 
-    if (!this._emittedRuntimeId && decision[0] === 'triggered') {
-      // Tags won't change anymore, so we can emit the runtime ID metric now
+    if (
+      !this._emittedRuntimeId &&
+      decision[0] === 'triggered' &&
+      // When enablement choice is SSI_ENABLED, hasSentProfiles can transition from false to true when the
+      // profiler gets started and the first profile is submitted, so we have to wait for it.
+      (this.enablementChoice !== EnablementChoice.SSI_ENABLED || this.hasSentProfiles)
+    ) {
+      // Tags won't change anymore, so we can emit the runtime ID metric now.
       this._emittedRuntimeId = true
       this._runtimeIdCount.inc()
     }
@@ -164,4 +192,4 @@ class SSITelemetry {
   }
 }
 
-module.exports = { SSITelemetry, EnablementChoice }
+module.exports = { SSIHeuristics, EnablementChoice }

package/packages/dd-trace/src/profiling/ssi-telemetry-mock-profiler.js

@@ -12,16 +12,11 @@ module.exports = {
     // Copied from packages/dd-trace/src/profiler.js
     const flushInterval = coalesce(config.interval, Number(DD_PROFILING_UPLOAD_PERIOD) * 1000, 65 * 1000)
 
-    function scheduleProfileSubmit () {
-      timerId = setTimeout(emitProfileSubmit, flushInterval)
-    }
-
-    function emitProfileSubmit () {
+    timerId = setTimeout(() => {
       profileSubmittedChannel.publish()
-      scheduleProfileSubmit()
-    }
-
-    scheduleProfileSubmit()
+      timerId.refresh()
+    }, flushInterval)
+    timerId.unref()
   },
 
   stop: () => {

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

@@ -13,7 +13,7 @@ const AppsecSdk = require('./appsec/sdk')
 const dogstatsd = require('./dogstatsd')
 const NoopDogStatsDClient = require('./noop/dogstatsd')
 const spanleak = require('./spanleak')
-const { SSITelemetry } = require('./profiling/ssi-telemetry')
+const { SSIHeuristics } = require('./profiling/ssi-heuristics')
 const telemetryLog = require('dc-polyfill').channel('datadog:telemetry:log')
 
 class LazyModule {
@@ -40,6 +40,7 @@ class Tracer extends NoopProxy {
     this._pluginManager = new PluginManager(this)
     this.dogstatsd = new NoopDogStatsDClient()
     this._tracingInitialized = false
+    this._flare = new LazyModule(() => require('./flare'))
 
     // these requires must work with esm bundler
     this._modules = {
@@ -90,29 +91,46 @@ class Tracer extends NoopProxy {
           }
           this._enableOrDisableTracing(config)
         })
+
+        rc.on('AGENT_CONFIG', (action, conf) => {
+          if (!conf?.name?.startsWith('flare-log-level.')) return
+
+          if (action === 'unapply') {
+            this._flare.disable()
+          } else if (conf.config?.log_level) {
+            this._flare.enable(config)
+            this._flare.module.prepare(conf.config.log_level)
+          }
+        })
+
+        rc.on('AGENT_TASK', (action, conf) => {
+          if (action === 'unapply' || !conf) return
+          if (conf.task_type !== 'tracer_flare' || !conf.args) return
+
+          this._flare.enable(config)
+          this._flare.module.send(conf.args)
+        })
       }
 
       if (config.isGCPFunction || config.isAzureFunction) {
         require('./serverless').maybeStartServerlessMiniAgent(config)
       }
 
-      const ssiTelemetry = new SSITelemetry()
-      ssiTelemetry.start()
+      const ssiHeuristics = new SSIHeuristics(config.profiling)
+      ssiHeuristics.start()
       if (config.profiling.enabled) {
-        // do not stop tracer initialization if the profiler fails to be imported
-        try {
-          const profiler = require('./profiler')
-          this._profilerStarted = profiler.start(config)
-        } catch (e) {
-          log.error(e)
-          telemetryLog.publish({
-            message: e.message,
-            level: 'ERROR',
-            stack_trace: e.stack
+        this._profilerStarted = this._startProfiler(config)
+      } else if (config.profiling.ssi) {
+        const mockProfiler = require('./profiling/ssi-telemetry-mock-profiler')
+        mockProfiler.start(config)
+
+        if (config.profiling.heuristicsEnabled) {
+          ssiHeuristics.onTriggered(() => {
+            mockProfiler.stop()
+            this._startProfiler(config)
+            ssiHeuristics.onTriggered()
           })
         }
-      } else if (ssiTelemetry.enabled()) {
-        require('./profiling/ssi-telemetry-mock-profiler').start(config)
       }
       if (!this._profilerStarted) {
         this._profilerStarted = Promise.resolve(false)
@@ -138,6 +156,22 @@ class Tracer extends NoopProxy {
     return this
   }
 
+  _startProfiler (config) {
+    // do not stop tracer initialization if the profiler fails to be imported
+    try {
+      return require('./profiler').start(config)
+    } catch (e) {
+      log.error(e)
+      if (telemetryLog.hasSubscribers) {
+        telemetryLog.publish({
+          message: e.message,
+          level: 'ERROR',
+          stack_trace: e.stack
+        })
+      }
+    }
+  }
+
   _enableOrDisableTracing (config) {
     if (config.tracing !== false) {
       if (config.appsec.enabled) {

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

@@ -50,8 +50,20 @@ function Hook (modules, options, onrequire) {
 
   if (patchedRequire) return
 
+  const _origRequire = Module.prototype.require
   patchedRequire = Module.prototype.require = function (request) {
-    const filename = Module._resolveFilename(request, this)
+    /*
+    If resolving the filename for a `require(...)` fails, defer to the wrapped
+    require implementation rather than failing right away. This allows a
+    possibly monkey patched `require` to work.
+    */
+    let filename
+    try {
+      filename = Module._resolveFilename(request, this)
+    } catch (resolveErr) {
+      return _origRequire.apply(this, arguments)
+    }
+
     const core = filename.indexOf(path.sep) === -1
     let name, basedir, hooks
     // return known patched modules immediately

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

@@ -64,7 +64,7 @@ function serviceLocator (span) {
 }
 
 class SamplingRule {
-  constructor ({ name, service, resource, tags, sampleRate = 1.0, maxPerSecond } = {}) {
+  constructor ({ name, service, resource, tags, sampleRate = 1.0, provenance = undefined, maxPerSecond } = {}) {
     this.matchers = []
 
     if (name) {
@@ -82,6 +82,7 @@ class SamplingRule {
 
     this._sampler = new Sampler(sampleRate)
     this._limiter = undefined
+    this.provenance = provenance
 
     if (Number.isFinite(maxPerSecond)) {
       this._limiter = new RateLimiter(maxPerSecond)

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

@@ -37,6 +37,23 @@ function startupLog ({ agentError } = {}) {
     return
   }
 
+  const out = tracerInfo({ agentError })
+
+  if (agentError) {
+    out.agent_error = agentError.message
+  }
+
+  info('DATADOG TRACER CONFIGURATION - ' + out)
+  if (agentError) {
+    warn('DATADOG TRACER DIAGNOSTIC - Agent Error: ' + agentError.message)
+    errors.agentError = {
+      code: agentError.code ? agentError.code : '',
+      message: `Agent Error:${agentError.message}`
+    }
+  }
+}
+
+function tracerInfo () {
   const url = config.url || `http://${config.hostname || 'localhost'}:${config.port}`
 
   const out = {
@@ -59,9 +76,6 @@ function startupLog ({ agentError } = {}) {
   out.enabled = config.enabled
   out.service = config.service
   out.agent_url = url
-  if (agentError) {
-    out.agent_error = agentError.message
-  }
   out.debug = !!config.debug
   out.sample_rate = config.sampler.sampleRate
   out.sampling_rules = samplingRules
@@ -87,18 +101,7 @@ function startupLog ({ agentError } = {}) {
   // out.service_mapping
   // out.service_mapping_error
 
-  info('DATADOG TRACER CONFIGURATION - ' + out)
-  if (agentError) {
-    warn('DATADOG TRACER DIAGNOSTIC - Agent Error: ' + agentError.message)
-    errors.agentError = {
-      code: agentError.code ? agentError.code : '',
-      message: `Agent Error:${agentError.message}`
-    }
-  }
-
-  config = undefined
-  pluginManager = undefined
-  samplingRules = undefined
+  return out
 }
 
 function setStartupLogConfig (aConfig) {
@@ -118,5 +121,6 @@ module.exports = {
   setStartupLogConfig,
   setStartupLogPluginManager,
   setSamplingRules,
+  tracerInfo,
   errors
 }

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

@@ -313,7 +313,8 @@ function updateConfig (changes, config) {
     sampleRate: 'DD_TRACE_SAMPLE_RATE',
     logInjection: 'DD_LOG_INJECTION',
     headerTags: 'DD_TRACE_HEADER_TAGS',
-    tags: 'DD_TAGS'
+    tags: 'DD_TAGS',
+    'sampler.rules': 'DD_TRACE_SAMPLING_RULES'
   }
 
   const namesNeedFormatting = new Set(['DD_TAGS', 'peerServiceMapping'])
@@ -328,9 +329,12 @@ function updateConfig (changes, config) {
     const { origin, value } = change
     const entry = { name, value, origin }
 
-    if (Array.isArray(value)) entry.value = value.join(',')
     if (namesNeedFormatting.has(entry.name)) entry.value = formatMapForTelemetry(entry.value)
     if (entry.name === 'url' && entry.value) entry.value = entry.value.toString()
+    if (entry.name === 'DD_TRACE_SAMPLING_RULES') {
+      entry.value = JSON.stringify(entry.value)
+    }
+    if (Array.isArray(entry.value)) entry.value = value.join(',')
 
     configuration.push(entry)
   }

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

@@ -11,6 +11,8 @@ const { DataStreamsProcessor } = require('./datastreams/processor')
 const { DsmPathwayCodec } = require('./datastreams/pathway')
 const { DD_MAJOR } = require('../../../version')
 const DataStreamsContext = require('./data_streams_context')
+const { flushStartupLogs } = require('../../datadog-instrumentations/src/check_require_cache')
+const log = require('./log/writer')
 
 const SPAN_TYPE = tags.SPAN_TYPE
 const RESOURCE_NAME = tags.RESOURCE_NAME
@@ -23,6 +25,7 @@ class DatadogTracer extends Tracer {
     this._dataStreamsProcessor = new DataStreamsProcessor(config)
     this._scope = new Scope()
     setStartupLogConfig(config)
+    flushStartupLogs(log)
   }
 
   configure ({ env, sampler }) {

package/packages/dd-trace/src/plugins/util/ip_blocklist.js

@@ -1,51 +0,0 @@
-'use strict'
-
-const semver = require('semver')
-
-if (semver.satisfies(process.version, '>=14.18.0')) {
-  const net = require('net')
-
-  module.exports = net.BlockList
-} else {
-  const ipaddr = require('ipaddr.js')
-
-  module.exports = class BlockList {
-    constructor () {
-      this.v4Ranges = []
-      this.v6Ranges = []
-    }
-
-    addSubnet (net, prefix, type) {
-      this[type === 'ipv4' ? 'v4Ranges' : 'v6Ranges'].push(ipaddr.parseCIDR(`${net}/${prefix}`))
-    }
-
-    check (address, type) {
-      try {
-        let ip = ipaddr.parse(address)
-
-        type = ip.kind()
-
-        if (type === 'ipv6') {
-          for (const range of this.v6Ranges) {
-            if (ip.match(range)) return true
-          }
-
-          if (ip.isIPv4MappedAddress()) {
-            ip = ip.toIPv4Address()
-            type = ip.kind()
-          }
-        }
-
-        if (type === 'ipv4') {
-          for (const range of this.v4Ranges) {
-            if (ip.match(range)) return true
-          }
-        }
-
-        return false
-      } catch {
-        return false
-      }
-    }
-  }
-}