dd-trace 4.21.0 → 4.23.0

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

@@ -0,0 +1,130 @@
+'use strict'
+
+const { globMatch } = require('../src/util')
+const RateLimiter = require('./rate_limiter')
+const Sampler = require('./sampler')
+
+class AlwaysMatcher {
+  match () {
+    return true
+  }
+}
+
+class GlobMatcher {
+  constructor (pattern, locator) {
+    this.pattern = pattern
+    this.locator = locator
+  }
+
+  match (span) {
+    const subject = this.locator(span)
+    if (!subject) return false
+    return globMatch(this.pattern, subject)
+  }
+}
+
+class RegExpMatcher {
+  constructor (pattern, locator) {
+    this.pattern = pattern
+    this.locator = locator
+  }
+
+  match (span) {
+    const subject = this.locator(span)
+    if (!subject) return false
+    return this.pattern.test(subject)
+  }
+}
+
+function matcher (pattern, locator) {
+  if (pattern instanceof RegExp) {
+    return new RegExpMatcher(pattern, locator)
+  }
+
+  if (typeof pattern === 'string' && pattern !== '*') {
+    return new GlobMatcher(pattern, locator)
+  }
+
+  return new AlwaysMatcher()
+}
+
+function makeTagLocator (tag) {
+  return (span) => span.context()._tags[tag]
+}
+
+function nameLocator (span) {
+  return span.context()._name
+}
+
+function serviceLocator (span) {
+  const { _tags: tags } = span.context()
+  return tags.service ||
+    tags['service.name'] ||
+    span.tracer()._service
+}
+
+class SamplingRule {
+  constructor ({ name, service, resource, tags, sampleRate = 1.0, maxPerSecond } = {}) {
+    this.matchers = []
+
+    if (name) {
+      this.matchers.push(matcher(name, nameLocator))
+    }
+    if (service) {
+      this.matchers.push(matcher(service, serviceLocator))
+    }
+    if (resource) {
+      this.matchers.push(matcher(resource, makeTagLocator('resource.name')))
+    }
+    for (const [key, value] of Object.entries(tags || {})) {
+      this.matchers.push(matcher(value, makeTagLocator(key)))
+    }
+
+    this._sampler = new Sampler(sampleRate)
+    this._limiter = undefined
+
+    if (Number.isFinite(maxPerSecond)) {
+      this._limiter = new RateLimiter(maxPerSecond)
+    }
+  }
+
+  static from (config) {
+    return new SamplingRule(config)
+  }
+
+  get sampleRate () {
+    return this._sampler.rate()
+  }
+
+  get effectiveRate () {
+    return this._limiter && this._limiter.effectiveRate()
+  }
+
+  get maxPerSecond () {
+    return this._limiter && this._limiter._rateLimit
+  }
+
+  match (span) {
+    for (const matcher of this.matchers) {
+      if (!matcher.match(span)) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  sample () {
+    if (!this._sampler.isSampled()) {
+      return false
+    }
+
+    if (this._limiter) {
+      return this._limiter.isAllowed()
+    }
+
+    return true
+  }
+}
+
+module.exports = SamplingRule

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

@@ -1,67 +1,16 @@
 'use strict'
-const { globMatch } = require('../src/util')
-const { USER_KEEP, AUTO_KEEP } = require('../../../ext').priority
-const RateLimiter = require('./rate_limiter')
-const Sampler = require('./sampler')
-
-class SpanSamplingRule {
-  constructor ({ service, name, sampleRate = 1.0, maxPerSecond } = {}) {
-    this.service = service
-    this.name = name
-
-    this._sampler = new Sampler(sampleRate)
-    this._limiter = undefined
-
-    if (Number.isFinite(maxPerSecond)) {
-      this._limiter = new RateLimiter(maxPerSecond)
-    }
-  }
-
-  get sampleRate () {
-    return this._sampler.rate()
-  }
-
-  get maxPerSecond () {
-    return this._limiter && this._limiter._rateLimit
-  }
-
-  static from (config) {
-    return new SpanSamplingRule(config)
-  }
-
-  match (service, name) {
-    if (this.service && !globMatch(this.service, service)) {
-      return false
-    }
-
-    if (this.name && !globMatch(this.name, name)) {
-      return false
-    }
-
-    return true
-  }
-
-  sample () {
-    if (!this._sampler.isSampled()) {
-      return false
-    }
 
-    if (this._limiter) {
-      return this._limiter.isAllowed()
-    }
-
-    return true
-  }
-}
+const { USER_KEEP, AUTO_KEEP } = require('../../../ext').priority
+const SamplingRule = require('./sampling_rule')
 
 class SpanSampler {
   constructor ({ spanSamplingRules = [] } = {}) {
-    this._rules = spanSamplingRules.map(SpanSamplingRule.from)
+    this._rules = spanSamplingRules.map(SamplingRule.from)
   }
 
-  findRule (service, name) {
+  findRule (context) {
     for (const rule of this._rules) {
-      if (rule.match(service, name)) {
+      if (rule.match(context)) {
         return rule
       }
     }
@@ -73,14 +22,7 @@ class SpanSampler {
 
     const { started } = spanContext._trace
     for (const span of started) {
-      const context = span.context()
-      const tags = context._tags || {}
-      const name = context._name
-      const service = tags.service ||
-        tags['service.name'] ||
-        span.tracer()._service
-
-      const rule = this.findRule(service, name)
+      const rule = this.findRule(span)
       if (rule && rule.sample()) {
         span.context()._spanSampling = {
           sampleRate: rule.sampleRate,

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

@@ -112,11 +112,26 @@ function flatten (input, result = [], prefix = [], traversedObjects = null) {
   return result
 }
 
+function getInstallSignature (config) {
+  const { installSignature: sig } = config
+  if (sig && (sig.id || sig.time || sig.type)) {
+    return {
+      install_id: sig.id,
+      install_time: sig.time,
+      install_type: sig.type
+    }
+  }
+}
+
 function appStarted (config) {
   const app = {
     products: getProducts(config),
     configuration: flatten(config)
   }
+  const installSignature = getInstallSignature(config)
+  if (installSignature) {
+    app.install_signature = installSignature
+  }
   // TODO: add app.error with correct error codes
   // if (errors.agentError) {
   //   app.error = errors.agentError
@@ -129,6 +144,10 @@ function onBeforeExit () {
   process.removeListener('beforeExit', onBeforeExit)
   const { reqType, payload } = createPayload('app-closing')
   sendData(config, application, host, reqType, payload)
+  // we flush before shutting down. Only in CI Visibility
+  if (config.isCiVisibility) {
+    metricsManager.send(config, application, host)
+  }
 }
 
 function createAppObject (config) {
@@ -286,11 +305,30 @@ function updateConfig (changes, config) {
   const application = createAppObject(config)
   const host = createHostObject()
 
-  const configuration = changes.map(change => ({
-    name: change.name,
-    value: Array.isArray(change.value) ? change.value.join(',') : change.value,
-    origin: change.origin
-  }))
+  const names = {
+    sampleRate: 'DD_TRACE_SAMPLE_RATE',
+    logInjection: 'DD_LOG_INJECTION',
+    headerTags: 'DD_TRACE_HEADER_TAGS',
+    tags: 'DD_TAGS'
+  }
+
+  const configuration = []
+
+  for (const change of changes) {
+    if (!names.hasOwnProperty(change.name)) continue
+
+    const name = names[change.name]
+    const { origin, value } = change
+    const entry = { name, origin, value }
+
+    if (Array.isArray(value)) {
+      entry.value = value.join(',')
+    } else if (name === 'DD_TAGS') {
+      entry.value = Object.entries(value).map(([key, value]) => `${key}:${value}`)
+    }
+
+    configuration.push(entry)
+  }
 
   const { reqType, payload } = createPayload('app-client-configuration-change', { configuration })