dd-trace 4.9.0 → 4.11.0

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

@@ -19,11 +19,11 @@ class NextPlugin extends ServerPlugin {
   start ({ req, res }) {
     const store = storage.getStore()
     const childOf = store ? store.span : store
-    const span = this.tracer.startSpan('next.request', {
+    const span = this.tracer.startSpan(this.operationName(), {
       childOf,
       tags: {
         [COMPONENT]: this.constructor.id,
-        'service.name': this.config.service || this.tracer._service,
+        'service.name': this.config.service || this.serviceName(),
         'resource.name': req.method,
         'span.type': 'web',
         'span.kind': 'server',

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

@@ -10,7 +10,7 @@ class OracledbPlugin extends DatabasePlugin {
   static get peerServicePrecursors () { return ['db.instance', 'db.hostname'] }
 
   start ({ query, connAttrs }) {
-    const service = this.serviceName(this.config, connAttrs)
+    const service = this.serviceName({ pluginConfig: this.config, params: connAttrs })
     const url = getUrl(connAttrs.connectString)
 
     this.startSpan(this.operationName(), {

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

@@ -9,8 +9,8 @@ class PGPlugin extends DatabasePlugin {
   static get system () { return 'postgres' }
 
   start ({ params = {}, query, processId }) {
-    const service = this.serviceName(this.config, params)
-    const originalStatement = query.text
+    const service = this.serviceName({ pluginConfig: this.config, params })
+    const originalStatement = this.maybeTruncate(query.text)
 
     this.startSpan(this.operationName(), {
       service,

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

@@ -15,7 +15,7 @@ class RedisPlugin extends CachePlugin {
 
     this.startSpan({
       resource,
-      service: this.serviceName(this.config, this.system, connectionName),
+      service: this.serviceName({ pluginConfig: this.config, system: this.system, connectionName }),
       type: 'redis',
       meta: {
         'db.type': 'redis',

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

@@ -10,7 +10,7 @@ class TediousPlugin extends DatabasePlugin {
 
   start ({ queryOrProcedure, connectionConfig }) {
     this.startSpan(this.operationName(), {
-      service: this.serviceName(this.config, this.system),
+      service: this.serviceName({ pluginConfig: this.config, system: this.system }),
       resource: queryOrProcedure,
       type: 'sql',
       kind: 'client',

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

@@ -22,17 +22,24 @@ class TracingPlugin extends Plugin {
     return store && store.span
   }
 
-  serviceName (...serviceArgs) {
-    if (Nomenclature.shouldUseConsistentServiceNaming) {
-      return Nomenclature.shortCircuitServiceName(this.config, ...serviceArgs)
-    }
-    const { type, id, kind } = this.constructor
-    return Nomenclature.serviceName(type, kind, id, ...serviceArgs)
+  serviceName (opts = {}) {
+    const {
+      type = this.constructor.type,
+      id = this.constructor.id,
+      kind = this.constructor.kind
+    } = opts
+
+    return Nomenclature.serviceName(type, kind, id, opts)
   }
 
-  operationName (...opNameArgs) {
-    const { type, id, kind } = this.constructor
-    return Nomenclature.opName(type, kind, id, ...opNameArgs)
+  operationName (opts = {}) {
+    const {
+      type = this.constructor.type,
+      id = this.constructor.id,
+      kind = this.constructor.kind
+    } = opts
+
+    return Nomenclature.opName(type, kind, id, opts)
   }
 
   configure (config) {

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/service-naming/index.js

@@ -18,20 +18,16 @@ class SchemaManager {
     return this.config.spanRemoveIntegrationFromService && this.version === 'v0'
   }
 
-  opName (type, kind, plugin, ...opNameArgs) {
-    return this.schema.getOpName(type, kind, plugin, ...opNameArgs)
+  opName (type, kind, plugin, opts) {
+    return this.schema.getOpName(type, kind, plugin, opts)
   }
 
-  serviceName (type, kind, plugin, ...serviceNameArgs) {
-    return this.schema.getServiceName(type, kind, plugin, this.config.service, ...serviceNameArgs)
-  }
+  serviceName (type, kind, plugin, opts) {
+    const schema = this.shouldUseConsistentServiceNaming
+      ? this.schemas.v1
+      : this.schema
 
-  shortCircuitServiceName (pluginConfig, ...args) {
-    // We're short-circuiting, so we do not obey custom service functions
-    if (typeof pluginConfig.service === 'function') {
-      return this.config.service
-    }
-    return pluginConfig.service || this.config.service
+    return schema.getServiceName(type, kind, plugin, { ...opts, tracerService: this.config.service })
   }
 
   configure (config = {}) {

package/packages/dd-trace/src/service-naming/schemas/definition.js

@@ -10,14 +10,14 @@ class SchemaDefinition {
     }
   }
 
-  getOpName (type, kind, plugin, ...opNameArgs) {
+  getOpName (type, kind, plugin, opts) {
     const item = this.getSchemaItem(type, kind, plugin)
-    return item.opName(...opNameArgs)
+    return item.opName(opts)
   }
 
-  getServiceName (type, kind, plugin, service, ...serviceNameArgs) {
+  getServiceName (type, kind, plugin, opts) {
     const item = this.getSchemaItem(type, kind, plugin)
-    return item.serviceName(service, ...serviceNameArgs)
+    return item.serviceName(opts)
   }
 }
 

package/packages/dd-trace/src/service-naming/schemas/util.js

@@ -1,5 +1,23 @@
-function identityService (service) {
-  return service
+function identityService ({ tracerService }) {
+  return tracerService
 }
 
-module.exports = { identityService }
+function getFormattedHostString ({ host, port }) {
+  return [host, port].filter(val => val).join(':')
+}
+
+function httpPluginClientService ({ tracerService, pluginConfig, sessionDetails }) {
+  if (pluginConfig.splitByDomain) {
+    return getFormattedHostString(sessionDetails)
+  } else if (pluginConfig.service) {
+    return pluginConfig.service
+  }
+
+  return tracerService
+}
+
+function awsServiceV0 ({ tracerService, awsService }) {
+  return `${tracerService}-aws-${awsService}`
+}
+
+module.exports = { identityService, httpPluginClientService, awsServiceV0 }

package/packages/dd-trace/src/service-naming/schemas/v0/messaging.js

@@ -1,7 +1,7 @@
-const { identityService } = require('../util')
+const { identityService, awsServiceV0 } = require('../util')
 
-function amqpServiceName (service) {
-  return `${service}-amqp`
+function amqpServiceName ({ tracerService }) {
+  return `${tracerService}-amqp`
 }
 
 const messaging = {
@@ -16,15 +16,23 @@ const messaging = {
     },
     'google-cloud-pubsub': {
       opName: () => 'pubsub.request',
-      serviceName: service => `${service}-pubsub`
+      serviceName: ({ tracerService }) => `${tracerService}-pubsub`
     },
     kafkajs: {
       opName: () => 'kafka.produce',
-      serviceName: service => `${service}-kafka`
+      serviceName: ({ tracerService }) => `${tracerService}-kafka`
     },
     rhea: {
       opName: () => 'amqp.send',
-      serviceName: service => `${service}-amqp-producer`
+      serviceName: ({ tracerService }) => `${tracerService}-amqp-producer`
+    },
+    sqs: {
+      opName: () => 'aws.request',
+      serviceName: awsServiceV0
+    },
+    sns: {
+      opName: () => 'aws.request',
+      serviceName: awsServiceV0
     }
   },
   consumer: {
@@ -42,11 +50,15 @@ const messaging = {
     },
     kafkajs: {
       opName: () => 'kafka.consume',
-      serviceName: service => `${service}-kafka`
+      serviceName: ({ tracerService }) => `${tracerService}-kafka`
     },
     rhea: {
       opName: () => 'amqp.receive',
       serviceName: identityService
+    },
+    sqs: {
+      opName: () => 'aws.request',
+      serviceName: awsServiceV0
     }
   },
   client: {
@@ -56,7 +68,7 @@ const messaging = {
     },
     'google-cloud-pubsub': {
       opName: () => 'pubsub.request',
-      serviceName: service => `${service}-pubsub`
+      serviceName: ({ tracerService }) => `${tracerService}-pubsub`
     }
   }
 }