dd-trace 2.2.0 → 2.3.1

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

@@ -1,20 +1,14 @@
 'use strict'
 
-const coalesce = require('koalas')
 const RateLimiter = require('./rate_limiter')
 const Sampler = require('./sampler')
 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,
-  UPSTREAM_SERVICES_KEY
+  SAMPLING_AGENT_DECISION
 } = require('./constants')
 
 const SERVICE_NAME = ext.tags.SERVICE_NAME
@@ -28,7 +22,6 @@ const USER_KEEP = ext.priority.USER_KEEP
 const DEFAULT_KEY = 'service:,env:'
 
 const defaultSampler = new Sampler(AUTO_KEEP)
-const serviceNames = new Map()
 
 class PrioritySampler {
   constructor (env, { sampleRate, rateLimit = 100, rules = [] } = {}) {
@@ -59,14 +52,9 @@ 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._addUpstreamService(root)
   }
 
   update (rates) {
@@ -127,7 +115,6 @@ 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
   }
@@ -146,44 +133,9 @@ 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
   }
 
-  _addUpstreamService (span) {
-    const context = span.context()
-    const trace = context._trace
-    const service = this._toBase64(context._tags['service.name'])
-    const priority = context._sampling.priority
-    const mechanism = context._sampling.mechanism
-    const rate = Math.ceil(coalesce(
-      context._trace[SAMPLING_RULE_DECISION],
-      context._trace[SAMPLING_AGENT_DECISION]
-    ) * 10000) / 10000
-    const group = `${service}|${priority}|${mechanism}|${rate}`
-    const groups = trace.tags[UPSTREAM_SERVICES_KEY]
-      ? `${trace.tags[UPSTREAM_SERVICES_KEY]};${group}`
-      : group
-
-    trace.tags[UPSTREAM_SERVICES_KEY] = groups
-  }
-
-  _toBase64 (serviceName) {
-    let encoded = serviceNames.get(serviceName)
-
-    if (!encoded) {
-      encoded = Buffer.from(serviceName).toString('base64')
-      serviceNames.set(serviceName, encoded)
-    }
-
-    return encoded
-  }
-
   _normalizeRules (rules, sampleRate) {
     return rules
       .concat({ sampleRate })

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

@@ -2,6 +2,14 @@
 
 const { storage } = require('../../datadog-core')
 
+// TODO: deprecate binding event emitters in 3.0
+
+const originals = new WeakMap()
+const listenerMaps = new WeakMap()
+const emitterSpans = new WeakMap()
+const emitterScopes = new WeakMap()
+const emitters = new WeakSet()
+
 class Scope {
   active () {
     const store = storage.getStore()
@@ -58,7 +66,7 @@ class Scope {
       })
     }
 
-    bound._datadog_unbound = fn
+    originals.set(bound, fn)
 
     return bound
   }
@@ -66,16 +74,16 @@ class Scope {
   _unbindFn (fn) {
     if (typeof fn !== 'function') return fn
 
-    return fn._datadog_unbound || fn
+    return originals.get(fn) || fn
   }
 
   _bindEmitter (emitter, span) {
     if (!this._isEmitter(emitter)) return emitter
-    if (!emitter.__is_dd_emitter) {
+    if (!emitters.has(emitter)) {
       Scope._wrapEmitter(emitter)
     }
-    emitter.__dd_span = span
-    emitter.__dd_scope = this
+    emitterSpans.set(emitter, span)
+    emitterScopes.set(emitter, this)
     return emitter
   }
 
@@ -90,13 +98,13 @@ class Scope {
     wrapMethod(emitter, 'removeListener', wrapRemoveListener)
     wrapMethod(emitter, 'off', wrapRemoveListener)
     wrapMethod(emitter, 'removeAllListeners', wrapRemoveAllListeners)
-    emitter.__is_dd_emitter = true
+    emitters.add(emitter)
   }
 
   _unbindEmitter (emitter) {
     if (!this._isEmitter(emitter)) return emitter
-    delete emitter.__dd_scope
-    delete emitter.__dd_span
+    emitterScopes.delete(emitter)
+    emitterSpans.delete(emitter)
     return emitter
   }
 
@@ -111,7 +119,7 @@ class Scope {
   _unbindPromise (promise) {
     if (!this._isPromise(promise)) return promise
 
-    promise.then = promise.then._datadog_unbound || promise.then
+    promise.then = originals.get(promise.then) || promise.then
 
     return promise
   }
@@ -133,6 +141,18 @@ class Scope {
   }
 }
 
+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)
@@ -147,21 +167,22 @@ function wrapThen (then, scope, span) {
 
 function wrapAddListener (addListener) {
   return function addListenerWithTrace (eventName, listener) {
-    if (!this.__dd_scope || !listener || listener._datadog_unbound || listener.listener) {
+    const scope = getScope(this)
+    if (!scope || !listener || originals.has(listener) || listener.listener) {
       return addListener.apply(this, arguments)
     }
-    const scope = this.__dd_scope
-    const span = this.__dd_span
+    const span = getSpan(this)
 
     const bound = scope.bind(listener, scope._spanOrActive(span))
+    const listenerMap = listenerMaps.get(this) || {}
 
-    this._datadog_events = this._datadog_events || {}
+    listenerMaps.set(this, listenerMap)
 
-    if (!this._datadog_events[eventName]) {
-      this._datadog_events[eventName] = new WeakMap()
+    if (!listenerMap[eventName]) {
+      listenerMap[eventName] = new WeakMap()
     }
 
-    const events = this._datadog_events[eventName]
+    const events = listenerMap[eventName]
 
     if (!events.has(listener)) {
       events.set(listener, [])
@@ -175,11 +196,12 @@ function wrapAddListener (addListener) {
 
 function wrapRemoveListener (removeListener) {
   return function removeListenerWithTrace (eventName, listener) {
-    if (!this.__dd_scope) {
+    if (!hasScope(this)) {
       return removeListener.apply(this, arguments)
     }
 
-    const listeners = this._datadog_events && this._datadog_events[eventName]
+    const listenerMap = listenerMaps.get(this)
+    const listeners = listenerMap && listenerMap[eventName]
 
     if (!listener || !listeners || !listeners.has(listener)) {
       return removeListener.apply(this, arguments)
@@ -197,11 +219,13 @@ function wrapRemoveListener (removeListener) {
 
 function wrapRemoveAllListeners (removeAllListeners) {
   return function removeAllListenersWithTrace (eventName) {
-    if (this.__dd_scope && this._datadog_events) {
+    const listenerMap = listenerMaps.get(this)
+
+    if (hasScope(this) && listenerMap) {
       if (eventName) {
-        delete this._datadog_events[eventName]
+        delete listenerMap[eventName]
       } else {
-        delete this._datadog_events
+        listenerMaps.delete(this)
       }
     }
 
@@ -210,12 +234,12 @@ function wrapRemoveAllListeners (removeAllListeners) {
 }
 
 function wrapMethod (target, name, wrapper, ...args) {
-  if (!target[name] || target[name]._datadog_unbound) return
+  if (!target[name] || originals.has(target[name])) return
 
   const original = target[name]
 
   target[name] = wrapper(target[name], ...args)
-  target[name]._datadog_unbound = original
+  originals.set(target[name], original)
 }
 
 module.exports = Scope

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

@@ -1,3 +1,5 @@
+'use strict'
+
 const log = require('./log')
 const format = require('./format')
 
@@ -5,24 +7,37 @@ const startedSpans = new WeakSet()
 const finishedSpans = new WeakSet()
 
 class SpanProcessor {
-  constructor (exporter, prioritySampler) {
+  constructor (exporter, prioritySampler, config) {
     this._exporter = exporter
     this._prioritySampler = prioritySampler
+    this._config = config
   }
 
   process (span) {
     const spanContext = span.context()
+    const active = []
+    const formatted = []
     const trace = spanContext._trace
+    const { flushMinSpans } = this._config
+    const { started, finished } = trace
 
-    if (trace.started.length === trace.finished.length) {
+    if (started.length === finished.length || finished.length >= flushMinSpans) {
       this._prioritySampler.sample(spanContext)
-      const formattedSpans = trace.finished.map(format)
-      this._exporter.export(formattedSpans)
-      this._erase(trace)
+
+      for (const span of started) {
+        if (span._duration !== undefined) {
+          formatted.push(format(span))
+        } else {
+          active.push(span)
+        }
+      }
+
+      this._exporter.export(formatted)
+      this._erase(trace, active)
     }
   }
 
-  _erase (trace) {
+  _erase (trace, active) {
     if (process.env.DD_TRACE_EXPERIMENTAL_STATE_TRACKING === 'true') {
       const started = new Set()
       const startedIds = new Set()
@@ -98,7 +113,7 @@ class SpanProcessor {
       span.context()._tags = {}
     }
 
-    trace.started = []
+    trace.started = active
     trace.finished = []
   }
 }

package/packages/datadog-plugin-generic-pool/src/index.js

@@ -1,52 +0,0 @@
-'use strict'
-
-function createWrapAcquire (tracer, config) {
-  return function wrapAcquire (acquire) {
-    return function acquireWithTrace (callback, priority) {
-      if (typeof callback === 'function') {
-        arguments[0] = tracer.scope().bind(callback)
-      }
-
-      return acquire.apply(this, arguments)
-    }
-  }
-}
-
-function createWrapPool (tracer, config, instrumenter) {
-  return function wrapPool (Pool) {
-    if (typeof Pool !== 'function') return Pool
-
-    return function PoolWithTrace (factory) {
-      const pool = Pool.apply(this, arguments)
-
-      if (pool && typeof pool.acquire === 'function') {
-        instrumenter.wrap(pool, 'acquire', createWrapAcquire(tracer, config))
-      }
-
-      return pool
-    }
-  }
-}
-
-module.exports = [
-  {
-    name: 'generic-pool',
-    versions: ['^2.4'],
-    patch (genericPool, tracer, config) {
-      this.wrap(genericPool.Pool.prototype, 'acquire', createWrapAcquire(tracer, config))
-    },
-    unpatch (genericPool) {
-      this.unwrap(genericPool.Pool.prototype, 'acquire')
-    }
-  },
-  {
-    name: 'generic-pool',
-    versions: ['2 - 2.3'],
-    patch (genericPool, tracer, config) {
-      this.wrap(genericPool, 'Pool', createWrapPool(tracer, config, this))
-    },
-    unpatch (genericPool) {
-      this.unwrap(genericPool, 'Pool')
-    }
-  }
-]

package/packages/datadog-plugin-mongoose/src/index.js

@@ -1,51 +0,0 @@
-'use strict'
-
-const { wrapThen } = require('../../datadog-instrumentations/src/helpers/promise')
-
-function createWrapCollectionAddQueue (tracer, config) {
-  return function wrapAddQueue (addQueue) {
-    return function addQueueWithTrace (name) {
-      const scope = tracer.scope()
-
-      if (typeof name === 'function') {
-        arguments[0] = scope.bind(name)
-      } else if (typeof this[name] === 'function') {
-        arguments[0] = scope.bind((...args) => this[name](...args))
-      }
-
-      return addQueue.apply(this, arguments)
-    }
-  }
-}
-
-function createWrapWrapCallback (tracer, config) {
-  return function wrapWrapCallback ($wrapCallback) {
-    return function $wrapCallbackWithTrace (cb) {
-      arguments[0] = tracer.scope().bind(cb)
-      return $wrapCallback.apply(this, arguments)
-    }
-  }
-}
-
-module.exports = [
-  {
-    name: 'mongoose',
-    versions: ['>=4.6.4'],
-    patch (mongoose, tracer, config) {
-      if (mongoose.Promise !== global.Promise) {
-        this.wrap(mongoose.Promise.prototype, 'then', wrapThen)
-      }
-
-      this.wrap(mongoose.Collection.prototype, 'addQueue', createWrapCollectionAddQueue(tracer, config))
-      this.wrap(mongoose.Model, '$wrapCallback', createWrapWrapCallback(tracer, config))
-    },
-    unpatch (mongoose) {
-      if (mongoose.Promise !== global.Promise) {
-        this.unwrap(mongoose.Promise.prototype, 'then')
-      }
-
-      this.unwrap(mongoose.Collection.prototype, 'addQueue')
-      this.unwrap(mongoose.Model, '$wrapCallback')
-    }
-  }
-]