dd-trace 3.5.0 → 3.6.0

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
 }