dd-trace 2.9.0 → 2.11.0

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

@@ -1,149 +1,81 @@
 'use strict'
 
-// TODO: either instrument all or none of the render functions
-
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 
-const contexts = new WeakMap()
-
-function createWrapHandleRequest (tracer, config) {
-  return function wrapHandleRequest (handleRequest) {
-    return function handleRequestWithTrace (req, res, pathname, query) {
-      return trace(tracer, config, req, res, () => handleRequest.apply(this, arguments))
-    }
+class NextPlugin extends Plugin {
+  static get name () {
+    return 'next'
   }
-}
-
-function createWrapHandleApiRequest (tracer, config) {
-  return function wrapHandleApiRequest (handleApiRequest) {
-    return function handleApiRequestWithTrace (req, res, pathname, query) {
-      return trace(tracer, config, req, res, () => {
-        const promise = handleApiRequest.apply(this, arguments)
-
-        return promise.then(handled => {
-          if (!handled) return handled
 
-          const page = getPageFromPath(pathname, this.dynamicRoutes)
-
-          addPage(req, page)
-
-          return handled
-        })
+  constructor (...args) {
+    super(...args)
+
+    this._requests = new WeakMap()
+
+    this.addSub('apm:next:request:start', ({ req, res }) => {
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
+      const span = this.tracer.startSpan('next.request', {
+        childOf,
+        tags: {
+          'service.name': this.config.service || this.tracer._service,
+          'resource.name': 'test',
+          'span.type': 'web',
+          'span.kind': 'server',
+          'http.method': req.method
+        }
       })
-    }
-  }
-}
 
-function createWrapRenderToResponse (tracer, config) {
-  return function wrapRenderToResponse (renderToResponse) {
-    return function renderToResponseWithTrace (ctx) {
-      return trace(tracer, config, ctx.req, ctx.res, () => renderToResponse.apply(this, arguments))
-    }
-  }
-}
+      analyticsSampler.sample(span, this.config.measured, true)
 
-function createWrapRenderErrorToResponse (tracer, config) {
-  return function wrapRenderErrorToResponse (renderErrorToResponse) {
-    return function renderErrorToResponseWithTrace (ctx) {
-      return trace(tracer, config, ctx.req, ctx.res, () => renderErrorToResponse.apply(this, arguments))
-    }
-  }
-}
+      this.enter(span, store)
 
-function createWrapRenderToHTML (tracer, config) {
-  return function wrapRenderToHTML (renderToHTML) {
-    return function renderToHTMLWithTrace (req, res, pathname, query, parsedUrl) {
-      return trace(tracer, config, req, res, () => renderToHTML.apply(this, arguments))
-    }
-  }
-}
+      this._requests.set(span, req)
+    })
 
-function createWrapRenderErrorToHTML (tracer, config) {
-  return function wrapRenderErrorToHTML (renderErrorToHTML) {
-    return function renderErrorToHTMLWithTrace (err, req, res, pathname, query) {
-      return trace(tracer, config, req, res, () => renderErrorToHTML.apply(this, arguments))
-    }
-  }
-}
+    this.addSub('apm:next:request:error', this.addError)
 
-function createWrapFindPageComponents (tracer, config) {
-  return function wrapFindPageComponents (findPageComponents) {
-    return function findPageComponentsWithTrace (pathname, query) {
-      const result = findPageComponents.apply(this, arguments)
-      const span = tracer.scope().active()
-      const req = span && span._nextReq
+    this.addSub('apm:next:request:finish', ({ req, res }) => {
+      const store = storage.getStore()
 
-      if (result) {
-        addPage(req, pathname)
-      }
+      if (!store) return
 
-      return result
-    }
-  }
-}
-
-function getPageFromPath (page, dynamicRoutes = []) {
-  for (const dynamicRoute of dynamicRoutes) {
-    if (dynamicRoute.page.startsWith('/api') && dynamicRoute.match(page)) {
-      return dynamicRoute.page
-    }
-  }
-
-  return page
-}
-
-function trace (tracer, config, req, res, handler) {
-  const scope = tracer.scope()
-  const context = contexts.get(req)
-
-  if (context) return scope.activate(context.span, handler)
-
-  const childOf = scope.active()
-  const tags = {
-    'service.name': config.service || tracer._service,
-    'resource.name': req.method,
-    'span.type': 'web',
-    'span.kind': 'server',
-    'http.method': req.method
-  }
-  const span = tracer.startSpan('next.request', { childOf, tags })
+      const span = store.span
+      const error = span.context()._tags['error']
 
-  analyticsSampler.sample(span, config.measured, true)
+      if (!this.config.validateStatus(res.statusCode) && !error) {
+        span.setTag('error', true)
+      }
 
-  contexts.set(req, { span })
+      span.addTags({
+        'http.status_code': res.statusCode
+      })
 
-  const promise = scope.activate(span, handler)
+      this.config.hooks.request(span, req, res)
 
-  // HACK: Store the request object on the span for findPageComponents.
-  // TODO: Use CLS when it will be available in core.
-  span._nextReq = req
+      span.finish()
+    })
 
-  return promise.then(
-    result => finish(span, config, req, res, result),
-    err => finish(span, config, req, res, null, err)
-  )
-}
+    this.addSub('apm:next:page:load', ({ page }) => {
+      const store = storage.getStore()
 
-function addPage (req, page) {
-  const context = contexts.get(req)
+      if (!store) return
 
-  if (!context) return
-
-  context.span.addTags({
-    'resource.name': `${req.method} ${page}`.trim(),
-    'next.page': page
-  })
-}
+      const span = store.span
+      const req = this._requests.get(span)
 
-function finish (span, config, req, res, result, err) {
-  span.setTag('error', err || !config.validateStatus(res.statusCode))
-  span.addTags({
-    'http.status_code': res.statusCode
-  })
-  config.hooks.request(span, req, res)
-  span.finish()
+      span.addTags({
+        'resource.name': `${req.method} ${page}`.trim(),
+        'next.page': page
+      })
+    })
+  }
 
-  return result || err
+  configure (config) {
+    return super.configure(normalizeConfig(config))
+  }
 }
 
 function normalizeConfig (config) {
@@ -162,48 +94,4 @@ function getHooks (config) {
   return { request }
 }
 
-module.exports = [
-  {
-    name: 'next',
-    versions: ['>=9.5 <11.1'],
-    file: 'dist/next-server/server/next-server.js',
-    patch ({ default: Server }, tracer, config) {
-      config = normalizeConfig(config)
-
-      this.wrap(Server.prototype, 'handleRequest', createWrapHandleRequest(tracer, config))
-      this.wrap(Server.prototype, 'handleApiRequest', createWrapHandleApiRequest(tracer, config))
-      this.wrap(Server.prototype, 'renderToHTML', createWrapRenderToHTML(tracer, config))
-      this.wrap(Server.prototype, 'renderErrorToHTML', createWrapRenderErrorToHTML(tracer, config))
-      this.wrap(Server.prototype, 'findPageComponents', createWrapFindPageComponents(tracer, config))
-    },
-    unpatch ({ default: Server }) {
-      this.unwrap(Server.prototype, 'handleRequest')
-      this.unwrap(Server.prototype, 'handleApiRequest')
-      this.unwrap(Server.prototype, 'renderToHTML')
-      this.unwrap(Server.prototype, 'renderErrorToHTML')
-      this.unwrap(Server.prototype, 'findPageComponents')
-    }
-  },
-
-  {
-    name: 'next',
-    versions: ['>=11.1'],
-    file: 'dist/server/next-server.js',
-    patch ({ default: Server }, tracer, config) {
-      config = normalizeConfig(config)
-
-      this.wrap(Server.prototype, 'handleRequest', createWrapHandleRequest(tracer, config))
-      this.wrap(Server.prototype, 'handleApiRequest', createWrapHandleApiRequest(tracer, config))
-      this.wrap(Server.prototype, 'renderToResponse', createWrapRenderToResponse(tracer, config))
-      this.wrap(Server.prototype, 'renderErrorToResponse', createWrapRenderErrorToResponse(tracer, config))
-      this.wrap(Server.prototype, 'findPageComponents', createWrapFindPageComponents(tracer, config))
-    },
-    unpatch ({ default: Server }) {
-      this.unwrap(Server.prototype, 'handleRequest')
-      this.unwrap(Server.prototype, 'handleApiRequest')
-      this.unwrap(Server.prototype, 'renderToResponse')
-      this.unwrap(Server.prototype, 'renderErrorToResponse')
-      this.unwrap(Server.prototype, 'findPageComponents')
-    }
-  }
-]
+module.exports = NextPlugin

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

@@ -32,10 +32,14 @@ class RouterPlugin extends WebPlugin {
       if (!context) return
 
       context.stack.pop()
+    })
 
-      if (context.middleware.length > 0) {
-        context.middleware.pop().finish()
-      }
+    this.addSub(`apm:${this.constructor.name}:middleware:exit`, ({ req }) => {
+      const context = this._contexts.get(req)
+
+      if (!context || context.middleware.length === 0) return
+
+      context.middleware.pop().finish()
     })
 
     this.addSub(`apm:${this.constructor.name}:middleware:error`, this.addError)

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

@@ -93,7 +93,7 @@ class Config {
     )
     const DD_TRACE_TELEMETRY_ENABLED = coalesce(
       process.env.DD_TRACE_TELEMETRY_ENABLED,
-      true
+      !process.env.AWS_LAMBDA_FUNCTION_NAME
     )
     const DD_TRACE_DEBUG = coalesce(
       process.env.DD_TRACE_DEBUG,
@@ -237,7 +237,8 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
     }
     this.lookup = options.lookup
     this.startupLogs = isTrue(DD_TRACE_STARTUP_LOGS)
-    this.telemetryEnabled = isTrue(DD_TRACE_TELEMETRY_ENABLED)
+    // Disabled for CI Visibility's agentless
+    this.telemetryEnabled = DD_TRACE_EXPORTER !== 'datadog' && isTrue(DD_TRACE_TELEMETRY_ENABLED)
     this.protocolVersion = DD_TRACE_AGENT_PROTOCOL_VERSION
     this.appsec = {
       enabled: isTrue(DD_APPSEC_ENABLED),

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

@@ -4,7 +4,7 @@ const request = require('../common/request')
 const { startupLog } = require('../../startup-log')
 const metrics = require('../../metrics')
 const log = require('../../log')
-const tracerVersion = require('../../../lib/version')
+const tracerVersion = require('../../../../../package.json').version
 const BaseWriter = require('../common/writer')
 
 const METRIC_PREFIX = 'datadog.tracer.node.exporter.agent'

package/packages/dd-trace/src/opentracing/span.js

@@ -13,7 +13,10 @@ const metrics = require('../metrics')
 const log = require('../log')
 const { storage } = require('../../../datadog-core')
 
-const { DD_TRACE_EXPERIMENTAL_STATE_TRACKING } = process.env
+const {
+  DD_TRACE_EXPERIMENTAL_STATE_TRACKING,
+  DD_TRACE_EXPERIMENTAL_SPAN_COUNTS
+} = process.env
 
 const unfinishedRegistry = createRegistry('unfinished')
 const finishedRegistry = createRegistry('finished')
@@ -41,7 +44,7 @@ class DatadogSpan extends Span {
 
     this._startTime = fields.startTime || this._getTime()
 
-    if (this._debug && unfinishedRegistry) {
+    if (DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
       metrics.increment('runtime.node.spans.unfinished')
       metrics.increment('runtime.node.spans.unfinished.by.name', `span_name:${operationName}`)
 
@@ -137,7 +140,7 @@ class DatadogSpan extends Span {
       }
     }
 
-    if (this._debug && finishedRegistry) {
+    if (DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
       metrics.decrement('runtime.node.spans.unfinished')
       metrics.decrement('runtime.node.spans.unfinished.by.name', `span_name:${this._name}`)
       metrics.increment('runtime.node.spans.finished')

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

@@ -2,6 +2,7 @@
 
 const { isTrue } = require('./util')
 const plugins = require('./plugins')
+const log = require('./log')
 
 // instrument everything that needs Plugin System V2 instrumentation
 require('../../datadog-instrumentations')
@@ -21,6 +22,15 @@ function getConfig (name, config = {}) {
   return config
 }
 
+// TODO: maybe needs to DRY up as well, but depending on how the remaining old plugins
+// are migrated to the new system, can stay here for now, since this is the level
+// this check maybe should be happening on, even if it deals with env variabls
+const disabledPlugins = process.env.DD_TRACE_DISABLED_PLUGINS
+
+const collectDisabledPlugins = () => {
+  return new Set(disabledPlugins && disabledPlugins.split(',').map(plugin => plugin.trim()))
+}
+
 // TODO actually ... should we be looking at envrionment variables this deep down in the code?
 
 // TODO this must always be a singleton.
@@ -28,7 +38,18 @@ module.exports = class PluginManager {
   constructor (tracer) {
     this._pluginsByName = {}
     this._configsByName = {}
+
+    const _disabledPlugins = collectDisabledPlugins()
+
     for (const PluginClass of Object.values(plugins)) {
+      /**
+       * disabling the plugin here instead of in `configure` so we don't waste subscriber
+       * resources on a plugin that will eventually be disabled anyways
+       */
+      if (_disabledPlugins.has(PluginClass.name)) {
+        log.debug(`Plugin "${PluginClass.name}" was disabled via configuration option.`)
+        continue
+      }
       if (typeof PluginClass !== 'function') continue
       this._pluginsByName[PluginClass.name] = new PluginClass(tracer)
       this._configsByName[PluginClass.name] = {}

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

@@ -53,7 +53,9 @@ module.exports = class Plugin {
 
     if (!store || !store.span) return
 
-    store.span.setTag('error', error)
+    if (!store.span._spanContext._tags['error']) {
+      store.span.setTag('error', error || 1)
+    }
   }
 
   configure (config) {

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

@@ -34,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 TEST_SOURCE_FILE = 'test.source.file'
 const LIBRARY_VERSION = 'library_version'
 
 const ERROR_TYPE = 'error.type'
@@ -56,6 +57,7 @@ module.exports = {
   TEST_PARAMETERS,
   TEST_SKIP_REASON,
   TEST_IS_RUM_ACTIVE,
+  TEST_SOURCE_FILE,
   ERROR_TYPE,
   ERROR_MESSAGE,
   ERROR_STACK,
@@ -151,6 +153,7 @@ function getTestCommonTags (name, suite, version) {
     [SAMPLING_PRIORITY]: AUTO_KEEP,
     [TEST_NAME]: name,
     [TEST_SUITE]: suite,
+    [TEST_SOURCE_FILE]: suite,
     [RESOURCE_NAME]: `${suite}.${name}`,
     [TEST_FRAMEWORK_VERSION]: version,
     [LIBRARY_VERSION]: ddTraceVersion

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

@@ -106,7 +106,6 @@ const web = {
     const context = contexts.get(req)
     if (!context.instrumented) {
       this.wrapEnd(context)
-      this.wrapEvents(context)
       context.instrumented = true
     }
   },
@@ -355,12 +354,6 @@ const web = {
         ends.set(this, scope.bind(value, context.span))
       }
     })
-  },
-  wrapEvents (context) {
-    const scope = context.tracer.scope()
-    const res = context.res
-
-    scope.bind(res, context.span)
   }
 }
 

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

@@ -6,7 +6,7 @@ const FormData = require('form-data')
 
 // TODO: avoid using dd-trace internals. Make this a separate module?
 const docker = require('../../exporters/common/docker')
-const version = require('../../../lib/version')
+const version = require('../../../../../package.json').version
 
 const containerId = docker.id()
 

package/packages/dd-trace/src/startup-log.js

@@ -4,7 +4,7 @@ const mainLogger = require('./log')
 
 const os = require('os')
 const { inspect } = require('util')
-const tracerVersion = require('../lib/version')
+const tracerVersion = require('../../../package.json').version
 const requirePackageJson = require('./require-package-json')
 
 const logger = Object.create(mainLogger)

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const tracerVersion = require('../lib/version')
+const tracerVersion = require('../../../package.json').version
 const pkg = require('./pkg')
 const containerId = require('./exporters/common/docker').id()
 const requirePackageJson = require('./require-package-json')

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

@@ -1 +0,0 @@
-module.exports = '2.9.0'