dd-trace 2.11.0 → 3.0.0-pre.0

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

@@ -6,6 +6,7 @@ const { URL } = require('url')
 const { AgentExporter } = require('./exporters/agent')
 const { FileExporter } = require('./exporters/file')
 const { ConsoleLogger } = require('./loggers/console')
+const CpuProfiler = require('./profilers/cpu')
 const WallProfiler = require('./profilers/wall')
 const SpaceProfiler = require('./profilers/space')
 const { tagger } = require('./tagger')
@@ -13,6 +14,7 @@ const { tagger } = require('./tagger')
 const {
   DD_PROFILING_ENABLED,
   DD_PROFILING_PROFILERS,
+  DD_PROFILING_ENDPOINT_COLLECTION_ENABLED,
   DD_ENV,
   DD_TAGS,
   DD_SERVICE,
@@ -37,6 +39,8 @@ class Config {
       DD_PROFILING_UPLOAD_TIMEOUT, 60 * 1000)
     const sourceMap = coalesce(options.sourceMap,
       DD_PROFILING_SOURCE_MAP, true)
+    const endpointCollection = coalesce(options.endpointCollection,
+      DD_PROFILING_ENDPOINT_COLLECTION_ENABLED, false)
 
     this.enabled = String(enabled) !== 'false'
     this.service = service
@@ -53,6 +57,7 @@ class Config {
     this.flushInterval = flushInterval
     this.uploadTimeout = uploadTimeout
     this.sourceMap = sourceMap
+    this.endpointCollection = endpointCollection
 
     const hostname = coalesce(options.hostname, DD_AGENT_HOST, 'localhost')
     const port = coalesce(options.port, DD_TRACE_AGENT_PORT, 8126)
@@ -64,8 +69,8 @@ class Config {
     ], this)
 
     const profilers = coalesce(options.profilers, DD_PROFILING_PROFILERS, [
-      new WallProfiler(),
-      new SpaceProfiler()
+      new WallProfiler(this),
+      new SpaceProfiler(this)
     ])
 
     this.profilers = ensureProfilers(profilers, this)
@@ -100,10 +105,13 @@ function ensureExporters (exporters, options) {
 
 function getProfiler (name, options) {
   switch (name) {
+    case 'cpu':
     case 'wall':
       return new WallProfiler(options)
     case 'space':
       return new SpaceProfiler(options)
+    case 'cpu-experimental':
+      return new CpuProfiler(options)
     default:
       options.logger.error(`Unknown profiler "${name}"`)
   }

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

@@ -2,7 +2,7 @@
 
 const retry = require('retry')
 const { request } = require('http')
-const FormData = require('form-data')
+const FormData = require('./form-data')
 
 // TODO: avoid using dd-trace internals. Make this a separate module?
 const docker = require('../../exporters/common/docker')
@@ -22,7 +22,6 @@ function sendRequest (options, form, callback) {
   })
   req.on('error', callback)
   if (form) form.pipe(req)
-  req.end()
 }
 
 function getBody (stream, callback) {

package/packages/dd-trace/src/profiling/exporters/form-data.js

@@ -0,0 +1,53 @@
+'use strict'
+
+const { Readable } = require('stream')
+const id = require('../../id')
+
+class FormData extends Readable {
+  constructor () {
+    super()
+
+    this._boundary = id().toString()
+    this._data = []
+  }
+
+  append (key, value, options = {}) {
+    this._appendBoundary()
+
+    if (options.filename) {
+      this._appendFile(key, value, options)
+    } else {
+      this._appendMetadata(key, value, options)
+    }
+  }
+
+  getHeaders () {
+    return { 'Content-Type': 'multipart/form-data; boundary=' + this._boundary }
+  }
+
+  _appendBoundary () {
+    this._data.push(`--${this._boundary}\r\n`)
+  }
+
+  _appendMetadata (key, value) {
+    this._data.push(`Content-Disposition: form-data; name="${key}"\r\n\r\n${value}\r\n`)
+  }
+
+  _appendFile (key, value, { filename, contentType = 'application/octet-stream' }) {
+    this._data.push(`Content-Disposition: form-data; name="${key}"; filename="${filename}"\r\n`)
+    this._data.push(`Content-Type: ${contentType}\r\n\r\n`)
+    this._data.push(value)
+    this._data.push('\r\n')
+  }
+
+  _read () {
+    this.push(this._data.shift())
+
+    if (this._data.length === 0) {
+      this.push(`--${this._boundary}--\r\n`)
+      this.push(null)
+    }
+  }
+}
+
+module.exports = FormData

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

@@ -1,6 +1,7 @@
 'use strict'
 
 const { Profiler } = require('./profiler')
+const CpuProfiler = require('./profilers/cpu')
 const WallProfiler = require('./profilers/wall')
 const SpaceProfiler = require('./profilers/space')
 const { AgentExporter } = require('./exporters/agent')
@@ -13,6 +14,7 @@ module.exports = {
   profiler,
   AgentExporter,
   FileExporter,
+  CpuProfiler,
   WallProfiler,
   SpaceProfiler,
   ConsoleLogger

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

@@ -91,7 +91,12 @@ class Profiler extends EventEmitter {
         if (!profile) continue
 
         profiles[profiler.type] = await profiler.encode(profile)
-        this._logger.debug(`Collected ${profiler.type} profile: ` + JSON.stringify(profile))
+        this._logger.debug(() => {
+          const profileJson = JSON.stringify(profile, (key, value) => {
+            return typeof value === 'bigint' ? value.toString() : value
+          })
+          return `Collected ${profiler.type} profile: ` + profileJson
+        })
       }
 
       this._capture(this._config.flushInterval)

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

@@ -0,0 +1,126 @@
+'use strict'
+
+const { storage } = require('../../../../datadog-core')
+
+const dc = require('diagnostics_channel')
+
+const beforeCh = dc.channel('dd-trace:storage:before')
+const afterCh = dc.channel('dd-trace:storage:after')
+
+function getActiveSpan () {
+  const store = storage.getStore()
+  if (!store) return
+  return store.span
+}
+
+function getStartedSpans (activeSpan) {
+  const context = activeSpan.context()
+  if (!context) return
+  return context._trace.started
+}
+
+function getSpanContextTags (span) {
+  return span._context()._tags
+}
+
+function isWebServerSpan (tags) {
+  return tags['span.type'] === 'web'
+}
+
+function endpointNameFromTags (tags) {
+  return tags['resource.name'] || [
+    tags['http.method'],
+    tags['http.route']
+  ].filter(v => v).join(' ')
+}
+
+class NativeCpuProfiler {
+  constructor (options = {}) {
+    this.type = 'cpu'
+    this._frequency = options.frequency || 99
+    this._mapper = undefined
+    this._pprof = undefined
+    this._started = false
+    this._cpuProfiler = undefined
+    this._endpointCollection = options.endpointCollection
+
+    // Bind to this so the same value can be used to unsubscribe later
+    this._enter = this._enter.bind(this)
+    this._exit = this._exit.bind(this)
+  }
+
+  _enter () {
+    if (!this._cpuProfiler) return
+
+    const active = getActiveSpan()
+    if (!active) return
+
+    const activeCtx = active._context()
+    if (!activeCtx) return
+
+    const spans = getStartedSpans(active)
+    if (!spans || !spans.length) return
+
+    const firstCtx = spans[0]._context()
+    if (!firstCtx) return
+
+    const labels = {
+      'local root span id': firstCtx.toSpanId(),
+      'span id': activeCtx.toSpanId()
+    }
+
+    if (this._endpointCollection) {
+      const webServerTags = spans
+        .map(getSpanContextTags)
+        .filter(isWebServerSpan)[0]
+
+      if (webServerTags) {
+        labels['trace endpoint'] = endpointNameFromTags(webServerTags)
+      }
+    }
+
+    this._cpuProfiler.labels = labels
+  }
+
+  _exit () {
+    if (!this._cpuProfiler) return
+    this._cpuProfiler.labels = {}
+  }
+
+  start ({ mapper } = {}) {
+    if (this._started) return
+    this._started = true
+
+    this._mapper = mapper
+    if (!this._pprof) {
+      this._pprof = require('@datadog/pprof')
+      this._cpuProfiler = new this._pprof.CpuProfiler()
+    }
+
+    this._cpuProfiler.start(this._frequency)
+
+    this._enter()
+    beforeCh.subscribe(this._enter)
+    afterCh.subscribe(this._exit)
+  }
+
+  profile () {
+    if (!this._started) return
+    return this._cpuProfiler.profile()
+  }
+
+  encode (profile) {
+    return this._pprof.encode(profile)
+  }
+
+  stop () {
+    if (!this._started) return
+    this._started = false
+
+    this._cpuProfiler.stop()
+    beforeCh.unsubscribe(this._enter)
+    afterCh.unsubscribe(this._exit)
+  }
+}
+
+module.exports = NativeCpuProfiler

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')