dd-trace 2.38.0 → 2.40.0

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

@@ -12,7 +12,7 @@ const WallProfiler = require('./profilers/wall')
 const SpaceProfiler = require('./profilers/space')
 const { oomExportStrategies, snapshotKinds } = require('./constants')
 const { tagger } = require('./tagger')
-const { isTrue } = require('../util')
+const { isFalse, isTrue } = require('../util')
 
 class Config {
   constructor (options = {}) {
@@ -32,6 +32,8 @@ class Config {
       DD_PROFILING_SOURCE_MAP,
       DD_PROFILING_UPLOAD_PERIOD,
       DD_PROFILING_PPROF_PREFIX,
+      DD_PROFILING_HEAP_ENABLED,
+      DD_PROFILING_WALLTIME_ENABLED,
       DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED,
       DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE,
       DD_PROFILING_EXPERIMENTAL_OOM_MAX_HEAP_EXTENSION_COUNT,
@@ -106,10 +108,9 @@ class Config {
       exportCommand
     }
 
-    const profilers = coalesce(options.profilers, DD_PROFILING_PROFILERS, [
-      new WallProfiler(this),
-      new SpaceProfiler(this)
-    ])
+    const profilers = options.profilers
+      ? options.profilers
+      : getProfilers({ DD_PROFILING_HEAP_ENABLED, DD_PROFILING_WALLTIME_ENABLED, DD_PROFILING_PROFILERS })
 
     this.profilers = ensureProfilers(profilers, this)
   }
@@ -117,6 +118,32 @@ class Config {
 
 module.exports = { Config }
 
+function getProfilers ({ DD_PROFILING_HEAP_ENABLED, DD_PROFILING_WALLTIME_ENABLED, DD_PROFILING_PROFILERS }) {
+  // First consider "legacy" DD_PROFILING_PROFILERS env variable, defaulting to wall + space
+  // Use a Set to avoid duplicates
+  const profilers = new Set(coalesce(DD_PROFILING_PROFILERS, 'wall,space').split(','))
+
+  // Add/remove wall depending on the value of DD_PROFILING_WALLTIME_ENABLED
+  if (DD_PROFILING_WALLTIME_ENABLED != null) {
+    if (isTrue(DD_PROFILING_WALLTIME_ENABLED)) {
+      profilers.add('wall')
+    } else if (isFalse(DD_PROFILING_WALLTIME_ENABLED)) {
+      profilers.delete('wall')
+    }
+  }
+
+  // Add/remove wall depending on the value of DD_PROFILING_HEAP_ENABLED
+  if (DD_PROFILING_HEAP_ENABLED != null) {
+    if (isTrue(DD_PROFILING_HEAP_ENABLED)) {
+      profilers.add('space')
+    } else if (isFalse(DD_PROFILING_HEAP_ENABLED)) {
+      profilers.delete('space')
+    }
+  }
+
+  return [...profilers]
+}
+
 function getExportStrategy (name, options) {
   const strategy = Object.values(oomExportStrategies).find(value => value === name)
   if (strategy === undefined) {

package/packages/dd-trace/src/service-naming/index.js

@@ -3,7 +3,7 @@ const { schemaDefinitions } = require('./schemas')
 class SchemaManager {
   constructor () {
     this.schemas = schemaDefinitions
-    this.config = { spanAttributeSchema: 'v0' }
+    this.config = { spanAttributeSchema: 'v0', traceRemoveIntegrationServiceNamesEnabled: false }
   }
 
   get schema () {
@@ -14,6 +14,10 @@ class SchemaManager {
     return this.config.spanAttributeSchema
   }
 
+  get shouldUseConsistentServiceNaming () {
+    return this.config.traceRemoveIntegrationServiceNamesEnabled && this.version === 'v0'
+  }
+
   opName (type, kind, plugin, ...opNameArgs) {
     return this.schema.getOpName(type, kind, plugin, ...opNameArgs)
   }
@@ -22,6 +26,14 @@ class SchemaManager {
     return this.schema.getServiceName(type, kind, plugin, this.config.service, ...serviceNameArgs)
   }
 
+  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
+  }
+
   configure (config = {}) {
     this.config = config
   }

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

@@ -1,13 +1,22 @@
 const { identityService } = require('../util')
+const { DD_MAJOR } = require('../../../../../../version')
 
 const web = {
   client: {
+    grpc: {
+      opName: () => DD_MAJOR <= 2 ? 'grpc.request' : 'grpc.client',
+      serviceName: identityService
+    },
     moleculer: {
       opName: () => 'moleculer.call',
       serviceName: identityService
     }
   },
   server: {
+    grpc: {
+      opName: () => DD_MAJOR <= 2 ? 'grpc.request' : 'grpc.server',
+      serviceName: identityService
+    },
     moleculer: {
       opName: () => 'moleculer.action',
       serviceName: identityService

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

@@ -2,12 +2,20 @@ const { identityService } = require('../util')
 
 const web = {
   client: {
+    grpc: {
+      opName: () => 'grpc.client.request',
+      serviceName: identityService
+    },
     moleculer: {
       opName: () => 'moleculer.client.request',
       serviceName: identityService
     }
   },
   server: {
+    grpc: {
+      opName: () => 'grpc.server.request',
+      serviceName: identityService
+    },
     moleculer: {
       opName: () => 'moleculer.server.request',
       serviceName: identityService

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

@@ -89,6 +89,26 @@ class CountMetric extends Metric {
   }
 }
 
+class DistributionMetric extends Metric {
+  get type () {
+    return 'distribution'
+  }
+
+  track (value = 1) {
+    this.points.push(value)
+  }
+
+  toJSON () {
+    const { metric, points, tags, common } = this
+    return {
+      metric,
+      points,
+      common,
+      tags
+    }
+  }
+}
+
 class GaugeMetric extends Metric {
   get type () {
     return 'gauge'
@@ -129,11 +149,12 @@ class RateMetric extends Metric {
 
 const metricsTypes = {
   count: CountMetric,
+  distribution: DistributionMetric,
   gauge: GaugeMetric,
   rate: RateMetric
 }
 
-class Namespace extends Map {
+class MetricsCollection extends Map {
   constructor (namespace) {
     super()
     this.namespace = namespace
@@ -146,43 +167,68 @@ class Namespace extends Map {
   }
 
   toString () {
-    return `dd.instrumentation_telemetry_data.${this.namespace}`
+    return this.namespace
+  }
+
+  toJSON () {
+    if (!this.size) return
+    const { namespace } = this
+    return {
+      namespace,
+      series: mapToJsonArray(this)
+    }
   }
+}
 
-  getMetric (type, name, tags, interval) {
-    const metricId = getId(type, this, name, tags)
+function getMetric (collection, type, name, tags, interval) {
+  const metricId = getId(type, collection, name, tags)
 
-    let metric = this.get(metricId)
-    if (metric) return metric
+  let metric = collection.get(metricId)
+  if (metric) return metric
 
-    const Factory = metricsTypes[type]
-    if (!Factory) {
-      throw new Error(`Unknown metric type ${type}`)
-    }
+  const Factory = metricsTypes[type]
+  if (!Factory) {
+    throw new Error(`Unknown metric type ${type}`)
+  }
+
+  metric = new Factory(collection, name, true, tags, interval)
+  collection.set(metricId, metric)
 
-    metric = new Factory(this, name, true, tags, interval)
-    this.set(metricId, metric)
+  return metric
+}
 
-    return metric
+class Namespace {
+  constructor (namespace) {
+    this.distributions = new MetricsCollection(namespace)
+    this.metrics = new MetricsCollection(namespace)
+  }
+
+  reset () {
+    this.metrics.reset()
+    this.distributions.reset()
   }
 
   count (name, tags) {
-    return this.getMetric('count', name, tags)
+    return getMetric(this.metrics, 'count', name, tags)
   }
 
   gauge (name, tags) {
-    return this.getMetric('gauge', name, tags)
+    return getMetric(this.metrics, 'gauge', name, tags)
   }
 
   rate (name, interval, tags) {
-    return this.getMetric('rate', name, tags, interval)
+    return getMetric(this.metrics, 'rate', name, tags, interval)
+  }
+
+  distribution (name, tags) {
+    return getMetric(this.distributions, 'distribution', name, tags)
   }
 
   toJSON () {
-    const { namespace } = this
+    const { distributions, metrics } = this
     return {
-      namespace,
-      series: mapToJsonArray(this)
+      distributions: distributions.toJSON(),
+      metrics: metrics.toJSON()
     }
   }
 }
@@ -203,7 +249,15 @@ class NamespaceManager extends Map {
 
   send (config, application, host) {
     for (const namespace of this.values()) {
-      sendData(config, application, host, 'generate-metrics', namespace.toJSON())
+      const { metrics, distributions } = namespace.toJSON()
+
+      if (metrics) {
+        sendData(config, application, host, 'generate-metrics', metrics)
+      }
+
+      if (distributions) {
+        sendData(config, application, host, 'distributions', distributions)
+      }
 
       // TODO: This could also be clear() but then it'd have to rebuild all
       // metric instances on every send. This may be desirable if we want tags
@@ -217,8 +271,10 @@ const manager = new NamespaceManager()
 
 module.exports = {
   CountMetric,
+  DistributionMetric,
   GaugeMetric,
   RateMetric,
+  MetricsCollection,
   Namespace,
   NamespaceManager,
   manager

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

@@ -7,7 +7,10 @@ const { storage } = require('../../datadog-core')
 const { isError } = require('./util')
 const { setStartupLogConfig } = require('./startup-log')
 const { ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK } = require('../../dd-trace/src/constants')
+const { DataStreamsProcessor } = require('./datastreams/processor')
+const { decodePathwayContext } = require('./datastreams/pathway')
 const { DD_MAJOR } = require('../../../version')
+const DataStreamsContext = require('./data_streams_context')
 
 const SPAN_TYPE = tags.SPAN_TYPE
 const RESOURCE_NAME = tags.RESOURCE_NAME
@@ -17,11 +20,26 @@ const MEASURED = tags.MEASURED
 class DatadogTracer extends Tracer {
   constructor (config) {
     super(config)
-
+    this._dataStreamsProcessor = new DataStreamsProcessor(config)
     this._scope = new Scope()
     setStartupLogConfig(config)
   }
 
+  // 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) {
+    const ctx = this._dataStreamsProcessor.setCheckpoint(edgeTags, DataStreamsContext.getDataStreamsContext())
+    DataStreamsContext.setDataStreamsContext(ctx)
+    return ctx
+  }
+
+  decodeDataStreamsContext (data) {
+    const ctx = decodePathwayContext(data)
+    // we erase the previous context everytime we decode a new one
+    DataStreamsContext.setDataStreamsContext(ctx)
+    return ctx
+  }
+
   trace (name, options, fn) {
     options = Object.assign({
       childOf: this.scope().active()