dd-trace 4.18.0 → 4.20.0

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

@@ -0,0 +1,26 @@
+const { URL } = require('url')
+
+function filterSensitiveInfoFromRepository (repositoryUrl) {
+  if (!repositoryUrl) {
+    return ''
+  }
+  if (repositoryUrl.startsWith('git@')) {
+    return repositoryUrl
+  }
+
+  // Remove the username from ssh URLs
+  if (repositoryUrl.startsWith('ssh://')) {
+    const sshRegex = /^(ssh:\/\/)[^@/]*@/
+    return repositoryUrl.replace(sshRegex, '$1')
+  }
+
+  try {
+    const { protocol, host, pathname } = new URL(repositoryUrl)
+
+    return `${protocol}//${host}${pathname === '/' ? '' : pathname}`
+  } catch (e) {
+    return ''
+  }
+}
+
+module.exports = { filterSensitiveInfoFromRepository }

package/packages/dd-trace/src/plugins/util/user-provided-git.js

@@ -13,7 +13,7 @@ const {
 } = require('./tags')
 
 const { normalizeRef } = require('./ci')
-const { URL } = require('url')
+const { filterSensitiveInfoFromRepository } = require('./url')
 
 function removeEmptyValues (tags) {
   return Object.keys(tags).reduce((filteredTags, tag) => {
@@ -27,19 +27,6 @@ function removeEmptyValues (tags) {
   }, {})
 }
 
-function filterSensitiveInfoFromRepository (repositoryUrl) {
-  try {
-    if (repositoryUrl.startsWith('git@')) {
-      return repositoryUrl
-    }
-    const { protocol, hostname, pathname } = new URL(repositoryUrl)
-
-    return `${protocol}//${hostname}${pathname}`
-  } catch (e) {
-    return repositoryUrl
-  }
-}
-
 // The regex is extracted from
 // https://github.com/jonschlinkert/is-git-url/blob/396965ffabf2f46656c8af4c47bef1d69f09292e/index.js#L9C15-L9C87
 function validateGitRepositoryUrl (repoUrl) {

package/packages/dd-trace/src/profiling/config.js

@@ -9,6 +9,7 @@ const { FileExporter } = require('./exporters/file')
 const { ConsoleLogger } = require('./loggers/console')
 const WallProfiler = require('./profilers/wall')
 const SpaceProfiler = require('./profilers/space')
+const EventsProfiler = require('./profilers/events')
 const { oomExportStrategies, snapshotKinds } = require('./constants')
 const { tagger } = require('./tagger')
 const { isFalse, isTrue } = require('../util')
@@ -37,6 +38,7 @@ class Config {
       DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE,
       DD_PROFILING_EXPERIMENTAL_OOM_MAX_HEAP_EXTENSION_COUNT,
       DD_PROFILING_EXPERIMENTAL_OOM_EXPORT_STRATEGIES,
+      DD_PROFILING_EXPERIMENTAL_TIMELINE_ENABLED,
       DD_PROFILING_CODEHOTSPOTS_ENABLED,
       DD_PROFILING_ENDPOINT_COLLECTION_ENABLED,
       DD_PROFILING_EXPERIMENTAL_CODEHOTSPOTS_ENABLED,
@@ -126,7 +128,14 @@ class Config {
 
     const profilers = options.profilers
       ? options.profilers
-      : getProfilers({ DD_PROFILING_HEAP_ENABLED, DD_PROFILING_WALLTIME_ENABLED, DD_PROFILING_PROFILERS })
+      : getProfilers({
+        DD_PROFILING_HEAP_ENABLED,
+        DD_PROFILING_WALLTIME_ENABLED,
+        DD_PROFILING_PROFILERS
+      })
+
+    this.timelineEnabled = isTrue(coalesce(options.timelineEnabled,
+      DD_PROFILING_EXPERIMENTAL_TIMELINE_ENABLED, false))
 
     this.codeHotspotsEnabled = isTrue(coalesce(options.codeHotspotsEnabled,
       DD_PROFILING_CODEHOTSPOTS_ENABLED,
@@ -139,7 +148,9 @@ class Config {
 
 module.exports = { Config }
 
-function getProfilers ({ DD_PROFILING_HEAP_ENABLED, DD_PROFILING_WALLTIME_ENABLED, DD_PROFILING_PROFILERS }) {
+function getProfilers ({
+  DD_PROFILING_HEAP_ENABLED, DD_PROFILING_WALLTIME_ENABLED, DD_PROFILING_PROFILERS
+}) {
   // First consider "legacy" DD_PROFILING_PROFILERS env variable, defaulting to wall + space
   // Use a Set to avoid duplicates
   const profilers = new Set(coalesce(DD_PROFILING_PROFILERS, 'wall,space').split(','))
@@ -240,6 +251,11 @@ function ensureProfilers (profilers, options) {
     }
   }
 
+  // Events profiler is a profiler for timeline events
+  if (options.timelineEnabled) {
+    profilers.push(new EventsProfiler(options))
+  }
+
   // Filter out any invalid profilers
   return profilers.filter(v => v)
 }

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

@@ -0,0 +1,166 @@
+const { performance, constants, PerformanceObserver } = require('node:perf_hooks')
+const { END_TIMESTAMP, THREAD_NAME, threadNamePrefix } = require('./shared')
+const semver = require('semver')
+const { Function, Label, Line, Location, Profile, Sample, StringTable, ValueType } = require('pprof-format')
+const pprof = require('@datadog/pprof/')
+
+// Format of perf_hooks events changed with Node 16, we need to be mindful of it.
+const node16 = semver.gte(process.version, '16.0.0')
+
+// perf_hooks uses millis, with fractional part representing nanos. We emit nanos into the pprof file.
+const MS_TO_NS = 1000000
+
+// While this is an "events profiler", meaning it emits a pprof file based on events observed as
+// perf_hooks events, the emitted pprof file uses the type "timeline".
+const pprofValueType = 'timeline'
+const pprofValueUnit = 'nanoseconds'
+const threadName = `${threadNamePrefix} GC`
+
+/**
+ * This class generates pprof files with timeline events sourced from Node.js
+ * performance measurement APIs.
+ */
+class EventsProfiler {
+  constructor (options = {}) {
+    this.type = 'events'
+    this._flushIntervalNanos = (options.flushInterval || 60000) * 1e6 // 60 sec
+    this._observer = undefined
+    this.entries = []
+  }
+
+  start () {
+    function add (items) {
+      this.entries.push(...items.getEntries())
+    }
+    if (!this._observer) {
+      this._observer = new PerformanceObserver(add.bind(this))
+    }
+    // Currently only support GC
+    this._observer.observe({ entryTypes: ['gc'] })
+  }
+
+  stop () {
+    if (this._observer) {
+      this._observer.disconnect()
+    }
+  }
+
+  profile () {
+    if (this.entries.length === 0) {
+      // No events in the period; don't produce a profile
+      return null
+    }
+
+    const stringTable = new StringTable()
+    const timestampLabelKey = stringTable.dedup(END_TIMESTAMP)
+    const kindLabelKey = stringTable.dedup('gc type')
+    const reasonLabelKey = stringTable.dedup('gc reason')
+    const kindLabels = []
+    const reasonLabels = []
+    const locations = []
+    const functions = []
+    const locationsPerKind = []
+    const flagObj = {}
+
+    function labelFromStr (key, valStr) {
+      return new Label({ key, str: stringTable.dedup(valStr) })
+    }
+
+    function labelFromStrStr (keyStr, valStr) {
+      return labelFromStr(stringTable.dedup(keyStr), valStr)
+    }
+
+    // Create labels for all GC performance flags and kinds of GC
+    for (const [key, value] of Object.entries(constants)) {
+      if (key.startsWith('NODE_PERFORMANCE_GC_FLAGS_')) {
+        flagObj[key.substring(26).toLowerCase()] = value
+      } else if (key.startsWith('NODE_PERFORMANCE_GC_')) {
+        // It's a constant for a kind of GC
+        const kind = key.substring(20).toLowerCase()
+        kindLabels[value] = labelFromStr(kindLabelKey, kind)
+        // Construct a single-frame "location" too
+        const fn = new Function({ id: functions.length + 1, name: stringTable.dedup(`${kind} GC`) })
+        functions.push(fn)
+        const line = new Line({ functionId: fn.id })
+        const location = new Location({ id: locations.length + 1, line: [line] })
+        locations.push(location)
+        locationsPerKind[value] = [location.id]
+      }
+    }
+
+    const gcEventLabel = labelFromStrStr('event', 'gc')
+    const threadLabel = labelFromStrStr(THREAD_NAME, threadName)
+
+    function getReasonLabel (flags) {
+      if (flags === 0) {
+        return null
+      }
+      let reasonLabel = reasonLabels[flags]
+      if (!reasonLabel) {
+        const reasons = []
+        for (const [key, value] of Object.entries(flagObj)) {
+          if (value & flags) {
+            reasons.push(key)
+          }
+        }
+        const reasonStr = reasons.join(',')
+        reasonLabel = labelFromStr(reasonLabelKey, reasonStr)
+        reasonLabels[flags] = reasonLabel
+      }
+      return reasonLabel
+    }
+
+    let durationFrom = Number.POSITIVE_INFINITY
+    let durationTo = 0
+    const dateOffset = BigInt(Math.round(performance.timeOrigin * MS_TO_NS))
+
+    const samples = this.entries.map((item) => {
+      const { startTime, duration } = item
+      const { kind, flags } = node16 ? item.detail : item
+      const endTime = startTime + duration
+      if (durationFrom > startTime) durationFrom = startTime
+      if (durationTo < endTime) durationTo = endTime
+      const labels = [
+        gcEventLabel,
+        threadLabel,
+        new Label({ key: timestampLabelKey, num: dateOffset + BigInt(Math.round(endTime * MS_TO_NS)) }),
+        kindLabels[kind]
+      ]
+      const reasonLabel = getReasonLabel(flags)
+      if (reasonLabel) {
+        labels.push(reasonLabel)
+      }
+      const sample = new Sample({
+        value: [Math.round(duration * MS_TO_NS)],
+        label: labels,
+        locationId: locationsPerKind[kind]
+      })
+      return sample
+    })
+
+    this.entries = []
+
+    const timeValueType = new ValueType({
+      type: stringTable.dedup(pprofValueType),
+      unit: stringTable.dedup(pprofValueUnit)
+    })
+
+    return new Profile({
+      sampleType: [timeValueType],
+      timeNanos: dateOffset + BigInt(Math.round(durationFrom * MS_TO_NS)),
+      periodType: timeValueType,
+      period: this._flushIntervalNanos,
+      durationNanos: Math.max(0, Math.round((durationTo - durationFrom) * MS_TO_NS)),
+      sample: samples,
+      location: locations,
+      function: functions,
+      stringTable: stringTable
+    })
+  }
+
+  encode (profile) {
+    return pprof.encode(profile)
+  }
+}
+
+module.exports = EventsProfiler

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

@@ -0,0 +1,9 @@
+'use strict'
+
+const { isMainThread, threadId } = require('node:worker_threads')
+
+module.exports = {
+  END_TIMESTAMP: 'end_timestamp_ns',
+  THREAD_NAME: 'thread name',
+  threadNamePrefix: isMainThread ? 'Main' : `Worker #${threadId}`
+}

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

@@ -2,21 +2,20 @@
 
 const { storage } = require('../../../../datadog-core')
 
-const dc = require('../../../../diagnostics_channel')
+const dc = require('dc-polyfill')
 const { HTTP_METHOD, HTTP_ROUTE, RESOURCE_NAME, SPAN_TYPE } = require('../../../../../ext/tags')
 const { WEB } = require('../../../../../ext/types')
 const runtimeMetrics = require('../../runtime_metrics')
 const telemetryMetrics = require('../../telemetry/metrics')
+const { END_TIMESTAMP, THREAD_NAME, threadNamePrefix } = require('./shared')
 
 const beforeCh = dc.channel('dd-trace:storage:before')
 const enterCh = dc.channel('dd-trace:storage:enter')
+const spanFinishCh = dc.channel('dd-trace:span:finish')
 const profilerTelemetryMetrics = telemetryMetrics.manager.namespace('profilers')
+const threadName = `${threadNamePrefix} Event Loop`
 
-const threadName = (function () {
-  const { isMainThread, threadId } = require('node:worker_threads')
-  const name = isMainThread ? 'Main' : `Worker #${threadId}`
-  return `${name} Event Loop`
-})()
+const MemoizedWebTags = Symbol('NativeWallProfiler.MemoizedWebTags')
 
 let kSampleCount
 
@@ -29,30 +28,6 @@ function getStartedSpans (context) {
   return context._trace.started
 }
 
-function generateLabels ({ context: { spanId, rootSpanId, webTags, endpoint }, timestamp }) {
-  const labels = { 'thread name': threadName }
-  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
-  }
-  // Incoming timestamps are in microseconds, we emit nanos.
-  labels['end_timestamp_ns'] = timestamp * 1000n
-
-  return labels
-}
-
-function getSpanContextTags (span) {
-  return span.context()._tags
-}
-
 function isWebServerSpan (tags) {
   return tags[SPAN_TYPE] === WEB
 }
@@ -64,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'
@@ -71,13 +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)
+    // 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
   }
@@ -115,15 +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._lastSampleCount = 0
 
-      beforeCh.subscribe(this._enter)
-      enterCh.subscribe(this._enter)
+      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
@@ -144,11 +173,17 @@ class NativeWallProfiler {
 
     const span = getActiveSpan()
     if (span) {
+      const context = span.context()
       this._lastSpan = span
-      this._lastStartedSpans = getStartedSpans(span.context())
+      const startedSpans = getStartedSpans(context)
+      this._lastStartedSpans = startedSpans
+      if (this._endpointCollectionEnabled) {
+        this._lastWebTags = getWebTags(startedSpans, startedSpans.length, span)
+      }
     } else {
       this._lastStartedSpans = undefined
       this._lastSpan = undefined
+      this._lastWebTags = undefined
     }
   }
 
@@ -163,21 +198,17 @@ class NativeWallProfiler {
         context.rootSpanId = rootSpan.context().toSpanId()
       }
     }
-    if (this._endpointCollectionEnabled) {
-      const startedSpans = this._lastStartedSpans
-      // 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 haves the correct endpoint information.
-      for (let i = startedSpans.length - 1; i >= 0; i--) {
-        const tags = getSpanContextTags(startedSpans[i])
-        if (isWebServerSpan(tags)) {
-          context.webTags = tags
-          // endpoint may not be determined yet, but keep it as fallback
-          // if tags are not available anymore during serialization
-          context.endpoint = endpointNameFromTags(tags)
-          break
-        }
-      }
+    if (this._lastWebTags) {
+      context.webTags = this._lastWebTags
+      // endpoint may not be determined yet, but keep it as fallback
+      // if tags are not available anymore during serialization
+      context.endpoint = endpointNameFromTags(this._lastWebTags)
+    }
+  }
+
+  _spanFinished (span) {
+    if (span[MemoizedWebTags]) {
+      span[MemoizedWebTags] = undefined
     }
   }
 
@@ -193,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) {
@@ -208,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)
   }
@@ -220,10 +274,14 @@ 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)
       this._profilerState = undefined
+      this._lastSpan = undefined
+      this._lastStartedSpans = undefined
+      this._lastWebTags = undefined
     }
 
     this._started = false

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

@@ -3,7 +3,7 @@
 const path = require('path')
 const Module = require('module')
 const parse = require('module-details-from-path')
-const dc = require('../../diagnostics_channel')
+const dc = require('dc-polyfill')
 
 const origRequire = Module.prototype.require
 

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

@@ -138,6 +138,10 @@ class SpanProcessor {
       }
     }
 
+    for (const span of trace.finished) {
+      span.context()._tags = {}
+    }
+
     trace.started = active
     trace.finished = []
   }

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

@@ -4,7 +4,7 @@ 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 savedDependenciesToSend = new Set()

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

@@ -1,7 +1,7 @@
 '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')

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')
 

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

@@ -31,8 +31,10 @@ class DatadogTracer extends Tracer {
 
   // todo[piochelepiotr] These two methods are not related to the tracer, but to data streams monitoring.
   // They should be moved outside of the tracer in the future.
-  setCheckpoint (edgeTags) {
-    const ctx = this._dataStreamsProcessor.setCheckpoint(edgeTags, DataStreamsContext.getDataStreamsContext())
+  setCheckpoint (edgeTags, span, payloadSize = 0) {
+    const ctx = this._dataStreamsProcessor.setCheckpoint(
+      edgeTags, span, DataStreamsContext.getDataStreamsContext(), payloadSize
+    )
     DataStreamsContext.setDataStreamsContext(ctx)
     return ctx
   }

package/packages/diagnostics_channel/index.js

@@ -1,3 +0,0 @@
-'use strict'
-
-module.exports = require('./src')