dd-trace 2.12.1 → 3.0.0-pre.2

package/ci/init.js

@@ -1,10 +1,7 @@
 /* eslint-disable no-console */
-
-const path = require('path')
 const tracer = require('../packages/dd-trace')
 const { ORIGIN_KEY } = require('../packages/dd-trace/src/constants')
-const { mochaHook } = require('../packages/datadog-instrumentations/src/mocha')
-const { pickleHook, testCaseHook } = require('../packages/datadog-instrumentations/src/cucumber')
+const { isTrue } = require('../packages/dd-trace/src/util')
 
 const options = {
   startupLogs: false,
@@ -15,9 +12,7 @@ const options = {
 
 let shouldInit = true
 
-const isAgentlessEnabled = process.env.DD_CIVISIBILITY_AGENTLESS_ENABLED &&
-  process.env.DD_CIVISIBILITY_AGENTLESS_ENABLED !== 'false' &&
-  process.env.DD_CIVISIBILITY_AGENTLESS_ENABLED !== '0'
+const isAgentlessEnabled = isTrue(process.env.DD_CIVISIBILITY_AGENTLESS_ENABLED)
 
 if (isAgentlessEnabled) {
   if (process.env.DATADOG_API_KEY || process.env.DD_API_KEY) {
@@ -32,25 +27,6 @@ so dd-trace will not be initialized.`)
   }
 }
 
-// TODO: remove this in a later major version since we now recommend using
-// `NODE_OPTIONS='-r dd-trace/ci/init'`.
-try {
-  for (const filename in require.cache) {
-    const cache = require.cache[filename]
-    const id = filename.split(path.sep).join('/')
-
-    if (id.includes('/node_modules/mocha/lib/runner.js')) {
-      cache.exports = mochaHook(cache.exports)
-    } else if (id.includes('/node_modules/@cucumber/cucumber/lib/runtime/pickle_runner.js')) {
-      cache.exports = pickleHook(cache.exports)
-    } else if (id.includes('/node_modules/@cucumber/cucumber/lib/runtime/test_case_runner.js')) {
-      cache.exports = testCaseHook(cache.exports)
-    }
-  }
-} catch (e) {
-  // ignore error and let the tracer initialize anyway
-}
-
 if (shouldInit) {
   tracer.init(options)
   tracer.use('fs', false)

package/ci/jest/env.js

@@ -2,6 +2,7 @@
 
 const tracer = require('../../packages/dd-trace')
 const { ORIGIN_KEY } = require('../../packages/dd-trace/src/constants')
+const { isTrue } = require('../../packages/dd-trace/src/util')
 
 const options = {
   startupLogs: false,
@@ -10,9 +11,7 @@ const options = {
   }
 }
 
-const isAgentlessEnabled = process.env.DD_CIVISIBILITY_AGENTLESS_ENABLED &&
-  process.env.DD_CIVISIBILITY_AGENTLESS_ENABLED !== 'false' &&
-  process.env.DD_CIVISIBILITY_AGENTLESS_ENABLED !== '0'
+const isAgentlessEnabled = isTrue(process.env.DD_CIVISIBILITY_AGENTLESS_ENABLED)
 
 if (isAgentlessEnabled) {
   if (process.env.DATADOG_API_KEY || process.env.DD_API_KEY) {

package/index.d.ts

@@ -562,7 +562,6 @@ interface Plugins {
   "elasticsearch": plugins.elasticsearch;
   "express": plugins.express;
   "fastify": plugins.fastify;
-  "fs": plugins.fs;
   "generic-pool": plugins.generic_pool;
   "google-cloud-pubsub": plugins.google_cloud_pubsub;
   "graphql": plugins.graphql;
@@ -903,12 +902,6 @@ declare namespace plugins {
    */
   interface fastify extends HttpServer {}
 
-  /**
-   * This plugin automatically instruments the
-   * [fs](https://nodejs.org/api/fs.html) module.
-   */
-  interface fs extends Instrumentation {}
-
   /**
    * This plugin patches the [generic-pool](https://github.com/coopernurse/node-pool)
    * module to bind the callbacks the the caller context.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "2.12.1",
+  "version": "3.0.0-pre.2",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",

package/packages/datadog-plugin-grpc/src/client.js

@@ -19,13 +19,13 @@ class GrpcClientPlugin extends Plugin {
       const metadataFilter = this.config.metadataFilter
       const store = storage.getStore()
       const childOf = store && store.span
-      const span = this.tracer.startSpan('grpc.request', {
+      const span = this.tracer.startSpan('grpc.client', {
         childOf,
         tags: {
           [Tags.SPAN_KIND]: 'client',
           'span.type': 'http',
           'resource.name': path,
-          'service.name': this.config.service || `${this.tracer._service}-grpc-client`,
+          'service.name': this.config.service || this.tracer._service,
           'component': 'grpc'
         }
       })

package/packages/datadog-plugin-grpc/src/server.js

@@ -19,13 +19,13 @@ class GrpcServerPlugin extends Plugin {
       const metadataFilter = this.config.metadataFilter
       const store = storage.getStore()
       const childOf = extract(this.tracer, metadata)
-      const span = this.tracer.startSpan('grpc.request', {
+      const span = this.tracer.startSpan('grpc.server', {
         childOf,
         tags: {
           [Tags.SPAN_KIND]: 'server',
           'span.type': 'web',
           'resource.name': name,
-          'service.name': this.config.service || `${this.tracer._service}`,
+          'service.name': this.config.service || this.tracer._service,
           'component': 'grpc'
         }
       })

package/packages/datadog-plugin-http/src/client.js

@@ -190,7 +190,7 @@ function getServiceName (tracer, config, options) {
     return config.service
   }
 
-  return `${tracer._service}-http-client`
+  return tracer._service
 }
 
 function getHost (options) {

package/packages/datadog-plugin-http/src/server.js

@@ -15,7 +15,7 @@ class HttpServerPlugin extends Plugin {
 
     this.addSub('apm:http:server:request:start', ({ req, res }) => {
       const store = storage.getStore()
-      const span = web.startSpan(this.tracer, this.config, req, res, 'http.request')
+      const span = web.startSpan(this.tracer, this.config, req, res, 'web.request')
 
       this.enter(span, { ...store, req })
 

package/packages/datadog-plugin-http2/src/client.js

@@ -118,7 +118,7 @@ function getServiceName (tracer, config, sessionDetails) {
     return config.service
   }
 
-  return `${tracer._service}-http-client`
+  return tracer._service
 }
 
 function hasAmazonSignature (headers, path) {

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

@@ -13,6 +13,9 @@ const uuid = require('crypto-randomuuid')
 const fromEntries = Object.fromEntries || (entries =>
   entries.reduce((obj, [k, v]) => Object.assign(obj, { [k]: v }), {}))
 
+// eslint-disable-next-line max-len
+const qsRegex = '(?:p(?:ass)?w(?:or)?d|pass(?:_?phrase)?|secret|(?:api_?|private_?|public_?|access_?|secret_?)key(?:_?id)?|token|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)(?:(?:\\s|%20)*(?:=|%3D)[^&]+|(?:"|%22)(?:\\s|%20)*(?::|%3A)(?:\\s|%20)*(?:"|%22)(?:%2[^2]|%[^2]|[^"%])+(?:"|%22))|bearer(?:\\s|%20)+[a-z0-9\\._\\-]|token(?::|%3A)[a-z0-9]{13}|gh[opsu]_[0-9a-zA-Z]{36}|ey[I-L](?:[\\w=-]|%3D)+\\.ey[I-L](?:[\\w=-]|%3D)+(?:\\.(?:[\\w.+\\/=-]|%3D|%2F|%2B)+)?|[\\-]{5}BEGIN(?:[a-z\\s]|%20)+PRIVATE(?:\\s|%20)KEY[\\-]{5}[^\\-]+[\\-]{5}END(?:[a-z\\s]|%20)+PRIVATE(?:\\s|%20)KEY|ssh-rsa(?:\\s|%20)*(?:[a-z0-9\\/\\.+]|%2F|%5C|%2B){100,}'
+
 class Config {
   constructor (options) {
     options = options || {}
@@ -109,6 +112,10 @@ class Config {
       parseInt(process.env.DD_TRACE_PARTIAL_FLUSH_MIN_SPANS),
       1000
     )
+    const DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP = coalesce(
+      process.env.DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP,
+      qsRegex
+    )
     const DD_TRACE_B3_ENABLED = coalesce(
       options.experimental && options.experimental.b3,
       process.env.DD_TRACE_EXPERIMENTAL_B3_ENABLED,
@@ -203,6 +210,7 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
     this.flushInterval = coalesce(parseInt(options.flushInterval, 10), defaultFlushInterval)
     this.flushMinSpans = DD_TRACE_PARTIAL_FLUSH_MIN_SPANS
     this.sampleRate = coalesce(Math.min(Math.max(sampler.sampleRate, 0), 1), 1)
+    this.queryStringObfuscation = DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP
     this.logger = options.logger
     this.plugins = !!coalesce(options.plugins, true)
     this.service = DD_SERVICE

package/packages/dd-trace/src/encode/0.4.js

@@ -57,6 +57,10 @@ class AgentEncoder {
     return buffer
   }
 
+  reset () {
+    this._reset()
+  }
+
   _encode (bytes, trace) {
     this._encodeArrayPrefix(bytes, trace)
 

package/packages/dd-trace/src/exporters/common/request.js

@@ -1,22 +1,33 @@
 'use strict'
 
+// TODO: Add test with slow or unresponsive agent.
+// TODO: Add telemetry for things like dropped requests, errors, etc.
+
 const http = require('http')
 const https = require('https')
-const log = require('../../log')
 const docker = require('./docker')
 const { storage } = require('../../../../datadog-core')
 
-const httpAgent = new http.Agent({ keepAlive: true })
-const httpsAgent = new https.Agent({ keepAlive: true })
+const keepAlive = true
+const maxTotalSockets = 1
+const maxActiveRequests = 8
+const httpAgent = new http.Agent({ keepAlive, maxTotalSockets })
+const httpsAgent = new https.Agent({ keepAlive, maxTotalSockets })
 const containerId = docker.id()
 
+let activeRequests = 0
+
 function request (data, options, keepAlive, callback) {
   if (!options.headers) {
     options.headers = {}
   }
+
+  // The timeout should be kept low to avoid excessive queueing.
+  const timeout = options.timeout || 2000
   const isSecure = options.protocol === 'https:'
   const client = isSecure ? https : http
   const dataArray = [].concat(data)
+
   options.headers['Content-Length'] = byteLength(dataArray)
 
   if (containerId) {
@@ -27,39 +38,15 @@ function request (data, options, keepAlive, callback) {
     options.agent = isSecure ? httpsAgent : httpAgent
   }
 
-  const firstRequest = retriableRequest(options, client, callback)
-  dataArray.forEach(buffer => firstRequest.write(buffer))
-
-  // The first request will be retried
-  const firstRequestErrorHandler = () => {
-    log.debug('Retrying request to the intake')
-    const retriedReq = retriableRequest(options, client, callback)
-    dataArray.forEach(buffer => retriedReq.write(buffer))
-    // The retried request will fail normally
-    retriedReq.on('error', e => callback(new Error(`Network error trying to reach the intake: ${e.message}`)))
-    retriedReq.end()
-  }
-
-  firstRequest.on('error', firstRequestErrorHandler)
-  firstRequest.end()
-
-  return firstRequest
-}
-
-function retriableRequest (options, client, callback) {
-  const store = storage.getStore()
-
-  storage.enterWith({ noop: true })
-
-  const timeout = options.timeout || 15000
-
-  const request = client.request(options, res => {
+  const onResponse = res => {
     let responseData = ''
 
     res.setTimeout(timeout)
 
     res.on('data', chunk => { responseData += chunk })
     res.on('end', () => {
+      activeRequests--
+
       if (res.statusCode >= 200 && res.statusCode <= 299) {
         callback(null, responseData, res.statusCode)
       } else {
@@ -69,15 +56,43 @@ function retriableRequest (options, client, callback) {
         callback(error, null, res.statusCode)
       }
     })
-  })
-  request.setTimeout(timeout, request.abort)
-  storage.enterWith(store)
+  }
 
-  return request
+  const makeRequest = onError => {
+    if (!request.writable) return callback(null)
+
+    activeRequests++
+
+    const store = storage.getStore()
+
+    storage.enterWith({ noop: true })
+
+    const req = client.request(options, onResponse)
+
+    req.once('error', err => {
+      activeRequests--
+      onError(err)
+    })
+
+    dataArray.forEach(buffer => req.write(buffer))
+
+    req.setTimeout(timeout, req.abort)
+    req.end()
+
+    storage.enterWith(store)
+  }
+
+  makeRequest(() => makeRequest(callback))
 }
 
 function byteLength (data) {
   return data.length > 0 ? data.reduce((prev, next) => prev + next.length, 0) : 0
 }
 
+Object.defineProperty(request, 'writable', {
+  get () {
+    return activeRequests < maxActiveRequests
+  }
+})
+
 module.exports = request

package/packages/dd-trace/src/exporters/common/writer.js

@@ -1,4 +1,6 @@
 'use strict'
+
+const request = require('./request')
 const log = require('../../log')
 
 class Writer {
@@ -9,7 +11,10 @@ class Writer {
   flush (done = () => {}) {
     const count = this._encoder.count()
 
-    if (count > 0) {
+    if (!request.writable) {
+      this._encoder.reset()
+      done()
+    } else if (count > 0) {
       const payload = this._encoder.makePayload()
 
       this._sendPayload(payload, count, done)
@@ -19,6 +24,8 @@ class Writer {
   }
 
   append (spans) {
+    if (!request.writable) return
+
     log.debug(() => `Encoding trace: ${JSON.stringify(spans)}`)
 
     this._encode(spans)

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

@@ -24,10 +24,6 @@ class NoopTracer extends Tracer {
     return this._scope
   }
 
-  currentSpan () {
-    return null
-  }
-
   getRumData () {
     return ''
   }

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

@@ -63,7 +63,7 @@ module.exports = class PluginManager {
 
   // like instrumenter.enable()
   configure (config = {}) {
-    const { logInjection, serviceMapping, experimental } = config
+    const { logInjection, serviceMapping, experimental, queryStringObfuscation } = config
 
     for (const PluginClass of Object.values(plugins)) {
       const name = PluginClass.name
@@ -87,6 +87,10 @@ module.exports = class PluginManager {
         pluginConfig.logInjection = logInjection
       }
 
+      if (queryStringObfuscation !== undefined) {
+        pluginConfig.queryStringObfuscation = queryStringObfuscation
+      }
+
       // TODO: update so that it's available for every CI Visibility's plugin
       if (name === 'mocha') {
         pluginConfig.isAgentlessEnabled = experimental && experimental.exporter === 'datadog'

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

@@ -15,7 +15,6 @@ module.exports = {
   'express': require('../../../datadog-plugin-express/src'),
   'fastify': require('../../../datadog-plugin-fastify/src'),
   'find-my-way': require('../../../datadog-plugin-find-my-way/src'),
-  'fs': require('../../../datadog-plugin-fs/src'),
   'google-cloud-pubsub': require('../../../datadog-plugin-google-cloud-pubsub/src'),
   'graphql': require('../../../datadog-plugin-graphql/src'),
   'grpc': require('../../../datadog-plugin-grpc/src'),

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
     })
   },
 
@@ -318,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
@@ -407,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,
@@ -522,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')

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

@@ -1,548 +0,0 @@
-'use strict'
-
-const { storage } = require('../../datadog-core')
-
-let kDirReadPromisified
-let kDirClosePromisified
-let kHandle
-
-const ddFhSym = Symbol('ddFileHandle')
-
-const tagMakers = {
-  open: createOpenTags,
-  close: createCloseTags,
-  readFile: createReadFileTags,
-  writeFile: createWriteFileTags,
-  appendFile: createAppendFileTags,
-  access: createPathTags,
-  copyFile: createCopyFileTags,
-  stat: createPathTags,
-  lstat: createPathTags,
-  fstat: createFDTags,
-  readdir: createPathTags,
-  opendir: createPathTags,
-  read: createFDTags,
-  write: createFDTags,
-  writev: createFDTags,
-  chmod: createChmodTags,
-  lchmod: createChmodTags,
-  fchmod: createFchmodTags,
-  chown: createChownTags,
-  lchown: createChownTags,
-  fchown: createFchownTags,
-  realpath: createPathTags,
-  readlink: createPathTags,
-  unlink: createPathTags,
-  symlink: createCopyFileTags,
-  link: createCopyFileTags,
-  rmdir: createPathTags,
-  rename: createCopyFileTags,
-  fsync: createFDTags,
-  fdatasync: createFDTags,
-  mkdir: createPathTags,
-  truncate: createPathTags,
-  ftruncate: createFDTags,
-  utimes: createPathTags,
-  futimes: createFDTags,
-  mkdtemp: createPathTags
-}
-
-const promisifiable = ['read', 'readv', 'write', 'writev']
-
-const orphanable = false
-
-function createWrapCreateReadStream (config, tracer) {
-  return function wrapCreateReadStream (createReadStream) {
-    return function createReadStreamWithTrace (path, options) {
-      if (!hasParent()) {
-        return createReadStream.apply(this, arguments)
-      }
-      const tags = makeFSFlagTags('ReadStream', path, options, 'r', config, tracer)
-      return tracer.trace('fs.operation', { tags, orphanable }, (span, done) => {
-        const stream = createReadStream.apply(this, arguments)
-        stream.once('close', done)
-        stream.once('end', done)
-        stream.once('error', done)
-        return stream
-      })
-    }
-  }
-}
-
-function createWrapCreateWriteStream (config, tracer) {
-  return function wrapCreateWriteStream (createWriteStream) {
-    return function createWriteStreamWithTrace (path, options) {
-      const tags = makeFSFlagTags('WriteStream', path, options, 'w', config, tracer)
-      return tracer.trace('fs.operation', { tags, orphanable }, (span, done) => {
-        const stream = createWriteStream.apply(this, arguments)
-        stream.once('close', done)
-        stream.once('finish', done)
-        stream.once('error', done)
-        return stream
-      })
-    }
-  }
-}
-
-function createWrapExists (config, tracer) {
-  return function wrapExists (exists) {
-    const existsWithTrace = function existsWithTrace (path, cb) {
-      if (typeof cb !== 'function') {
-        return exists.apply(this, arguments)
-      }
-      const tags = makeFSTags('exists', path, null, config, tracer)
-      return tracer.trace('fs.operation', { tags, orphanable }, (span, done) => {
-        arguments[1] = function (result) {
-          done()
-          cb.apply(this, arguments)
-        }
-        return exists.apply(this, arguments)
-      })
-    }
-
-    copySymbols(exists, existsWithTrace)
-
-    return existsWithTrace
-  }
-}
-
-function createWrapDirRead (config, tracer, sync) {
-  const name = sync ? 'dir.readSync' : 'dir.read'
-  return function wrapDirRead (read) {
-    function options () {
-      const tags = makeFSTags(name, this.path, null, config, tracer)
-      return { tags, orphanable }
-    }
-    return tracer.wrap('fs.operation', options, read, true)
-  }
-}
-
-function createWrapDirClose (config, tracer, sync) {
-  const name = sync ? 'dir.closeSync' : 'dir.close'
-  return function wrapDirClose (close) {
-    function options () {
-      const tags = makeFSTags(name, this.path, null, config, tracer)
-      return { tags, orphanable }
-    }
-    return tracer.wrap('fs.operation', options, close, true)
-  }
-}
-
-function createWrapDirAsyncIterator (config, tracer, instrumenter) {
-  return function wrapDirAsyncIterator (asyncIterator) {
-    return function asyncIteratorWithTrace () {
-      if (!kDirReadPromisified) {
-        const keys = Reflect.ownKeys(this)
-        for (const key of keys) {
-          if (kDirReadPromisified && kDirClosePromisified) break
-          if (typeof key !== 'symbol') continue
-          if (!kDirReadPromisified && getSymbolName(key).includes('kDirReadPromisified')) {
-            kDirReadPromisified = key
-          }
-          if (!kDirClosePromisified && getSymbolName(key).includes('kDirClosePromisified')) {
-            kDirClosePromisified = key
-          }
-        }
-      }
-      instrumenter.wrap(this, kDirReadPromisified, createWrapDirRead(config, tracer))
-      instrumenter.wrap(this, kDirClosePromisified, createWrapKDirClose(config, tracer, instrumenter))
-      return asyncIterator.apply(this, arguments)
-    }
-  }
-}
-
-function createWrapKDirClose (config, tracer, instrumenter) {
-  return function wrapKDirClose (kDirClose) {
-    return function kDirCloseWithTrace () {
-      const tags = makeFSTags('dir.close', this.path, null, config, tracer)
-      return tracer.trace('fs.operation', { tags, orphanable }, (span) => {
-        const p = kDirClose.apply(this, arguments)
-        const unwrapBoth = () => {
-          instrumenter.unwrap(this, kDirReadPromisified)
-          instrumenter.unwrap(this, kDirClosePromisified)
-        }
-        p.then(unwrapBoth, unwrapBoth)
-        return p
-      })
-    }
-  }
-}
-
-function createOpenTags (resourceName, config, tracer) {
-  return function openTags (path, flag, mode) {
-    if (!flag || typeof flag === 'function') {
-      flag = null
-    }
-    return makeFSFlagTags(resourceName, path, { flag }, 'r', config, tracer)
-  }
-}
-
-function createCloseTags (resourceName, config, tracer) {
-  return function closeTags (fd) {
-    if (typeof fd === 'undefined' && this && this[ddFhSym]) {
-      fd = this[ddFhSym].fd
-    }
-    if (typeof fd !== 'number' || !Number.isInteger(fd)) {
-      return
-    }
-    return makeFSTags(resourceName, fd, null, config, tracer)
-  }
-}
-
-function createReadFileTags (resourceName, config, tracer) {
-  return function readFileTags (path, options) {
-    return makeFSFlagTags(resourceName, path, options, 'r', config, tracer)
-  }
-}
-
-function createWriteFileTags (resourceName, config, tracer) {
-  return function writeFileTags (path, data, options) {
-    return makeFSFlagTags(resourceName, path, options, 'w', config, tracer)
-  }
-}
-
-function createAppendFileTags (resourceName, config, tracer) {
-  return function appendFileTags (path, data, options) {
-    return makeFSFlagTags(resourceName, path, options, 'a', config, tracer)
-  }
-}
-
-function createCopyFileTags (resourceName, config, tracer) {
-  return function copyFileTags (src, dest, flag) {
-    return makeFSTags(resourceName, { src, dest }, null, config, tracer)
-  }
-}
-
-function createChmodTags (resourceName, config, tracer) {
-  return function chmodTags (fd, mode) {
-    const tags = makeFSTags(resourceName, fd, null, config, tracer)
-    tags['file.mode'] = mode.toString(8)
-    return tags
-  }
-}
-
-function createFchmodTags (resourceName, config, tracer) {
-  return function fchmodTags (fd, mode) {
-    if (typeof this === 'object' && this !== null && this.fd) {
-      mode = fd
-      fd = this.fd
-    }
-
-    const tags = makeFSTags(resourceName, fd, null, config, tracer)
-    if (mode) {
-      tags['file.mode'] = mode.toString(8)
-    }
-    return tags
-  }
-}
-
-function createPathTags (resourceName, config, tracer) {
-  return function pathTags (path) {
-    return makeFSTags(resourceName, path, null, config, tracer)
-  }
-}
-
-function createFDTags (resourceName, config, tracer) {
-  return function fdTags (fd) {
-    if (typeof this === 'object' && this !== null && this.fd) {
-      fd = this.fd
-    }
-    return makeFSTags(resourceName, fd, null, config, tracer)
-  }
-}
-
-function createChownTags (resourceName, config, tracer) {
-  return function chownTags (fd, uid, gid) {
-    const tags = makeFSTags(resourceName, fd, null, config, tracer)
-    if (typeof uid === 'number') {
-      tags['file.uid'] = uid.toString()
-    }
-    if (typeof gid === 'number') {
-      tags['file.gid'] = gid.toString()
-    }
-    return tags
-  }
-}
-
-function createFchownTags (resourceName, config, tracer) {
-  return function fchownTags (fd, uid, gid) {
-    if (typeof this === 'object' && this !== null && this.fd) {
-      gid = uid
-      uid = fd
-      fd = this.fd
-    }
-    const tags = makeFSTags(resourceName, fd, null, config, tracer)
-    if (typeof uid === 'number') {
-      tags['file.uid'] = uid.toString()
-    }
-    if (typeof gid === 'number') {
-      tags['file.gid'] = gid.toString()
-    }
-    return tags
-  }
-}
-
-function getSymbolName (sym) {
-  return sym.description || sym.toString()
-}
-
-function hasParent () {
-  const store = storage.getStore()
-
-  return store && store.span && !store.noop
-}
-
-function createWrapCb (tracer, config, name, tagMaker) {
-  const makeTags = tagMaker(name, config, tracer)
-  return function wrapFunction (fn) {
-    return tracer.wrap('fs.operation', function () {
-      if (typeof arguments[arguments.length - 1] !== 'function') {
-        return
-      }
-      const tags = makeTags.apply(this, arguments)
-      return tags ? { tags, orphanable } : { orphanable }
-    }, fn, true)
-  }
-}
-
-function createWrap (tracer, config, name, tagMaker) {
-  const makeTags = tagMaker(name, config, tracer)
-
-  return function wrapSyncFunction (fn) {
-    return tracer.wrap('fs.operation', function () {
-      const tags = makeTags.apply(this, arguments)
-      return tags ? { tags, orphanable } : { orphanable }
-    }, fn, true)
-  }
-}
-
-function makeFSFlagTags (resourceName, path, options, defaultFlag, config, tracer) {
-  const tags = makeFSTags(resourceName, path, options, config, tracer)
-
-  if (tags) {
-    let flag = defaultFlag
-    if (typeof options === 'object' && options !== null) {
-      if (options.flag) {
-        flag = options.flag
-      } else if (options.flags) {
-        flag = options.flags
-      }
-    }
-    tags['file.flag'] = flag
-    return tags
-  }
-}
-
-function makeFSTags (resourceName, path, options, config, tracer) {
-  path = options && typeof options === 'object' && 'fd' in options ? options.fd : path
-  const tags = {
-    'component': 'fs',
-    'span.kind': 'internal',
-    'resource.name': resourceName,
-    'service.name': config.service || tracer._service
-  }
-
-  switch (typeof path) {
-    case 'object': {
-      if (path === null) return tags
-      const src = 'src' in path ? path.src : null
-      const dest = 'dest' in path ? path.dest : null
-      if (src || dest) {
-        tags['file.src'] = src
-        tags['file.dest'] = dest
-      } else {
-        tags['file.path'] = path
-      }
-      break
-    }
-    case 'string': {
-      tags['file.path'] = path
-      break
-    }
-    case 'number': {
-      tags['file.descriptor'] = path.toString()
-      break
-    }
-  }
-
-  return tags
-}
-
-function copySymbols (from, to) {
-  const props = Object.getOwnPropertyDescriptors(from)
-  const keys = Reflect.ownKeys(props)
-
-  for (const key of keys) {
-    if (typeof key !== 'symbol' || to.hasOwnProperty(key)) continue
-
-    Object.defineProperty(to, key, props[key])
-  }
-}
-
-function getFileHandlePrototype (fs) {
-  return fs.promises.open(__filename, 'r')
-    .then(fh => {
-      if (!kHandle) {
-        kHandle = Reflect.ownKeys(fh).find(key => typeof key === 'symbol' && key.toString().includes('kHandle'))
-      }
-      fh.close()
-
-      return Object.getPrototypeOf(fh)
-    })
-}
-
-function patchClassicFunctions (fs, tracer, config) {
-  for (const name in fs) {
-    if (!fs[name]) continue
-    const tagMakerName = name.endsWith('Sync') ? name.substr(0, name.length - 4) : name
-    const original = fs[name]
-    if (tagMakerName in tagMakers) {
-      const tagMaker = tagMakers[tagMakerName]
-      if (name.endsWith('Sync')) {
-        this.wrap(fs, name, createWrap(tracer, config, name, tagMaker))
-      } else {
-        this.wrap(fs, name, createWrapCb(tracer, config, name, tagMaker))
-      }
-      if (name in promisifiable) {
-        copySymbols(original, fs[name])
-      }
-    }
-  }
-}
-
-function patchFileHandle (fs, tracer, config) {
-  getFileHandlePrototype(fs).then((fileHandlePrototype) => {
-    for (const name of Reflect.ownKeys(fileHandlePrototype)) {
-      if (typeof name !== 'string' || name === 'constructor' || name === 'fd' || name === 'getAsyncId') {
-        continue
-      }
-      let tagMaker
-      const fName = 'f' + name
-      if (fName in tagMakers) {
-        tagMaker = tagMakers[fName]
-      } else {
-        tagMaker = createFDTags
-      }
-
-      const instrumenter = this
-
-      const desc = Reflect.getOwnPropertyDescriptor(fileHandlePrototype, kHandle)
-      if (!desc || !desc.get) {
-        Reflect.defineProperty(fileHandlePrototype, kHandle, {
-          get () {
-            return this[ddFhSym]
-          },
-          set (h) {
-            this[ddFhSym] = h
-            instrumenter.wrap(this, 'close', createWrap(tracer, config, 'filehandle.close', tagMakers.close))
-          },
-          configurable: true
-        })
-      }
-
-      this.wrap(fileHandlePrototype, name, createWrap(tracer, config, 'filehandle.' + name, tagMaker))
-    }
-  })
-}
-
-function patchPromiseFunctions (fs, tracer, config) {
-  for (const name in fs.promises) {
-    if (name in tagMakers) {
-      const tagMaker = tagMakers[name]
-      this.wrap(fs.promises, name, createWrap(tracer, config, 'promises.' + name, tagMaker))
-    }
-  }
-}
-
-function patchDirFunctions (fs, tracer, config) {
-  this.wrap(fs.Dir.prototype, 'close', createWrapDirClose(config, tracer))
-  this.wrap(fs.Dir.prototype, 'closeSync', createWrapDirClose(config, tracer, true))
-  this.wrap(fs.Dir.prototype, 'read', createWrapDirRead(config, tracer))
-  this.wrap(fs.Dir.prototype, 'readSync', createWrapDirRead(config, tracer, true))
-  this.wrap(fs.Dir.prototype, Symbol.asyncIterator, createWrapDirAsyncIterator(config, tracer, this))
-}
-
-function unpatchClassicFunctions (fs) {
-  for (const name in fs) {
-    if (!fs[name]) continue
-    const tagMakerName = name.endsWith('Sync') ? name.substr(0, name.length - 4) : name
-    if (tagMakerName in tagMakers) {
-      this.unwrap(fs, name)
-    }
-  }
-}
-
-function unpatchFileHandle (fs) {
-  getFileHandlePrototype(fs).then(fileHandlePrototype => {
-    for (const name of Reflect.ownKeys(fileHandlePrototype)) {
-      if (typeof name !== 'string' || name === 'constructor' || name === 'fd' || name === 'getAsyncId') {
-        continue
-      }
-      this.unwrap(fileHandlePrototype, name)
-    }
-    delete fileHandlePrototype[kHandle]
-  })
-}
-
-function unpatchPromiseFunctions (fs) {
-  for (const name in fs.promises) {
-    if (name in tagMakers) {
-      this.unwrap(fs.promises, name)
-    }
-  }
-}
-
-function unpatchDirFunctions (fs) {
-  this.unwrap(fs.Dir.prototype, 'close')
-  this.unwrap(fs.Dir.prototype, 'closeSync')
-  this.unwrap(fs.Dir.prototype, 'read')
-  this.unwrap(fs.Dir.prototype, 'readSync')
-  this.unwrap(fs.Dir.prototype, Symbol.asyncIterator)
-}
-
-module.exports = {
-  name: 'fs',
-  patch (fs, tracer, config) {
-    const realpathNative = fs.realpath.native
-    const realpathSyncNative = fs.realpathSync.native
-    patchClassicFunctions.call(this, fs, tracer, config)
-    if (fs.promises) {
-      patchFileHandle.call(this, fs, tracer, config)
-      patchPromiseFunctions.call(this, fs, tracer, config)
-    }
-    if (fs.Dir) {
-      patchDirFunctions.call(this, fs, tracer, config)
-    }
-    this.wrap(fs, 'createReadStream', createWrapCreateReadStream(config, tracer))
-    this.wrap(fs, 'createWriteStream', createWrapCreateWriteStream(config, tracer))
-    this.wrap(fs, 'existsSync', createWrap(tracer, config, 'existsSync', createPathTags))
-    this.wrap(fs, 'exists', createWrapExists(config, tracer))
-    if (realpathNative) {
-      fs.realpath.native = createWrapCb(tracer, config, 'realpath.native', createPathTags)(realpathNative)
-    }
-    if (realpathSyncNative) {
-      fs.realpathSync.native = createWrap(tracer, config, 'realpath.native', createPathTags)(realpathSyncNative)
-    }
-  },
-  unpatch (fs) {
-    unpatchClassicFunctions.call(this, fs)
-    if (fs.promises) {
-      unpatchFileHandle.call(this, fs)
-      unpatchPromiseFunctions.call(this, fs)
-    }
-    if (fs.Dir) {
-      unpatchDirFunctions.call(this, fs)
-    }
-    this.unwrap(fs, 'createReadStream')
-    this.unwrap(fs, 'createWriteStream')
-    this.unwrap(fs, 'existsSync')
-    this.unwrap(fs, 'exists')
-  }
-}
-
-/** TODO fs functions:
-
-unwatchFile
-watch
-watchFile
-*/