dd-trace 2.9.1 → 2.12.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': req.method,
+          '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

@@ -16,11 +16,15 @@ class RouterPlugin extends WebPlugin {
     this._contexts = new WeakMap()
 
     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)
+      const childOf = this._getActive(req)
+      const span = this._getMiddlewareSpan(name, childOf)
+      const context = this._createContext(req, route, childOf)
+
+      if (childOf !== span) {
+        context.middleware.push(span)
+      }
 
-      this.enter(span, store)
+      this.enter(span)
 
       web.patch(req)
       web.setRoute(req, context.route)
@@ -32,13 +36,25 @@ 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)
+    this.addSub(`apm:${this.constructor.name}:middleware:error`, err => {
+      const store = storage.getStore()
+
+      web.addError(store.req, err)
+
+      if (this.config.middleware) {
+        this.addError(err)
+      }
+    })
 
     this.addSub(`apm:http:server:request:finish`, ({ req }) => {
       const context = this._contexts.get(req)
@@ -53,9 +69,22 @@ class RouterPlugin extends WebPlugin {
     })
   }
 
-  _getMiddlewareSpan (context, store, name) {
-    const childOf = store && store.span
+  _getActive (req) {
+    const context = this._contexts.get(req)
+
+    if (!context) return this._getStoreSpan()
+    if (context.middleware.length === 0) return context.span
+
+    return context.middleware[context.middleware.length - 1]
+  }
+
+  _getStoreSpan () {
+    const store = storage.getStore()
 
+    return store && store.span
+  }
+
+  _getMiddlewareSpan (name, childOf) {
     if (this.config.middleware === false) {
       return childOf
     }
@@ -67,14 +96,12 @@ class RouterPlugin extends WebPlugin {
       }
     })
 
-    context.middleware.push(span)
-
     analyticsSampler.sample(span, this.config.measured)
 
     return span
   }
 
-  _createContext (req, route) {
+  _createContext (req, route, span) {
     let context = this._contexts.get(req)
 
     if (!route || route === '/' || route === '*') {
@@ -92,6 +119,7 @@ class RouterPlugin extends WebPlugin {
       }
     } else {
       context = {
+        span,
         stack: [route],
         route,
         middleware: []

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/encode/agentless-ci-visibility.js

@@ -3,13 +3,25 @@ const { truncateSpan, normalizeSpan } = require('./tags-processors')
 const Chunk = require('./chunk')
 const { AgentEncoder } = require('./0.4')
 const { version: ddTraceVersion } = require('../../../../package.json')
+const id = require('../../../dd-trace/src/id')
 
 const ENCODING_VERSION = 1
 
+const ALLOWED_CONTENT_TYPES = ['test_session_end', 'test_suite_end', 'test']
+
+const TEST_SUITE_KEYS_LENGTH = 11
+const TEST_SESSION_KEYS_LENGTH = 10
+
+const CHUNK_SIZE = 4 * 1024 * 1024 // 4MB
+
 function formatSpan (span) {
+  let encodingVersion = ENCODING_VERSION
+  if (span.type === 'test' && span.meta && span.meta.test_session_id) {
+    encodingVersion = 2
+  }
   return {
-    type: span.type === 'test' ? 'test' : 'span',
-    version: ENCODING_VERSION,
+    type: ALLOWED_CONTENT_TYPES.includes(span.type) ? span.type : 'span',
+    version: encodingVersion,
     content: normalizeSpan(truncateSpan(span))
   }
 }
@@ -21,8 +33,8 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     this.runtimeId = runtimeId
     this.service = service
     this.env = env
-    this._traceBytes = new Chunk()
-    this._stringBytes = new Chunk()
+    this._traceBytes = new Chunk(CHUNK_SIZE)
+    this._stringBytes = new Chunk(CHUNK_SIZE)
     this._stringCount = 0
     this._stringMap = {}
 
@@ -33,8 +45,69 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     this.reset()
   }
 
+  _encodeTestSuite (bytes, content) {
+    this._encodeMapPrefix(bytes, TEST_SUITE_KEYS_LENGTH)
+    this._encodeString(bytes, 'type')
+    this._encodeString(bytes, content.type)
+
+    this._encodeString(bytes, 'test_session_id')
+    this._encodeId(bytes, content.trace_id)
+
+    this._encodeString(bytes, 'test_suite_id')
+    this._encodeId(bytes, content.span_id)
+
+    this._encodeString(bytes, 'error')
+    this._encodeNumber(bytes, content.error)
+    this._encodeString(bytes, 'name')
+    this._encodeString(bytes, content.name)
+    this._encodeString(bytes, 'service')
+    this._encodeString(bytes, content.service)
+    this._encodeString(bytes, 'resource')
+    this._encodeString(bytes, content.resource)
+    this._encodeString(bytes, 'start')
+    this._encodeNumber(bytes, content.start)
+    this._encodeString(bytes, 'duration')
+    this._encodeNumber(bytes, content.duration)
+    this._encodeString(bytes, 'meta')
+    this._encodeMap(bytes, content.meta)
+    this._encodeString(bytes, 'metrics')
+    this._encodeMap(bytes, content.metrics)
+  }
+
+  _encodeTestSession (bytes, content) {
+    this._encodeMapPrefix(bytes, TEST_SESSION_KEYS_LENGTH)
+    this._encodeString(bytes, 'type')
+    this._encodeString(bytes, content.type)
+
+    this._encodeString(bytes, 'test_session_id')
+    this._encodeId(bytes, content.trace_id)
+
+    this._encodeString(bytes, 'error')
+    this._encodeNumber(bytes, content.error)
+    this._encodeString(bytes, 'name')
+    this._encodeString(bytes, content.name)
+    this._encodeString(bytes, 'service')
+    this._encodeString(bytes, content.service)
+    this._encodeString(bytes, 'resource')
+    this._encodeString(bytes, content.resource)
+    this._encodeString(bytes, 'start')
+    this._encodeNumber(bytes, content.start)
+    this._encodeString(bytes, 'duration')
+    this._encodeNumber(bytes, content.duration)
+    this._encodeString(bytes, 'meta')
+    this._encodeMap(bytes, content.meta)
+    this._encodeString(bytes, 'metrics')
+    this._encodeMap(bytes, content.metrics)
+  }
+
   _encodeEventContent (bytes, content) {
-    this._encodeMapPrefix(bytes, content)
+    const keysLength = Object.keys(content).length
+    if (content.meta.test_session_id) {
+      this._encodeMapPrefix(bytes, keysLength + 2)
+    } else {
+      this._encodeMapPrefix(bytes, keysLength)
+    }
+
     if (content.type) {
       this._encodeString(bytes, 'type')
       this._encodeString(bytes, content.type)
@@ -57,6 +130,24 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     this._encodeNumber(bytes, content.start)
     this._encodeString(bytes, 'duration')
     this._encodeNumber(bytes, content.duration)
+    /**
+     * We include `test_session_id` and `test_suite_id`
+     * in the root of the event by passing them via the `meta` dict.
+     * This is to avoid changing the span format in packages/dd-trace/src/format.js,
+     * which can have undesired side effects in other products.
+     * But `test_session_id` and `test_suite_id` are *not* supposed to be in `meta`,
+     * so we delete them before enconding the dictionary.
+     * TODO: find a better way to do this.
+     */
+    if (content.meta.test_session_id) {
+      this._encodeString(bytes, 'test_session_id')
+      this._encodeId(bytes, id(content.meta.test_session_id))
+      delete content.meta.test_session_id
+
+      this._encodeString(bytes, 'test_suite_id')
+      this._encodeId(bytes, id(content.meta.test_suite_id))
+      delete content.meta.test_suite_id
+    }
     this._encodeString(bytes, 'meta')
     this._encodeMap(bytes, content.meta)
     this._encodeString(bytes, 'metrics')
@@ -64,7 +155,7 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
   }
 
   _encodeEvent (bytes, event) {
-    this._encodeMapPrefix(bytes, event)
+    this._encodeMapPrefix(bytes, Object.keys(event).length)
     this._encodeString(bytes, 'type')
     this._encodeString(bytes, event.type)
 
@@ -72,7 +163,13 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     this._encodeNumber(bytes, event.version)
 
     this._encodeString(bytes, 'content')
-    this._encodeEventContent(bytes, event.content)
+    if (event.type === 'span' || event.type === 'test') {
+      this._encodeEventContent(bytes, event.content)
+    } else if (event.type === 'test_suite_end') {
+      this._encodeTestSuite(bytes, event.content)
+    } else if (event.type === 'test_session_end') {
+      this._encodeTestSession(bytes, event.content)
+    }
   }
 
   _encodeNumber (bytes, value) {
@@ -107,18 +204,17 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     buffer[offset + 8] = lo
   }
 
-  _encodeMapPrefix (bytes, map) {
-    const keys = Object.keys(map)
+  _encodeMapPrefix (bytes, keysLength) {
     const buffer = bytes.buffer
     const offset = bytes.length
 
     bytes.reserve(5)
     bytes.length += 5
     buffer[offset] = 0xdf
-    buffer[offset + 1] = keys.length >> 24
-    buffer[offset + 2] = keys.length >> 16
-    buffer[offset + 3] = keys.length >> 8
-    buffer[offset + 4] = keys.length
+    buffer[offset + 1] = keysLength >> 24
+    buffer[offset + 2] = keysLength >> 16
+    buffer[offset + 3] = keysLength >> 8
+    buffer[offset + 4] = keysLength
   }
 
   _encode (bytes, trace) {
@@ -171,11 +267,11 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
       payload.metadata['*']['runtime-id'] = this.runtimeId
     }
 
-    this._encodeMapPrefix(bytes, payload)
+    this._encodeMapPrefix(bytes, Object.keys(payload).length)
     this._encodeString(bytes, 'version')
     this._encodeNumber(bytes, payload.version)
     this._encodeString(bytes, 'metadata')
-    this._encodeMapPrefix(bytes, payload.metadata)
+    this._encodeMapPrefix(bytes, Object.keys(payload.metadata).length)
     this._encodeString(bytes, '*')
     this._encodeMap(bytes, payload.metadata['*'])
     this._encodeString(bytes, 'events')

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')