dd-trace 2.17.0 → 2.19.0

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

@@ -17,7 +17,7 @@ class OutgoingPlugin extends TracingPlugin {
   }
 
   addHost (hostname, port) {
-    const span = this.activeSpan()
+    const span = this.activeSpan
 
     if (!span) return
 

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

@@ -0,0 +1,9 @@
+'use strict'
+
+const OutgoingPlugin = require('./outgoing')
+
+class ProducerPlugin extends OutgoingPlugin {
+  static get operation () { return 'publish' }
+}
+
+module.exports = ProducerPlugin

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

@@ -0,0 +1,9 @@
+'use strict'
+
+const IncomingPlugin = require('./incoming')
+
+class ServerPlugin extends IncomingPlugin {
+  static get operation () { return 'request' }
+}
+
+module.exports = ServerPlugin

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

@@ -7,10 +7,6 @@ class StoragePlugin extends ClientPlugin {
     super(...args)
 
     this.system = this.constructor.system || this.component
-
-    this.addTraceSub('connect', message => {
-      this.connect(message)
-    })
   }
 
   startSpan (name, options) {

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

@@ -24,6 +24,12 @@ class TracingPlugin extends Plugin {
     })
   }
 
+  get activeSpan () {
+    const store = storage.getStore()
+
+    return store && store.span
+  }
+
   configure (config) {
     return super.configure({
       ...config,
@@ -37,7 +43,7 @@ class TracingPlugin extends Plugin {
   start () {} // implemented by individual plugins
 
   finish () {
-    this.activeSpan().finish()
+    this.activeSpan.finish()
   }
 
   error (error) {
@@ -49,7 +55,7 @@ class TracingPlugin extends Plugin {
   }
 
   addError (error) {
-    const span = this.activeSpan()
+    const span = this.activeSpan
 
     if (!span._spanContext._tags['error']) {
       span.setTag('error', error || 1)
@@ -64,8 +70,9 @@ class TracingPlugin extends Plugin {
     }
 
     const span = this.tracer.startSpan(name, {
+      childOf,
       tags: {
-        'service.name': service,
+        'service.name': service || this.tracer._service,
         'resource.name': resource,
         'span.kind': kind,
         'span.type': type,
@@ -80,12 +87,6 @@ class TracingPlugin extends Plugin {
 
     return span
   }
-
-  activeSpan () {
-    const store = storage.getStore()
-
-    return store && store.span
-  }
 }
 
 module.exports = TracingPlugin

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

@@ -58,13 +58,15 @@ const web = {
     const hooks = getHooks(config)
     const filter = urlFilter.getFilter(config)
     const middleware = getMiddlewareSetting(config)
+    const queryStringObfuscation = getQsObfuscator(config)
 
     return Object.assign({}, config, {
       headers,
       validateStatus,
       hooks,
       filter,
-      middleware
+      middleware,
+      queryStringObfuscation
     })
   },
 
@@ -368,6 +370,24 @@ const web = {
     return req.socket && req.socket.remoteAddress
   },
 
+  obfuscateQs (config, url) {
+    const { queryStringObfuscation } = config
+
+    if (queryStringObfuscation === false) return url
+
+    const i = url.indexOf('?')
+    if (i === -1) return url
+
+    const path = url.slice(0, i)
+    if (queryStringObfuscation === true) return path
+
+    let qs = url.slice(i + 1)
+
+    qs = qs.replace(queryStringObfuscation, '<redacted>')
+
+    return `${path}?${qs}`
+  },
+
   wrapWriteHead (context) {
     const { req, res } = context
     const writeHead = res.writeHead
@@ -458,11 +478,11 @@ function reactivate (req, fn) {
 }
 
 function addRequestTags (context) {
-  const { req, span } = context
+  const { req, span, config } = context
   const url = extractURL(req)
 
   span.addTags({
-    [HTTP_URL]: url.split('?')[0],
+    [HTTP_URL]: web.obfuscateQs(config, url),
     [HTTP_METHOD]: req.method,
     [SPAN_KIND]: SERVER,
     [SPAN_TYPE]: WEB,
@@ -619,4 +639,30 @@ function getMiddlewareSetting (config) {
   return true
 }
 
+function getQsObfuscator (config) {
+  const obfuscator = config.queryStringObfuscation
+
+  if (typeof obfuscator === 'boolean') {
+    return obfuscator
+  }
+
+  if (typeof obfuscator === 'string') {
+    if (obfuscator === '') return false // disable obfuscator
+
+    if (obfuscator === '.*') return true // optimize full redact
+
+    try {
+      return new RegExp(obfuscator, 'gi')
+    } catch (err) {
+      log.error(err)
+    }
+  }
+
+  if (config.hasOwnProperty('queryStringObfuscation')) {
+    log.error('Expected `queryStringObfuscation` to be a regex string or boolean.')
+  }
+
+  return true
+}
+
 module.exports = web

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

@@ -36,9 +36,16 @@ class Profiler extends EventEmitter {
     this._logger = config.logger
     this._enabled = true
 
+    // Log errors if the source map finder fails, but don't prevent the rest
+    // of the profiler from running without source maps.
+    let mapper
     try {
-      const mapper = await maybeSourceMap(config.sourceMap)
+      mapper = await maybeSourceMap(config.sourceMap)
+    } catch (err) {
+      this._logger.error(err)
+    }
 
+    try {
       for (const profiler of config.profilers) {
         // TODO: move this out of Profiler when restoring sourcemap support
         profiler.start({ mapper })

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

@@ -2,6 +2,7 @@
 
 const log = require('./log')
 const format = require('./format')
+const SpanSampler = require('./span_sampler')
 
 const { SpanStatsProcessor } = require('./span_stats')
 
@@ -15,6 +16,7 @@ class SpanProcessor {
     this._config = config
 
     this._stats = new SpanStatsProcessor(config)
+    this._spanSampler = new SpanSampler(config)
   }
 
   process (span) {
@@ -27,6 +29,7 @@ class SpanProcessor {
 
     if (started.length === finished.length || finished.length >= flushMinSpans) {
       this._prioritySampler.sample(spanContext)
+      this._spanSampler.sample(spanContext)
 
       for (const span of started) {
         if (span._duration !== undefined) {

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

@@ -0,0 +1,80 @@
+'use strict'
+const { globMatch } = require('../src/util')
+const {
+  USER_KEEP,
+  AUTO_KEEP
+} = require('../../../ext').priority
+const RateLimiter = require('./rate_limiter')
+
+class SpanSampler {
+  constructor ({ spanSamplingRules = [] }) {
+    this._rules = spanSamplingRules
+    this._limiters = {}
+  }
+
+  sample (spanContext) {
+    const decision = spanContext._sampling.priority
+    if (decision === USER_KEEP || decision === AUTO_KEEP) return
+
+    const { started } = spanContext._trace
+    for (const span of started) {
+      const service = span.tracer()._service
+      const name = span._name
+      const rule = findRule(this._rules, service, name)
+      if (!rule) continue
+
+      const sampleRate = getSampleRate(rule.sampleRate)
+      const maxPerSecond = getMaxPerSecond(rule.maxPerSecond)
+      const sampled = sample(sampleRate)
+      if (!sampled) continue
+
+      const key = `${service}:${name}`
+      const limiter = getLimiter(this._limiters, key, maxPerSecond)
+      if (limiter.isAllowed()) {
+        span.context()._sampling.spanSampling = {
+          sampleRate,
+          maxPerSecond
+        }
+      }
+    }
+  }
+}
+
+function findRule (rules, service, name) {
+  for (const rule of rules) {
+    const servicePattern = getService(rule.service)
+    const namePattern = getName(rule.name)
+    if (globMatch(servicePattern, service) && globMatch(namePattern, name)) {
+      return rule
+    }
+  }
+}
+
+function getLimiter (list, key, maxPerSecond) {
+  if (typeof list[key] === 'undefined') {
+    list[key] = new RateLimiter(maxPerSecond)
+  }
+  return list[key]
+}
+
+function sample (sampleRate) {
+  return Math.random() < sampleRate
+}
+
+function getService (service) {
+  return service || '*'
+}
+
+function getName (name) {
+  return name || '*'
+}
+
+function getSampleRate (sampleRate) {
+  return sampleRate || 1.0
+}
+
+function getMaxPerSecond (maxPerSecond) {
+  return maxPerSecond || Infinity
+}
+
+module.exports = SpanSampler

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

@@ -44,11 +44,15 @@ class DatadogTracer extends Tracer {
       const result = this.scope().activate(span, () => fn(span))
 
       if (result && typeof result.then === 'function') {
-        result.then(
-          () => span.finish(),
+        return result.then(
+          value => {
+            span.finish()
+            return value
+          },
           err => {
             addError(span, err)
             span.finish()
+            throw err
           }
         )
       } else {

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

@@ -20,8 +20,50 @@ function isError (value) {
   return false
 }
 
+// Matches a glob pattern to a given subject string
+function globMatch (pattern, subject) {
+  let px = 0 // [p]attern inde[x]
+  let sx = 0 // [s]ubject inde[x]
+  let nextPx = 0
+  let nextSx = 0
+  while (px < pattern.length || sx < subject.length) {
+    if (px < pattern.length) {
+      const c = pattern[px]
+      switch (c) {
+        default: // ordinary character
+          if (sx < subject.length && subject[sx] === c) {
+            px++
+            sx++
+            continue
+          }
+          break
+        case '?':
+          if (sx < subject.length) {
+            px++
+            sx++
+            continue
+          }
+          break
+        case '*':
+          nextPx = px
+          nextSx = sx + 1
+          px++
+          continue
+      }
+    }
+    if (nextSx > 0 && nextSx <= subject.length) {
+      px = nextPx
+      sx = nextSx
+      continue
+    }
+    return false
+  }
+  return true
+}
+
 module.exports = {
   isTrue,
   isFalse,
-  isError
+  isError,
+  globMatch
 }