dd-trace 2.12.1 → 3.2.0

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

@@ -6,9 +6,14 @@ const ext = require('../../../ext')
 const { setSamplingRules } = require('./startup-log')
 
 const {
+  SAMPLING_MECHANISM_DEFAULT,
+  SAMPLING_MECHANISM_AGENT,
+  SAMPLING_MECHANISM_RULE,
+  SAMPLING_MECHANISM_MANUAL,
   SAMPLING_RULE_DECISION,
   SAMPLING_LIMIT_DECISION,
-  SAMPLING_AGENT_DECISION
+  SAMPLING_AGENT_DECISION,
+  DECISION_MAKER_KEY
 } = require('./constants')
 
 const SERVICE_NAME = ext.tags.SERVICE_NAME
@@ -45,6 +50,7 @@ class PrioritySampler {
     const context = this._getContext(span)
     const root = context._trace.started[0]
 
+    // TODO: remove the decision maker tag when priority is less than AUTO_KEEP
     if (context._sampling.priority !== undefined) return
     if (!root) return // noop span
 
@@ -52,9 +58,14 @@ class PrioritySampler {
 
     if (this.validate(tag)) {
       context._sampling.priority = tag
+      context._sampling.mechanism = SAMPLING_MECHANISM_MANUAL
     } else if (auto) {
       context._sampling.priority = this._getPriorityFromAuto(root)
+    } else {
+      return
     }
+
+    this._addDecisionMaker(root)
   }
 
   update (rates) {
@@ -115,6 +126,7 @@ class PrioritySampler {
 
   _getPriorityByRule (context, rule) {
     context._trace[SAMPLING_RULE_DECISION] = rule.sampleRate
+    context._sampling.mechanism = SAMPLING_MECHANISM_RULE
 
     return rule.sampler.isSampled(context) && this._isSampledByRateLimit(context) ? USER_KEEP : USER_REJECT
   }
@@ -133,10 +145,33 @@ class PrioritySampler {
 
     context._trace[SAMPLING_AGENT_DECISION] = sampler.rate()
 
+    if (sampler === defaultSampler) {
+      context._sampling.mechanism = SAMPLING_MECHANISM_DEFAULT
+    } else {
+      context._sampling.mechanism = SAMPLING_MECHANISM_AGENT
+    }
+
     return sampler.isSampled(context) ? AUTO_KEEP : AUTO_REJECT
   }
 
+  _addDecisionMaker (span) {
+    const context = span.context()
+    const trace = context._trace
+    const priority = context._sampling.priority
+    const mechanism = context._sampling.mechanism
+
+    if (priority >= AUTO_KEEP) {
+      if (!trace.tags[DECISION_MAKER_KEY]) {
+        trace.tags[DECISION_MAKER_KEY] = `-${mechanism}`
+      }
+    } else {
+      delete trace.tags[DECISION_MAKER_KEY]
+    }
+  }
+
   _normalizeRules (rules, sampleRate) {
+    rules = [].concat(rules || [])
+
     return rules
       .concat({ sampleRate })
       .map(rule => ({ ...rule, sampleRate: parseFloat(rule.sampleRate) }))

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

@@ -2,10 +2,10 @@
 
 const retry = require('retry')
 const { request } = require('http')
-const FormData = require('./form-data')
 
 // 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 version = require('../../../../../package.json').version
 
 const containerId = docker.id()

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

@@ -20,7 +20,7 @@ function getStartedSpans (activeSpan) {
 }
 
 function getSpanContextTags (span) {
-  return span._context()._tags
+  return span.context()._tags
 }
 
 function isWebServerSpan (tags) {
@@ -55,13 +55,13 @@ class NativeCpuProfiler {
     const active = getActiveSpan()
     if (!active) return
 
-    const activeCtx = active._context()
+    const activeCtx = active.context()
     if (!activeCtx) return
 
     const spans = getStartedSpans(active)
     if (!spans || !spans.length) return
 
-    const firstCtx = spans[0]._context()
+    const firstCtx = spans[0].context()
     if (!firstCtx) return
 
     const labels = {

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

@@ -1,36 +1,25 @@
 'use strict'
 
-const BaseTracer = require('opentracing').Tracer
-const NoopTracer = require('./noop/tracer')
+const NoopProxy = require('./noop/proxy')
 const DatadogTracer = require('./tracer')
 const Config = require('./config')
-const Instrumenter = require('./instrumenter')
-const PluginManager = require('./plugin_manager')
 const metrics = require('./metrics')
 const log = require('./log')
-const { isFalse } = require('./util')
-const { setStartupLogInstrumenter } = require('./startup-log')
+const { setStartupLogPluginManager } = require('./startup-log')
 const telemetry = require('./telemetry')
+const PluginManager = require('./plugin_manager')
+const { sendGitMetadata } = require('./ci-visibility/exporters/git/git_metadata')
 
-const noop = new NoopTracer()
-
-class Tracer extends BaseTracer {
+class Tracer extends NoopProxy {
   constructor () {
     super()
 
     this._initialized = false
-    this._tracer = noop
-    this._instrumenter = new Instrumenter(this)
     this._pluginManager = new PluginManager(this)
-    this._deprecate = method => log.deprecate(`tracer.${method}`, [
-      `tracer.${method}() is deprecated.`,
-      'Please use tracer.startSpan() and tracer.scope() instead.',
-      'See: https://datadog.github.io/dd-trace-js/#manual-instrumentation.'
-    ].join(' '))
   }
 
   init (options) {
-    if (isFalse(process.env.DD_TRACE_ENABLED) || this._initialized) return this
+    if (this._initialized) return this
 
     this._initialized = true
 
@@ -59,12 +48,24 @@ class Tracer extends BaseTracer {
         if (config.appsec.enabled) {
           require('./appsec').enable(config)
         }
+        if (config.iast.enabled) {
+          require('./appsec/iast').enable(config)
+        }
 
         this._tracer = new DatadogTracer(config)
-        this._instrumenter.enable(config)
         this._pluginManager.configure(config)
-        setStartupLogInstrumenter(this._instrumenter)
-        telemetry.start(config, this._instrumenter, this._pluginManager)
+        setStartupLogPluginManager(this._pluginManager)
+        telemetry.start(config, this._pluginManager)
+      }
+
+      if (config.isGitUploadEnabled) {
+        sendGitMetadata(config.site, (err) => {
+          if (err) {
+            log.error(`Error uploading git metadata: ${err}`)
+          } else {
+            log.debug('Successfully uploaded git metadata')
+          }
+        })
       }
     } catch (e) {
       log.error(e)
@@ -74,79 +75,9 @@ class Tracer extends BaseTracer {
   }
 
   use () {
-    this._instrumenter.use(...arguments)
     this._pluginManager.configurePlugin(...arguments)
     return this
   }
-
-  trace (name, options, fn) {
-    if (!fn) {
-      fn = options
-      options = {}
-    }
-
-    if (typeof fn !== 'function') return
-
-    options = options || {}
-
-    return this._tracer.trace(name, options, fn)
-  }
-
-  wrap (name, options, fn) {
-    if (!fn) {
-      fn = options
-      options = {}
-    }
-
-    if (typeof fn !== 'function') return fn
-
-    options = options || {}
-
-    return this._tracer.wrap(name, options, fn)
-  }
-
-  setUrl () {
-    this._tracer.setUrl.apply(this._tracer, arguments)
-    return this
-  }
-
-  startSpan () {
-    return this._tracer.startSpan.apply(this._tracer, arguments)
-  }
-
-  inject () {
-    return this._tracer.inject.apply(this._tracer, arguments)
-  }
-
-  extract () {
-    return this._tracer.extract.apply(this._tracer, arguments)
-  }
-
-  scope () {
-    return this._tracer.scope.apply(this._tracer, arguments)
-  }
-
-  currentSpan () {
-    this._deprecate('currentSpan')
-    return this._tracer.currentSpan.apply(this._tracer, arguments)
-  }
-
-  bind (callback) {
-    this._deprecate('bind')
-    return callback
-  }
-
-  bindEmitter () {
-    this._deprecate('bindEmitter')
-  }
-
-  getRumData () {
-    return this._tracer.getRumData.apply(this._tracer, arguments)
-  }
-
-  setUser () {
-    return this._tracer.setUser.apply(this.tracer, arguments)
-  }
 }
 
 module.exports = Tracer

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

@@ -3,6 +3,7 @@
 const path = require('path')
 const Module = require('module')
 const parse = require('module-details-from-path')
+const dc = require('diagnostics_channel')
 
 const origRequire = Module.prototype.require
 
@@ -14,7 +15,7 @@ let moduleHooks = Object.create(null)
 let cache = Object.create(null)
 let patching = Object.create(null)
 let patchedRequire = null
-
+const moduleLoadStartChannel = dc.channel('dd-trace:moduleLoadStart')
 function Hook (modules, options, onrequire) {
   if (!(this instanceof Hook)) return new Hook(modules, options, onrequire)
   if (typeof modules === 'function') {
@@ -78,6 +79,14 @@ function Hook (modules, options, onrequire) {
     // so the patching mark can be cleaned up.
     delete patching[filename]
 
+    if (moduleLoadStartChannel.hasSubscribers) {
+      moduleLoadStartChannel.publish({
+        filename,
+        module: exports,
+        request
+      })
+    }
+
     if (core) {
       hooks = moduleHooks[filename]
       if (!hooks) return exports // abort if module name isn't on whitelist

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

@@ -2,13 +2,9 @@
 
 const { storage } = require('../../datadog-core')
 
-// TODO: deprecate binding event emitters in 3.0
+// TODO: refactor bind to use shimmer once the new internal tracer lands
 
 const originals = new WeakMap()
-const listenerMaps = new WeakMap()
-const emitterSpans = new WeakMap()
-const emitterScopes = new WeakMap()
-const emitters = new WeakSet()
 
 class Scope {
   active () {
@@ -38,23 +34,7 @@ class Scope {
     }
   }
 
-  bind (target, span) {
-    target = this._bindEmitter(target, span)
-    target = this._bindPromise(target, span)
-    target = this._bindFn(target, span)
-
-    return target
-  }
-
-  unbind (target) {
-    target = this._unbindFn(target)
-    target = this._unbindPromise(target)
-    target = this._unbindEmitter(target)
-
-    return target
-  }
-
-  _bindFn (fn, span) {
+  bind (fn, span) {
     if (typeof fn !== 'function') return fn
 
     const scope = this
@@ -71,175 +51,13 @@ class Scope {
     return bound
   }
 
-  _unbindFn (fn) {
-    if (typeof fn !== 'function') return fn
-
-    return originals.get(fn) || fn
-  }
-
-  _bindEmitter (emitter, span) {
-    if (!this._isEmitter(emitter)) return emitter
-    if (!emitters.has(emitter)) {
-      Scope._wrapEmitter(emitter)
-    }
-    emitterSpans.set(emitter, span)
-    emitterScopes.set(emitter, this)
-    return emitter
-  }
-
-  // Occasionally we want to wrap a prototype rather than emitter instances,
-  // so we're exposing this as a static method. This gives us a faster
-  // path for binding instances of known EventEmitter subclasses.
-  static _wrapEmitter (emitter) {
-    wrapMethod(emitter, 'addListener', wrapAddListener)
-    wrapMethod(emitter, 'prependListener', wrapAddListener)
-    wrapMethod(emitter, 'on', wrapAddListener)
-    wrapMethod(emitter, 'once', wrapAddListener)
-    wrapMethod(emitter, 'removeListener', wrapRemoveListener)
-    wrapMethod(emitter, 'off', wrapRemoveListener)
-    wrapMethod(emitter, 'removeAllListeners', wrapRemoveAllListeners)
-    emitters.add(emitter)
-  }
-
-  _unbindEmitter (emitter) {
-    if (!this._isEmitter(emitter)) return emitter
-    emitterScopes.delete(emitter)
-    emitterSpans.delete(emitter)
-    return emitter
-  }
-
-  _bindPromise (promise, span) {
-    if (!this._isPromise(promise)) return promise
-
-    wrapMethod(promise, 'then', wrapThen, this, span)
-
-    return promise
-  }
-
-  _unbindPromise (promise) {
-    if (!this._isPromise(promise)) return promise
-
-    promise.then = originals.get(promise.then) || promise.then
-
-    return promise
-  }
-
   _spanOrActive (span) {
     return span !== undefined ? span : this.active()
   }
 
-  _isEmitter (emitter) {
-    return emitter &&
-      typeof emitter.emit === 'function' &&
-      typeof emitter.on === 'function' &&
-      typeof emitter.addListener === 'function' &&
-      typeof emitter.removeListener === 'function'
-  }
-
   _isPromise (promise) {
     return promise && typeof promise.then === 'function'
   }
 }
 
-function getScope (emitter) {
-  return emitterScopes.get(emitter) || emitterScopes.get(emitter.constructor.prototype)
-}
-
-function getSpan (emitter) {
-  return emitterSpans.get(emitter) || emitterSpans.get(emitter.constructor.prototype)
-}
-
-function hasScope (emitter) {
-  return emitterScopes.has(emitter) || emitterScopes.has(emitter.constructor.prototype)
-}
-
-function wrapThen (then, scope, span) {
-  return function thenWithTrace (onFulfilled, onRejected) {
-    const args = new Array(arguments.length)
-
-    for (let i = 0, l = args.length; i < l; i++) {
-      args[i] = scope.bind(arguments[i], span)
-    }
-
-    return then.apply(this, args)
-  }
-}
-
-function wrapAddListener (addListener) {
-  return function addListenerWithTrace (eventName, listener) {
-    const scope = getScope(this)
-    if (!scope || !listener || originals.has(listener) || listener.listener) {
-      return addListener.apply(this, arguments)
-    }
-    const span = getSpan(this)
-
-    const bound = scope.bind(listener, scope._spanOrActive(span))
-    const listenerMap = listenerMaps.get(this) || {}
-
-    listenerMaps.set(this, listenerMap)
-
-    if (!listenerMap[eventName]) {
-      listenerMap[eventName] = new WeakMap()
-    }
-
-    const events = listenerMap[eventName]
-
-    if (!events.has(listener)) {
-      events.set(listener, [])
-    }
-
-    events.get(listener).push(bound)
-
-    return addListener.call(this, eventName, bound)
-  }
-}
-
-function wrapRemoveListener (removeListener) {
-  return function removeListenerWithTrace (eventName, listener) {
-    if (!hasScope(this)) {
-      return removeListener.apply(this, arguments)
-    }
-
-    const listenerMap = listenerMaps.get(this)
-    const listeners = listenerMap && listenerMap[eventName]
-
-    if (!listener || !listeners || !listeners.has(listener)) {
-      return removeListener.apply(this, arguments)
-    }
-
-    for (const bound of listeners.get(listener)) {
-      removeListener.call(this, eventName, bound)
-    }
-
-    listeners.delete(listener)
-
-    return removeListener.apply(this, arguments)
-  }
-}
-
-function wrapRemoveAllListeners (removeAllListeners) {
-  return function removeAllListenersWithTrace (eventName) {
-    const listenerMap = listenerMaps.get(this)
-
-    if (hasScope(this) && listenerMap) {
-      if (eventName) {
-        delete listenerMap[eventName]
-      } else {
-        listenerMaps.delete(this)
-      }
-    }
-
-    return removeAllListeners.apply(this, arguments)
-  }
-}
-
-function wrapMethod (target, name, wrapper, ...args) {
-  if (!target[name] || originals.has(target[name])) return
-
-  const original = target[name]
-
-  target[name] = wrapper(target[name], ...args)
-  originals.set(target[name], original)
-}
-
 module.exports = Scope

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

@@ -3,6 +3,8 @@
 const log = require('./log')
 const format = require('./format')
 
+const { SpanStatsProcessor } = require('./span_stats')
+
 const startedSpans = new WeakSet()
 const finishedSpans = new WeakSet()
 
@@ -11,6 +13,8 @@ class SpanProcessor {
     this._exporter = exporter
     this._prioritySampler = prioritySampler
     this._config = config
+
+    this._stats = new SpanStatsProcessor(config)
   }
 
   process (span) {
@@ -26,7 +30,9 @@ class SpanProcessor {
 
       for (const span of started) {
         if (span._duration !== undefined) {
-          formatted.push(format(span))
+          const formattedSpan = format(span)
+          this._stats.onSpanFinished(formattedSpan)
+          formatted.push(formattedSpan)
         } else {
           active.push(span)
         }