dd-trace 4.18.0 → 5.6.0

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

@@ -1,67 +1,16 @@
 'use strict'
-const { globMatch } = require('../src/util')
-const { USER_KEEP, AUTO_KEEP } = require('../../../ext').priority
-const RateLimiter = require('./rate_limiter')
-const Sampler = require('./sampler')
-
-class SpanSamplingRule {
-  constructor ({ service, name, sampleRate = 1.0, maxPerSecond } = {}) {
-    this.service = service
-    this.name = name
-
-    this._sampler = new Sampler(sampleRate)
-    this._limiter = undefined
-
-    if (Number.isFinite(maxPerSecond)) {
-      this._limiter = new RateLimiter(maxPerSecond)
-    }
-  }
-
-  get sampleRate () {
-    return this._sampler.rate()
-  }
-
-  get maxPerSecond () {
-    return this._limiter && this._limiter._rateLimit
-  }
-
-  static from (config) {
-    return new SpanSamplingRule(config)
-  }
-
-  match (service, name) {
-    if (this.service && !globMatch(this.service, service)) {
-      return false
-    }
-
-    if (this.name && !globMatch(this.name, name)) {
-      return false
-    }
-
-    return true
-  }
-
-  sample () {
-    if (!this._sampler.isSampled()) {
-      return false
-    }
 
-    if (this._limiter) {
-      return this._limiter.isAllowed()
-    }
-
-    return true
-  }
-}
+const { USER_KEEP, AUTO_KEEP } = require('../../../ext').priority
+const SamplingRule = require('./sampling_rule')
 
 class SpanSampler {
   constructor ({ spanSamplingRules = [] } = {}) {
-    this._rules = spanSamplingRules.map(SpanSamplingRule.from)
+    this._rules = spanSamplingRules.map(SamplingRule.from)
   }
 
-  findRule (service, name) {
+  findRule (context) {
     for (const rule of this._rules) {
-      if (rule.match(service, name)) {
+      if (rule.match(context)) {
         return rule
       }
     }
@@ -73,14 +22,7 @@ class SpanSampler {
 
     const { started } = spanContext._trace
     for (const span of started) {
-      const context = span.context()
-      const tags = context._tags || {}
-      const name = context._name
-      const service = tags.service ||
-        tags['service.name'] ||
-        span.tracer()._service
-
-      const rule = this.findRule(service, name)
+      const rule = this.findRule(span)
       if (rule && rule.sample()) {
         span.context()._spanSampling = {
           sampleRate: rule.sampleRate,

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

@@ -0,0 +1,98 @@
+'use strict'
+
+/* eslint-disable no-console */
+
+const SortedSet = require('tlhunter-sorted-set')
+
+const INTERVAL = 1000 // look for expired spans every 1s
+const LIFETIME = 60 * 1000 // all spans have a max lifetime of 1m
+
+const MODES = {
+  DISABLED: 0,
+  // METRICS_ONLY
+  LOG: 1,
+  GC_AND_LOG: 2
+  // GC
+}
+
+module.exports.MODES = MODES
+
+const spans = new SortedSet()
+
+// TODO: should these also be delivered as runtime metrics?
+
+// const registry = new FinalizationRegistry(name => {
+//   spans.del(span) // there is no span
+// })
+
+let interval
+let mode = MODES.DISABLED
+
+module.exports.disable = function () {
+  mode = MODES.DISABLED
+}
+
+module.exports.enableLogging = function () {
+  mode = MODES.LOG
+}
+
+module.exports.enableGarbageCollection = function () {
+  mode = MODES.GC_AND_LOG
+}
+
+module.exports.startScrubber = function () {
+  if (!isEnabled()) return
+
+  interval = setInterval(() => {
+    const now = Date.now()
+    const expired = spans.rangeByScore(0, now)
+
+    if (!expired.length) return
+
+    const gc = isGarbageCollecting()
+
+    const expirationsByType = Object.create(null) // { [spanType]: count }
+
+    for (const wrapped of expired) {
+      spans.del(wrapped)
+      const span = wrapped.deref()
+
+      if (!span) continue // span has already been garbage collected
+
+      // TODO: Should we also do things like record the route to help users debug leaks?
+      if (!expirationsByType[span._name]) expirationsByType[span._name] = 0
+      expirationsByType[span._name]++
+
+      if (!gc) continue // everything after this point is related to manual GC
+
+      // TODO: what else can we do to alleviate memory usage
+      span.context()._tags = Object.create(null)
+    }
+
+    console.log('expired spans:' +
+      Object.keys(expirationsByType).reduce((a, c) => `${a} ${c}: ${expirationsByType[c]}`, ''))
+  }, INTERVAL)
+}
+
+module.exports.stopScrubber = function () {
+  clearInterval(interval)
+}
+
+module.exports.addSpan = function (span) {
+  if (!isEnabled()) return
+
+  const now = Date.now()
+  const expiration = now + LIFETIME
+  // eslint-disable-next-line no-undef
+  const wrapped = new WeakRef(span)
+  spans.add(wrapped, expiration)
+  // registry.register(span, span._name)
+}
+
+function isEnabled () {
+  return mode > MODES.DISABLED
+}
+
+function isGarbageCollecting () {
+  return mode >= MODES.GC_AND_LOG
+}

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

@@ -6,6 +6,7 @@ const os = require('os')
 const { inspect } = require('util')
 const tracerVersion = require('../../../package.json').version
 
+const errors = {}
 let config
 let pluginManager
 let samplingRules = []
@@ -89,6 +90,10 @@ function startupLog ({ agentError } = {}) {
   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
@@ -112,5 +117,6 @@ module.exports = {
   startupLog,
   setStartupLogConfig,
   setStartupLogPluginManager,
-  setSamplingRules
+  setSamplingRules,
+  errors
 }

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

@@ -4,8 +4,9 @@ const path = require('path')
 const parse = require('module-details-from-path')
 const requirePackageJson = require('../require-package-json')
 const { sendData } = require('./send-data')
-const dc = require('../../../diagnostics_channel')
+const dc = require('dc-polyfill')
 const { fileURLToPath } = require('url')
+const { isTrue } = require('../../src/util')
 
 const savedDependenciesToSend = new Set()
 const detectedDependencyKeys = new Set()
@@ -14,20 +15,57 @@ const detectedDependencyVersions = new Set()
 const FILE_URI_START = `file://`
 const moduleLoadStartChannel = dc.channel('dd-trace:moduleLoadStart')
 
-let immediate, config, application, host
+let immediate, config, application, host, initialLoad
 let isFirstModule = true
+let getRetryData
+let updateRetryData
 
+function createBatchPayload (payload) {
+  const batchPayload = []
+  payload.map(item => {
+    batchPayload.push({
+      request_type: item.reqType,
+      payload: item.payload
+    })
+  })
+
+  return batchPayload
+}
 function waitAndSend (config, application, host) {
   if (!immediate) {
     immediate = setImmediate(() => {
       immediate = null
       if (savedDependenciesToSend.size > 0) {
-        const dependencies = Array.from(savedDependenciesToSend.values()).splice(0, 1000).map(pair => {
-          savedDependenciesToSend.delete(pair)
-          const [name, version] = pair.split(' ')
-          return { name, version }
-        })
-        sendData(config, application, host, 'app-dependencies-loaded', { dependencies })
+        const dependencies = Array.from(savedDependenciesToSend.values())
+          // if a depencdency is from the initial load, *always* send the event
+          // Otherwise, only send if dependencyCollection is enabled
+          .filter(dep => {
+            const initialLoadModule = isTrue(dep.split(' ')[2])
+            const sendModule = initialLoadModule || (config.telemetry?.dependencyCollection)
+
+            if (!sendModule) savedDependenciesToSend.delete(dep) // we'll never send it
+            return sendModule
+          })
+          .splice(0, 2000) // v2 documentation specifies up to 2000 dependencies can be sent at once
+          .map(pair => {
+            savedDependenciesToSend.delete(pair)
+            const [name, version] = pair.split(' ')
+            return { name, version }
+          })
+        let currPayload
+        const retryData = getRetryData()
+        if (retryData) {
+          currPayload = { reqType: 'app-dependencies-loaded', payload: { dependencies } }
+        } else {
+          if (!dependencies.length) return // no retry data and no dependencies, nothing to send
+          currPayload = { dependencies }
+        }
+
+        const payload = retryData ? createBatchPayload([currPayload, retryData]) : currPayload
+        const reqType = retryData ? 'message-batch' : 'app-dependencies-loaded'
+
+        sendData(config, application, host, reqType, payload, updateRetryData)
+
         if (savedDependenciesToSend.size > 0) {
           waitAndSend(config, application, host)
         }
@@ -76,7 +114,7 @@ function onModuleLoad (data) {
             const dependencyAndVersion = `${name} ${version}`
 
             if (!detectedDependencyVersions.has(dependencyAndVersion)) {
-              savedDependenciesToSend.add(dependencyAndVersion)
+              savedDependenciesToSend.add(`${dependencyAndVersion} ${initialLoad}`)
               detectedDependencyVersions.add(dependencyAndVersion)
 
               waitAndSend(config, application, host)
@@ -89,11 +127,19 @@ function onModuleLoad (data) {
     }
   }
 }
-function start (_config, _application, _host) {
+function start (_config = {}, _application, _host, getRetryDataFunction, updateRetryDatafunction) {
   config = _config
   application = _application
   host = _host
+  initialLoad = true
+  getRetryData = getRetryDataFunction
+  updateRetryData = updateRetryDatafunction
   moduleLoadStartChannel.subscribe(onModuleLoad)
+
+  // try and capture intially loaded modules in the first tick
+  // since, ideally, the tracer (and this module) should be loaded first,
+  // this should capture any first-tick dependencies
+  queueMicrotask(() => { initialLoad = false })
 }
 
 function isDependency (filename, request) {

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

@@ -1,11 +1,10 @@
 'use strict'
-
 const tracerVersion = require('../../../../package.json').version
-const dc = require('../../../diagnostics_channel')
+const dc = require('dc-polyfill')
 const os = require('os')
 const dependencies = require('./dependencies')
 const { sendData } = require('./send-data')
-
+const { errors } = require('../startup-log')
 const { manager: metricsManager } = require('./metrics')
 const logs = require('./logs')
 
@@ -17,11 +16,54 @@ let pluginManager
 
 let application
 let host
-let interval
 let heartbeatTimeout
 let heartbeatInterval
+let extendedInterval
+let integrations
+let configWithOrigin = []
+let retryData = null
+const extendedHeartbeatPayload = {}
+
 const sentIntegrations = new Set()
 
+function getRetryData () {
+  return retryData
+}
+
+function updateRetryData (error, retryObj) {
+  if (error) {
+    if (retryObj.reqType === 'message-batch') {
+      const payload = retryObj.payload[0].payload
+      const reqType = retryObj.payload[0].request_type
+      retryData = { payload: payload, reqType: reqType }
+
+      // Since this payload failed twice it now gets save in to the extended heartbeat
+      const failedPayload = retryObj.payload[1].payload
+      const failedReqType = retryObj.payload[1].request_type
+
+      // save away the dependencies and integration request for extended heartbeat.
+      if (failedReqType === 'app-integrations-change') {
+        if (extendedHeartbeatPayload['integrations']) {
+          extendedHeartbeatPayload['integrations'].push(failedPayload)
+        } else {
+          extendedHeartbeatPayload['integrations'] = [failedPayload]
+        }
+      }
+      if (failedReqType === 'app-dependencies-loaded') {
+        if (extendedHeartbeatPayload['dependencies']) {
+          extendedHeartbeatPayload['dependencies'].push(failedPayload)
+        } else {
+          extendedHeartbeatPayload['dependencies'] = [failedPayload]
+        }
+      }
+    } else {
+      retryData = retryObj
+    }
+  } else {
+    retryData = null
+  }
+}
+
 function getIntegrations () {
   const newIntegrations = []
   for (const pluginName in pluginManager._pluginsByName) {
@@ -38,43 +80,66 @@ function getIntegrations () {
   return newIntegrations
 }
 
-function flatten (input, result = [], prefix = [], traversedObjects = null) {
-  traversedObjects = traversedObjects || new WeakSet()
-  if (traversedObjects.has(input)) {
-    return
+function getProducts (config) {
+  const products = {
+    appsec: {
+      enabled: config.appsec.enabled
+    },
+    profiler: {
+      version: tracerVersion,
+      enabled: config.profiling.enabled
+    }
   }
-  traversedObjects.add(input)
-  for (const [key, value] of Object.entries(input)) {
-    if (typeof value === 'object' && value !== null) {
-      flatten(value, result, [...prefix, key], traversedObjects)
-    } else {
-      result.push({ name: [...prefix, key].join('.'), value })
+  if (errors.profilingError) {
+    products.profiler.error = errors.profilingError
+    errors.profilingError = {}
+  }
+  return products
+}
+
+function getInstallSignature (config) {
+  const { installSignature: sig } = config
+  if (sig && (sig.id || sig.time || sig.type)) {
+    return {
+      install_id: sig.id,
+      install_time: sig.time,
+      install_type: sig.type
     }
   }
-  return result
 }
 
-function appStarted () {
-  return {
-    integrations: getIntegrations(),
-    dependencies: [],
-    configuration: flatten(formatConfig(config)),
-    additional_payload: []
+function appStarted (config) {
+  const app = {
+    products: getProducts(config),
+    configuration: configWithOrigin
+  }
+  const installSignature = getInstallSignature(config)
+  if (installSignature) {
+    app.install_signature = installSignature
   }
+  // TODO: add app.error with correct error codes
+  // if (errors.agentError) {
+  //   app.error = errors.agentError
+  //   errors.agentError = {}
+  // }
+  return app
 }
 
-function formatConfig (config) {
-  // format peerServiceMapping from an object to a string map in order for
-  // telemetry intake to accept the configuration
-  config.peerServiceMapping = config.peerServiceMapping
-    ? Object.entries(config.peerServiceMapping).map(([key, value]) => `${key}:${value}`).join(',')
-    : ''
-  return config
+function appClosing () {
+  if (!config?.telemetry?.enabled) {
+    return
+  }
+  const { reqType, payload } = createPayload('app-closing')
+  sendData(config, application, host, reqType, payload)
+  // we flush before shutting down. Only in CI Visibility
+  if (config.isCiVisibility) {
+    metricsManager.send(config, application, host)
+  }
 }
 
 function onBeforeExit () {
   process.removeListener('beforeExit', onBeforeExit)
-  sendData(config, application, host, 'app-closing')
+  appClosing()
 }
 
 function createAppObject (config) {
@@ -121,14 +186,53 @@ function getTelemetryData () {
   return { config, application, host, heartbeatInterval }
 }
 
+function createBatchPayload (payload) {
+  const batchPayload = []
+  payload.map(item => {
+    batchPayload.push({
+      request_type: item.reqType,
+      payload: item.payload
+    })
+  })
+
+  return batchPayload
+}
+
+function createPayload (currReqType, currPayload = {}) {
+  if (getRetryData()) {
+    const payload = { reqType: currReqType, payload: currPayload }
+    const batchPayload = createBatchPayload([payload, retryData])
+    return { 'reqType': 'message-batch', 'payload': batchPayload }
+  }
+
+  return { 'reqType': currReqType, 'payload': currPayload }
+}
+
 function heartbeat (config, application, host) {
   heartbeatTimeout = setTimeout(() => {
-    sendData(config, application, host, 'app-heartbeat')
+    metricsManager.send(config, application, host)
+    logs.send(config, application, host)
+
+    const { reqType, payload } = createPayload('app-heartbeat')
+    sendData(config, application, host, reqType, payload, updateRetryData)
     heartbeat(config, application, host)
   }, heartbeatInterval).unref()
   return heartbeatTimeout
 }
 
+function extendedHeartbeat (config) {
+  extendedInterval = setInterval(() => {
+    const appPayload = appStarted(config)
+    const payload = {
+      ...appPayload,
+      ...extendedHeartbeatPayload
+    }
+    sendData(config, application, host, 'app-extended-heartbeat', payload)
+    Object.keys(extendedHeartbeatPayload).forEach(key => delete extendedHeartbeatPayload[key])
+  }, 1000 * 60 * 60 * 24).unref()
+  return extendedInterval
+}
+
 function start (aConfig, thePluginManager) {
   if (!aConfig.telemetry.enabled) {
     return
@@ -138,19 +242,23 @@ function start (aConfig, thePluginManager) {
   application = createAppObject(config)
   host = createHostObject()
   heartbeatInterval = config.telemetry.heartbeatInterval
+  integrations = getIntegrations()
 
-  dependencies.start(config, application, host)
+  dependencies.start(config, application, host, getRetryData, updateRetryData)
   logs.start(config)
 
-  sendData(config, application, host, 'app-started', appStarted())
+  sendData(config, application, host, 'app-started', appStarted(config))
+
+  if (integrations.length > 0) {
+    sendData(config, application, host, 'app-integrations-change',
+      { integrations }, updateRetryData)
+  }
+
   heartbeat(config, application, host)
-  interval = setInterval(() => {
-    metricsManager.send(config, application, host)
-    logs.send(config, application, host)
-  }, heartbeatInterval)
-  interval.unref()
-  process.on('beforeExit', onBeforeExit)
 
+  extendedHeartbeat(config)
+
+  process.on('beforeExit', onBeforeExit)
   telemetryStartChannel.publish(getTelemetryData())
 }
 
@@ -158,7 +266,7 @@ function stop () {
   if (!config) {
     return
   }
-  clearInterval(interval)
+  clearInterval(extendedInterval)
   clearTimeout(heartbeatTimeout)
   process.removeListener('beforeExit', onBeforeExit)
 
@@ -175,39 +283,60 @@ function updateIntegrations () {
   if (integrations.length === 0) {
     return
   }
-  sendData(config, application, host, 'app-integrations-change', { integrations })
+
+  const { reqType, payload } = createPayload('app-integrations-change', { integrations })
+
+  sendData(config, application, host, reqType, payload, updateRetryData)
+}
+
+function formatMapForTelemetry (map) {
+  // format from an object to a string map in order for
+  // telemetry intake to accept the configuration
+  return map
+    ? Object.entries(map).map(([key, value]) => `${key}:${value}`).join(',')
+    : ''
 }
 
 function updateConfig (changes, config) {
   if (!config.telemetry.enabled) return
   if (changes.length === 0) return
 
-  // Hack to make system tests happy until we ship telemetry v2
-  if (process.env.DD_INTERNAL_TELEMETRY_V2_ENABLED !== '1') return
-
   const application = createAppObject(config)
   const host = createHostObject()
 
   const names = {
     sampleRate: 'DD_TRACE_SAMPLE_RATE',
     logInjection: 'DD_LOG_INJECTION',
-    headerTags: 'DD_TRACE_HEADER_TAGS'
+    headerTags: 'DD_TRACE_HEADER_TAGS',
+    tags: 'DD_TAGS'
   }
 
-  const configuration = changes.map(change => ({
-    name: names[change.name],
-    value: Array.isArray(change.value) ? change.value.join(',') : change.value,
-    origin: change.origin
-  }))
+  const configuration = []
 
-  sendData(config, application, host, 'app-client-configuration-change', {
-    configuration
-  })
+  for (const change of changes) {
+    const name = names[change.name] || change.name
+    const { origin, value } = change
+    const entry = { name, value, origin }
+
+    if (Array.isArray(value)) entry.value = value.join(',')
+    if (entry.name === 'DD_TAGS') entry.value = formatMapForTelemetry(entry.value)
+    if (entry.name === 'url' && entry.value) entry.value = entry.value.toString()
+    if (entry.name === 'peerServiceMapping' || entry.name === 'tags') entry.value = formatMapForTelemetry(entry.value)
+
+    configuration.push(entry)
+  }
+  if (!configWithOrigin.length) {
+    configWithOrigin = configuration
+  } else {
+    const { reqType, payload } = createPayload('app-client-configuration-change', { configuration })
+    sendData(config, application, host, reqType, payload, updateRetryData)
+  }
 }
 
 module.exports = {
   start,
   stop,
   updateIntegrations,
-  updateConfig
+  updateConfig,
+  appClosing
 }

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const dc = require('../../../../diagnostics_channel')
+const dc = require('dc-polyfill')
 const logCollector = require('./log-collector')
 const { sendData } = require('../send-data')
 
@@ -54,7 +54,7 @@ function send (config, application, host) {
 
   const logs = logCollector.drain()
   if (logs) {
-    sendData(config, application, host, 'logs', logs)
+    sendData(config, application, host, 'logs', { logs })
   }
 }