dd-trace 2.6.0 → 2.8.0

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

@@ -1,204 +1,107 @@
 'use strict'
 
-const METHODS = require('methods').concat('all')
-const pathToRegExp = require('path-to-regexp')
-const shimmer = require('../../datadog-shimmer')
 const web = require('../../dd-trace/src/plugins/util/web')
+const WebPlugin = require('../../datadog-plugin-web/src')
+const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
+const { storage } = require('../../datadog-core')
 
-// TODO: stop checking for fast star and fast slash
-
-const contexts = new WeakMap()
-const layerMatchers = new WeakMap()
-const regexpCache = Object.create(null)
-
-function createWrapHandle (tracer, config) {
-  return function wrapHandle (handle) {
-    return function handleWithTrace (req, res, done) {
-      web.patch(req)
-
-      if (!contexts.has(req)) {
-        const context = {
-          route: '',
-          stack: []
-        }
-
-        web.beforeEnd(req, () => {
-          web.enterRoute(req, context.route)
-        })
-
-        contexts.set(req, context)
-      }
-
-      return handle.apply(this, arguments)
-    }
+class RouterPlugin extends WebPlugin {
+  static get name () {
+    return 'router'
   }
-}
 
-function wrapRouterMethod (original) {
-  return function methodWithTrace (fn) {
-    const offset = this.stack ? [].concat(this.stack).length : 0
-    const router = original.apply(this, arguments)
+  constructor (...args) {
+    super(...args)
 
-    if (typeof this.stack === 'function') {
-      this.stack = [{ handle: this.stack }]
-    }
+    this._contexts = new WeakMap()
 
-    wrapStack(this.stack, offset, extractMatchers(fn))
-
-    return router
-  }
-}
+    this.addSub(`apm:${this.constructor.name}:middleware:enter`, ({ req, name, route }) => {
+      const store = storage.getStore()
+      const context = this._createContext(req, route)
+      const span = this._getMiddlewareSpan(context, store, name)
 
-function wrapLayerHandle (layer, handle) {
-  handle._name = handle._name || layer.name
+      this.enter(span, store)
 
-  let wrapCallHandle
-
-  if (handle.length === 4) {
-    wrapCallHandle = shimmer.wrap(handle, function (error, req, res, next) {
-      return callHandle(layer, handle, req, [error, req, res, wrapNext(layer, req, next)])
-    })
-  } else {
-    wrapCallHandle = shimmer.wrap(handle, function (req, res, next) {
-      return callHandle(layer, handle, req, [req, res, wrapNext(layer, req, next)])
+      web.patch(req)
+      web.setRoute(req, context.route)
     })
-  }
 
-  // This is a workaround for the `loopback` library so that it can find the correct express layer
-  // that contains the real handle function
-  wrapCallHandle._datadog_orig = handle
+    this.addSub(`apm:${this.constructor.name}:middleware:next`, ({ req }) => {
+      const context = this._contexts.get(req)
 
-  return wrapCallHandle
-}
+      if (!context) return
 
-function wrapStack (stack, offset, matchers) {
-  [].concat(stack).slice(offset).forEach(layer => {
-    if (layer.__handle) { // express-async-errors
-      layer.__handle = wrapLayerHandle(layer, layer.__handle)
-    } else {
-      layer.handle = wrapLayerHandle(layer, layer.handle)
-    }
-
-    layerMatchers.set(layer, matchers)
-
-    if (layer.route) {
-      METHODS.forEach(method => {
-        if (typeof layer.route.stack === 'function') {
-          layer.route.stack = [{ handle: layer.route.stack }]
-        }
+      context.stack.pop()
 
-        layer.route[method] = wrapRouterMethod(layer.route[method])
-      })
-    }
-  })
-}
+      if (context.middleware.length > 0) {
+        context.middleware.pop().finish()
+      }
+    })
 
-function wrapNext (layer, req, next) {
-  if (!next || !web.active(req)) return next
+    this.addSub(`apm:${this.constructor.name}:middleware:error`, this.addError)
 
-  const originalNext = next
-  const context = contexts.get(req)
-  const matchers = layerMatchers.get(layer)
+    this.addSub(`apm:http:server:request:finish`, ({ req }) => {
+      const context = this._contexts.get(req)
 
-  return function (error) {
-    if (layer.path && !isFastStar(layer, matchers) && !isFastSlash(layer, matchers)) {
-      context.stack.pop()
-    }
+      if (!context) return
 
-    web.finish(req, error)
+      let span
 
-    originalNext.apply(null, arguments)
+      while ((span = context.middleware.pop())) {
+        span.finish()
+      }
+    })
   }
-}
-
-function callHandle (layer, handle, req, args) {
-  const matchers = layerMatchers.get(layer)
 
-  if (web.active(req) && matchers) {
-    // Try to guess which path actually matched
-    for (let i = 0; i < matchers.length; i++) {
-      if (matchers[i].test(layer)) {
-        const context = contexts.get(req)
+  _getMiddlewareSpan (context, store, name) {
+    const childOf = store && store.span
 
-        context.stack.push(matchers[i].path)
-
-        const route = context.stack.join('')
-
-        // Longer route is more likely to be the actual route handler route.
-        if (route.length > context.route.length) {
-          context.route = route
-        }
+    if (this.config.middleware === false) {
+      return childOf
+    }
 
-        break
+    const span = this.tracer.startSpan(`${this.constructor.name}.middleware`, {
+      childOf,
+      tags: {
+        'resource.name': name || '<anonymous>'
       }
-    }
-  }
+    })
 
-  return web.wrapMiddleware(req, handle, 'express.middleware', () => {
-    return handle.apply(layer, args)
-  })
-}
+    context.middleware.push(span)
 
-function extractMatchers (fn) {
-  const arg = flatten([].concat(fn))
+    analyticsSampler.sample(span, this.config.measured)
 
-  if (typeof arg[0] === 'function') {
-    return []
+    return span
   }
 
-  return arg.map(pattern => ({
-    path: pattern instanceof RegExp ? `(${pattern})` : pattern,
-    test: layer => {
-      const matchers = layerMatchers.get(layer)
+  _createContext (req, route) {
+    let context = this._contexts.get(req)
 
-      return !isFastStar(layer, matchers) &&
-        !isFastSlash(layer, matchers) &&
-        cachedPathToRegExp(pattern).test(layer.path)
+    if (!route || route === '/' || route === '*') {
+      route = ''
     }
-  }))
-}
 
-function isFastStar (layer, matchers) {
-  if (layer.regexp.fast_star !== undefined) {
-    return layer.regexp.fast_star
-  }
+    if (context) {
+      context.stack.push(route)
 
-  return matchers.some(matcher => matcher.path === '*')
-}
+      route = context.stack.join('')
 
-function isFastSlash (layer, matchers) {
-  if (layer.regexp.fast_slash !== undefined) {
-    return layer.regexp.fast_slash
-  }
-
-  return matchers.some(matcher => matcher.path === '/')
-}
+      // Longer route is more likely to be the actual route handler route.
+      if (route.length > context.route.length) {
+        context.route = route
+      }
+    } else {
+      context = {
+        stack: [route],
+        route,
+        middleware: []
+      }
 
-function flatten (arr) {
-  return arr.reduce((acc, val) => Array.isArray(val) ? acc.concat(flatten(val)) : acc.concat(val), [])
-}
+      this._contexts.set(req, context)
+    }
 
-function cachedPathToRegExp (pattern) {
-  const maybeCached = regexpCache[pattern]
-  if (maybeCached) {
-    return maybeCached
+    return context
   }
-  const regexp = pathToRegExp(pattern)
-  regexpCache[pattern] = regexp
-  return regexp
 }
 
-module.exports = {
-  name: 'router',
-  versions: ['>=1'],
-  patch (Router, tracer, config) {
-    this.wrap(Router.prototype, 'handle', createWrapHandle(tracer, config))
-    this.wrap(Router.prototype, 'use', wrapRouterMethod)
-    this.wrap(Router.prototype, 'route', wrapRouterMethod)
-  },
-  unpatch (Router) {
-    this.unwrap(Router.prototype, 'handle')
-    this.unwrap(Router.prototype, 'use')
-    this.unwrap(Router.prototype, 'route')
-  }
-}
+module.exports = RouterPlugin

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

@@ -31,16 +31,12 @@ class SharedbPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub(`apm:sharedb:request:end`, () => {
-      this.exit()
-    })
-
     this.addSub(`apm:sharedb:request:error`, err => {
       const span = storage.getStore().span
       span.setTag('error', err)
     })
 
-    this.addSub(`apm:sharedb:request:async-end`, ({ request, res }) => {
+    this.addSub(`apm:sharedb:request:finish`, ({ request, res }) => {
       const span = storage.getStore().span
       if (this.config.hooks && this.config.hooks.reply) {
         this.config.hooks.reply(span, request, res)

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

@@ -35,16 +35,12 @@ class TediousPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub(`apm:tedious:request:end`, () => {
-      this.exit()
-    })
-
     this.addSub(`apm:tedious:request:error`, err => {
       const span = storage.getStore().span
       span.setTag('error', err)
     })
 
-    this.addSub(`apm:tedious:request:async-end`, () => {
+    this.addSub(`apm:tedious:request:finish`, () => {
       const span = storage.getStore().span
       span.finish()
     })

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

@@ -0,0 +1,20 @@
+'use strict'
+
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const web = require('../../dd-trace/src/plugins/util/web')
+
+class WebPlugin extends Plugin {
+  static get name () {
+    return 'web'
+  }
+
+  configure (config) {
+    return super.configure(web.normalizeConfig(config))
+  }
+
+  setFramework (req, name, config) {
+    web.setFramework(req, name, config)
+  }
+}
+
+module.exports = WebPlugin

package/packages/dd-trace/lib/version.js

@@ -1 +1 @@
-module.exports = '2.6.0'
+module.exports = '2.8.0'

package/packages/dd-trace/src/appsec/callbacks/ddwaf.js

@@ -33,10 +33,11 @@ class WAFCallback {
 
     Reporter.metricsQueue.set('_dd.appsec.waf.version', `${version.major}.${version.minor}.${version.patch}`)
 
-    const { loaded, failed } = this.ddwaf.rulesInfo
+    const { loaded, failed, errors } = this.ddwaf.rulesInfo
 
     Reporter.metricsQueue.set('_dd.appsec.event_rules.loaded', loaded)
     Reporter.metricsQueue.set('_dd.appsec.event_rules.error_count', failed)
+    if (failed) Reporter.metricsQueue.set('_dd.appsec.event_rules.errors', JSON.stringify(errors))
 
     Reporter.metricsQueue.set('manual.keep', true)
 
@@ -95,8 +96,12 @@ class WAFCallback {
 
     try {
       // TODO: possible optimizaion: only send params that haven't already been sent to this wafContext
+      const start = process.hrtime.bigint()
+
       const result = wafContext.run(params, this.wafTimeout)
 
+      result.durationExt = parseInt(process.hrtime.bigint() - start)
+
       return this.applyResult(result, store)
     } catch (err) {
       log.error('Error while running the AppSec WAF')
@@ -108,7 +113,8 @@ class WAFCallback {
 
   applyResult (result, store) {
     Reporter.reportMetrics({
-      duration: result.totalRuntime,
+      duration: result.totalRuntime / 1e3,
+      durationExt: result.durationExt / 1e3,
       rulesVersion: this.ddwaf.rulesInfo.version
     }, store)
 

package/packages/dd-trace/src/appsec/reporter.js

@@ -93,6 +93,10 @@ function reportMetrics (metrics, store) {
     topSpan.setTag('_dd.appsec.waf.duration', metrics.duration)
   }
 
+  if (metrics.durationExt) {
+    topSpan.setTag('_dd.appsec.waf.duration_ext', metrics.durationExt)
+  }
+
   if (metrics.rulesVersion) {
     topSpan.setTag('_dd.appsec.event_rules.version', metrics.rulesVersion)
   }

package/packages/dd-trace/src/encode/agentless-ci-visibility.js

@@ -2,6 +2,7 @@
 const { truncateSpan, normalizeSpan } = require('./tags-processors')
 const Chunk = require('./chunk')
 const { AgentEncoder } = require('./0.4')
+const { version: ddTraceVersion } = require('../../../../package.json')
 
 const ENCODING_VERSION = 1
 
@@ -156,7 +157,8 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
       version: ENCODING_VERSION,
       metadata: {
         '*': {
-          'language': 'javascript'
+          'language': 'javascript',
+          'library_version': ddTraceVersion
         }
       },
       events: []

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

@@ -27,9 +27,11 @@ function getConfig (name, config = {}) {
 module.exports = class PluginManager {
   constructor (tracer) {
     this._pluginsByName = {}
+    this._configsByName = {}
     for (const PluginClass of Object.values(plugins)) {
       if (typeof PluginClass !== 'function') continue
       this._pluginsByName[PluginClass.name] = new PluginClass(tracer)
+      this._configsByName[PluginClass.name] = {}
     }
   }
 
@@ -40,25 +42,29 @@ module.exports = class PluginManager {
       pluginConfig = { enabled: pluginConfig }
     }
 
-    this._pluginsByName[name].configure(getConfig(name, pluginConfig))
+    const config = {
+      ...this._configsByName[name],
+      ...pluginConfig
+    }
+
+    this._pluginsByName[name].configure(getConfig(name, config))
   }
 
   // like instrumenter.enable()
   configure (config) {
-    const serviceMapping = config.serviceMapping
+    const { logInjection, serviceMapping } = config
 
     if (config.plugins !== false) {
       for (const name in this._pluginsByName) {
-        const pluginConfig = {}
+        const pluginConfig = {
+          ...this._configsByName[name],
+          logInjection
+        }
         if (serviceMapping && serviceMapping[name]) {
           pluginConfig.service = serviceMapping[name]
         }
         this.configurePlugin(name, pluginConfig)
       }
-    } else {
-      for (const name in this._pluginsByName) {
-        this.configurePlugin(name, false)
-      }
     }
   }
 

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

@@ -14,6 +14,7 @@ module.exports = {
   'elasticsearch': require('../../../datadog-plugin-elasticsearch/src'),
   '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'),
@@ -23,10 +24,8 @@ module.exports = {
   'http2': require('../../../datadog-plugin-http2/src'),
   'ioredis': require('../../../datadog-plugin-ioredis/src'),
   'jest': require('../../../datadog-plugin-jest/src'),
-  'knex': require('../../../datadog-plugin-knex/src'),
   'koa': require('../../../datadog-plugin-koa/src'),
   'kafkajs': require('../../../datadog-plugin-kafkajs/src'),
-  'limitd-client': require('../../../datadog-plugin-limitd-client/src'),
   'memcached': require('../../../datadog-plugin-memcached/src'),
   'microgateway-core': require('../../../datadog-plugin-microgateway-core/src'),
   'mocha': require('../../../datadog-plugin-mocha/src'),

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

@@ -31,11 +31,8 @@ function messageProxy (message, holder) {
 module.exports = class LogPlugin extends Plugin {
   constructor (...args) {
     super(...args)
-    this.addSub(`apm:${this.constructor.name}:log`, (arg) => {
-      // TODO rather than checking this every time, setting it ought to enable/disable any plugin
-      // extending from this one
-      if (!this.tracer._logInjection) return
 
+    this.addSub(`apm:${this.constructor.name}:log`, (arg) => {
       const store = storage.getStore()
       const span = store && store.span
 
@@ -46,4 +43,11 @@ module.exports = class LogPlugin extends Plugin {
       arg.message = messageProxy(arg.message, holder)
     })
   }
+
+  configure (config) {
+    return super.configure({
+      ...config,
+      enabled: config.enabled && config.logInjection
+    })
+  }
 }

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

@@ -27,7 +27,6 @@ module.exports = class Plugin {
   constructor (tracer) {
     this._subscriptions = []
     this._enabled = false
-    this._storeStack = []
     this._tracer = tracer
   }
 
@@ -37,25 +36,26 @@ module.exports = class Plugin {
 
   enter (span, store) {
     store = store || storage.getStore()
-    this._storeStack.push(store)
     storage.enterWith({ ...store, span })
   }
 
   /** Prevents creation of spans here and for all async descendants. */
   skip () {
-    const store = storage.getStore()
-    this._storeStack.push(store)
     storage.enterWith({ noop: true })
   }
 
-  exit () {
-    storage.enterWith(this._storeStack.pop())
-  }
-
   addSub (channelName, handler) {
     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

@@ -22,6 +22,7 @@ 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 { version: ddTraceVersion } = require('../../../../../package.json')
 
 const TEST_FRAMEWORK = 'test.framework'
 const TEST_FRAMEWORK_VERSION = 'test.framework_version'
@@ -33,6 +34,7 @@ const TEST_PARAMETERS = 'test.parameters'
 const TEST_SKIP_REASON = 'test.skip_reason'
 const TEST_IS_RUM_ACTIVE = 'test.is_rum_active'
 const TEST_CODE_OWNERS = 'test.codeowners'
+const LIBRARY_VERSION = 'library_version'
 
 const ERROR_TYPE = 'error.type'
 const ERROR_MESSAGE = 'error.msg'
@@ -58,6 +60,7 @@ module.exports = {
   ERROR_MESSAGE,
   ERROR_STACK,
   CI_APP_ORIGIN,
+  LIBRARY_VERSION,
   getTestEnvironmentMetadata,
   getTestParametersString,
   finishAllTraceSpans,
@@ -149,7 +152,8 @@ function getTestCommonTags (name, suite, version) {
     [TEST_NAME]: name,
     [TEST_SUITE]: suite,
     [RESOURCE_NAME]: `${suite}.${name}`,
-    [TEST_FRAMEWORK_VERSION]: version
+    [TEST_FRAMEWORK_VERSION]: version,
+    [LIBRARY_VERSION]: ddTraceVersion
   }
 }
 

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,16 +97,7 @@ const web = {
     context.span = span
     context.res = res
 
-    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)
+    this.setConfig(req, config)
 
     return span
   },
@@ -111,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()
@@ -232,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)
     }
   },