dd-trace 4.19.0 → 4.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "4.19.0",
+  "version": "4.20.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",

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

@@ -36,7 +36,7 @@ function enable (_config) {
 
     setTemplates(_config)
 
-    RuleManager.applyRules(_config.appsec.rules, _config.appsec)
+    RuleManager.loadRules(_config.appsec)
 
     remoteConfig.enableWafUpdate(_config.appsec)
 

package/packages/dd-trace/src/appsec/rule_manager.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const fs = require('fs')
 const waf = require('./waf')
 const { ACKNOWLEDGED, ERROR } = require('./remote_config/apply_states')
 const blocking = require('./blocking')
@@ -13,13 +14,15 @@ let appliedExclusions = new Map()
 let appliedCustomRules = new Map()
 let appliedActions = new Map()
 
-function applyRules (rules, config) {
-  defaultRules = rules
+function loadRules (config) {
+  defaultRules = config.rules
+    ? JSON.parse(fs.readFileSync(config.rules))
+    : require('./recommended.json')
 
-  waf.init(rules, config)
+  waf.init(defaultRules, config)
 
-  if (rules.actions) {
-    blocking.updateBlockingConfiguration(rules.actions.find(action => action.id === 'block'))
+  if (defaultRules.actions) {
+    blocking.updateBlockingConfiguration(defaultRules.actions.find(action => action.id === 'block'))
   }
 }
 
@@ -252,7 +255,7 @@ function clearAllRules () {
 }
 
 module.exports = {
-  applyRules,
+  loadRules,
   updateWafFromRC,
   clearAllRules
 }

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

@@ -309,6 +309,10 @@ class Config {
       options.tracePropagationStyle,
       defaultPropagationStyle
     )
+    const DD_TRACE_PROPAGATION_EXTRACT_FIRST = coalesce(
+      process.env.DD_TRACE_PROPAGATION_EXTRACT_FIRST,
+      false
+    )
     const DD_TRACE_RUNTIME_ID_ENABLED = coalesce(
       options.experimental && options.experimental.runtimeId,
       process.env.DD_TRACE_EXPERIMENTAL_RUNTIME_ID_ENABLED,
@@ -579,6 +583,7 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
       inject: DD_TRACE_PROPAGATION_STYLE_INJECT,
       extract: DD_TRACE_PROPAGATION_STYLE_EXTRACT
     }
+    this.tracePropagationExtractFirst = isTrue(DD_TRACE_PROPAGATION_EXTRACT_FIRST)
     this.experimental = {
       runtimeId: isTrue(DD_TRACE_RUNTIME_ID_ENABLED),
       exporter: DD_TRACE_EXPORTER,
@@ -610,7 +615,7 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
     this.tagsHeaderMaxLength = parseInt(DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH)
     this.appsec = {
       enabled: DD_APPSEC_ENABLED,
-      rules: DD_APPSEC_RULES ? safeJsonParse(maybeFile(DD_APPSEC_RULES)) : require('./appsec/recommended.json'),
+      rules: DD_APPSEC_RULES,
       customRulesProvided: !!DD_APPSEC_RULES,
       rateLimit: DD_APPSEC_TRACE_RATE_LIMIT,
       wafTimeout: DD_APPSEC_WAF_TIMEOUT,

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

@@ -42,6 +42,18 @@ class Identifier {
   toJSON () {
     return this.toString()
   }
+
+  equals (other) {
+    const length = this._buffer.length
+    const otherLength = other._buffer.length
+
+    // Only compare the bytes available in both IDs.
+    for (let i = length, j = otherLength; i >= 0 && j >= 0; i--, j--) {
+      if (this._buffer[i] !== other._buffer[j]) return false
+    }
+
+    return true
+  }
 }
 
 // Create a buffer, using an optional hexadecimal value if provided.

package/packages/dd-trace/src/opentracing/propagation/text_map.js

@@ -236,11 +236,20 @@ class TextMapPropagator {
   _extractDatadogContext (carrier) {
     const spanContext = this._extractGenericContext(carrier, traceKey, spanKey, 10)
 
-    if (spanContext) {
-      this._extractOrigin(carrier, spanContext)
-      this._extractBaggageItems(carrier, spanContext)
-      this._extractSamplingPriority(carrier, spanContext)
-      this._extractTags(carrier, spanContext)
+    if (!spanContext) return spanContext
+
+    this._extractOrigin(carrier, spanContext)
+    this._extractBaggageItems(carrier, spanContext)
+    this._extractSamplingPriority(carrier, spanContext)
+    this._extractTags(carrier, spanContext)
+
+    if (this._config.tracePropagationExtractFirst) return spanContext
+
+    const tc = this._extractTraceparentContext(carrier)
+
+    if (tc && spanContext._traceId.equals(tc._traceId)) {
+      spanContext._traceparent = tc._traceparent
+      spanContext._tracestate = tc._tracestate
     }
 
     return spanContext

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

@@ -131,10 +131,12 @@ class Config {
       : getProfilers({
         DD_PROFILING_HEAP_ENABLED,
         DD_PROFILING_WALLTIME_ENABLED,
-        DD_PROFILING_EXPERIMENTAL_TIMELINE_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,
       DD_PROFILING_EXPERIMENTAL_CODEHOTSPOTS_ENABLED, false))
@@ -147,8 +149,7 @@ class Config {
 module.exports = { Config }
 
 function getProfilers ({
-  DD_PROFILING_HEAP_ENABLED, DD_PROFILING_WALLTIME_ENABLED,
-  DD_PROFILING_PROFILERS, DD_PROFILING_EXPERIMENTAL_TIMELINE_ENABLED
+  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
@@ -172,11 +173,6 @@ function getProfilers ({
     }
   }
 
-  // Events profiler is a profiler for timeline events that goes with the wall
-  // profiler
-  if (profilers.has('wall') && DD_PROFILING_EXPERIMENTAL_TIMELINE_ENABLED) {
-    profilers.add('events')
-  }
   return [...profilers]
 }
 
@@ -238,8 +234,6 @@ function getProfiler (name, options) {
       return new WallProfiler(options)
     case 'space':
       return new SpaceProfiler(options)
-    case 'events':
-      return new EventsProfiler(options)
     default:
       options.logger.error(`Unknown profiler "${name}"`)
   }
@@ -257,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

@@ -36,7 +36,7 @@ class EventsProfiler {
       this._observer = new PerformanceObserver(add.bind(this))
     }
     // Currently only support GC
-    this._observer.observe({ type: 'gc' })
+    this._observer.observe({ entryTypes: ['gc'] })
   }
 
   stop () {
@@ -46,6 +46,11 @@ class EventsProfiler {
   }
 
   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')

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)