dd-trace 5.28.0 → 5.29.1

package/packages/dd-trace/src/plugins/plugin.js

@@ -79,7 +79,7 @@ module.exports = class Plugin {
         return handler.apply(this, arguments)
       } catch (e) {
         logger.error('Error in plugin handler:', e)
-        logger.info('Disabling plugin:', plugin.id)
+        logger.info('Disabling plugin: %s', plugin.id)
         plugin.configure(false)
       }
     }

package/packages/dd-trace/src/plugins/tracing.js

@@ -94,7 +94,7 @@ class TracingPlugin extends Plugin {
   }
 
   addError (error, span = this.activeSpan) {
-    if (!span._spanContext._tags.error) {
+    if (span && !span._spanContext._tags.error) {
       // Errors may be wrapped in a context.
       error = (error && error.error) || error
       span.setTag('error', error || 1)

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

@@ -61,7 +61,7 @@ function sanitizedExec (
         exitCode: err.status || err.errno
       })
     }
-    log.error(err)
+    log.error('Git plugin error executing command', err)
     return ''
   } finally {
     storage.enterWith(store)
@@ -144,7 +144,7 @@ function unshallowRepository () {
     ], { stdio: 'pipe' })
   } catch (err) {
     // If the local HEAD is a commit that has not been pushed to the remote, the above command will fail.
-    log.error(err)
+    log.error('Git plugin error executing git command', err)
     incrementCountMetric(
       TELEMETRY_GIT_COMMAND_ERRORS,
       { command: 'unshallow', errorType: err.code, exitCode: err.status || err.errno }
@@ -157,7 +157,7 @@ function unshallowRepository () {
       ], { stdio: 'pipe' })
     } catch (err) {
       // If the CI is working on a detached HEAD or branch tracking hasn’t been set up, the above command will fail.
-      log.error(err)
+      log.error('Git plugin error executing fallback git command', err)
       incrementCountMetric(
         TELEMETRY_GIT_COMMAND_ERRORS,
         { command: 'unshallow', errorType: err.code, exitCode: err.status || err.errno }
@@ -196,7 +196,7 @@ function getLatestCommits () {
     distributionMetric(TELEMETRY_GIT_COMMAND_MS, { command: 'get_local_commits' }, Date.now() - startTime)
     return result
   } catch (err) {
-    log.error(`Get latest commits failed: ${err.message}`)
+    log.error('Get latest commits failed: %s', err.message)
     incrementCountMetric(
       TELEMETRY_GIT_COMMAND_ERRORS,
       { command: 'get_local_commits', errorType: err.status }
@@ -229,7 +229,7 @@ function getCommitsRevList (commitsToExclude, commitsToInclude) {
       .split('\n')
       .filter(commit => commit)
   } catch (err) {
-    log.error(`Get commits to upload failed: ${err.message}`)
+    log.error('Get commits to upload failed: %s', err.message)
     incrementCountMetric(
       TELEMETRY_GIT_COMMAND_ERRORS,
       { command: 'get_objects', errorType: err.code, exitCode: err.status || err.errno } // err.status might be null
@@ -272,7 +272,7 @@ function generatePackFilesForCommits (commitsToUpload) {
   try {
     result = execGitPackObjects(temporaryPath)
   } catch (err) {
-    log.error(err)
+    log.error('Git plugin error executing git pack-objects command', err)
     incrementCountMetric(
       TELEMETRY_GIT_COMMAND_ERRORS,
       { command: 'pack_objects', exitCode: err.status || err.errno, errorType: err.code }
@@ -292,7 +292,7 @@ function generatePackFilesForCommits (commitsToUpload) {
     try {
       result = execGitPackObjects(cwdPath)
     } catch (err) {
-      log.error(err)
+      log.error('Git plugin error executing fallback git pack-objects command', err)
       incrementCountMetric(
         TELEMETRY_GIT_COMMAND_ERRORS,
         { command: 'pack_objects', exitCode: err.status || err.errno, errorType: err.code }

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

@@ -106,6 +106,13 @@ const TEST_LEVEL_EVENT_TYPES = [
   'test_session_end'
 ]
 
+// Dynamic instrumentation - Test optimization integration tags
+const DI_ERROR_DEBUG_INFO_CAPTURED = 'error.debug_info_captured'
+// TODO: for the moment we'll only use a single snapshot id, so `0` is hardcoded
+const DI_DEBUG_ERROR_SNAPSHOT_ID = '_dd.debug.error.0.snapshot_id'
+const DI_DEBUG_ERROR_FILE = '_dd.debug.error.0.file'
+const DI_DEBUG_ERROR_LINE = '_dd.debug.error.0.line'
+
 module.exports = {
   TEST_CODE_OWNERS,
   TEST_SESSION_NAME,
@@ -181,7 +188,12 @@ module.exports = {
   TEST_BROWSER_VERSION,
   getTestSessionName,
   TEST_LEVEL_EVENT_TYPES,
-  getNumFromKnownTests
+  getNumFromKnownTests,
+  getFileAndLineNumberFromError,
+  DI_ERROR_DEBUG_INFO_CAPTURED,
+  DI_DEBUG_ERROR_SNAPSHOT_ID,
+  DI_DEBUG_ERROR_FILE,
+  DI_DEBUG_ERROR_LINE
 }
 
 // Returns pkg manager and its version, separated by '-', e.g. npm-8.15.0 or yarn-1.22.19
@@ -206,13 +218,13 @@ function removeInvalidMetadata (metadata) {
   return Object.keys(metadata).reduce((filteredTags, tag) => {
     if (tag === GIT_REPOSITORY_URL) {
       if (!validateGitRepositoryUrl(metadata[GIT_REPOSITORY_URL])) {
-        log.error(`Repository URL is not a valid repository URL: ${metadata[GIT_REPOSITORY_URL]}.`)
+        log.error('Repository URL is not a valid repository URL: %s.', metadata[GIT_REPOSITORY_URL])
         return filteredTags
       }
     }
     if (tag === GIT_COMMIT_SHA) {
       if (!validateGitCommitSha(metadata[GIT_COMMIT_SHA])) {
-        log.error(`Git commit SHA must be a full-length git SHA: ${metadata[GIT_COMMIT_SHA]}.`)
+        log.error('Git commit SHA must be a full-length git SHA: %s.', metadata[GIT_COMMIT_SHA])
         return filteredTags
       }
     }
@@ -637,3 +649,24 @@ function getNumFromKnownTests (knownTests) {
 
   return totalNumTests
 }
+
+function getFileAndLineNumberFromError (error) {
+  // Split the stack trace into individual lines
+  const stackLines = error.stack.split('\n')
+
+  // The top frame is usually the second line
+  const topFrame = stackLines[1]
+
+  // Regular expression to match the file path, line number, and column number
+  const regex = /\s*at\s+(?:.*\()?(.+):(\d+):(\d+)\)?/
+  const match = topFrame.match(regex)
+
+  if (match) {
+    const filePath = match[1]
+    const lineNumber = Number(match[2])
+    const columnNumber = Number(match[3])
+
+    return [filePath, lineNumber, columnNumber]
+  }
+  return []
+}

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

@@ -546,7 +546,7 @@ function getHeadersToRecord (config) {
         .map(h => h.split(':'))
         .map(([key, tag]) => [key.toLowerCase(), tag])
     } catch (err) {
-      log.error(err)
+      log.error('Web plugin error getting headers', err)
     }
   } else if (config.hasOwnProperty('headers')) {
     log.error('Expected `headers` to be an array of strings.')
@@ -595,7 +595,7 @@ function getQsObfuscator (config) {
     try {
       return new RegExp(obfuscator, 'gi')
     } catch (err) {
-      log.error(err)
+      log.error('Web plugin error getting qs obfuscator', err)
     }
   }
 

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

@@ -1,5 +1,6 @@
 'use strict'
 
+const log = require('./log')
 const RateLimiter = require('./rate_limiter')
 const Sampler = require('./sampler')
 const { setSamplingRules } = require('./startup-log')
@@ -44,16 +45,19 @@ class PrioritySampler {
     this.update({})
   }
 
-  configure (env, { sampleRate, provenance = undefined, rateLimit = 100, rules = [] } = {}) {
+  configure (env, opts = {}) {
+    const { sampleRate, provenance = undefined, rateLimit = 100, rules = [] } = opts
     this._env = env
     this._rules = this._normalizeRules(rules, sampleRate, rateLimit, provenance)
     this._limiter = new RateLimiter(rateLimit)
 
+    log.trace(env, opts)
     setSamplingRules(this._rules)
   }
 
   isSampled (span) {
     const priority = this._getPriorityFromAuto(span)
+    log.trace(span)
     return priority === USER_KEEP || priority === AUTO_KEEP
   }
 
@@ -67,6 +71,8 @@ class PrioritySampler {
     if (context._sampling.priority !== undefined) return
     if (!root) return // noop span
 
+    log.trace(span, auto)
+
     const tag = this._getPriorityFromTags(context._tags, context)
 
     if (this.validate(tag)) {
@@ -94,6 +100,8 @@ class PrioritySampler {
     samplers[DEFAULT_KEY] = samplers[DEFAULT_KEY] || defaultSampler
 
     this._samplers = samplers
+
+    log.trace(rates)
   }
 
   validate (samplingPriority) {
@@ -117,6 +125,8 @@ class PrioritySampler {
     context._sampling.mechanism = mechanism
 
     const root = context._trace.started[0]
+
+    log.trace(span, samplingPriority, mechanism)
     this._addDecisionMaker(root)
   }
 

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

@@ -21,6 +21,7 @@ class Config {
     const {
       DD_AGENT_HOST,
       DD_ENV,
+      DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED, // used for testing
       DD_PROFILING_CODEHOTSPOTS_ENABLED,
       DD_PROFILING_CPU_ENABLED,
       DD_PROFILING_DEBUG_SOURCE_MAPS,
@@ -175,6 +176,8 @@ class Config {
       DD_PROFILING_EXPERIMENTAL_TIMELINE_ENABLED, samplingContextsAvailable))
     logExperimentalVarDeprecation('TIMELINE_ENABLED')
     checkOptionWithSamplingContextAllowed(this.timelineEnabled, 'Timeline view')
+    this.timelineSamplingEnabled = isTrue(coalesce(options.timelineSamplingEnabled,
+      DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED, true))
 
     this.codeHotspotsEnabled = isTrue(coalesce(options.codeHotspotsEnabled,
       DD_PROFILING_CODEHOTSPOTS_ENABLED,

package/packages/dd-trace/src/profiling/exporters/agent.js

@@ -3,13 +3,13 @@
 const retry = require('retry')
 const { request: httpRequest } = require('http')
 const { request: httpsRequest } = require('https')
+const { EventSerializer } = require('./event_serializer')
 
 // TODO: avoid using dd-trace internals. Make this a separate module?
 const docker = require('../../exporters/common/docker')
 const FormData = require('../../exporters/common/form-data')
 const { storage } = require('../../../../datadog-core')
 const version = require('../../../../../package.json').version
-const os = require('os')
 const { urlToHttpOptions } = require('url')
 const perf = require('perf_hooks').performance
 
@@ -89,8 +89,10 @@ function computeRetries (uploadTimeout) {
   return [tries, Math.floor(uploadTimeout)]
 }
 
-class AgentExporter {
-  constructor ({ url, logger, uploadTimeout, env, host, service, version, libraryInjected, activation } = {}) {
+class AgentExporter extends EventSerializer {
+  constructor (config = {}) {
+    super(config)
+    const { url, logger, uploadTimeout } = config
     this._url = url
     this._logger = logger
 
@@ -98,74 +100,13 @@ class AgentExporter {
 
     this._backoffTime = backoffTime
     this._backoffTries = backoffTries
-    this._env = env
-    this._host = host
-    this._service = service
-    this._appVersion = version
-    this._libraryInjected = !!libraryInjected
-    this._activation = activation || 'unknown'
   }
 
-  export ({ profiles, start, end, tags }) {
+  export (exportSpec) {
+    const { profiles } = exportSpec
     const fields = []
 
-    function typeToFile (type) {
-      return `${type}.pprof`
-    }
-
-    const event = JSON.stringify({
-      attachments: Object.keys(profiles).map(typeToFile),
-      start: start.toISOString(),
-      end: end.toISOString(),
-      family: 'node',
-      version: '4',
-      tags_profiler: [
-        'language:javascript',
-        'runtime:nodejs',
-        `runtime_arch:${process.arch}`,
-        `runtime_os:${process.platform}`,
-        `runtime_version:${process.version}`,
-        `process_id:${process.pid}`,
-        `profiler_version:${version}`,
-        'format:pprof',
-        ...Object.entries(tags).map(([key, value]) => `${key}:${value}`)
-      ].join(','),
-      info: {
-        application: {
-          env: this._env,
-          service: this._service,
-          start_time: new Date(perf.nodeTiming.nodeStart + perf.timeOrigin).toISOString(),
-          version: this._appVersion
-        },
-        platform: {
-          hostname: this._host,
-          kernel_name: os.type(),
-          kernel_release: os.release(),
-          kernel_version: os.version()
-        },
-        profiler: {
-          activation: this._activation,
-          ssi: {
-            mechanism: this._libraryInjected ? 'injected_agent' : 'none'
-          },
-          version
-        },
-        runtime: {
-          // Using `nodejs` for consistency with the existing `runtime` tag.
-          // Note that the event `family` property uses `node`, as that's what's
-          // proscribed by the Intake API, but that's an internal enum and is
-          // not customer visible.
-          engine: 'nodejs',
-          // strip off leading 'v'. This makes the format consistent with other
-          // runtimes (e.g. Ruby) but not with the existing `runtime_version` tag.
-          // We'll keep it like this as we want cross-engine consistency. We
-          // also aren't changing the format of the existing tag as we don't want
-          // to break it.
-          version: process.version.substring(1)
-        }
-      }
-    })
-
+    const event = this.getEventJSON(exportSpec)
     fields.push(['event', event, {
       filename: 'event.json',
       contentType: 'application/json'
@@ -181,7 +122,7 @@ class AgentExporter {
         return `Adding ${type} profile to agent export: ` + bytes
       })
 
-      const filename = typeToFile(type)
+      const filename = this.typeToFile(type)
       fields.push([filename, buffer, {
         filename,
         contentType: 'application/octet-stream'

package/packages/dd-trace/src/profiling/exporters/event_serializer.js

@@ -0,0 +1,76 @@
+const os = require('os')
+const perf = require('perf_hooks').performance
+const version = require('../../../../../package.json').version
+
+class EventSerializer {
+  constructor ({ env, host, service, version, libraryInjected, activation } = {}) {
+    this._env = env
+    this._host = host
+    this._service = service
+    this._appVersion = version
+    this._libraryInjected = !!libraryInjected
+    this._activation = activation || 'unknown'
+  }
+
+  typeToFile (type) {
+    return `${type}.pprof`
+  }
+
+  getEventJSON ({ profiles, start, end, tags = {}, endpointCounts }) {
+    return JSON.stringify({
+      attachments: Object.keys(profiles).map(t => this.typeToFile(t)),
+      start: start.toISOString(),
+      end: end.toISOString(),
+      family: 'node',
+      version: '4',
+      tags_profiler: [
+        'language:javascript',
+        'runtime:nodejs',
+        `runtime_arch:${process.arch}`,
+        `runtime_os:${process.platform}`,
+        `runtime_version:${process.version}`,
+        `process_id:${process.pid}`,
+        `profiler_version:${version}`,
+        'format:pprof',
+        ...Object.entries(tags).map(([key, value]) => `${key}:${value}`)
+      ].join(','),
+      endpoint_counts: endpointCounts,
+      info: {
+        application: {
+          env: this._env,
+          service: this._service,
+          start_time: new Date(perf.nodeTiming.nodeStart + perf.timeOrigin).toISOString(),
+          version: this._appVersion
+        },
+        platform: {
+          hostname: this._host,
+          kernel_name: os.type(),
+          kernel_release: os.release(),
+          kernel_version: os.version()
+        },
+        profiler: {
+          activation: this._activation,
+          ssi: {
+            mechanism: this._libraryInjected ? 'injected_agent' : 'none'
+          },
+          version
+        },
+        runtime: {
+          // Using `nodejs` for consistency with the existing `runtime` tag.
+          // Note that the event `family` property uses `node`, as that's what's
+          // proscribed by the Intake API, but that's an internal enum and is
+          // not customer visible.
+          engine: 'nodejs',
+          // strip off leading 'v'. This makes the format consistent with other
+          // runtimes (e.g. Ruby) but not with the existing `runtime_version` tag.
+          // We'll keep it like this as we want cross-engine consistency. We
+          // also aren't changing the format of the existing tag as we don't want
+          // to break it.
+          version: process.version.substring(1)
+        }
+      }
+    })
+  }
+}
+
+module.exports = { EventSerializer }

package/packages/dd-trace/src/profiling/exporters/file.js

@@ -4,6 +4,7 @@ const fs = require('fs')
 const { promisify } = require('util')
 const { threadId } = require('worker_threads')
 const writeFile = promisify(fs.writeFile)
+const { EventSerializer } = require('./event_serializer')
 
 function formatDateTime (t) {
   const pad = (n) => String(n).padStart(2, '0')
@@ -11,18 +12,21 @@ function formatDateTime (t) {
          `T${pad(t.getUTCHours())}${pad(t.getUTCMinutes())}${pad(t.getUTCSeconds())}Z`
 }
 
-class FileExporter {
-  constructor ({ pprofPrefix } = {}) {
+class FileExporter extends EventSerializer {
+  constructor (config = {}) {
+    super(config)
+    const { pprofPrefix } = config
     this._pprofPrefix = pprofPrefix || ''
   }
 
-  export ({ profiles, end }) {
+  export (exportSpec) {
+    const { profiles, end } = exportSpec
     const types = Object.keys(profiles)
     const dateStr = formatDateTime(end)
     const tasks = types.map(type => {
       return writeFile(`${this._pprofPrefix}${type}_worker_${threadId}_${dateStr}.pprof`, profiles[type])
     })
-
+    tasks.push(writeFile(`event_worker_${threadId}_${dateStr}.json`, this.getEventJSON(exportSpec)))
     return Promise.all(tasks)
   }
 }

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

@@ -4,9 +4,11 @@ const { EventEmitter } = require('events')
 const { Config } = require('./config')
 const { snapshotKinds } = require('./constants')
 const { threadNamePrefix } = require('./profilers/shared')
+const { isWebServerSpan, endpointNameFromTags, getStartedSpans } = require('./webspan-utils')
 const dc = require('dc-polyfill')
 
 const profileSubmittedChannel = dc.channel('datadog:profiling:profile-submitted')
+const spanFinishedChannel = dc.channel('dd-trace:span:finish')
 
 function maybeSourceMap (sourceMap, SourceMapper, debug) {
   if (!sourceMap) return
@@ -21,6 +23,20 @@ function logError (logger, err) {
   }
 }
 
+function findWebSpan (startedSpans, spanId) {
+  for (let i = startedSpans.length; --i >= 0;) {
+    const ispan = startedSpans[i]
+    const context = ispan.context()
+    if (context._spanId === spanId) {
+      if (isWebServerSpan(context._tags)) {
+        return true
+      }
+      spanId = context._parentId
+    }
+  }
+  return false
+}
+
 class Profiler extends EventEmitter {
   constructor () {
     super()
@@ -30,6 +46,7 @@ class Profiler extends EventEmitter {
     this._timer = undefined
     this._lastStart = undefined
     this._timeoutInterval = undefined
+    this.endpointCounts = new Map()
   }
 
   start (options) {
@@ -82,6 +99,11 @@ class Profiler extends EventEmitter {
         this._logger.debug(`Started ${profiler.type} profiler in ${threadNamePrefix} thread`)
       }
 
+      if (config.endpointCollectionEnabled) {
+        this._spanFinishListener = this._onSpanFinish.bind(this)
+        spanFinishedChannel.subscribe(this._spanFinishListener)
+      }
+
       this._capture(this._timeoutInterval, start)
       return true
     } catch (e) {
@@ -117,6 +139,11 @@ class Profiler extends EventEmitter {
 
     this._enabled = false
 
+    if (this._spanFinishListener !== undefined) {
+      spanFinishedChannel.unsubscribe(this._spanFinishListener)
+      this._spanFinishListener = undefined
+    }
+
     for (const profiler of this._config.profilers) {
       profiler.stop()
       this._logger.debug(`Stopped ${profiler.type} profiler in ${threadNamePrefix} thread`)
@@ -137,6 +164,26 @@ class Profiler extends EventEmitter {
     }
   }
 
+  _onSpanFinish (span) {
+    const context = span.context()
+    const tags = context._tags
+    if (!isWebServerSpan(tags)) return
+
+    const endpointName = endpointNameFromTags(tags)
+    if (!endpointName) return
+
+    // Make sure this is the outermost web span, just in case so we don't overcount
+    if (findWebSpan(getStartedSpans(context), context._parentId)) return
+
+    let counter = this.endpointCounts.get(endpointName)
+    if (counter === undefined) {
+      counter = { count: 1 }
+      this.endpointCounts.set(endpointName, counter)
+    } else {
+      counter.count++
+    }
+  }
+
   async _collect (snapshotKind, restart = true) {
     if (!this._enabled) return
 
@@ -194,18 +241,23 @@ class Profiler extends EventEmitter {
 
   _submit (profiles, start, end, snapshotKind) {
     const { tags } = this._config
-    const tasks = []
 
-    tags.snapshot = snapshotKind
-    for (const exporter of this._config.exporters) {
-      const task = exporter.export({ profiles, start, end, tags })
-        .catch(err => {
-          if (this._logger) {
-            this._logger.warn(err)
-          }
-        })
-      tasks.push(task)
+    // Flatten endpoint counts
+    const endpointCounts = {}
+    for (const [endpoint, { count }] of this.endpointCounts) {
+      endpointCounts[endpoint] = count
     }
+    this.endpointCounts.clear()
+
+    tags.snapshot = snapshotKind
+    const exportSpec = { profiles, start, end, tags, endpointCounts }
+    const tasks = this._config.exporters.map(exporter =>
+      exporter.export(exportSpec).catch(err => {
+        if (this._logger) {
+          this._logger.warn(err)
+        }
+      })
+    )
 
     return Promise.all(tasks)
   }

package/packages/dd-trace/src/profiling/profilers/event_plugins/event.js

@@ -1,14 +1,15 @@
-const { AsyncLocalStorage } = require('async_hooks')
+const { storage } = require('../../../../../datadog-core')
 const TracingPlugin = require('../../../plugins/tracing')
 const { performance } = require('perf_hooks')
 
 // We are leveraging the TracingPlugin class for its functionality to bind
 // start/error/finish methods to the appropriate diagnostic channels.
 class EventPlugin extends TracingPlugin {
-  constructor (eventHandler) {
+  constructor (eventHandler, eventFilter) {
     super()
     this.eventHandler = eventHandler
-    this.store = new AsyncLocalStorage()
+    this.eventFilter = eventFilter
+    this.store = storage('profiling')
     this.entryType = this.constructor.entryType
   }
 
@@ -20,27 +21,36 @@ class EventPlugin extends TracingPlugin {
   }
 
   error () {
-    this.store.getStore().error = true
+    const store = this.store.getStore()
+    if (store) {
+      store.error = true
+    }
   }
 
   finish () {
-    const { startEvent, startTime, error } = this.store.getStore()
+    const store = this.store.getStore()
+    if (!store) return
+
+    const { startEvent, startTime, error } = store
     if (error) {
       return // don't emit perf events for failed operations
     }
     const duration = performance.now() - startTime
 
-    const context = this.activeSpan?.context()
-    const _ddSpanId = context?.toSpanId()
-    const _ddRootSpanId = context?._trace.started[0]?.context().toSpanId() || _ddSpanId
-
     const event = {
       entryType: this.entryType,
       startTime,
-      duration,
-      _ddSpanId,
-      _ddRootSpanId
+      duration
     }
+
+    if (!this.eventFilter(event)) {
+      return
+    }
+
+    const context = this.activeSpan?.context()
+    event._ddSpanId = context?.toSpanId()
+    event._ddRootSpanId = context?._trace.started[0]?.context().toSpanId() || event._ddSpanId
+
     this.eventHandler(this.extendEvent(event, startEvent))
   }
 }