dd-trace 5.41.0 → 5.41.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.41.0",
+  "version": "5.41.1",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",

package/packages/datadog-instrumentations/src/fetch.js

@@ -17,7 +17,7 @@ if (globalThis.fetch) {
 
     const ch = tracingChannel('apm:fetch:request')
     const wrapFetch = createWrapFetch(globalThis.Request, ch, () => {
-      channel('dd-trace:instrumentation:load').publish({ name: 'fetch' })
+      channel('dd-trace:instrumentation:load').publish({ name: 'global:fetch' })
     })
 
     fetch = wrapFetch(globalFetch)

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

@@ -6,6 +6,7 @@ const dgram = require('dgram')
 const isIP = require('net').isIP
 const log = require('./log')
 const { URL, format } = require('url')
+const Histogram = require('./histogram')
 
 const MAX_BUFFER_SIZE = 1024 // limit from the agent
 
@@ -193,6 +194,117 @@ class DogStatsDClient {
   }
 }
 
+// TODO: Handle arrays of tags and tags translation.
+class MetricsAggregationClient {
+  constructor (client) {
+    this._client = client
+
+    this.reset()
+  }
+
+  flush () {
+    this._captureCounters()
+    this._captureGauges()
+    this._captureHistograms()
+
+    this._client.flush()
+  }
+
+  reset () {
+    this._counters = {}
+    this._gauges = {}
+    this._histograms = {}
+  }
+
+  distribution (name, value, tag) {
+    this._client.distribution(name, value, tag && [tag])
+  }
+
+  boolean (name, value, tag) {
+    this.gauge(name, value ? 1 : 0, tag)
+  }
+
+  histogram (name, value, tag) {
+    this._histograms[name] = this._histograms[name] || new Map()
+
+    if (!this._histograms[name].has(tag)) {
+      this._histograms[name].set(tag, new Histogram())
+    }
+
+    this._histograms[name].get(tag).record(value)
+  }
+
+  count (name, count, tag, monotonic = false) {
+    if (typeof tag === 'boolean') {
+      monotonic = tag
+      tag = undefined
+    }
+
+    const map = monotonic ? this._counters : this._gauges
+
+    map[name] = map[name] || new Map()
+
+    const value = map[name].get(tag) || 0
+
+    map[name].set(tag, value + count)
+  }
+
+  gauge (name, value, tag) {
+    this._gauges[name] = this._gauges[name] || new Map()
+    this._gauges[name].set(tag, value)
+  }
+
+  increment (name, count = 1, tag, monotonic) {
+    this.count(name, count, tag, monotonic)
+  }
+
+  decrement (name, count = 1, tag) {
+    this.count(name, -count, tag)
+  }
+
+  _captureGauges () {
+    Object.keys(this._gauges).forEach(name => {
+      this._gauges[name].forEach((value, tag) => {
+        this._client.gauge(name, value, tag && [tag])
+      })
+    })
+  }
+
+  _captureCounters () {
+    Object.keys(this._counters).forEach(name => {
+      this._counters[name].forEach((value, tag) => {
+        this._client.increment(name, value, tag && [tag])
+      })
+    })
+
+    this._counters = {}
+  }
+
+  _captureHistograms () {
+    Object.keys(this._histograms).forEach(name => {
+      this._histograms[name].forEach((stats, tag) => {
+        const tags = tag && [tag]
+
+        // Stats can contain garbage data when a value was never recorded.
+        if (stats.count === 0) {
+          stats = { max: 0, min: 0, sum: 0, avg: 0, median: 0, p95: 0, count: 0, reset: stats.reset }
+        }
+
+        this._client.gauge(`${name}.min`, stats.min, tags)
+        this._client.gauge(`${name}.max`, stats.max, tags)
+        this._client.increment(`${name}.sum`, stats.sum, tags)
+        this._client.increment(`${name}.total`, stats.sum, tags)
+        this._client.gauge(`${name}.avg`, stats.avg, tags)
+        this._client.increment(`${name}.count`, stats.count, tags)
+        this._client.gauge(`${name}.median`, stats.median, tags)
+        this._client.gauge(`${name}.95percentile`, stats.p95, tags)
+
+        stats.reset()
+      })
+    })
+  }
+}
+
 /**
  * This is a simplified user-facing proxy to the underlying DogStatsDClient instance
  *
@@ -201,7 +313,7 @@ class DogStatsDClient {
 class CustomMetrics {
   constructor (config) {
     const clientConfig = DogStatsDClient.generateClientConfig(config)
-    this.dogstatsd = new DogStatsDClient(clientConfig)
+    this._client = new MetricsAggregationClient(new DogStatsDClient(clientConfig))
 
     const flush = this.flush.bind(this)
 
@@ -212,47 +324,43 @@ class CustomMetrics {
   }
 
   increment (stat, value = 1, tags) {
-    return this.dogstatsd.increment(
-      stat,
-      value,
-      CustomMetrics.tagTranslator(tags)
-    )
+    for (const tag of this._normalizeTags(tags)) {
+      this._client.increment(stat, value, tag)
+    }
   }
 
   decrement (stat, value = 1, tags) {
-    return this.dogstatsd.decrement(
-      stat,
-      value,
-      CustomMetrics.tagTranslator(tags)
-    )
+    for (const tag of this._normalizeTags(tags)) {
+      this._client.decrement(stat, value, tag)
+    }
   }
 
   gauge (stat, value, tags) {
-    return this.dogstatsd.gauge(
-      stat,
-      value,
-      CustomMetrics.tagTranslator(tags)
-    )
+    for (const tag of this._normalizeTags(tags)) {
+      this._client.gauge(stat, value, tag)
+    }
   }
 
   distribution (stat, value, tags) {
-    return this.dogstatsd.distribution(
-      stat,
-      value,
-      CustomMetrics.tagTranslator(tags)
-    )
+    for (const tag of this._normalizeTags(tags)) {
+      this._client.distribution(stat, value, tag)
+    }
   }
 
   histogram (stat, value, tags) {
-    return this.dogstatsd.histogram(
-      stat,
-      value,
-      CustomMetrics.tagTranslator(tags)
-    )
+    for (const tag of this._normalizeTags(tags)) {
+      this._client.histogram(stat, value, tag)
+    }
   }
 
   flush () {
-    return this.dogstatsd.flush()
+    return this._client.flush()
+  }
+
+  _normalizeTags (tags) {
+    tags = CustomMetrics.tagTranslator(tags)
+
+    return tags.length === 0 ? [undefined] : tags
   }
 
   /**
@@ -274,5 +382,6 @@ class CustomMetrics {
 
 module.exports = {
   DogStatsDClient,
-  CustomMetrics
+  CustomMetrics,
+  MetricsAggregationClient
 }

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

@@ -103,10 +103,6 @@ module.exports = class PluginManager {
     this._tracerConfig = config
     this._tracer._nomenclature.configure(config)
 
-    if (!config._isInServerlessEnvironment?.()) {
-      maybeEnable(require('../../datadog-plugin-fetch/src'))
-    }
-
     for (const name in pluginClasses) {
       this.loadPlugin(name)
     }

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

@@ -39,6 +39,7 @@ module.exports = {
   get express () { return require('../../../datadog-plugin-express/src') },
   get fastify () { return require('../../../datadog-plugin-fastify/src') },
   get 'find-my-way' () { return require('../../../datadog-plugin-find-my-way/src') },
+  get 'global:fetch' () { return require('../../../datadog-plugin-fetch/src') },
   get graphql () { return require('../../../datadog-plugin-graphql/src') },
   get grpc () { return require('../../../datadog-plugin-grpc/src') },
   get hapi () { return require('../../../datadog-plugin-hapi/src') },

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

@@ -4,7 +4,7 @@
 
 const v8 = require('v8')
 const os = require('os')
-const { DogStatsDClient } = require('../dogstatsd')
+const { DogStatsDClient, MetricsAggregationClient } = require('../dogstatsd')
 const log = require('../log')
 const Histogram = require('../histogram')
 const { performance, PerformanceObserver } = require('perf_hooks')
@@ -25,9 +25,6 @@ let interval
 let client
 let time
 let cpuUsage
-let gauges
-let counters
-let histograms
 let elu
 
 reset()
@@ -49,7 +46,7 @@ const runtimeMetrics = module.exports = {
       nativeMetrics = null
     }
 
-    client = new DogStatsDClient(clientConfig)
+    client = new MetricsAggregationClient(new DogStatsDClient(clientConfig))
 
     time = process.hrtime()
 
@@ -98,50 +95,27 @@ const runtimeMetrics = module.exports = {
   },
 
   boolean (name, value, tag) {
-    this.gauge(name, value ? 1 : 0, tag)
+    client && client.boolean(name, value, tag)
   },
 
   histogram (name, value, tag) {
-    if (!client) return
-
-    histograms[name] = histograms[name] || new Map()
-
-    if (!histograms[name].has(tag)) {
-      histograms[name].set(tag, new Histogram())
-    }
-
-    histograms[name].get(tag).record(value)
+    client && client.histogram(name, value, tag)
   },
 
   count (name, count, tag, monotonic = false) {
-    if (!client) return
-    if (typeof tag === 'boolean') {
-      monotonic = tag
-      tag = undefined
-    }
-
-    const map = monotonic ? counters : gauges
-
-    map[name] = map[name] || new Map()
-
-    const value = map[name].get(tag) || 0
-
-    map[name].set(tag, value + count)
+    client && client.count(name, count, tag, monotonic)
   },
 
   gauge (name, value, tag) {
-    if (!client) return
-
-    gauges[name] = gauges[name] || new Map()
-    gauges[name].set(tag, value)
+    client && client.gauge(name, value, tag)
   },
 
   increment (name, tag, monotonic) {
-    this.count(name, 1, tag, monotonic)
+    client && client.increment(name, 1, tag, monotonic)
   },
 
   decrement (name, tag) {
-    this.count(name, -1, tag)
+    client && client.decrement(name, 1, tag)
   }
 }
 
@@ -150,9 +124,6 @@ function reset () {
   client = null
   time = null
   cpuUsage = null
-  gauges = {}
-  counters = {}
-  histograms = {}
   nativeMetrics = null
   gcObserver && gcObserver.disconnect()
   gcObserver = null
@@ -246,33 +217,6 @@ function captureGCMetrics () {
   gcProfiler.start()
 }
 
-function captureGauges () {
-  Object.keys(gauges).forEach(name => {
-    gauges[name].forEach((value, tag) => {
-      client.gauge(name, value, tag && [tag])
-    })
-  })
-}
-
-function captureCounters () {
-  Object.keys(counters).forEach(name => {
-    counters[name].forEach((value, tag) => {
-      client.increment(name, value, tag && [tag])
-    })
-  })
-
-  counters = {}
-}
-
-function captureHistograms () {
-  Object.keys(histograms).forEach(name => {
-    histograms[name].forEach((stats, tag) => {
-      histogram(name, stats, tag && [tag])
-      stats.reset()
-    })
-  })
-}
-
 /**
  * Gathers and reports Event Loop Utilization (ELU) since last run
  *
@@ -295,9 +239,6 @@ function captureCommonMetrics () {
   captureMemoryUsage()
   captureProcess()
   captureHeapStats()
-  captureGauges()
-  captureCounters()
-  captureHistograms()
   captureELU()
   captureGCMetrics()
 }
@@ -339,21 +280,15 @@ function captureNativeMetrics () {
 }
 
 function histogram (name, stats, tags) {
-  tags = [].concat(tags)
+  tags = tags ? [].concat(tags) : []
 
-  // Stats can contain garbage data when a value was never recorded.
-  if (stats.count === 0) {
-    stats = { max: 0, min: 0, sum: 0, avg: 0, median: 0, p95: 0, count: 0 }
+  if (tags.length > 0) {
+    for (const tag of tags) {
+      client.histogram(name, stats, tag)
+    }
+  } else {
+    client.histogram(name, stats)
   }
-
-  client.gauge(`${name}.min`, stats.min, tags)
-  client.gauge(`${name}.max`, stats.max, tags)
-  client.increment(`${name}.sum`, stats.sum, tags)
-  client.increment(`${name}.total`, stats.sum, tags)
-  client.gauge(`${name}.avg`, stats.avg, tags)
-  client.increment(`${name}.count`, stats.count, tags)
-  client.gauge(`${name}.median`, stats.median, tags)
-  client.gauge(`${name}.95percentile`, stats.p95, tags)
 }
 
 function startGCObserver () {