dd-trace 2.18.0 → 2.20.0

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)
@@ -66,7 +72,7 @@ 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,
@@ -81,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/config.js

@@ -2,7 +2,7 @@
 
 const coalesce = require('koalas')
 const os = require('os')
-const { URL } = require('url')
+const { URL, format } = require('url')
 const { AgentExporter } = require('./exporters/agent')
 const { FileExporter } = require('./exporters/file')
 const { ConsoleLogger } = require('./loggers/console')
@@ -59,10 +59,13 @@ class Config {
     this.sourceMap = sourceMap
     this.endpointCollection = endpointCollection
 
-    const hostname = coalesce(options.hostname, DD_AGENT_HOST, 'localhost')
-    const port = coalesce(options.port, DD_TRACE_AGENT_PORT, 8126)
-    this.url = new URL(coalesce(options.url, DD_TRACE_AGENT_URL,
-      `http://${hostname || 'localhost'}:${port || 8126}`))
+    const hostname = coalesce(options.hostname, DD_AGENT_HOST) || 'localhost'
+    const port = coalesce(options.port, DD_TRACE_AGENT_PORT) || 8126
+    this.url = new URL(coalesce(options.url, DD_TRACE_AGENT_URL, format({
+      protocol: 'http:',
+      hostname,
+      port
+    })))
 
     this.exporters = ensureExporters(options.exporters || [
       new AgentExporter(this)

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/span_stats.js

@@ -65,8 +65,8 @@ class SpanAggStats {
       TopLevelHits: this.topLevelHits,
       Errors: this.errors,
       Duration: this.duration,
-      OkSummary: this.okDistribution.toProto(),
-      ErrorSummary: this.errorDistribution.toProto()
+      OkSummary: this.okDistribution.toProto(), // TODO: custom proto encoding
+      ErrorSummary: this.errorDistribution.toProto() // TODO: custom proto encoding
     }
   }
 }

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

@@ -7,7 +7,7 @@ const { sendData } = require('./send-data')
 const dc = require('diagnostics_channel')
 const { fileURLToPath } = require('url')
 
-const savedDependencies = []
+const savedDependencies = new Set()
 const detectedDependencyNames = new Set()
 const FILE_URI_START = `file://`
 const moduleLoadStartChannel = dc.channel('dd-trace:moduleLoadStart')
@@ -18,10 +18,14 @@ function waitAndSend (config, application, host) {
   if (!immediate) {
     immediate = setImmediate(() => {
       immediate = null
-      if (savedDependencies.length > 0) {
-        const dependencies = savedDependencies.splice(0, 1000)
+      if (savedDependencies.size > 0) {
+        const dependencies = Array.from(savedDependencies.values()).splice(0, 1000).map(pair => {
+          savedDependencies.delete(pair)
+          const [name, version] = pair.split(' ')
+          return { name, version }
+        })
         sendData(config, application, host, 'app-dependencies-loaded', { dependencies })
-        if (savedDependencies.length > 0) {
+        if (savedDependencies.size > 0) {
           waitAndSend(config, application, host)
         }
       }
@@ -49,7 +53,7 @@ function onModuleLoad (data) {
         if (basedir) {
           try {
             const { version } = requirePackageJson(basedir, module)
-            savedDependencies.push({ name, version })
+            savedDependencies.add(`${name} ${version}`)
             waitAndSend(config, application, host)
           } catch (e) {
             // can not read the package.json, do nothing
@@ -75,7 +79,7 @@ function stop () {
   application = null
   host = null
   detectedDependencyNames.clear()
-  savedDependencies.splice(0, savedDependencies.length)
+  savedDependencies.clear()
   if (moduleLoadStartChannel.hasSubscribers) {
     moduleLoadStartChannel.unsubscribe(onModuleLoad)
   }

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

@@ -3,9 +3,11 @@ let seqId = 0
 function sendData (config, application, host, reqType, payload = {}) {
   const {
     hostname,
-    port
+    port,
+    url
   } = config
   const options = {
+    url,
     hostname,
     port,
     method: 'POST',

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
 }