dd-trace 2.12.0 → 3.0.0-pre.1

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

@@ -43,13 +43,15 @@ const web = {
     const hooks = getHooks(config)
     const filter = urlFilter.getFilter(config)
     const middleware = getMiddlewareSetting(config)
+    const queryStringObfuscation = getQsObfuscator(config)
 
     return Object.assign({}, config, {
       headers,
       validateStatus,
       hooks,
       filter,
-      middleware
+      middleware,
+      queryStringObfuscation
     })
   },
 
@@ -270,7 +272,10 @@ const web = {
   addError (req, error) {
     if (error instanceof Error) {
       const context = contexts.get(req)
-      context.error = error
+
+      if (context) {
+        context.error = error
+      }
     }
   },
 
@@ -315,6 +320,23 @@ const web = {
     web.finishSpan(context)
   },
 
+  obfuscateQs (config, url) {
+    const { queryStringObfuscation } = config
+
+    if (queryStringObfuscation === false) return url
+
+    const i = url.indexOf('?')
+    if (i === -1) return url
+
+    const path = url.slice(0, i)
+    if (queryStringObfuscation === true) return path
+
+    let qs = url.slice(i + 1)
+
+    qs = qs.replace(queryStringObfuscation, '<redacted>')
+
+    return `${path}?${qs}`
+  },
   wrapWriteHead (context) {
     const { req, res } = context
     const writeHead = res.writeHead
@@ -404,11 +426,11 @@ function reactivate (req, fn) {
 }
 
 function addRequestTags (context) {
-  const { req, span } = context
+  const { req, span, config } = context
   const url = extractURL(req)
 
   span.addTags({
-    [HTTP_URL]: url.split('?')[0],
+    [HTTP_URL]: web.obfuscateQs(config, url),
     [HTTP_METHOD]: req.method,
     [SPAN_KIND]: SERVER,
     [SPAN_TYPE]: WEB,
@@ -519,4 +541,30 @@ function getMiddlewareSetting (config) {
   return true
 }
 
+function getQsObfuscator (config) {
+  const obfuscator = config.queryStringObfuscation
+
+  if (typeof obfuscator === 'boolean') {
+    return obfuscator
+  }
+
+  if (typeof obfuscator === 'string') {
+    if (obfuscator === '') return false // disable obfuscator
+
+    if (obfuscator === '.*') return true // optimize full redact
+
+    try {
+      return new RegExp(obfuscator, 'gi')
+    } catch (err) {
+      log.error(err)
+    }
+  }
+
+  if (config.hasOwnProperty('queryStringObfuscation')) {
+    log.error('Expected `queryStringObfuscation` to be a regex string or boolean.')
+  }
+
+  return true
+}
+
 module.exports = web

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

@@ -22,11 +22,6 @@ class Tracer extends BaseTracer {
     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) {
@@ -126,20 +121,6 @@ class Tracer extends BaseTracer {
     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)
   }

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 () {
@@ -39,7 +35,6 @@ class Scope {
   }
 
   bind (target, span) {
-    target = this._bindEmitter(target, span)
     target = this._bindPromise(target, span)
     target = this._bindFn(target, span)
 
@@ -49,7 +44,6 @@ class Scope {
   unbind (target) {
     target = this._unbindFn(target)
     target = this._unbindPromise(target)
-    target = this._unbindEmitter(target)
 
     return target
   }
@@ -77,37 +71,6 @@ class Scope {
     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
 
@@ -128,31 +91,11 @@ class Scope {
     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)
@@ -165,74 +108,6 @@ function wrapThen (then, scope, span) {
   }
 }
 
-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
 

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

@@ -107,10 +107,6 @@ class DatadogTracer extends Tracer {
     return this._scope
   }
 
-  currentSpan () {
-    return this.scope().active()
-  }
-
   getRumData () {
     if (!this._enableGetRumData) {
       return ''

package/cypress/plugin.js

@@ -1,5 +0,0 @@
-require('..').init({
-  startupLogs: false
-})
-
-module.exports = require('../packages/datadog-plugin-cypress/src/plugin')

package/cypress/support.js

@@ -1 +0,0 @@
-require('../packages/datadog-plugin-cypress/src/support')