dd-trace 2.2.0 → 2.2.1

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

@@ -29,6 +29,9 @@ const HTTP2_HEADER_AUTHORITY = ':authority'
 const HTTP2_HEADER_SCHEME = ':scheme'
 const HTTP2_HEADER_PATH = ':path'
 
+const contexts = new WeakMap()
+const ends = new WeakMap()
+
 const web = {
   // Ensure the configuration has the correct structure and defaults.
   normalizeConfig (config) {
@@ -51,8 +54,7 @@ const web = {
 
   // Start a span and activate a scope for a request.
   instrument (tracer, config, req, res, name, callback) {
-    this.patch(req)
-
+    const context = this.patch(req)
     const span = startSpan(tracer, config, req, res, name)
 
     if (!config.filter(req.url)) {
@@ -65,11 +67,11 @@ const web = {
 
     analyticsSampler.sample(span, config.measured, true)
 
-    if (!req._datadog.instrumented) {
-      wrapEnd(req)
-      wrapEvents(req)
+    if (!context.instrumented) {
+      wrapEnd(context)
+      wrapEvents(context)
 
-      req._datadog.instrumented = true
+      context.instrumented = true
     }
 
     return callback && tracer.scope().activate(span, () => callback(span))
@@ -83,22 +85,23 @@ const web = {
   // Add a route segment that will be used for the resource name.
   enterRoute (req, path) {
     if (typeof path === 'string') {
-      req._datadog.paths.push(path)
+      contexts.get(req).paths.push(path)
     }
   },
 
   // Remove the current route segment.
   exitRoute (req) {
-    req._datadog.paths.pop()
+    contexts.get(req).paths.pop()
   },
 
   // Start a new middleware span and activate a new scope with the span.
   wrapMiddleware (req, middleware, name, fn) {
     if (!this.active(req)) return fn()
 
-    const tracer = req._datadog.tracer
+    const context = contexts.get(req)
+    const tracer = context.tracer
     const childOf = this.active(req)
-    const config = req._datadog.config
+    const config = context.config
 
     if (config.middleware === false) return this.bindAndWrapMiddlewareErrors(fn, req, tracer, childOf)
 
@@ -110,7 +113,7 @@ const web = {
       [RESOURCE_NAME]: middleware._name || middleware.name || '<anonymous>'
     })
 
-    req._datadog.middleware.push(span)
+    context.middleware.push(span)
 
     return tracer.scope().activate(span, fn)
   },
@@ -129,7 +132,8 @@ const web = {
   finish (req, error) {
     if (!this.active(req)) return
 
-    const span = req._datadog.middleware.pop()
+    const context = contexts.get(req)
+    const span = context.middleware.pop()
 
     if (span) {
       if (error) {
@@ -146,38 +150,50 @@ const web = {
 
   // Register a callback to run before res.end() is called.
   beforeEnd (req, callback) {
-    req._datadog.beforeEnd.push(callback)
+    contexts.get(req).beforeEnd.push(callback)
   },
 
   // Prepare the request for instrumentation.
   patch (req) {
-    if (req._datadog) return
+    let context = contexts.get(req)
+
+    if (context) return context
 
-    if (req.stream && req.stream._datadog) {
-      req._datadog = req.stream._datadog
-      return
+    context = req.stream && contexts.get(req.stream)
+
+    if (context) {
+      contexts.set(req, context)
+      return context
     }
 
-    req._datadog = {
+    context = {
+      req,
       span: null,
       paths: [],
       middleware: [],
       beforeEnd: [],
       config: {}
     }
+
+    contexts.set(req, context)
+
+    return context
   },
 
   // Return the request root span.
   root (req) {
-    return req._datadog ? req._datadog.span : null
+    const context = contexts.get(req)
+    return context ? context.span : null
   },
 
   // Return the active span.
   active (req) {
-    if (!req._datadog) return null
-    if (req._datadog.middleware.length === 0) return req._datadog.span || null
+    const context = contexts.get(req)
 
-    return req._datadog.middleware.slice(-1)[0]
+    if (!context) return null
+    if (context.middleware.length === 0) return context.span || null
+
+    return context.middleware.slice(-1)[0]
   },
 
   // Extract the parent span from the headers and start a new span as its child
@@ -190,10 +206,11 @@ const web = {
 
   // Validate a request's status code and then add error tags if necessary
   addStatusError (req, statusCode) {
-    const span = req._datadog.span
-    const error = req._datadog.error
+    const context = contexts.get(req)
+    const span = context.span
+    const error = context.error
 
-    if (!req._datadog.config.validateStatus(statusCode)) {
+    if (!context.config.validateStatus(statusCode)) {
       span.setTag(ERROR, error || true)
     }
   },
@@ -201,94 +218,95 @@ const web = {
   // Add an error to the request
   addError (req, error) {
     if (error instanceof Error) {
-      req._datadog.error = req._datadog.error || error
+      const context = contexts.get(req)
+      context.error = context.error || error
     }
   }
 }
 
 function startSpan (tracer, config, req, res, name) {
-  req._datadog.config = config
+  const context = contexts.get(req)
+
+  context.config = config
 
   let span
 
-  if (req._datadog.span) {
-    req._datadog.span.context()._name = name
-    span = req._datadog.span
+  if (context.span) {
+    context.span.context()._name = name
+    span = context.span
   } else {
     span = web.startChildSpan(tracer, name, req.headers)
   }
 
-  configureDatadogObject(tracer, span, req, res)
+  context.tracer = tracer
+  context.span = span
+  context.res = res
 
   return span
 }
 
-function configureDatadogObject (tracer, span, req, res) {
-  const ddObj = req._datadog
-  ddObj.tracer = tracer
-  ddObj.span = span
-  ddObj.res = res
-}
+function finish (context) {
+  const { req, res } = context
 
-function finish (req, res) {
-  if (req._datadog.finished && !req.stream) return
+  if (context.finished && !req.stream) return
 
-  addRequestTags(req)
-  addResponseTags(req)
+  addRequestTags(context)
+  addResponseTags(context)
 
-  req._datadog.config.hooks.request(req._datadog.span, req, res)
-  addResourceTag(req)
+  context.config.hooks.request(context.span, req, res)
+  addResourceTag(context)
 
-  req._datadog.span.finish()
-  req._datadog.finished = true
+  context.span.finish()
+  context.finished = true
 }
 
-function finishMiddleware (req, res) {
-  if (req._datadog.finished) return
+function finishMiddleware (context) {
+  if (context.finished) return
 
   let span
 
-  while ((span = req._datadog.middleware.pop())) {
+  while ((span = context.middleware.pop())) {
     span.finish()
   }
 }
 
-function wrapEnd (req) {
-  const scope = req._datadog.tracer.scope()
-  const res = req._datadog.res
+function wrapEnd (context) {
+  const scope = context.tracer.scope()
+  const req = context.req
+  const res = context.res
   const end = res.end
 
-  res.writeHead = wrapWriteHead(req)
+  res.writeHead = wrapWriteHead(context)
 
-  res._datadog_end = function () {
-    for (const beforeEnd of req._datadog.beforeEnd) {
+  ends.set(res, function () {
+    for (const beforeEnd of context.beforeEnd) {
       beforeEnd()
     }
 
-    finishMiddleware(req, res)
+    finishMiddleware(context)
 
     if (incomingHttpRequestEnd.hasSubscribers) incomingHttpRequestEnd.publish({ req, res })
 
     const returnValue = end.apply(res, arguments)
 
-    finish(req, res)
+    finish(context)
 
     return returnValue
-  }
+  })
 
   Object.defineProperty(res, 'end', {
     configurable: true,
     get () {
-      return this._datadog_end
+      return ends.get(this)
     },
     set (value) {
-      this._datadog_end = scope.bind(value, req._datadog.span)
+      ends.set(this, scope.bind(value, context.span))
     }
   })
 }
 
-function wrapWriteHead (req) {
-  const res = req._datadog.res
+function wrapWriteHead (context) {
+  const { req, res } = context
   const writeHead = res.writeHead
 
   return function (statusCode, statusMessage, headers) {
@@ -296,15 +314,14 @@ function wrapWriteHead (req) {
     headers = Object.assign(res.getHeaders(), headers)
 
     if (req.method.toLowerCase() === 'options' && isOriginAllowed(req, headers)) {
-      addAllowHeaders(req, headers)
+      addAllowHeaders(req, res, headers)
     }
 
     return writeHead.apply(this, arguments)
   }
 }
 
-function addAllowHeaders (req, headers) {
-  const res = req._datadog.res
+function addAllowHeaders (req, res, headers) {
   const allowHeaders = splitHeader(headers['access-control-allow-headers'])
   const requestHeaders = splitHeader(req.headers['access-control-request-headers'])
   const contextHeaders = [
@@ -337,22 +354,24 @@ function splitHeader (str) {
   return typeof str === 'string' ? str.split(/\s*,\s*/) : []
 }
 
-function wrapEvents (req) {
-  const scope = req._datadog.tracer.scope()
-  const res = req._datadog.res
+function wrapEvents (context) {
+  const scope = context.tracer.scope()
+  const res = context.res
 
-  scope.bind(res, req._datadog.span)
+  scope.bind(res, context.span)
 }
 
 function reactivate (req, fn) {
-  return req._datadog
-    ? req._datadog.tracer.scope().activate(req._datadog.span, fn)
+  const context = contexts.get(req)
+
+  return context
+    ? context.tracer.scope().activate(context.span, fn)
     : fn()
 }
 
-function addRequestTags (req) {
+function addRequestTags (context) {
+  const { req, span } = context
   const url = extractURL(req)
-  const span = req._datadog.span
 
   span.addTags({
     [HTTP_URL]: url.split('?')[0],
@@ -361,15 +380,14 @@ function addRequestTags (req) {
     [SPAN_TYPE]: WEB
   })
 
-  addHeaders(req)
+  addHeaders(context)
 }
 
-function addResponseTags (req) {
-  const span = req._datadog.span
-  const res = req._datadog.res
+function addResponseTags (context) {
+  const { req, res, paths, span } = context
 
-  if (req._datadog.paths.length > 0) {
-    span.setTag(HTTP_ROUTE, req._datadog.paths.join(''))
+  if (paths.length > 0) {
+    span.setTag(HTTP_ROUTE, paths.join(''))
   }
 
   span.addTags({
@@ -379,8 +397,8 @@ function addResponseTags (req) {
   web.addStatusError(req, res.statusCode)
 }
 
-function addResourceTag (req) {
-  const span = req._datadog.span
+function addResourceTag (context) {
+  const { req, span } = context
   const tags = span.context()._tags
 
   if (tags['resource.name']) return
@@ -392,12 +410,12 @@ function addResourceTag (req) {
   span.setTag(RESOURCE_NAME, resource)
 }
 
-function addHeaders (req) {
-  const span = req._datadog.span
+function addHeaders (context) {
+  const { req, res, config, span } = context
 
-  req._datadog.config.headers.forEach(key => {
+  config.headers.forEach(key => {
     const reqHeader = req.headers[key]
-    const resHeader = req._datadog.res.getHeader(key)
+    const resHeader = res.getHeader(key)
 
     if (reqHeader) {
       span.setTag(`${HTTP_REQUEST_HEADERS}.${key}`, reqHeader)

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/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')
-    }
-  }
-]