dd-trace 2.2.0 → 2.3.1

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

@@ -7,6 +7,7 @@ const { incomingHttpRequestStart, incomingHttpRequestEnd } = require('./gateway/
 const Gateway = require('./gateway/engine')
 const addresses = require('./addresses')
 const Reporter = require('./reporter')
+const web = require('../plugins/util/web')
 
 function enable (config) {
   try {
@@ -39,7 +40,7 @@ function enable (config) {
 
 function incomingHttpStartTranslator (data) {
   // TODO: get span from datadog-core storage instead
-  const topSpan = data.req._datadog && data.req._datadog.span
+  const topSpan = web.root(data.req)
   if (topSpan) {
     topSpan.addTags({
       '_dd.appsec.enabled': 1,

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

@@ -2,6 +2,7 @@
 
 const addresses = require('./addresses')
 const Limiter = require('../rate_limiter')
+const web = require('../plugins/util/web')
 
 // default limiter, configurable with setRateLimit()
 let limiter = new Limiter(100)
@@ -83,7 +84,7 @@ function formatHeaderName (name) {
 
 function reportAttack (attackData, store) {
   const req = store && store.get('req')
-  const topSpan = req && req._datadog && req._datadog.span
+  const topSpan = web.root(req)
   if (!topSpan) return false
 
   const currentTags = topSpan.context()._tags
@@ -129,7 +130,7 @@ function reportAttack (attackData, store) {
 }
 
 function finishAttacks (req, context) {
-  const topSpan = req && req._datadog && req._datadog.span
+  const topSpan = web.root(req)
   if (!topSpan || !context) return false
 
   const resolvedResponse = resolveHTTPResponse(context)

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

@@ -99,6 +99,11 @@ class Config {
       process.env.DD_TRACE_AGENT_PROTOCOL_VERSION,
       '0.4'
     )
+    const DD_TRACE_PARTIAL_FLUSH_MIN_SPANS = coalesce(
+      parseInt(options.flushMinSpans),
+      parseInt(process.env.DD_TRACE_PARTIAL_FLUSH_MIN_SPANS),
+      1000
+    )
     const DD_TRACE_B3_ENABLED = coalesce(
       options.experimental && options.experimental.b3,
       process.env.DD_TRACE_EXPERIMENTAL_B3_ENABLED,
@@ -166,6 +171,7 @@ class Config {
     this.hostname = DD_AGENT_HOST || (this.url && this.url.hostname)
     this.port = String(DD_TRACE_AGENT_PORT || (this.url && this.url.port))
     this.flushInterval = coalesce(parseInt(options.flushInterval, 10), defaultFlushInterval)
+    this.flushMinSpans = DD_TRACE_PARTIAL_FLUSH_MIN_SPANS
     this.sampleRate = coalesce(Math.min(Math.max(sampler.sampleRate, 0), 1), 1)
     this.logger = options.logger
     this.plugins = !!coalesce(options.plugins, true)
@@ -229,7 +235,7 @@ function getAgentUrl (url, options) {
     !process.env.DD_TRACE_AGENT_PORT &&
     fs.existsSync('/var/run/datadog/apm.socket')
   ) {
-    return new URL('file:///var/run/datadog/apm.socket')
+    return new URL('unix:///var/run/datadog/apm.socket')
   }
 }
 

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

@@ -8,10 +8,5 @@ module.exports = {
   SAMPLING_RULE_DECISION: '_dd.rule_psr',
   SAMPLING_LIMIT_DECISION: '_dd.limit_psr',
   SAMPLING_AGENT_DECISION: '_dd.agent_psr',
-  SAMPLING_MECHANISM_DEFAULT: 0,
-  SAMPLING_MECHANISM_AGENT: 1,
-  SAMPLING_MECHANISM_RULE: 3,
-  SAMPLING_MECHANISM_MANUAL: 4,
-  DATADOG_LAMBDA_EXTENSION_PATH: '/opt/extensions/datadog-agent',
-  UPSTREAM_SERVICES_KEY: '_dd.p.upstream_services'
+  DATADOG_LAMBDA_EXTENSION_PATH: '/opt/extensions/datadog-agent'
 }

package/packages/dd-trace/src/opentracing/propagation/text_map.js

@@ -11,7 +11,6 @@ const traceKey = 'x-datadog-trace-id'
 const spanKey = 'x-datadog-parent-id'
 const originKey = 'x-datadog-origin'
 const samplingKey = 'x-datadog-sampling-priority'
-const tagsKey = 'x-datadog-tags'
 const baggagePrefix = 'ot-baggage-'
 const b3TraceKey = 'x-b3-traceid'
 const b3TraceExpr = /^([0-9a-f]{16}){1,2}$/i
@@ -41,7 +40,6 @@ class TextMapPropagator {
     this._injectSamplingPriority(spanContext, carrier)
     this._injectBaggageItems(spanContext, carrier)
     this._injectB3(spanContext, carrier)
-    this._injectTags(spanContext, carrier)
 
     log.debug(() => `Inject into carrier: ${JSON.stringify(pick(carrier, logKeys))}.`)
   }
@@ -78,25 +76,6 @@ class TextMapPropagator {
     })
   }
 
-  _injectTags (spanContext, carrier) {
-    const trace = spanContext._trace
-    const tags = []
-
-    for (const key in trace.tags) {
-      if (!key.startsWith('_dd.p.')) continue
-
-      tags.push(`${key}=${trace.tags[key]}`)
-    }
-
-    const header = tags.join(',')
-
-    if (header.length <= 512) {
-      carrier[tagsKey] = header
-    } else {
-      trace.tags['_dd.propagation_error:max_size'] = 1
-    }
-  }
-
   _injectB3 (spanContext, carrier) {
     if (!this._config.experimental.b3) return
 
@@ -124,7 +103,6 @@ class TextMapPropagator {
       this._extractOrigin(carrier, spanContext)
       this._extractBaggageItems(carrier, spanContext)
       this._extractSamplingPriority(carrier, spanContext)
-      this._extractTags(carrier, spanContext)
     }
 
     return spanContext
@@ -262,18 +240,6 @@ class TextMapPropagator {
     }
   }
 
-  _extractTags (carrier, spanContext) {
-    if (!carrier[tagsKey]) return
-
-    const pairs = carrier[tagsKey].split(',')
-
-    for (const pair of pairs) {
-      const [key, value] = pair.split('=')
-
-      spanContext._trace.tags[key] = value
-    }
-  }
-
   _getPriority (sampled, debug) {
     if (debug) {
       return USER_KEEP

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

@@ -35,7 +35,7 @@ class DatadogTracer extends Tracer {
     this._debug = config.debug
     this._prioritySampler = new PrioritySampler(config.env, config.experimental.sampler)
     this._exporter = new Exporter(config, this._prioritySampler)
-    this._processor = new SpanProcessor(this._exporter, this._prioritySampler)
+    this._processor = new SpanProcessor(this._exporter, this._prioritySampler, config)
     this._url = this._exporter._url
     this._enableGetRumData = config.experimental.enableGetRumData
     this._propagators = {

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

@@ -15,7 +15,6 @@ module.exports = {
   'express': require('../../../datadog-plugin-express/src'),
   'fastify': require('../../../datadog-plugin-fastify/src'),
   'fs': require('../../../datadog-plugin-fs/src'),
-  'generic-pool': require('../../../datadog-plugin-generic-pool/src'),
   'google-cloud-pubsub': require('../../../datadog-plugin-google-cloud-pubsub/src'),
   'graphql': require('../../../datadog-plugin-graphql/src'),
   'grpc': require('../../../datadog-plugin-grpc/src'),
@@ -33,7 +32,6 @@ module.exports = {
   'mocha': require('../../../datadog-plugin-mocha/src'),
   'moleculer': require('../../../datadog-plugin-moleculer/src'),
   'mongodb-core': require('../../../datadog-plugin-mongodb-core/src'),
-  'mongoose': require('../../../datadog-plugin-mongoose/src'),
   'mysql': require('../../../datadog-plugin-mysql/src'),
   'mysql2': require('../../../datadog-plugin-mysql2/src'),
   'net': require('../../../datadog-plugin-net/src'),

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

@@ -0,0 +1,49 @@
+'use strict'
+
+const { LOG } = require('../../../../ext/formats')
+const Plugin = require('./plugin')
+const { storage } = require('../../../datadog-core')
+
+const hasOwn = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop)
+
+function messageProxy (message, holder) {
+  return new Proxy(message, {
+    get (target, p, receiver) {
+      switch (p) {
+        case Symbol.toStringTag:
+          return Object.prototype.toString.call(target).slice(8, -1)
+        case 'dd':
+          return holder.dd
+        default:
+          return Reflect.get(target, p, receiver)
+      }
+    },
+    ownKeys (target) {
+      const ownKeys = Reflect.ownKeys(target)
+      return hasOwn(target, 'dd') ? ownKeys : ['dd', ...ownKeys]
+    },
+    getOwnPropertyDescriptor (target, p) {
+      return Reflect.getOwnPropertyDescriptor(p === 'dd' ? holder : target, p)
+    }
+  })
+}
+
+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
+
+      const store = storage.getStore()
+      const span = store && store.span
+
+      if (!span) return
+
+      const holder = {}
+      this.tracer.inject(span, LOG, holder)
+      arg.message = messageProxy(arg.message, holder)
+    })
+  }
+}

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

@@ -42,6 +42,13 @@ module.exports = class Plugin {
     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())
   }

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

@@ -37,7 +37,7 @@ function getGitMetadata (ciMetadata) {
     committerName,
     committerEmail,
     committerDate
-  ] = sanitizedExec('git show -s --format=%an,%ae,%ad,%cn,%ce,%cd', { stdio: 'pipe' }).split(',')
+  ] = sanitizedExec('git show -s --format=%an,%ae,%aI,%cn,%ce,%cI', { stdio: 'pipe' }).split(',')
 
   return {
     [GIT_REPOSITORY_URL]:

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

@@ -29,6 +29,9 @@ const HTTP2_HEADER_AUTHORITY = ':authority'
 const HTTP2_HEADER_SCHEME = ':scheme'
 const HTTP2_HEADER_PATH = ':path'
 
+const contexts = new WeakMap()
+const ends = new WeakMap()
+
 const web = {
   // Ensure the configuration has the correct structure and defaults.
   normalizeConfig (config) {
@@ -51,8 +54,7 @@ const web = {
 
   // Start a span and activate a scope for a request.
   instrument (tracer, config, req, res, name, callback) {
-    this.patch(req)
-
+    const context = this.patch(req)
     const span = startSpan(tracer, config, req, res, name)
 
     if (!config.filter(req.url)) {
@@ -65,11 +67,11 @@ const web = {
 
     analyticsSampler.sample(span, config.measured, true)
 
-    if (!req._datadog.instrumented) {
-      wrapEnd(req)
-      wrapEvents(req)
+    if (!context.instrumented) {
+      wrapEnd(context)
+      wrapEvents(context)
 
-      req._datadog.instrumented = true
+      context.instrumented = true
     }
 
     return callback && tracer.scope().activate(span, () => callback(span))
@@ -83,22 +85,23 @@ const web = {
   // Add a route segment that will be used for the resource name.
   enterRoute (req, path) {
     if (typeof path === 'string') {
-      req._datadog.paths.push(path)
+      contexts.get(req).paths.push(path)
     }
   },
 
   // Remove the current route segment.
   exitRoute (req) {
-    req._datadog.paths.pop()
+    contexts.get(req).paths.pop()
   },
 
   // Start a new middleware span and activate a new scope with the span.
   wrapMiddleware (req, middleware, name, fn) {
     if (!this.active(req)) return fn()
 
-    const tracer = req._datadog.tracer
+    const context = contexts.get(req)
+    const tracer = context.tracer
     const childOf = this.active(req)
-    const config = req._datadog.config
+    const config = context.config
 
     if (config.middleware === false) return this.bindAndWrapMiddlewareErrors(fn, req, tracer, childOf)
 
@@ -110,7 +113,7 @@ const web = {
       [RESOURCE_NAME]: middleware._name || middleware.name || '<anonymous>'
     })
 
-    req._datadog.middleware.push(span)
+    context.middleware.push(span)
 
     return tracer.scope().activate(span, fn)
   },
@@ -129,7 +132,8 @@ const web = {
   finish (req, error) {
     if (!this.active(req)) return
 
-    const span = req._datadog.middleware.pop()
+    const context = contexts.get(req)
+    const span = context.middleware.pop()
 
     if (span) {
       if (error) {
@@ -146,38 +150,50 @@ const web = {
 
   // Register a callback to run before res.end() is called.
   beforeEnd (req, callback) {
-    req._datadog.beforeEnd.push(callback)
+    contexts.get(req).beforeEnd.push(callback)
   },
 
   // Prepare the request for instrumentation.
   patch (req) {
-    if (req._datadog) return
+    let context = contexts.get(req)
+
+    if (context) return context
 
-    if (req.stream && req.stream._datadog) {
-      req._datadog = req.stream._datadog
-      return
+    context = req.stream && contexts.get(req.stream)
+
+    if (context) {
+      contexts.set(req, context)
+      return context
     }
 
-    req._datadog = {
+    context = {
+      req,
       span: null,
       paths: [],
       middleware: [],
       beforeEnd: [],
       config: {}
     }
+
+    contexts.set(req, context)
+
+    return context
   },
 
   // Return the request root span.
   root (req) {
-    return req._datadog ? req._datadog.span : null
+    const context = contexts.get(req)
+    return context ? context.span : null
   },
 
   // Return the active span.
   active (req) {
-    if (!req._datadog) return null
-    if (req._datadog.middleware.length === 0) return req._datadog.span || null
+    const context = contexts.get(req)
 
-    return req._datadog.middleware.slice(-1)[0]
+    if (!context) return null
+    if (context.middleware.length === 0) return context.span || null
+
+    return context.middleware.slice(-1)[0]
   },
 
   // Extract the parent span from the headers and start a new span as its child
@@ -190,10 +206,11 @@ const web = {
 
   // Validate a request's status code and then add error tags if necessary
   addStatusError (req, statusCode) {
-    const span = req._datadog.span
-    const error = req._datadog.error
+    const context = contexts.get(req)
+    const span = context.span
+    const error = context.error
 
-    if (!req._datadog.config.validateStatus(statusCode)) {
+    if (!context.config.validateStatus(statusCode)) {
       span.setTag(ERROR, error || true)
     }
   },
@@ -201,94 +218,95 @@ const web = {
   // Add an error to the request
   addError (req, error) {
     if (error instanceof Error) {
-      req._datadog.error = req._datadog.error || error
+      const context = contexts.get(req)
+      context.error = context.error || error
     }
   }
 }
 
 function startSpan (tracer, config, req, res, name) {
-  req._datadog.config = config
+  const context = contexts.get(req)
+
+  context.config = config
 
   let span
 
-  if (req._datadog.span) {
-    req._datadog.span.context()._name = name
-    span = req._datadog.span
+  if (context.span) {
+    context.span.context()._name = name
+    span = context.span
   } else {
     span = web.startChildSpan(tracer, name, req.headers)
   }
 
-  configureDatadogObject(tracer, span, req, res)
+  context.tracer = tracer
+  context.span = span
+  context.res = res
 
   return span
 }
 
-function configureDatadogObject (tracer, span, req, res) {
-  const ddObj = req._datadog
-  ddObj.tracer = tracer
-  ddObj.span = span
-  ddObj.res = res
-}
+function finish (context) {
+  const { req, res } = context
 
-function finish (req, res) {
-  if (req._datadog.finished && !req.stream) return
+  if (context.finished && !req.stream) return
 
-  addRequestTags(req)
-  addResponseTags(req)
+  addRequestTags(context)
+  addResponseTags(context)
 
-  req._datadog.config.hooks.request(req._datadog.span, req, res)
-  addResourceTag(req)
+  context.config.hooks.request(context.span, req, res)
+  addResourceTag(context)
 
-  req._datadog.span.finish()
-  req._datadog.finished = true
+  context.span.finish()
+  context.finished = true
 }
 
-function finishMiddleware (req, res) {
-  if (req._datadog.finished) return
+function finishMiddleware (context) {
+  if (context.finished) return
 
   let span
 
-  while ((span = req._datadog.middleware.pop())) {
+  while ((span = context.middleware.pop())) {
     span.finish()
   }
 }
 
-function wrapEnd (req) {
-  const scope = req._datadog.tracer.scope()
-  const res = req._datadog.res
+function wrapEnd (context) {
+  const scope = context.tracer.scope()
+  const req = context.req
+  const res = context.res
   const end = res.end
 
-  res.writeHead = wrapWriteHead(req)
+  res.writeHead = wrapWriteHead(context)
 
-  res._datadog_end = function () {
-    for (const beforeEnd of req._datadog.beforeEnd) {
+  ends.set(res, function () {
+    for (const beforeEnd of context.beforeEnd) {
       beforeEnd()
     }
 
-    finishMiddleware(req, res)
+    finishMiddleware(context)
 
     if (incomingHttpRequestEnd.hasSubscribers) incomingHttpRequestEnd.publish({ req, res })
 
     const returnValue = end.apply(res, arguments)
 
-    finish(req, res)
+    finish(context)
 
     return returnValue
-  }
+  })
 
   Object.defineProperty(res, 'end', {
     configurable: true,
     get () {
-      return this._datadog_end
+      return ends.get(this)
     },
     set (value) {
-      this._datadog_end = scope.bind(value, req._datadog.span)
+      ends.set(this, scope.bind(value, context.span))
     }
   })
 }
 
-function wrapWriteHead (req) {
-  const res = req._datadog.res
+function wrapWriteHead (context) {
+  const { req, res } = context
   const writeHead = res.writeHead
 
   return function (statusCode, statusMessage, headers) {
@@ -296,15 +314,14 @@ function wrapWriteHead (req) {
     headers = Object.assign(res.getHeaders(), headers)
 
     if (req.method.toLowerCase() === 'options' && isOriginAllowed(req, headers)) {
-      addAllowHeaders(req, headers)
+      addAllowHeaders(req, res, headers)
     }
 
     return writeHead.apply(this, arguments)
   }
 }
 
-function addAllowHeaders (req, headers) {
-  const res = req._datadog.res
+function addAllowHeaders (req, res, headers) {
   const allowHeaders = splitHeader(headers['access-control-allow-headers'])
   const requestHeaders = splitHeader(req.headers['access-control-request-headers'])
   const contextHeaders = [
@@ -337,22 +354,24 @@ function splitHeader (str) {
   return typeof str === 'string' ? str.split(/\s*,\s*/) : []
 }
 
-function wrapEvents (req) {
-  const scope = req._datadog.tracer.scope()
-  const res = req._datadog.res
+function wrapEvents (context) {
+  const scope = context.tracer.scope()
+  const res = context.res
 
-  scope.bind(res, req._datadog.span)
+  scope.bind(res, context.span)
 }
 
 function reactivate (req, fn) {
-  return req._datadog
-    ? req._datadog.tracer.scope().activate(req._datadog.span, fn)
+  const context = contexts.get(req)
+
+  return context
+    ? context.tracer.scope().activate(context.span, fn)
     : fn()
 }
 
-function addRequestTags (req) {
+function addRequestTags (context) {
+  const { req, span } = context
   const url = extractURL(req)
-  const span = req._datadog.span
 
   span.addTags({
     [HTTP_URL]: url.split('?')[0],
@@ -361,15 +380,14 @@ function addRequestTags (req) {
     [SPAN_TYPE]: WEB
   })
 
-  addHeaders(req)
+  addHeaders(context)
 }
 
-function addResponseTags (req) {
-  const span = req._datadog.span
-  const res = req._datadog.res
+function addResponseTags (context) {
+  const { req, res, paths, span } = context
 
-  if (req._datadog.paths.length > 0) {
-    span.setTag(HTTP_ROUTE, req._datadog.paths.join(''))
+  if (paths.length > 0) {
+    span.setTag(HTTP_ROUTE, paths.join(''))
   }
 
   span.addTags({
@@ -379,8 +397,8 @@ function addResponseTags (req) {
   web.addStatusError(req, res.statusCode)
 }
 
-function addResourceTag (req) {
-  const span = req._datadog.span
+function addResourceTag (context) {
+  const { req, span } = context
   const tags = span.context()._tags
 
   if (tags['resource.name']) return
@@ -392,12 +410,12 @@ function addResourceTag (req) {
   span.setTag(RESOURCE_NAME, resource)
 }
 
-function addHeaders (req) {
-  const span = req._datadog.span
+function addHeaders (context) {
+  const { req, res, config, span } = context
 
-  req._datadog.config.headers.forEach(key => {
+  config.headers.forEach(key => {
     const reqHeader = req.headers[key]
-    const resHeader = req._datadog.res.getHeader(key)
+    const resHeader = res.getHeader(key)
 
     if (reqHeader) {
       span.setTag(`${HTTP_REQUEST_HEADERS}.${key}`, reqHeader)