dd-trace 2.3.0 → 2.4.1

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

@@ -1,40 +1,30 @@
 'use strict'
 
-const url = require('url')
-const log = require('../../dd-trace/src/log')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 const tags = require('../../../ext/tags')
-const kinds = require('../../../ext/kinds')
+const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 const formats = require('../../../ext/formats')
+const HTTP_HEADERS = formats.HTTP_HEADERS
 const urlFilter = require('../../dd-trace/src/plugins/util/urlfilter')
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-const { storage } = require('../../datadog-core')
+const log = require('../../dd-trace/src/log')
+const url = require('url')
 
-const HTTP_HEADERS = formats.HTTP_HEADERS
 const HTTP_STATUS_CODE = tags.HTTP_STATUS_CODE
 const HTTP_REQUEST_HEADERS = tags.HTTP_REQUEST_HEADERS
 const HTTP_RESPONSE_HEADERS = tags.HTTP_RESPONSE_HEADERS
-const SPAN_KIND = tags.SPAN_KIND
-const CLIENT = kinds.CLIENT
-
-function patch (http, methodName, tracer, config) {
-  config = normalizeConfig(tracer, config)
-  this.wrap(http, methodName, fn => makeRequestTrace(fn))
 
-  function makeRequestTrace (request) {
-    return function requestTrace () {
-      const store = storage.getStore()
-
-      if (store && store.noop) return request.apply(this, arguments)
-
-      let args
+class HttpClientPlugin extends Plugin {
+  static get name () {
+    return 'http'
+  }
 
-      try {
-        args = normalizeArgs.apply(null, arguments)
-      } catch (e) {
-        log.error(e)
-        return request.apply(this, arguments)
-      }
+  constructor (...args) {
+    super(...args)
 
+    this.addSub('apm:http:client:request:start', ({ args, http }) => {
+      const store = storage.getStore()
+      this.config = normalizeClientConfig(this.config)
       const options = args.options
       const agent = options.agent || options._defaultAgent || http.globalAgent
       const protocol = options.protocol || agent.protocol || 'http:'
@@ -43,17 +33,13 @@ function patch (http, methodName, tracer, config) {
       const path = options.path ? options.path.split(/[?#]/)[0] : '/'
       const uri = `${protocol}//${host}${path}`
 
-      let callback = args.callback
-
       const method = (options.method || 'GET').toUpperCase()
-
-      const scope = tracer.scope()
-      const childOf = scope.active()
-      const span = tracer.startSpan('http.request', {
+      const childOf = store ? store.span : store
+      const span = this.tracer.startSpan('http.request', {
         childOf,
         tags: {
-          [SPAN_KIND]: CLIENT,
-          'service.name': getServiceName(tracer, config, options),
+          'span.kind': 'client',
+          'service.name': getServiceName(this.tracer, this.config, options),
           'resource.name': method,
           'span.type': 'http',
           'http.method': method,
@@ -61,184 +47,113 @@ function patch (http, methodName, tracer, config) {
         }
       })
 
-      if (!(hasAmazonSignature(options) || !config.propagationFilter(uri))) {
-        tracer.inject(span, HTTP_HEADERS, options.headers)
+      if (!(hasAmazonSignature(options) || !this.config.propagationFilter(uri))) {
+        this.tracer.inject(span, HTTP_HEADERS, options.headers)
       }
 
-      analyticsSampler.sample(span, config.measured)
-
-      callback = scope.bind(callback, childOf)
-
-      const req = scope.bind(request, span).call(this, options, callback)
-      const emit = req.emit
-
-      req.emit = function (eventName, arg) {
-        switch (eventName) {
-          case 'response': {
-            const res = arg
+      analyticsSampler.sample(span, this.config.measured)
+      this.enter(span, store)
+    })
 
-            scope.bind(res)
+    this.addSub('apm:http:client:request:end', this.exit.bind(this))
 
-            res.on('end', () => finish(req, res, span, config))
+    this.addSub('apm:http:client:request:async-end', ({ req, res }) => {
+      const span = storage.getStore().span
+      if (res) {
+        span.setTag(HTTP_STATUS_CODE, res.statusCode)
 
-            break
-          }
-          case 'error':
-            addError(span, arg)
-          case 'abort': // eslint-disable-line no-fallthrough
-          case 'timeout': // eslint-disable-line no-fallthrough
-            finish(req, null, span, config)
+        if (!this.config.validateStatus(res.statusCode)) {
+          span.setTag('error', 1)
         }
 
-        return emit.apply(this, arguments)
-      }
-
-      scope.bind(req)
-
-      return req
-    }
-  }
-
-  function finish (req, res, span, config) {
-    if (res) {
-      span.setTag(HTTP_STATUS_CODE, res.statusCode)
-
-      if (!config.validateStatus(res.statusCode)) {
+        addResponseHeaders(res, span, this.config)
+      } else {
         span.setTag('error', 1)
       }
 
-      addResponseHeaders(res, span, config)
-    } else {
-      span.setTag('error', 1)
-    }
-
-    addRequestHeaders(req, span, config)
-
-    config.hooks.request(span, req, res)
+      addRequestHeaders(req, span, this.config)
 
-    span.finish()
-  }
-
-  function addError (span, error) {
-    span.addTags({
-      'error.type': error.name,
-      'error.msg': error.message,
-      'error.stack': error.stack
+      this.config.hooks.request(span, req, res)
+      span.finish()
     })
 
-    return error
-  }
-
-  function addRequestHeaders (req, span, config) {
-    config.headers.forEach(key => {
-      const value = req.getHeader(key)
-
-      if (value) {
-        span.setTag(`${HTTP_REQUEST_HEADERS}.${key}`, value)
-      }
-    })
-  }
-
-  function addResponseHeaders (res, span, config) {
-    config.headers.forEach(key => {
-      const value = res.headers[key]
-
-      if (value) {
-        span.setTag(`${HTTP_RESPONSE_HEADERS}.${key}`, value)
-      }
-    })
+    this.addSub('apm:http:client:request:error', errorHandler)
   }
+}
 
-  function normalizeArgs (inputURL, inputOptions, cb) {
-    inputURL = normalizeOptions(inputURL)
+function errorHandler (err) {
+  const span = storage.getStore().span
+  span.addTags({
+    'error.type': err.name,
+    'error.msg': err.message,
+    'error.stack': err.stack
+  })
+}
 
-    const [callback, inputOptionsNormalized] = normalizeCallback(inputOptions, cb, inputURL)
-    const options = combineOptions(inputURL, inputOptionsNormalized)
-    normalizeHeaders(options)
-    const uri = url.format(options)
+function addResponseHeaders (res, span, config) {
+  config.headers.forEach(key => {
+    const value = res.headers[key]
 
-    return { uri, options, callback }
-  }
-
-  function normalizeCallback (inputOptions, callback, inputURL) {
-    if (typeof inputOptions === 'function') {
-      return [inputOptions, inputURL || {}]
-    } else {
-      return [callback, inputOptions]
+    if (value) {
+      span.setTag(`${HTTP_RESPONSE_HEADERS}.${key}`, value)
     }
-  }
+  })
+}
+
+function addRequestHeaders (req, span, config) {
+  config.headers.forEach(key => {
+    const value = req.getHeader(key)
 
-  function combineOptions (inputURL, inputOptions) {
-    if (typeof inputOptions === 'object') {
-      return Object.assign(inputURL || {}, inputOptions)
-    } else {
-      return inputURL
+    if (value) {
+      span.setTag(`${HTTP_REQUEST_HEADERS}.${key}`, value)
     }
-  }
+  })
+}
 
-  function normalizeHeaders (options) {
-    options.headers = options.headers || {}
-  }
+function normalizeClientConfig (config) {
+  const validateStatus = getStatusValidator(config)
+  const propagationFilter = getFilter({ blocklist: config.propagationBlocklist })
+  const headers = getHeaders(config)
+  const hooks = getHooks(config)
 
-  // https://github.com/nodejs/node/blob/7e911d8b03a838e5ac6bb06c5b313533e89673ef/lib/internal/url.js#L1271
-  function urlToOptions (url) {
-    const agent = url.agent || http.globalAgent
-    const options = {
-      protocol: url.protocol || agent.protocol,
-      hostname: typeof url.hostname === 'string' && url.hostname.startsWith('[')
-        ? url.hostname.slice(1, -1)
-        : url.hostname ||
-        url.host ||
-        'localhost',
-      hash: url.hash,
-      search: url.search,
-      pathname: url.pathname,
-      path: `${url.pathname || ''}${url.search || ''}`,
-      href: url.href
-    }
-    if (url.port !== '') {
-      options.port = Number(url.port)
-    }
-    if (url.username || url.password) {
-      options.auth = `${url.username}:${url.password}`
-    }
-    return options
-  }
+  return Object.assign({}, config, {
+    validateStatus,
+    propagationFilter,
+    headers,
+    hooks
+  })
+}
 
-  function normalizeOptions (inputURL) {
-    if (typeof inputURL === 'string') {
-      try {
-        return urlToOptions(new url.URL(inputURL))
-      } catch (e) {
-        return url.parse(inputURL)
-      }
-    } else if (inputURL instanceof url.URL) {
-      return urlToOptions(inputURL)
-    } else {
-      return inputURL
-    }
+function getStatusValidator (config) {
+  if (typeof config.validateStatus === 'function') {
+    return config.validateStatus
+  } else if (config.hasOwnProperty('validateStatus')) {
+    log.error('Expected `validateStatus` to be a function.')
   }
+  return code => code < 400 || code >= 500
 }
 
-function getHost (options) {
-  if (typeof options === 'string') {
-    return url.parse(options).host
-  }
+function getFilter (config) {
+  config = Object.assign({}, config, {
+    blocklist: config.blocklist || []
+  })
 
-  const hostname = options.hostname || options.host || 'localhost'
-  const port = options.port
+  return urlFilter.getFilter(config)
+}
 
-  return [hostname, port].filter(val => val).join(':')
+function getHeaders (config) {
+  if (!Array.isArray(config.headers)) return []
+
+  return config.headers
+    .filter(key => typeof key === 'string')
+    .map(key => key.toLowerCase())
 }
 
-function getServiceName (tracer, config, options) {
-  if (config.splitByDomain) {
-    return getHost(options)
-  } else if (config.service) {
-    return config.service
-  }
+function getHooks (config) {
+  const noop = () => {}
+  const request = (config.hooks && config.hooks.request) || noop
 
-  return `${tracer._service}-http-client`
+  return { request }
 }
 
 function hasAmazonSignature (options) {
@@ -264,87 +179,29 @@ function hasAmazonSignature (options) {
   return options.path && options.path.toLowerCase().indexOf('x-amz-signature=') !== -1
 }
 
-function startsWith (searchString) {
-  return value => String(value).startsWith(searchString)
-}
-
-function unpatch (http) {
-  this.unwrap(http, 'request')
-  this.unwrap(http, 'get')
-}
-
-function getStatusValidator (config) {
-  if (typeof config.validateStatus === 'function') {
-    return config.validateStatus
-  } else if (config.hasOwnProperty('validateStatus')) {
-    log.error('Expected `validateStatus` to be a function.')
+function getServiceName (tracer, config, options) {
+  if (config.splitByDomain) {
+    return getHost(options)
+  } else if (config.service) {
+    return config.service
   }
-  return code => code < 400 || code >= 500
-}
 
-function getFilter (config) {
-  config = Object.assign({}, config, {
-    blocklist: config.blocklist || []
-  })
-
-  return urlFilter.getFilter(config)
+  return `${tracer._service}-http-client`
 }
 
-function normalizeConfig (tracer, config) {
-  config = config.client || config
-
-  const validateStatus = getStatusValidator(config)
-  const propagationFilter = getFilter({ blocklist: config.propagationBlocklist })
-  const headers = getHeaders(config)
-  const hooks = getHooks(config)
-
-  return Object.assign({}, config, {
-    validateStatus,
-    propagationFilter,
-    headers,
-    hooks
-  })
-}
+function getHost (options) {
+  if (typeof options === 'string') {
+    return url.parse(options).host
+  }
 
-function getHeaders (config) {
-  if (!Array.isArray(config.headers)) return []
+  const hostname = options.hostname || options.host || 'localhost'
+  const port = options.port
 
-  return config.headers
-    .filter(key => typeof key === 'string')
-    .map(key => key.toLowerCase())
+  return [hostname, port].filter(val => val).join(':')
 }
 
-function getHooks (config) {
-  const noop = () => {}
-  const request = (config.hooks && config.hooks.request) || noop
-
-  return { request }
+function startsWith (searchString) {
+  return value => String(value).startsWith(searchString)
 }
 
-module.exports = [
-  {
-    name: 'http',
-    patch: function (http, tracer, config) {
-      if (config.client === false) return
-
-      patch.call(this, http, 'request', tracer, config)
-      /**
-       * References internal to modules, such as `http(s).get` calling
-       * `http(s).request`, do not use externally patched versions, which is
-       * why we need to also patch `get` here separately.
-       */
-      patch.call(this, http, 'get', tracer, config)
-    },
-    unpatch
-  },
-  {
-    name: 'https',
-    patch: function (http, tracer, config) {
-      if (config.client === false) return
-
-      patch.call(this, http, 'request', tracer, config)
-      patch.call(this, http, 'get', tracer, config)
-    },
-    unpatch
-  }
-]
+module.exports = HttpClientPlugin

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

@@ -1,6 +1,32 @@
 'use strict'
 
-const client = require('./client')
-const server = require('./server')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const HttpServerPlugin = require('./server')
+const HttpClientPlugin = require('./client')
 
-module.exports = [].concat(client, server)
+class HttpPlugin extends Plugin {
+  static get name () {
+    return 'http'
+  }
+  constructor (...args) {
+    super(...args)
+    this.server = new HttpServerPlugin(...args)
+    this.client = new HttpClientPlugin(...args)
+  }
+  configure (config) {
+    const clientConfig = config.client === false ? false : {
+      ...config,
+      ...config.client
+    }
+
+    const serverConfig = config.server === false ? false : {
+      ...config,
+      ...config.server
+    }
+
+    this.server.configure(serverConfig)
+    this.client.configure(clientConfig)
+  }
+}
+
+module.exports = HttpPlugin

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

@@ -1,47 +1,64 @@
 'use strict'
 
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 const web = require('../../dd-trace/src/plugins/util/web')
-const Scope = require('../../dd-trace/src/scope')
 const { incomingHttpRequestStart } = require('../../dd-trace/src/appsec/gateway/channels')
+const tags = require('../../../ext/tags')
+const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
+const SERVICE_NAME = tags.SERVICE_NAME
 
-function createWrapEmit (tracer, config) {
-  config = web.normalizeConfig(config)
+class HttpServerPlugin extends Plugin {
+  static get name () {
+    return 'http'
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:http:server:request:start', ({ req, res }) => {
+      const store = storage.getStore()
+      this.config = web.normalizeConfig(this.config)
 
-  return function wrapEmit (emit) {
-    return function emitWithTrace (eventName, req, res) {
-      if (eventName === 'request') {
-        return web.instrument(tracer, config, req, res, 'http.request', () => {
-          if (incomingHttpRequestStart.hasSubscribers) {
-            incomingHttpRequestStart.publish({ req, res })
-          }
+      const span = web.startSpan(this.tracer, this.config, req, res, 'http.request')
 
-          return emit.apply(this, arguments)
-        })
+      if (this.config.service) {
+        span.setTag(SERVICE_NAME, this.config.service)
       }
 
-      return emit.apply(this, arguments)
-    }
-  }
-}
+      analyticsSampler.sample(span, this.config.measured, true)
+      this.enter(span, store)
 
-function plugin (name) {
-  return {
-    name,
-    patch (http, tracer, config) {
-      if (config.server === false) return
+      const context = web.getContext(req)
 
-      this.wrap(http.Server.prototype, 'emit', createWrapEmit(tracer, config))
-      if (http.ServerResponse) { // not present on https
-        Scope._wrapEmitter(http.ServerResponse.prototype)
+      if (!context.instrumented) {
+        context.res.writeHead = web.wrapWriteHead(context)
+        context.instrumented = true
       }
-    },
-    unpatch (http) {
-      this.unwrap(http.Server.prototype, 'emit')
-    }
+
+      if (incomingHttpRequestStart.hasSubscribers) {
+        incomingHttpRequestStart.publish({ req, res })
+      }
+    })
+
+    this.addSub('apm:http:server:request:end', () => {
+      this.exit()
+    })
+
+    this.addSub('apm:http:server:request:error', (error) => {
+      const span = storage.getStore().span
+      span.addTags({
+        'error.type': error.name,
+        'error.msg': error.message,
+        'error.stack': error.stack
+      })
+    })
+
+    this.addSub('apm:http:server:request:async-end', ({ req }) => {
+      const context = web.getContext(req)
+      web.wrapRes(context, context.req, context.res, context.res.end)()
+    })
   }
 }
 
-module.exports = [
-  plugin('http'),
-  plugin('https')
-]
+module.exports = HttpServerPlugin

package/packages/datadog-plugin-jest/src/jest-jasmine2.js

@@ -97,9 +97,11 @@ function createWrapOnException (tracer, globalInput) {
       if (isActiveSpanFailing && !testStatus) {
         activeTestSpan.setTag(TEST_STATUS, 'fail')
         // If we don't do this, jest will show this file on its error message
-        const stackFrames = err.stack.split('\n')
-        const filteredStackFrames = stackFrames.filter(frame => !frame.includes(__dirname)).join('\n')
-        err.stack = filteredStackFrames
+        if (err.stack) {
+          const stackFrames = err.stack.split('\n')
+          const filteredStackFrames = stackFrames.filter(frame => !frame.includes(__dirname)).join('\n')
+          err.stack = filteredStackFrames
+        }
         activeTestSpan.setTag('error', err)
         // need to manually finish, as it will not be caught in `itWithTrace`
         activeTestSpan.finish()