dd-trace 4.10.0 → 4.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "4.10.0",
+  "version": "4.11.1",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -77,7 +77,7 @@
     "crypto-randomuuid": "^1.0.0",
     "diagnostics_channel": "^1.1.0",
     "ignore": "^5.2.4",
-    "import-in-the-middle": "^1.4.1",
+    "import-in-the-middle": "^1.4.2",
     "int64-buffer": "^0.1.9",
     "ipaddr.js": "^2.1.0",
     "istanbul-lib-coverage": "3.2.0",

package/packages/datadog-instrumentations/src/http2/client.js

@@ -30,6 +30,8 @@ function createWrapEmit (ctx) {
 function createWrapRequest (authority, options) {
   return function wrapRequest (request) {
     return function (headers) {
+      if (!startChannel.hasSubscribers) return request.apply(this, arguments)
+
       const ctx = { headers, authority, options }
 
       return startChannel.runStores(ctx, () => {

package/packages/datadog-plugin-http/src/client.js

@@ -121,11 +121,11 @@ function addResponseHeaders (res, span, config) {
     ? Object.fromEntries(res.headers.entries())
     : res.headers
 
-  config.headers.forEach(key => {
+  config.headers.forEach(([key, tag]) => {
     const value = headers[key]
 
     if (value) {
-      span.setTag(`${HTTP_RESPONSE_HEADERS}.${key}`, value)
+      span.setTag(tag || `${HTTP_RESPONSE_HEADERS}.${key}`, value)
     }
   })
 }
@@ -135,11 +135,11 @@ function addRequestHeaders (req, span, config) {
     ? Object.fromEntries(req.headers.entries())
     : req.headers || req.getHeaders()
 
-  config.headers.forEach(key => {
-    const value = headers[key]
+  config.headers.forEach(([key, tag]) => {
+    const value = Array.isArray(headers[key]) ? headers[key].toString() : headers[key]
 
     if (value) {
-      span.setTag(`${HTTP_REQUEST_HEADERS}.${key}`, Array.isArray(value) ? value.toString() : value)
+      span.setTag(tag || `${HTTP_REQUEST_HEADERS}.${key}`, value)
     }
   })
 }
@@ -182,7 +182,8 @@ function getHeaders (config) {
 
   return config.headers
     .filter(key => typeof key === 'string')
-    .map(key => key.toLowerCase())
+    .map(h => h.split(':'))
+    .map(([key, tag]) => [key.toLowerCase(), tag])
 }
 
 function getHooks (config) {

package/packages/datadog-plugin-pg/src/index.js

@@ -10,7 +10,7 @@ class PGPlugin extends DatabasePlugin {
 
   start ({ params = {}, query, processId }) {
     const service = this.serviceName({ pluginConfig: this.config, params })
-    const originalStatement = query.text
+    const originalStatement = this.maybeTruncate(query.text)
 
     this.startSpan(this.operationName(), {
       service,

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

@@ -29,6 +29,8 @@ function enable (config) {
       }
     })
   }
+
+  return rc
 }
 
 function enableWafUpdate (appsecConfig) {

package/packages/dd-trace/src/appsec/remote_config/manager.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const { URL, format } = require('url')
 const uuid = require('crypto-randomuuid')
 const { EventEmitter } = require('events')
 const Scheduler = require('./scheduler')
@@ -22,13 +23,17 @@ class RemoteConfigManager extends EventEmitter {
   constructor (config) {
     super()
 
-    const pollInterval = config.remoteConfig.pollInterval * 1000
+    const pollInterval = Math.floor(config.remoteConfig.pollInterval * 1000)
+    const url = config.url || new URL(format({
+      protocol: 'http:',
+      hostname: config.hostname || 'localhost',
+      port: config.port
+    }))
+
     this.scheduler = new Scheduler((cb) => this.poll(cb), pollInterval)
 
     this.requestOptions = {
-      url: config.url,
-      hostname: config.hostname,
-      port: config.port,
+      url,
       method: 'POST',
       path: '/v0.7/config'
     }

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

@@ -11,6 +11,7 @@ const tagger = require('./tagger')
 const { isTrue, isFalse } = require('./util')
 const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('./plugins/util/tags')
 const { getGitMetadataFromGitProperties } = require('./git_properties')
+const { updateConfig } = require('./telemetry')
 const { getIsGCPFunction, getIsAzureFunctionConsumptionPlan } = require('./serverless')
 
 const fromEntries = Object.fromEntries || (entries =>
@@ -130,11 +131,6 @@ class Config {
       'agent'
     )
     const DD_PROFILING_SOURCE_MAP = process.env.DD_PROFILING_SOURCE_MAP
-    const DD_LOGS_INJECTION = coalesce(
-      options.logInjection,
-      process.env.DD_LOGS_INJECTION,
-      false
-    )
     const DD_RUNTIME_METRICS_ENABLED = coalesce(
       options.runtimeMetrics, // TODO: remove when enabled by default
       process.env.DD_RUNTIME_METRICS_ENABLED,
@@ -239,7 +235,7 @@ class Config {
       !inServerlessEnvironment
     )
     const DD_TELEMETRY_HEARTBEAT_INTERVAL = process.env.DD_TELEMETRY_HEARTBEAT_INTERVAL
-      ? parseInt(process.env.DD_TELEMETRY_HEARTBEAT_INTERVAL) * 1000
+      ? Math.floor(parseFloat(process.env.DD_TELEMETRY_HEARTBEAT_INTERVAL) * 1000)
       : 60000
     const DD_OPENAI_SPAN_CHAR_LIMIT = process.env.DD_OPENAI_SPAN_CHAR_LIMIT
       ? parseInt(process.env.DD_OPENAI_SPAN_CHAR_LIMIT)
@@ -441,8 +437,8 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
       !inServerlessEnvironment
     )
     const DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS = coalesce(
-      parseInt(remoteConfigOptions.pollInterval),
-      parseInt(process.env.DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS),
+      parseFloat(remoteConfigOptions.pollInterval),
+      parseFloat(process.env.DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS),
       5 // seconds
     )
 
@@ -510,11 +506,6 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
     const ingestion = options.ingestion || {}
     const dogstatsd = coalesce(options.dogstatsd, {})
     const sampler = {
-      sampleRate: coalesce(
-        options.sampleRate,
-        process.env.DD_TRACE_SAMPLE_RATE,
-        ingestion.sampleRate
-      ),
       rateLimit: coalesce(options.rateLimit, process.env.DD_TRACE_RATE_LIMIT, ingestion.rateLimit),
       rules: coalesce(
         options.samplingRules,
@@ -538,14 +529,13 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
       })
     }
 
-    const defaultFlushInterval = inServerlessEnvironment ? 0 : 2000
+    const defaultFlushInterval = inAWSLambda ? 0 : 2000
 
     this.tracing = !isFalse(DD_TRACING_ENABLED)
     this.dbmPropagationMode = DD_DBM_PROPAGATION_MODE
     this.dsmEnabled = isTrue(DD_DATA_STREAMS_ENABLED)
     this.openAiLogsEnabled = DD_OPENAI_LOGS_ENABLED
     this.apiKey = DD_API_KEY
-    this.logInjection = isTrue(DD_LOGS_INJECTION)
     this.env = DD_ENV
     this.url = DD_CIVISIBILITY_AGENTLESS_URL ? new URL(DD_CIVISIBILITY_AGENTLESS_URL)
       : getAgentUrl(DD_TRACE_AGENT_URL, options)
@@ -554,7 +544,6 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
     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.queryStringObfuscation = DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP
     this.clientIpEnabled = DD_TRACE_CLIENT_IP_ENABLED
     this.clientIpHeader = DD_TRACE_CLIENT_IP_HEADER
@@ -687,6 +676,139 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
       version: this.version,
       'runtime-id': uuid()
     })
+
+    this._applyDefaults()
+    this._applyEnvironment()
+    this._applyOptions(options)
+    this._applyRemote({})
+    this._merge()
+  }
+
+  // Supports only a subset of options for now.
+  configure (options, remote) {
+    if (remote) {
+      this._applyRemote(options)
+    } else {
+      this._applyOptions(options)
+    }
+
+    this._merge()
+  }
+
+  _applyDefaults () {
+    const defaults = this._defaults = {}
+
+    this._setUnit(defaults, 'sampleRate', undefined)
+    this._setBoolean(defaults, 'logInjection', false)
+    this._setArray(defaults, 'headerTags', [])
+  }
+
+  _applyEnvironment () {
+    const {
+      DD_TRACE_SAMPLE_RATE,
+      DD_LOGS_INJECTION,
+      DD_TRACE_HEADER_TAGS
+    } = process.env
+
+    const env = this._env = {}
+
+    this._setUnit(env, 'sampleRate', DD_TRACE_SAMPLE_RATE)
+    this._setBoolean(env, 'logInjection', DD_LOGS_INJECTION)
+    this._setArray(env, 'headerTags', DD_TRACE_HEADER_TAGS)
+  }
+
+  _applyOptions (options) {
+    const opts = this._options = this._options || {}
+
+    options = Object.assign({ ingestion: {} }, options, opts)
+
+    this._setUnit(opts, 'sampleRate', coalesce(options.sampleRate, options.ingestion.sampleRate))
+    this._setBoolean(opts, 'logInjection', options.logInjection)
+    this._setArray(opts, 'headerTags', options.headerTags)
+  }
+
+  _applyRemote (options) {
+    const opts = this._remote = this._remote || {}
+    const headerTags = options.tracing_header_tags
+      ? options.tracing_header_tags.map(tag => {
+        return tag.tag_name ? `${tag.header}:${tag.tag_name}` : tag.header
+      })
+      : undefined
+
+    this._setUnit(opts, 'sampleRate', options.tracing_sampling_rate)
+    this._setBoolean(opts, 'logInjection', options.log_injection_enabled)
+    this._setArray(opts, 'headerTags', headerTags)
+  }
+
+  _setBoolean (obj, name, value) {
+    if (value === undefined || value === null) {
+      this._setValue(obj, name, value)
+    } else if (isTrue(value)) {
+      this._setValue(obj, name, true)
+    } else if (isFalse(value)) {
+      this._setValue(obj, name, false)
+    }
+  }
+
+  _setUnit (obj, name, value) {
+    if (value === null || value === undefined) {
+      return this._setValue(obj, name, value)
+    }
+
+    value = parseFloat(value)
+
+    if (!isNaN(value)) {
+      // TODO: Ignore out of range values instead of normalizing them.
+      this._setValue(obj, name, Math.min(Math.max(value, 0), 1))
+    }
+  }
+
+  _setArray (obj, name, value) {
+    if (value === null || value === undefined) {
+      return this._setValue(obj, name, null)
+    }
+
+    if (typeof value === 'string') {
+      value = value && value.split(',')
+    }
+
+    if (Array.isArray(value)) {
+      this._setValue(obj, name, value)
+    }
+  }
+
+  _setValue (obj, name, value) {
+    obj[name] = value
+  }
+
+  // TODO: Report origin changes and errors to telemetry.
+  // TODO: Deeply merge configurations.
+  // TODO: Move change tracking to telemetry.
+  _merge () {
+    const containers = [this._remote, this._options, this._env, this._defaults]
+    const origins = ['remote_config', 'code', 'env_var', 'default']
+    const changes = []
+
+    for (const name in this._defaults) {
+      for (let i = 0; i < containers.length; i++) {
+        const container = containers[i]
+        const origin = origins[i]
+
+        if ((container[name] !== null && container[name] !== undefined) || container === this._defaults) {
+          if (this[name] === container[name] && this.hasOwnProperty(name)) break
+
+          const value = this[name] = container[name]
+
+          changes.push({ name, value, origin })
+
+          break
+        }
+      }
+    }
+
+    this.sampler.sampleRate = this.sampleRate
+
+    updateConfig(changes, this)
   }
 }
 

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

@@ -9,6 +9,8 @@ class NoopTracer {
     this._span = new Span(this)
   }
 
+  configure (options) {}
+
   trace (name, options, fn) {
     return fn(this._span, () => {})
   }

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

@@ -134,6 +134,7 @@ module.exports = class PluginManager {
       queryStringObfuscation,
       site,
       url,
+      headerTags,
       dbmPropagationMode,
       dsmEnabled,
       clientIpEnabled
@@ -162,6 +163,7 @@ module.exports = class PluginManager {
 
     sharedConfig.site = site
     sharedConfig.url = url
+    sharedConfig.headers = headerTags || []
 
     return sharedConfig
   }

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

@@ -55,6 +55,18 @@ class DatabasePlugin extends StoragePlugin {
       return `/*${servicePropagation},traceparent='${traceparent}'*/ ${query}`
     }
   }
+
+  maybeTruncate (query) {
+    const maxLength = typeof this.config.truncate === 'number'
+      ? this.config.truncate
+      : 5000 // same as what the agent does
+
+    if (this.config.truncate && query && query.length > maxLength) {
+      query = `${query.slice(0, maxLength - 3)}...`
+    }
+
+    return query
+  }
 }
 
 module.exports = DatabasePlugin

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

@@ -477,16 +477,16 @@ function addResourceTag (context) {
 function addHeaders (context) {
   const { req, res, config, span } = context
 
-  config.headers.forEach(key => {
+  config.headers.forEach(([key, tag]) => {
     const reqHeader = req.headers[key]
     const resHeader = res.getHeader(key)
 
     if (reqHeader) {
-      span.setTag(`${HTTP_REQUEST_HEADERS}.${key}`, reqHeader)
+      span.setTag(tag || `${HTTP_REQUEST_HEADERS}.${key}`, reqHeader)
     }
 
     if (resHeader) {
-      span.setTag(`${HTTP_RESPONSE_HEADERS}.${key}`, resHeader)
+      span.setTag(tag || `${HTTP_RESPONSE_HEADERS}.${key}`, resHeader)
     }
   })
 }
@@ -512,7 +512,9 @@ function getProtocol (req) {
 function getHeadersToRecord (config) {
   if (Array.isArray(config.headers)) {
     try {
-      return config.headers.map(key => key.toLowerCase())
+      return config.headers
+        .map(h => h.split(':'))
+        .map(([key, tag]) => [key.toLowerCase(), tag])
     } catch (err) {
       log.error(err)
     }

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

@@ -29,14 +29,17 @@ const DEFAULT_KEY = 'service:,env:'
 const defaultSampler = new Sampler(AUTO_KEEP)
 
 class PrioritySampler {
-  constructor (env, { sampleRate, rateLimit = 100, rules = [] } = {}) {
+  constructor (env, config) {
+    this.configure(env, config)
+    this.update({})
+  }
+
+  configure (env, { sampleRate, rateLimit = 100, rules = [] } = {}) {
     this._env = env
     this._rules = this._normalizeRules(rules, sampleRate)
     this._limiter = new RateLimiter(rateLimit)
 
     setSamplingRules(this._rules)
-
-    this.update({})
   }
 
   isSampled (span) {

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

@@ -24,10 +24,23 @@ class Tracer extends NoopProxy {
     this._initialized = true
 
     try {
-      const config = new Config(options) // TODO: support dynamic config
+      const config = new Config(options) // TODO: support dynamic code config
 
       if (config.remoteConfig.enabled && !config.isCiVisibility) {
-        remoteConfig.enable(config)
+        const rc = remoteConfig.enable(config)
+
+        rc.on('APM_TRACING', (action, conf) => {
+          if (action === 'unapply') {
+            config.configure({}, true)
+          } else {
+            config.configure(conf.lib_config, true)
+          }
+
+          if (config.tracing) {
+            this._tracer.configure(config)
+            this._pluginManager.configure(config)
+          }
+        })
       }
 
       if (config.isGCPFunction || config.isAzureFunctionConsumptionPlan) {
@@ -49,6 +62,9 @@ class Tracer extends NoopProxy {
       }
 
       if (config.tracing) {
+        // TODO: This should probably not require tracing to be enabled.
+        telemetry.start(config, this._pluginManager)
+
         // dirty require for now so zero appsec code is executed unless explicitly enabled
         if (config.appsec.enabled) {
           require('./appsec').enable(config)
@@ -63,7 +79,6 @@ class Tracer extends NoopProxy {
 
         this._pluginManager.configure(config)
         setStartupLogPluginManager(this._pluginManager)
-        telemetry.start(config, this._pluginManager)
 
         if (config.isManualApiEnabled) {
           const TestApiManualPlugin = require('./ci-visibility/test-api-manual/test-api-manual-plugin')

package/packages/dd-trace/src/startup-log.js

@@ -62,7 +62,7 @@ function startupLog ({ agentError } = {}) {
     out.agent_error = agentError.message
   }
   out.debug = !!config.debug
-  out.sample_rate = config.sampleRate
+  out.sample_rate = config.sampler.sampleRate
   out.sampling_rules = samplingRules
   out.tags = config.tags
   if (config.tags && config.tags.version) {

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

@@ -66,7 +66,7 @@ function onBeforeExit () {
   sendData(config, application, host, 'app-closing')
 }
 
-function createAppObject () {
+function createAppObject (config) {
   return {
     service_name: config.service,
     env: config.env,
@@ -116,7 +116,7 @@ function start (aConfig, thePluginManager) {
   }
   config = aConfig
   pluginManager = thePluginManager
-  application = createAppObject()
+  application = createAppObject(config)
   host = createHostObject()
   heartbeatInterval = config.telemetry.heartbeatInterval
 
@@ -155,8 +155,36 @@ function updateIntegrations () {
   sendData(config, application, host, 'app-integrations-change', { integrations })
 }
 
+function updateConfig (changes, config) {
+  if (!config.telemetry.enabled) return
+  if (changes.length === 0) return
+
+  // Hack to make system tests happy until we ship telemetry v2
+  if (process.env.DD_INTERNAL_TELEMETRY_V2_ENABLED !== '1') return
+
+  const application = createAppObject(config)
+  const host = createHostObject()
+
+  const names = {
+    sampleRate: 'DD_TRACE_SAMPLE_RATE',
+    logInjection: 'DD_LOG_INJECTION',
+    headerTags: 'DD_TRACE_HEADER_TAGS'
+  }
+
+  const configuration = changes.map(change => ({
+    name: names[change.name],
+    value: Array.isArray(change.value) ? change.value.join(',') : change.value,
+    origin: change.origin
+  }))
+
+  sendData(config, application, host, 'app-client-configuration-change', {
+    configuration
+  })
+}
+
 module.exports = {
   start,
   stop,
-  updateIntegrations
+  updateIntegrations,
+  updateConfig
 }

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

@@ -25,6 +25,10 @@ class DatadogTracer extends Tracer {
     setStartupLogConfig(config)
   }
 
+  configure ({ env, sampler }) {
+    this._prioritySampler.configure(env, sampler)
+  }
+
   // todo[piochelepiotr] These two methods are not related to the tracer, but to data streams monitoring.
   // They should be moved outside of the tracer in the future.
   setCheckpoint (edgeTags) {