dd-trace 4.19.0 → 4.21.0

package/packages/dd-trace/src/profiling/profilers/wall.js

@@ -15,7 +15,7 @@ const spanFinishCh = dc.channel('dd-trace:span:finish')
 const profilerTelemetryMetrics = telemetryMetrics.manager.namespace('profilers')
 const threadName = `${threadNamePrefix} Event Loop`
 
-const CachedWebTags = Symbol('NativeWallProfiler.CachedWebTags')
+const MemoizedWebTags = Symbol('NativeWallProfiler.MemoizedWebTags')
 
 let kSampleCount
 
@@ -28,28 +28,6 @@ function getStartedSpans (context) {
   return context._trace.started
 }
 
-function generateLabels ({ context: { spanId, rootSpanId, webTags, endpoint }, timestamp }) {
-  const labels = {
-    [THREAD_NAME]: threadName,
-    // Incoming timestamps are in microseconds, we emit nanos.
-    [END_TIMESTAMP]: timestamp * 1000n
-  }
-  if (spanId) {
-    labels['span id'] = spanId
-  }
-  if (rootSpanId) {
-    labels['local root span id'] = rootSpanId
-  }
-  if (webTags && Object.keys(webTags).length !== 0) {
-    labels['trace endpoint'] = endpointNameFromTags(webTags)
-  } else if (endpoint) {
-    // fallback to endpoint computed when sample was taken
-    labels['trace endpoint'] = endpoint
-  }
-
-  return labels
-}
-
 function isWebServerSpan (tags) {
   return tags[SPAN_TYPE] === WEB
 }
@@ -61,6 +39,38 @@ function endpointNameFromTags (tags) {
   ].filter(v => v).join(' ')
 }
 
+function getWebTags (startedSpans, i, span) {
+  // Are web tags for this span already memoized?
+  const memoizedWebTags = span[MemoizedWebTags]
+  if (memoizedWebTags !== undefined) {
+    return memoizedWebTags
+  }
+  // No, we'll have to memoize a new value
+  function memoize (tags) {
+    span[MemoizedWebTags] = tags
+    return tags
+  }
+  // Is this span itself a web span?
+  const context = span.context()
+  const tags = context._tags
+  if (isWebServerSpan(tags)) {
+    return memoize(tags)
+  }
+  // It isn't. Get parent's web tags (memoize them too recursively.)
+  // There might be several webspans, for example with next.js, http plugin creates the first span
+  // and then next.js plugin creates a child span, and this child span has the correct endpoint
+  // information. That's why we always use the tags of the closest ancestor web span.
+  const parentId = context._parentId
+  while (--i >= 0) {
+    const ispan = startedSpans[i]
+    if (ispan.context()._spanId === parentId) {
+      return memoize(getWebTags(startedSpans, i, ispan))
+    }
+  }
+  // Local root span with no web span
+  return memoize(null)
+}
+
 class NativeWallProfiler {
   constructor (options = {}) {
     this.type = 'wall'
@@ -68,14 +78,30 @@ class NativeWallProfiler {
     this._flushIntervalMillis = options.flushInterval || 60 * 1e3 // 60 seconds
     this._codeHotspotsEnabled = !!options.codeHotspotsEnabled
     this._endpointCollectionEnabled = !!options.endpointCollectionEnabled
-    this._withContexts = this._codeHotspotsEnabled || this._endpointCollectionEnabled
+    this._timelineEnabled = !!options.timelineEnabled
+    // We need to capture span data into the sample context for either code hotspots
+    // or endpoint collection.
+    this._captureSpanData = this._codeHotspotsEnabled || this._endpointCollectionEnabled
+    // We need to run the pprof wall profiler with sample contexts if we're either
+    // capturing span data or timeline is enabled (so we need sample timestamps, and for now
+    // timestamps require the sample contexts feature in the pprof wall profiler.)
+    this._withContexts = this._captureSpanData || this._timelineEnabled
     this._v8ProfilerBugWorkaroundEnabled = !!options.v8ProfilerBugWorkaroundEnabled
     this._mapper = undefined
     this._pprof = undefined
 
-    // Bind to this so the same value can be used to unsubscribe later
-    this._enter = this._enter.bind(this)
-    this._spanFinished = this._spanFinished.bind(this)
+    // Bind these to this so they can be used as callbacks
+    if (this._withContexts) {
+      if (this._captureSpanData) {
+        this._enter = this._enter.bind(this)
+        this._spanFinished = this._spanFinished.bind(this)
+      }
+      this._generateLabels = this._generateLabels.bind(this)
+    } else {
+      // Explicitly assigning, to express the intent that this is meant to be
+      // undefined when passed to pprof.time.stop() when not using sample contexts.
+      this._generateLabels = undefined
+    }
     this._logger = options.logger
     this._started = false
   }
@@ -113,17 +139,20 @@ class NativeWallProfiler {
     })
 
     if (this._withContexts) {
-      this._profilerState = this._pprof.time.getState()
       this._currentContext = {}
       this._pprof.time.setContext(this._currentContext)
-      this._lastSpan = undefined
-      this._lastStartedSpans = undefined
-      this._lastWebTags = undefined
-      this._lastSampleCount = 0
 
-      beforeCh.subscribe(this._enter)
-      enterCh.subscribe(this._enter)
-      spanFinishCh.subscribe(this._spanFinished)
+      if (this._captureSpanData) {
+        this._profilerState = this._pprof.time.getState()
+        this._lastSpan = undefined
+        this._lastStartedSpans = undefined
+        this._lastWebTags = undefined
+        this._lastSampleCount = 0
+
+        beforeCh.subscribe(this._enter)
+        enterCh.subscribe(this._enter)
+        spanFinishCh.subscribe(this._spanFinished)
+      }
     }
 
     this._started = true
@@ -149,33 +178,7 @@ class NativeWallProfiler {
       const startedSpans = getStartedSpans(context)
       this._lastStartedSpans = startedSpans
       if (this._endpointCollectionEnabled) {
-        const cachedWebTags = span[CachedWebTags]
-        if (cachedWebTags === undefined) {
-          let found = false
-          // Find the first webspan starting from the end:
-          // There might be several webspans, for example with next.js, http plugin creates a first span
-          // and then next.js plugin creates a child span, and this child span has the correct endpoint information.
-          let nextSpanId = context._spanId
-          for (let i = startedSpans.length - 1; i >= 0; i--) {
-            const nextContext = startedSpans[i].context()
-            if (nextContext._spanId === nextSpanId) {
-              const tags = nextContext._tags
-              if (isWebServerSpan(tags)) {
-                this._lastWebTags = tags
-                span[CachedWebTags] = tags
-                found = true
-                break
-              }
-              nextSpanId = nextContext._parentId
-            }
-          }
-          if (!found) {
-            this._lastWebTags = undefined
-            span[CachedWebTags] = null // cache negative lookup result
-          }
-        } else {
-          this._lastWebTags = cachedWebTags
-        }
+        this._lastWebTags = getWebTags(startedSpans, startedSpans.length, span)
       }
     } else {
       this._lastStartedSpans = undefined
@@ -204,8 +207,8 @@ class NativeWallProfiler {
   }
 
   _spanFinished (span) {
-    if (span[CachedWebTags]) {
-      span[CachedWebTags] = undefined
+    if (span[MemoizedWebTags]) {
+      span[MemoizedWebTags] = undefined
     }
   }
 
@@ -221,12 +224,12 @@ class NativeWallProfiler {
 
   _stop (restart) {
     if (!this._started) return
-    if (this._withContexts) {
+    if (this._captureSpanData) {
       // update last sample context if needed
       this._enter()
       this._lastSampleCount = 0
     }
-    const profile = this._pprof.time.stop(restart, this._withContexts ? generateLabels : undefined)
+    const profile = this._pprof.time.stop(restart, this._generateLabels)
     if (restart) {
       const v8BugDetected = this._pprof.time.v8ProfilerStuckEventLoopDetected()
       if (v8BugDetected !== 0) {
@@ -236,6 +239,29 @@ class NativeWallProfiler {
     return profile
   }
 
+  _generateLabels ({ context: { spanId, rootSpanId, webTags, endpoint }, timestamp }) {
+    const labels = this._timelineEnabled ? {
+      [THREAD_NAME]: threadName,
+      // Incoming timestamps are in microseconds, we emit nanos.
+      [END_TIMESTAMP]: timestamp * 1000n
+    } : {}
+
+    if (spanId) {
+      labels['span id'] = spanId
+    }
+    if (rootSpanId) {
+      labels['local root span id'] = rootSpanId
+    }
+    if (webTags && Object.keys(webTags).length !== 0) {
+      labels['trace endpoint'] = endpointNameFromTags(webTags)
+    } else if (endpoint) {
+      // fallback to endpoint computed when sample was taken
+      labels['trace endpoint'] = endpoint
+    }
+
+    return labels
+  }
+
   profile () {
     return this._stop(true)
   }
@@ -248,7 +274,7 @@ class NativeWallProfiler {
     if (!this._started) return
 
     const profile = this._stop(false)
-    if (this._withContexts) {
+    if (this._captureSpanData) {
       beforeCh.unsubscribe(this._enter)
       enterCh.unsubscribe(this._enter)
       spanFinishCh.unsubscribe(this._spanFinished)

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

@@ -10,6 +10,7 @@ const PluginManager = require('./plugin_manager')
 const remoteConfig = require('./appsec/remote_config')
 const AppsecSdk = require('./appsec/sdk')
 const dogstatsd = require('./dogstatsd')
+const spanleak = require('./spanleak')
 
 class Tracer extends NoopProxy {
   constructor () {
@@ -37,6 +38,15 @@ class Tracer extends NoopProxy {
         }, 10 * 1000).unref()
       }
 
+      if (config.spanLeakDebug > 0) {
+        if (config.spanLeakDebug === spanleak.MODES.LOG) {
+          spanleak.enableLogging()
+        } else if (config.spanLeakDebug === spanleak.MODES.GC_AND_LOG) {
+          spanleak.enableGarbageCollection()
+        }
+        spanleak.startScrubber()
+      }
+
       if (config.remoteConfig.enabled && !config.isCiVisibility) {
         const rc = remoteConfig.enable(config)
 
@@ -62,11 +72,14 @@ class Tracer extends NoopProxy {
         // do not stop tracer initialization if the profiler fails to be imported
         try {
           const profiler = require('./profiler')
-          profiler.start(config)
+          this._profilerStarted = profiler.start(config)
         } catch (e) {
           log.error(e)
         }
       }
+      if (!this._profilerStarted) {
+        this._profilerStarted = Promise.resolve(false)
+      }
 
       if (config.runtimeMetrics) {
         runtimeMetrics.start(config)
@@ -104,6 +117,13 @@ class Tracer extends NoopProxy {
     return this
   }
 
+  profilerStarted () {
+    if (!this._profilerStarted) {
+      throw new Error('profilerStarted() must be called after init()')
+    }
+    return this._profilerStarted
+  }
+
   use () {
     this._pluginManager.configurePlugin(...arguments)
     return this

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

@@ -37,6 +37,11 @@ const redisConfig = {
 
 const storage = {
   client: {
+    aerospike: {
+      opName: () => 'aerospike.command',
+      serviceName: ({ tracerService, pluginConfig }) =>
+        pluginConfig.service || `${tracerService}-aerospike`
+    },
     'cassandra-driver': {
       opName: () => 'cassandra.query',
       serviceName: ({ tracerService, pluginConfig, system }) =>

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

@@ -22,6 +22,10 @@ function withFunction ({ tracerService, pluginConfig, params }) {
 
 const storage = {
   client: {
+    aerospike: {
+      opName: () => 'aerospike.command',
+      serviceName: configWithFallback
+    },
     'cassandra-driver': {
       opName: () => 'cassandra.query',
       serviceName: configWithFallback

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

@@ -6,6 +6,7 @@ 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 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) {