dd-trace 2.5.0 → 2.7.1

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

@@ -56,6 +56,14 @@ module.exports = class Plugin {
     this._subscriptions.push(new Subscription(channelName, handler))
   }
 
+  addError (error) {
+    const store = storage.getStore()
+
+    if (!store || !store.span) return
+
+    store.span.setTag('error', error)
+  }
+
   configure (config) {
     if (typeof config === 'boolean') {
       config = { enabled: config }

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

@@ -19,6 +19,10 @@ const {
 } = require('./tags')
 const id = require('../../id')
 
+const { SPAN_TYPE, RESOURCE_NAME, SAMPLING_PRIORITY } = require('../../../../../ext/tags')
+const { SAMPLING_RULE_DECISION } = require('../../constants')
+const { AUTO_KEEP } = require('../../../../../ext/priority')
+
 const TEST_FRAMEWORK = 'test.framework'
 const TEST_FRAMEWORK_VERSION = 'test.framework_version'
 const TEST_TYPE = 'test.type'
@@ -60,7 +64,8 @@ module.exports = {
   getTestParentSpan,
   getTestSuitePath,
   getCodeOwnersFileEntries,
-  getCodeOwnersForFilename
+  getCodeOwnersForFilename,
+  getTestCommonTags
 }
 
 function getTestEnvironmentMetadata (testFramework, config) {
@@ -134,6 +139,20 @@ function getTestParentSpan (tracer) {
     'x-datadog-parent-id': '0000000000000000'
   })
 }
+
+function getTestCommonTags (name, suite, version) {
+  return {
+    [SPAN_TYPE]: 'test',
+    [TEST_TYPE]: 'test',
+    [SAMPLING_RULE_DECISION]: 1,
+    [SAMPLING_PRIORITY]: AUTO_KEEP,
+    [TEST_NAME]: name,
+    [TEST_SUITE]: suite,
+    [RESOURCE_NAME]: `${suite}.${name}`,
+    [TEST_FRAMEWORK_VERSION]: version
+  }
+}
+
 /**
  * We want to make sure that test suites are reported the same way for
  * every OS, so we replace `path.sep` by `/`

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

@@ -52,10 +52,38 @@ const web = {
     })
   },
 
-  startSpan (tracer, config, req, res, name) {
+  setFramework (req, name, config) {
     const context = this.patch(req)
+    const span = context.span
+
+    if (!span) return
+
+    span.context()._name = `${name}.request`
+
+    web.setConfig(req, config)
+  },
+
+  setConfig (req, config) {
+    const context = contexts.get(req)
+    const span = context.span
+
     context.config = config
 
+    if (!config.filter(req.url)) {
+      span.setTag(MANUAL_DROP, true)
+      span.context()._trace.isRecording = false
+    }
+
+    if (config.service) {
+      span.setTag(SERVICE_NAME, config.service)
+    }
+
+    analyticsSampler.sample(span, config.measured, true)
+  },
+
+  startSpan (tracer, config, req, res, name) {
+    const context = this.patch(req)
+
     let span
 
     if (context.span) {
@@ -69,6 +97,8 @@ const web = {
     context.span = span
     context.res = res
 
+    this.setConfig(req, config)
+
     return span
   },
   wrap (req) {
@@ -83,16 +113,6 @@ const web = {
   instrument (tracer, config, req, res, name, callback) {
     const span = this.startSpan(tracer, config, req, res, name)
 
-    if (!config.filter(req.url)) {
-      span.setTag(MANUAL_DROP, true)
-    }
-
-    if (config.service) {
-      span.setTag(SERVICE_NAME, config.service)
-    }
-
-    analyticsSampler.sample(span, config.measured, true)
-
     this.wrap(req)
 
     return callback && tracer.scope().activate(span, () => callback(span))
@@ -110,6 +130,14 @@ const web = {
     }
   },
 
+  setRoute (req, path) {
+    const context = contexts.get(req)
+
+    if (!context) return
+
+    context.paths = [path]
+  },
+
   // Remove the current route segment.
   exitRoute (req) {
     contexts.get(req).paths.pop()
@@ -231,8 +259,9 @@ const web = {
     const context = contexts.get(req)
     const span = context.span
     const error = context.error
+    const hasMiddlewareError = span.context()._tags['error'] || span.context()._tags['error.msg']
 
-    if (!context.config.validateStatus(statusCode)) {
+    if (!hasMiddlewareError && !context.config.validateStatus(statusCode)) {
       span.setTag(ERROR, error || true)
     }
   },

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

@@ -6,8 +6,8 @@ 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 HeapProfiler = require('./profilers/heap')
+const WallProfiler = require('./profilers/wall')
+const SpaceProfiler = require('./profilers/space')
 const { tagger } = require('./tagger')
 
 const {
@@ -64,8 +64,8 @@ class Config {
     ], this)
 
     const profilers = coalesce(options.profilers, DD_PROFILING_PROFILERS, [
-      new CpuProfiler(),
-      new HeapProfiler()
+      new WallProfiler(),
+      new SpaceProfiler()
     ])
 
     this.profilers = ensureProfilers(profilers, this)
@@ -100,10 +100,10 @@ function ensureExporters (exporters, options) {
 
 function getProfiler (name, options) {
   switch (name) {
-    case 'cpu':
-      return new CpuProfiler(options)
-    case 'heap':
-      return new HeapProfiler(options)
+    case 'wall':
+      return new WallProfiler(options)
+    case 'space':
+      return new SpaceProfiler(options)
     default:
       options.logger.error(`Unknown profiler "${name}"`)
   }

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

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

package/packages/dd-trace/src/profiling/profilers/{heap.js → space.js}

@@ -1,6 +1,6 @@
 'use strict'
 
-class NativeHeapProfiler {
+class NativeSpaceProfiler {
   constructor (options = {}) {
     this.type = 'space'
     this._samplingInterval = options.samplingInterval || 512 * 1024
@@ -27,4 +27,4 @@ class NativeHeapProfiler {
   }
 }
 
-module.exports = NativeHeapProfiler
+module.exports = NativeSpaceProfiler

package/packages/dd-trace/src/profiling/profilers/{cpu.js → wall.js}

@@ -1,9 +1,9 @@
 'use strict'
 
-class NativeCpuProfiler {
+class NativeWallProfiler {
   constructor (options = {}) {
     this.type = 'wall'
-    this._samplingInterval = options.samplingInterval || 10 * 1000
+    this._samplingInterval = options.samplingInterval || 1e6 / 99 // 99hz
     this._mapper = undefined
     this._pprof = undefined
   }
@@ -43,4 +43,4 @@ class NativeCpuProfiler {
   }
 }
 
-module.exports = NativeCpuProfiler
+module.exports = NativeWallProfiler

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

@@ -32,7 +32,10 @@ class SpanProcessor {
         }
       }
 
-      this._exporter.export(formatted)
+      if (formatted.length !== 0 && trace.isRecording !== false) {
+        this._exporter.export(formatted)
+      }
+
       this._erase(trace, active)
     }
   }

package/scripts/install_plugin_modules.js

@@ -186,6 +186,7 @@ const requirePackageJson = require('${requirePackageJsonPath}')
 
 module.exports = {
   get (id) { return require(id || '${name}') },
+  getPath (id) { return require.resolve(id || '${name}' ) },
   version () { return requirePackageJson('${name}', module).version }
 }
 `

package/packages/datadog-plugin-aws-sdk/src/helpers.js

@@ -1,103 +0,0 @@
-'use strict'
-
-const Tags = require('opentracing').Tags
-
-const services = {
-  cloudwatchlogs: getService(require('./services/cloudwatchlogs')),
-  dynamodb: getService(require('./services/dynamodb')),
-  kinesis: getService(require('./services/kinesis')),
-  lambda: getService(require('./services/lambda')),
-  s3: getService(require('./services/s3')),
-  redshift: getService(require('./services/redshift')),
-  sns: getService(require('./services/sns')),
-  sqs: getService(require('./services/sqs')),
-  eventbridge: getService(require('./services/eventbridge'))
-}
-
-function getService (Service) {
-  return new Service()
-}
-
-const helpers = {
-  finish (config, span, response, err) {
-    if (err) {
-      span.setTag('error', err)
-
-      if (err.requestId) {
-        span.addTags({ 'aws.response.request_id': err.requestId })
-      }
-    }
-
-    config.hooks.request(span, response)
-
-    span.finish()
-  },
-
-  isEnabled (serviceIdentifier, config, request) {
-    if (typeof config === 'boolean') {
-      return config
-    } else if (!config || typeof config !== 'object' || !services[serviceIdentifier]) {
-      return true
-    }
-
-    return services[serviceIdentifier].isEnabled
-      ? services[serviceIdentifier].isEnabled(config, request)
-      : true
-  },
-
-  addResponseTags (span, response, serviceName) {
-    if (!span) return
-
-    if (response.request) {
-      this.addServicesTags(span, response, serviceName)
-    }
-  },
-
-  addServicesTags (span, response, serviceName) {
-    if (!span) return
-
-    const params = response.request.params
-    const operation = response.request.operation
-    const extraTags = services[serviceName] ? services[serviceName].generateTags(params, operation, response) : {}
-    const tags = Object.assign({
-      'aws.response.request_id': response.requestId,
-      'resource.name': operation,
-      'span.kind': 'client'
-    }, extraTags)
-
-    span.addTags(tags)
-  },
-
-  responseExtract (serviceName, request, response, tracer) {
-    if (services[serviceName] && services[serviceName].responseExtract) {
-      const params = request.params
-      const operation = request.operation
-      return services[serviceName].responseExtract(params, operation, response, tracer)
-    }
-  },
-
-  requestInject (span, request, serviceName, tracer) {
-    if (!span) return
-
-    const service = services[serviceName] && services[serviceName]
-    if (service && service.requestInject) service.requestInject(span, request, tracer)
-  },
-
-  wrapCb (cb, serviceName, tags, request, tracer, childOf) {
-    const awsHelpers = this
-    return function wrappedCb (err, resp) {
-      const maybeChildOf = awsHelpers.responseExtract(serviceName, request, resp, tracer)
-      if (maybeChildOf) {
-        const options = {
-          childOf: maybeChildOf,
-          tags: Object.assign({}, tags, { [Tags.SPAN_KIND]: 'server' })
-        }
-        return tracer.wrap('aws.response', options, cb).apply(this, arguments)
-      } else {
-        return tracer.scope().bind(cb, childOf).apply(this, arguments)
-      }
-    }
-  }
-}
-
-module.exports = helpers

package/packages/datadog-plugin-fastify/src/fastify.js

@@ -1,198 +0,0 @@
-'use strict'
-
-const methods = require('methods').concat('all')
-const web = require('../../dd-trace/src/plugins/util/web')
-
-function createWrapFastify (tracer, config) {
-  config = web.normalizeConfig(config)
-
-  return function wrapFastify (fastify) {
-    if (typeof fastify !== 'function') return fastify
-
-    return function fastifyWithTrace () {
-      const app = fastify.apply(this, arguments)
-
-      if (!app) return app
-
-      if (typeof app.addHook === 'function') {
-        app.addHook('onRequest', createOnRequest(tracer, config))
-        app.addHook('preHandler', preHandler)
-        app.addHook = createWrapAddHook(tracer, config)(app.addHook)
-      }
-
-      methods.forEach(method => {
-        app[method] = wrapMethod(app[method])
-      })
-
-      app.route = wrapRoute(app.route)
-
-      return app
-    }
-  }
-}
-
-function createWrapAddHook (tracer, config) {
-  return function wrapAddHook (addHook) {
-    return function addHookWithTrace (name, fn) {
-      fn = arguments[arguments.length - 1]
-
-      if (typeof fn !== 'function') return addHook.apply(this, arguments)
-
-      arguments[arguments.length - 1] = safeWrap(fn, function (request, reply, done) {
-        const req = getReq(request)
-
-        if (!req) return fn.apply(this, arguments)
-
-        done = arguments[arguments.length - 1]
-
-        try {
-          if (typeof done === 'function') {
-            arguments[arguments.length - 1] = function (err) {
-              web.addError(req, err)
-              return done.apply(this, arguments)
-            }
-
-            return fn.apply(this, arguments)
-          } else {
-            const promise = fn.apply(this, arguments)
-
-            if (promise && typeof promise.catch === 'function') {
-              return promise.catch(err => {
-                web.addError(req, err)
-                throw err
-              })
-            }
-
-            return promise
-          }
-        } catch (e) {
-          web.addError(req, e)
-          throw e
-        }
-      })
-
-      return addHook.apply(this, arguments)
-    }
-  }
-}
-
-function createOnRequest (tracer, config) {
-  return function onRequest (request, reply, next) {
-    if (typeof next !== 'function') return
-
-    const req = getReq(request)
-    const res = getRes(reply)
-    const name = 'fastify.request'
-
-    return web.instrument(tracer, config, req, res, name, () => next())
-  }
-}
-
-function preHandler (request, reply, next) {
-  if (typeof next !== 'function') return
-  if (!reply || typeof reply.send !== 'function') return next()
-
-  reply.send = wrapSend(reply.send)
-
-  next()
-}
-
-function wrapSend (send) {
-  return function sendWithTrace (payload) {
-    const req = getReq(this && this.request)
-
-    web.addError(req, payload)
-
-    return send.apply(this, arguments)
-  }
-}
-
-function wrapRoute (route) {
-  if (typeof route !== 'function') return route
-
-  return function routeWithTrace (opts) {
-    opts.handler = wrapHandler(opts.handler)
-
-    return route.apply(this, arguments)
-  }
-}
-
-function wrapMethod (method) {
-  if (typeof method !== 'function') return method
-
-  return function methodWithTrace (url, opts, handler) {
-    const lastIndex = arguments.length - 1
-
-    handler = arguments[lastIndex]
-
-    if (typeof handler === 'function') {
-      arguments[lastIndex] = wrapHandler(handler)
-    } else if (handler) {
-      arguments[lastIndex].handler = wrapHandler(handler.handler)
-    }
-
-    return method.apply(this, arguments)
-  }
-}
-
-function wrapHandler (handler) {
-  if (!handler || typeof handler !== 'function' || handler.name === 'handlerWithTrace') {
-    return handler
-  }
-
-  return function handlerWithTrace (request, reply) {
-    const req = getReq(request)
-
-    return web.reactivate(req, () => handler.apply(this, arguments))
-  }
-}
-
-// TODO: move this to a common util
-function safeWrap (fn, wrapper) {
-  Object.defineProperty(wrapper, 'length', Object.getOwnPropertyDescriptor(fn, 'length'))
-
-  return wrapper
-}
-
-function getReq (request) {
-  return request && (request.raw || request.req || request)
-}
-
-function getRes (reply) {
-  return reply && (reply.raw || reply.res || reply)
-}
-
-module.exports = [
-  {
-    name: 'fastify',
-    versions: ['>=3'],
-    patch (fastify, tracer, config) {
-      // `fastify` is a function so we return a wrapper that will replace its export.
-      const wrapped = this.wrapExport(fastify, createWrapFastify(tracer, config)(fastify))
-
-      wrapped.fastify = wrapped
-      wrapped.default = wrapped
-
-      return wrapped
-    },
-    unpatch (fastify) {
-      const unwrapped = this.unwrapExport(fastify)
-
-      unwrapped.fastify = unwrapped
-      unwrapped.default = unwrapped
-
-      return unwrapped
-    }
-  },
-  {
-    name: 'fastify',
-    versions: ['1 - 2'],
-    patch (fastify, tracer, config) {
-      // `fastify` is a function so we return a wrapper that will replace its export.
-      return this.wrapExport(fastify, createWrapFastify(tracer, config)(fastify))
-    },
-    unpatch (fastify) {
-      this.unwrapExport(fastify)
-    }
-  }
-]

package/packages/datadog-plugin-fastify/src/find-my-way.js

@@ -1,37 +0,0 @@
-'use strict'
-
-const web = require('../../dd-trace/src/plugins/util/web')
-
-function createWrapOn () {
-  return function wrapOn (on) {
-    return function onWithTrace (method, path, opts) {
-      const index = typeof opts === 'function' ? 2 : 3
-      const handler = arguments[index]
-      const wrapper = function (req) {
-        web.patch(req)
-        web.enterRoute(req, path)
-
-        return handler.apply(this, arguments)
-      }
-
-      if (typeof handler === 'function') {
-        arguments[index] = wrapper
-      }
-
-      return on.apply(this, arguments)
-    }
-  }
-}
-
-module.exports = [
-  {
-    name: 'find-my-way',
-    versions: ['>=1'],
-    patch (Router, tracer, config) {
-      this.wrap(Router.prototype, 'on', createWrapOn(tracer, config))
-    },
-    unpatch (Router) {
-      this.unwrap(Router.prototype, 'on')
-    }
-  }
-]