dd-trace 5.14.1 → 5.15.0

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

@@ -3,44 +3,69 @@
 const { channel } = require('dc-polyfill')
 
 const Level = {
-  Debug: 'debug',
-  Info: 'info',
-  Warn: 'warn',
-  Error: 'error'
+  trace: 20,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  critical: 50,
+  off: 100
 }
 
-const defaultLevel = Level.Debug
+const debugChannel = channel('datadog:log:debug')
+const infoChannel = channel('datadog:log:info')
+const warnChannel = channel('datadog:log:warn')
+const errorChannel = channel('datadog:log:error')
 
-// based on: https://github.com/trentm/node-bunyan#levels
-const logChannels = {
-  [Level.Debug]: createLogChannel(Level.Debug, 20),
-  [Level.Info]: createLogChannel(Level.Info, 30),
-  [Level.Warn]: createLogChannel(Level.Warn, 40),
-  [Level.Error]: createLogChannel(Level.Error, 50)
-}
+const defaultLevel = Level.debug
 
-function createLogChannel (name, logLevel) {
-  const logChannel = channel(`datadog:log:${name}`)
-  logChannel.logLevel = logLevel
-  return logChannel
+function getChannelLogLevel (level) {
+  return level && typeof level === 'string'
+    ? Level[level.toLowerCase().trim()] || defaultLevel
+    : defaultLevel
 }
 
-function getChannelLogLevel (level) {
-  let logChannel
-  if (level && typeof level === 'string') {
-    logChannel = logChannels[level.toLowerCase().trim()] || logChannels[defaultLevel]
-  } else {
-    logChannel = logChannels[defaultLevel]
+class LogChannel {
+  constructor (level) {
+    this._level = getChannelLogLevel(level)
+  }
+
+  subscribe (logger) {
+    if (Level.debug >= this._level) {
+      debugChannel.subscribe(logger.debug)
+    }
+    if (Level.info >= this._level) {
+      infoChannel.subscribe(logger.info)
+    }
+    if (Level.warn >= this._level) {
+      warnChannel.subscribe(logger.warn)
+    }
+    if (Level.error >= this._level) {
+      errorChannel.subscribe(logger.error)
+    }
+  }
+
+  unsubscribe (logger) {
+    if (debugChannel.hasSubscribers) {
+      debugChannel.unsubscribe(logger.debug)
+    }
+    if (infoChannel.hasSubscribers) {
+      infoChannel.unsubscribe(logger.info)
+    }
+    if (warnChannel.hasSubscribers) {
+      warnChannel.unsubscribe(logger.warn)
+    }
+    if (errorChannel.hasSubscribers) {
+      errorChannel.unsubscribe(logger.error)
+    }
   }
-  return logChannel.logLevel
 }
 
 module.exports = {
-  Level,
-  getChannelLogLevel,
+  LogChannel,
 
-  debugChannel: logChannels[Level.Debug],
-  infoChannel: logChannels[Level.Info],
-  warnChannel: logChannels[Level.Warn],
-  errorChannel: logChannels[Level.Error]
+  debugChannel,
+  infoChannel,
+  warnChannel,
+  errorChannel
 }

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

@@ -1,8 +1,7 @@
 'use strict'
 
 const { storage } = require('../../../datadog-core')
-const { getChannelLogLevel, debugChannel, infoChannel, warnChannel, errorChannel } = require('./channels')
-
+const { LogChannel } = require('./channels')
 const defaultLogger = {
   debug: msg => console.debug(msg), /* eslint-disable-line no-console */
   info: msg => console.info(msg), /* eslint-disable-line no-console */
@@ -12,7 +11,7 @@ const defaultLogger = {
 
 let enabled = false
 let logger = defaultLogger
-let logLevel = getChannelLogLevel()
+let logChannel = new LogChannel()
 
 function withNoop (fn) {
   const store = storage.getStore()
@@ -23,45 +22,21 @@ function withNoop (fn) {
 }
 
 function unsubscribeAll () {
-  if (debugChannel.hasSubscribers) {
-    debugChannel.unsubscribe(onDebug)
-  }
-  if (infoChannel.hasSubscribers) {
-    infoChannel.unsubscribe(onInfo)
-  }
-  if (warnChannel.hasSubscribers) {
-    warnChannel.unsubscribe(onWarn)
-  }
-  if (errorChannel.hasSubscribers) {
-    errorChannel.unsubscribe(onError)
-  }
+  logChannel.unsubscribe({ debug, info, warn, error })
 }
 
-function toggleSubscription (enable) {
+function toggleSubscription (enable, level) {
   unsubscribeAll()
 
   if (enable) {
-    if (debugChannel.logLevel >= logLevel) {
-      debugChannel.subscribe(onDebug)
-    }
-    if (infoChannel.logLevel >= logLevel) {
-      infoChannel.subscribe(onInfo)
-    }
-    if (warnChannel.logLevel >= logLevel) {
-      warnChannel.subscribe(onWarn)
-    }
-    if (errorChannel.logLevel >= logLevel) {
-      errorChannel.subscribe(onError)
-    }
+    logChannel = new LogChannel(level)
+    logChannel.subscribe({ debug, info, warn, error })
   }
 }
 
 function toggle (enable, level) {
-  if (level !== undefined) {
-    logLevel = getChannelLogLevel(level)
-  }
   enabled = enable
-  toggleSubscription(enabled)
+  toggleSubscription(enabled, level)
 }
 
 function use (newLogger) {
@@ -73,26 +48,9 @@ function use (newLogger) {
 function reset () {
   logger = defaultLogger
   enabled = false
-  logLevel = getChannelLogLevel()
   toggleSubscription(false)
 }
 
-function onError (err) {
-  if (enabled) error(err)
-}
-
-function onWarn (message) {
-  if (enabled) warn(message)
-}
-
-function onInfo (message) {
-  if (enabled) info(message)
-}
-
-function onDebug (message) {
-  if (enabled) debug(message)
-}
-
 function error (err) {
   if (typeof err !== 'object' || !err) {
     err = String(err)

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

@@ -5,6 +5,7 @@ const id = require('../../id')
 const DatadogSpanContext = require('../span_context')
 const log = require('../../log')
 const TraceState = require('./tracestate')
+const tags = require('../../../../../ext/tags')
 
 const { AUTO_KEEP, AUTO_REJECT, USER_KEEP } = require('../../../../../ext/priority')
 
@@ -39,6 +40,7 @@ const tracestateTagKeyFilter = /[^\x21-\x2b\x2d-\x3c\x3e-\x7e]/g
 // Tag values in tracestate replace ',', '~' and ';' with '_'
 const tracestateTagValueFilter = /[^\x20-\x2b\x2d-\x3a\x3c-\x7d]/g
 const invalidSegment = /^0+$/
+const zeroTraceId = '0000000000000000'
 
 class TextMapPropagator {
   constructor (config) {
@@ -175,9 +177,9 @@ class TextMapPropagator {
         // SpanContext was created by a ddtrace span.
         // Last datadog span id should be set to the current span.
         state.set('p', spanContext._spanId)
-      } else if (spanContext._trace.tags['_dd.parent_id']) {
+      } else if (spanContext._trace.tags[tags.DD_PARENT_ID]) {
         // Propagate the last Datadog span id set on the remote span.
-        state.set('p', spanContext._trace.tags['_dd.parent_id'])
+        state.set('p', spanContext._trace.tags[tags.DD_PARENT_ID])
       }
       state.set('s', priority)
       if (mechanism) {
@@ -214,9 +216,56 @@ class TextMapPropagator {
     return this._config.tracePropagationStyle[mode].includes(name)
   }
 
+  _hasTraceIdConflict (w3cSpanContext, firstSpanContext) {
+    return w3cSpanContext !== null &&
+           firstSpanContext.toTraceId(true) === w3cSpanContext.toTraceId(true) &&
+           firstSpanContext.toSpanId() !== w3cSpanContext.toSpanId()
+  }
+
+  _hasParentIdInTags (spanContext) {
+    return tags.DD_PARENT_ID in spanContext._trace.tags &&
+      spanContext._trace.tags[tags.DD_PARENT_ID] !== zeroTraceId
+  }
+
+  _updateParentIdFromDdHeaders (carrier, firstSpanContext) {
+    const ddCtx = this._extractDatadogContext(carrier)
+    if (ddCtx !== null) {
+      firstSpanContext._trace.tags[tags.DD_PARENT_ID] = ddCtx._spanId.toString().padStart(16, '0')
+    }
+  }
+
+  _resolveTraceContextConflicts (w3cSpanContext, firstSpanContext, carrier) {
+    if (!this._hasTraceIdConflict(w3cSpanContext, firstSpanContext)) {
+      return firstSpanContext
+    }
+    if (this._hasParentIdInTags(w3cSpanContext)) {
+      // tracecontext headers contain a p value, ensure this value is sent to backend
+      firstSpanContext._trace.tags[tags.DD_PARENT_ID] = w3cSpanContext._trace.tags[tags.DD_PARENT_ID]
+    } else {
+      // if p value is not present in tracestate, use the parent id from the datadog headers
+      this._updateParentIdFromDdHeaders(carrier, firstSpanContext)
+    }
+    // the span_id in tracecontext takes precedence over the first extracted propagation style
+    firstSpanContext._spanId = w3cSpanContext._spanId
+    return firstSpanContext
+  }
+
   _extractSpanContext (carrier) {
+    let spanContext = null
     for (const extractor of this._config.tracePropagationStyle.extract) {
-      let spanContext = null
+      // add logic to ensure tracecontext headers takes precedence over other extracted headers
+      if (spanContext !== null) {
+        if (this._config.tracePropagationExtractFirst) {
+          return spanContext
+        }
+        if (extractor !== 'tracecontext') {
+          continue
+        }
+        spanContext = this._resolveTraceContextConflicts(
+          this._extractTraceparentContext(carrier), spanContext, carrier)
+        break
+      }
+
       switch (extractor) {
         case 'datadog':
           spanContext = this._extractDatadogContext(carrier)
@@ -238,13 +287,9 @@ class TextMapPropagator {
         default:
           log.warn(`Unknown propagation style: ${extractor}`)
       }
-
-      if (spanContext !== null) {
-        return spanContext
-      }
     }
 
-    return this._extractSqsdContext(carrier)
+    return spanContext || this._extractSqsdContext(carrier)
   }
 
   _extractDatadogContext (carrier) {
@@ -354,7 +399,7 @@ class TextMapPropagator {
         for (const [key, value] of state.entries()) {
           switch (key) {
             case 'p': {
-              spanContext._trace.tags['_dd.parent_id'] = value
+              spanContext._trace.tags[tags.DD_PARENT_ID] = value
               break
             }
             case 's': {
@@ -387,8 +432,8 @@ class TextMapPropagator {
         }
       })
 
-      if (!spanContext._trace.tags['_dd.parent_id']) {
-        spanContext._trace.tags['_dd.parent_id'] = '0000000000000000'
+      if (!spanContext._trace.tags[tags.DD_PARENT_ID]) {
+        spanContext._trace.tags[tags.DD_PARENT_ID] = zeroTraceId
       }
 
       this._extractBaggageItems(carrier, spanContext)
@@ -531,7 +576,7 @@ class TextMapPropagator {
 
     const tid = traceId.substring(0, 16)
 
-    if (tid === '0000000000000000') return
+    if (tid === zeroTraceId) return
 
     spanContext._trace.tags['_dd.p.tid'] = tid
   }

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

@@ -54,6 +54,7 @@ module.exports = {
   get 'microgateway-core' () { return require('../../../datadog-plugin-microgateway-core/src') },
   get mocha () { return require('../../../datadog-plugin-mocha/src') },
   get 'mocha-each' () { return require('../../../datadog-plugin-mocha/src') },
+  get workerpool () { return require('../../../datadog-plugin-mocha/src') },
   get moleculer () { return require('../../../datadog-plugin-moleculer/src') },
   get mongodb () { return require('../../../datadog-plugin-mongodb-core/src') },
   get 'mongodb-core' () { return require('../../../datadog-plugin-mongodb-core/src') },

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const BlockList = require('./ip_blocklist')
+const { BlockList } = require('net')
 const net = require('net')
 
 const ipHeaderList = [

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

@@ -62,6 +62,7 @@ const JEST_TEST_RUNNER = 'test.jest.test_runner'
 const JEST_DISPLAY_NAME = 'test.jest.display_name'
 
 const CUCUMBER_IS_PARALLEL = 'test.cucumber.is_parallel'
+const MOCHA_IS_PARALLEL = 'test.mocha.is_parallel'
 
 const TEST_ITR_TESTS_SKIPPED = '_dd.ci.itr.tests_skipped'
 const TEST_ITR_SKIPPING_ENABLED = 'test.itr.tests_skipping.enabled'
@@ -87,6 +88,9 @@ const JEST_WORKER_COVERAGE_PAYLOAD_CODE = 61
 // cucumber worker variables
 const CUCUMBER_WORKER_TRACE_PAYLOAD_CODE = 70
 
+// mocha worker variables
+const MOCHA_WORKER_TRACE_PAYLOAD_CODE = 80
+
 // Early flake detection util strings
 const EFD_STRING = "Retried by Datadog's Early Flake Detection"
 const EFD_TEST_NAME_REGEX = new RegExp(EFD_STRING + ' \\(#\\d+\\): ', 'g')
@@ -98,6 +102,7 @@ module.exports = {
   JEST_TEST_RUNNER,
   JEST_DISPLAY_NAME,
   CUCUMBER_IS_PARALLEL,
+  MOCHA_IS_PARALLEL,
   TEST_TYPE,
   TEST_NAME,
   TEST_SUITE,
@@ -111,6 +116,7 @@ module.exports = {
   JEST_WORKER_TRACE_PAYLOAD_CODE,
   JEST_WORKER_COVERAGE_PAYLOAD_CODE,
   CUCUMBER_WORKER_TRACE_PAYLOAD_CODE,
+  MOCHA_WORKER_TRACE_PAYLOAD_CODE,
   TEST_SOURCE_START,
   TEST_SKIPPED_BY_ITR,
   TEST_CONFIGURATION_BROWSER_NAME,

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

@@ -9,7 +9,7 @@ process.once('beforeExit', () => { profiler.stop() })
 module.exports = {
   start: config => {
     const { service, version, env, url, hostname, port, tags, repositoryUrl, commitSHA } = config
-    const { enabled, sourceMap, exporters } = config.profiling
+    const { enabled, sourceMap, exporters, heuristicsEnabled } = config.profiling
     const logger = {
       debug: (message) => log.debug(message),
       info: (message) => log.info(message),
@@ -19,6 +19,7 @@ module.exports = {
 
     return profiler.start({
       enabled,
+      heuristicsEnabled,
       service,
       version,
       env,

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

@@ -65,6 +65,7 @@ class Config {
       DD_PROFILING_PPROF_PREFIX, '')
 
     this.enabled = enabled
+    this.heuristicsEnabled = options.heuristicsEnabled
     this.service = service
     this.env = env
     this.host = host

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

@@ -55,7 +55,7 @@ class Profiler extends EventEmitter {
     if (this._enabled) return true
 
     const config = this._config = new Config(options)
-    if (!config.enabled) return false
+    if (!config.enabled && !config.heuristicsEnabled) return false
 
     this._logger = config.logger
     this._enabled = true

package/packages/dd-trace/src/profiling/{ssi-telemetry.js → ssi-heuristics.js}

@@ -2,28 +2,25 @@
 
 const telemetryMetrics = require('../telemetry/metrics')
 const profilersNamespace = telemetryMetrics.manager.namespace('profilers')
-const performance = require('perf_hooks').performance
 const dc = require('dc-polyfill')
-const { isTrue, isFalse } = require('../util')
 
-// If the process lived for less than 30 seconds, it's considered short-lived
-const DEFAULT_SHORT_LIVED_THRESHOLD = 30000
+// If the process lives for at least 30 seconds, it's considered long-lived
+const DEFAULT_LONG_LIVED_THRESHOLD = 30000
 
 const EnablementChoice = {
   MANUALLY_ENABLED: Symbol('SSITelemetry.EnablementChoice.MANUALLY_ENABLED'),
   SSI_ENABLED: Symbol('SSITelemetry.EnablementChoice.SSI_ENABLED'),
   SSI_NOT_ENABLED: Symbol('SSITelemetry.EnablementChoice.SSI_NOT_ENABLED'),
-  DISABLED: Symbol('SSITelemetry.EnablementChoice.MANUALLY_DISABLED')
+  DISABLED: Symbol('SSITelemetry.EnablementChoice.DISABLED')
 }
 Object.freeze(EnablementChoice)
 
-function getEnablementChoiceFromEnv () {
-  const { DD_PROFILING_ENABLED, DD_INJECTION_ENABLED } = process.env
-  if (DD_INJECTION_ENABLED === undefined || isFalse(DD_PROFILING_ENABLED)) {
+function getEnablementChoiceFromConfig (config) {
+  if (config.ssi === false || config.enabled === false) {
     return EnablementChoice.DISABLED
-  } else if (DD_INJECTION_ENABLED.split(',').includes('profiling')) {
+  } else if (config.heuristicsEnabled === true) {
     return EnablementChoice.SSI_ENABLED
-  } else if (isTrue(DD_PROFILING_ENABLED)) {
+  } else if (config.enabled === true) {
     return EnablementChoice.MANUALLY_ENABLED
   } else {
     return EnablementChoice.SSI_NOT_ENABLED
@@ -38,39 +35,38 @@ function enablementChoiceToTagValue (enablementChoice) {
       return 'ssi_enabled'
     case EnablementChoice.SSI_NOT_ENABLED:
       return 'not_enabled'
-    case EnablementChoice.MANUALLY_DISABLED:
+    case EnablementChoice.DISABLED:
       // Can't emit this one as a tag
       throw new Error('Invalid enablement choice')
   }
 }
 
 /**
- * This class emits telemetry metrics about the profiler behavior under SSI. It will only emit metrics
- * when the application closes, and will emit the following metrics:
+ * This class embodies the SSI profiler-triggering heuristics and also emits telemetry metrics about
+ * the profiler behavior under SSI. It emits the following metrics:
  * - `number_of_profiles`: The number of profiles that were submitted
- * - `number_of_runtime_id`: The number of runtime IDs in the app (always 1 for Node.js)
- * It will also add tags describing the state of heuristics triggers, the enablement choice, and whether
- * actual profiles were sent (as opposed to mock profiles). There is a mock profiler that is activated
- * when the profiler is not enabled, and it will emit mock profile submission events at the same cadence
- * the profiler would, providing insight into how many profiles would've been emitted if SSI enabled
- * profiling. Note that telemetry is per tracer instance, and each worker thread will have its own instance.
+ * - `number_of_runtime_id`: The number of runtime IDs in the app (always 1 for Node.js, emitted
+ *   once when the tags won't change for the remaineder of of the app's lifetime.)
+ * It will also add tags describing the state of heuristics triggers, the enablement choice, and
+ * whether actual profiles were sent (as opposed to mock profiles). There is a mock profiler that is
+ * activated when the profiler is not enabled, and it will emit mock profile submission events at
+ * the same cadence the profiler would, providing insight into how many profiles would've been
+ * emitted if SSI enabled profiling. Note that heuristics (and thus telemetry) is per tracer
+ * instance, and each worker thread will have its own instance.
  */
-class SSITelemetry {
-  constructor ({
-    enablementChoice = getEnablementChoiceFromEnv(),
-    shortLivedThreshold = DEFAULT_SHORT_LIVED_THRESHOLD
-  } = {}) {
-    if (!Object.values(EnablementChoice).includes(enablementChoice)) {
-      throw new Error('Invalid enablement choice')
-    }
-    if (typeof shortLivedThreshold !== 'number' || shortLivedThreshold <= 0) {
-      throw new Error('Short-lived threshold must be a positive number')
+class SSIHeuristics {
+  constructor (config) {
+    this.enablementChoice = getEnablementChoiceFromConfig(config)
+
+    const longLivedThreshold = config.longLivedThreshold || DEFAULT_LONG_LIVED_THRESHOLD
+    if (typeof longLivedThreshold !== 'number' || longLivedThreshold <= 0) {
+      throw new Error('Long-lived threshold must be a positive number')
     }
-    this.enablementChoice = enablementChoice
-    this.shortLivedThreshold = shortLivedThreshold
+    this.longLivedThreshold = longLivedThreshold
 
     this.hasSentProfiles = false
     this.noSpan = true
+    this.shortLived = true
   }
 
   enabled () {
@@ -83,7 +79,10 @@ class SSITelemetry {
       // reference point, but the tracer initialization point is more relevant, as we couldn't be
       // collecting profiles earlier anyway. The difference is not particularly significant if the
       // tracer is initialized early in the process lifetime.
-      this.startTime = performance.now()
+      setTimeout(() => {
+        this.shortLived = false
+        this._maybeTriggered()
+      }, this.longLivedThreshold).unref()
 
       this._onSpanCreated = this._onSpanCreated.bind(this)
       this._onProfileSubmitted = this._onProfileSubmitted.bind(this)
@@ -97,8 +96,31 @@ class SSITelemetry {
     }
   }
 
+  onTriggered (callback) {
+    switch (typeof callback) {
+      case 'undefined':
+      case 'function':
+        this.triggeredCallback = callback
+        process.nextTick(() => {
+          this._maybeTriggered()
+        })
+        break
+      default:
+        throw new TypeError('callback must be a function or undefined')
+    }
+  }
+
+  _maybeTriggered () {
+    if (!this.shortLived && !this.noSpan) {
+      if (typeof this.triggeredCallback === 'function') {
+        this.triggeredCallback.call(null)
+      }
+    }
+  }
+
   _onSpanCreated () {
     this.noSpan = false
+    this._maybeTriggered()
     dc.unsubscribe('dd-trace:span:start', this._onSpanCreated)
   }
 
@@ -121,7 +143,7 @@ class SSITelemetry {
     if (this.noSpan) {
       decision.push('no_span')
     }
-    if (performance.now() - this.startTime < this.shortLivedThreshold) {
+    if (this.shortLived) {
       decision.push('short_lived')
     }
     if (decision.length === 0) {
@@ -138,8 +160,14 @@ class SSITelemetry {
     this._profileCount = profilersNamespace.count('ssi_heuristic.number_of_profiles', tags)
     this._runtimeIdCount = profilersNamespace.count('ssi_heuristic.number_of_runtime_id', tags)
 
-    if (!this._emittedRuntimeId && decision[0] === 'triggered') {
-      // Tags won't change anymore, so we can emit the runtime ID metric now
+    if (
+      !this._emittedRuntimeId &&
+      decision[0] === 'triggered' &&
+      // When enablement choice is SSI_ENABLED, hasSentProfiles can transition from false to true when the
+      // profiler gets started and the first profile is submitted, so we have to wait for it.
+      (this.enablementChoice !== EnablementChoice.SSI_ENABLED || this.hasSentProfiles)
+    ) {
+      // Tags won't change anymore, so we can emit the runtime ID metric now.
       this._emittedRuntimeId = true
       this._runtimeIdCount.inc()
     }
@@ -164,4 +192,4 @@ class SSITelemetry {
   }
 }
 
-module.exports = { SSITelemetry, EnablementChoice }
+module.exports = { SSIHeuristics, EnablementChoice }

package/packages/dd-trace/src/profiling/ssi-telemetry-mock-profiler.js

@@ -12,16 +12,11 @@ module.exports = {
     // Copied from packages/dd-trace/src/profiler.js
     const flushInterval = coalesce(config.interval, Number(DD_PROFILING_UPLOAD_PERIOD) * 1000, 65 * 1000)
 
-    function scheduleProfileSubmit () {
-      timerId = setTimeout(emitProfileSubmit, flushInterval)
-    }
-
-    function emitProfileSubmit () {
+    timerId = setTimeout(() => {
       profileSubmittedChannel.publish()
-      scheduleProfileSubmit()
-    }
-
-    scheduleProfileSubmit()
+      timerId.refresh()
+    }, flushInterval)
+    timerId.unref()
   },
 
   stop: () => {