dd-trace 6.2.0 → 6.4.0

package/packages/dd-trace/src/openfeature/register.js

@@ -0,0 +1,46 @@
+'use strict'
+
+const { registerFeature } = require('../feature-registry')
+
+const noop = new (require('./noop'))()
+
+/**
+ * @param {import('../proxy')} proxy
+ * @returns {boolean}
+ */
+function hasFlaggingProvider (proxy) {
+  const descriptor = Reflect.getOwnPropertyDescriptor(proxy, 'openfeature')
+
+  return descriptor?.value !== undefined && descriptor.value !== noop
+}
+
+registerFeature({
+  name: 'openfeature',
+  noop,
+  factory: () => require('./index'),
+
+  /**
+   * @param {object} rc - RemoteConfig instance
+   * @param {import('../config/config-base')} config
+   * @param {import('../proxy')} proxy
+   */
+  remoteConfig (rc, config, proxy) {
+    const openfeatureRemoteConfig = require('./remote_config')
+    openfeatureRemoteConfig.enable(rc, config, () => proxy.openfeature)
+  },
+
+  /**
+   * @param {import('../config/config-base')} config
+   * @param {import('../tracer')} tracer
+   * @param {import('../proxy')} proxy
+   * @param {Function} lazyProxy
+   */
+  enable (config, tracer, proxy, lazyProxy) {
+    if (config.experimental.flaggingProvider.enabled) {
+      proxy._modules.openfeature.enable(config)
+      if (!hasFlaggingProvider(proxy)) {
+        lazyProxy(proxy, 'openfeature', () => require('./flagging_provider'), tracer, config)
+      }
+    }
+  },
+})

package/packages/dd-trace/src/opentelemetry/span_processor.js

@@ -14,32 +14,34 @@ class NoopSpanProcessor {
 }
 
 class MultiSpanProcessor extends NoopSpanProcessor {
+  #processors
+
   constructor (spanProcessors) {
     super()
-    this._processors = spanProcessors
+    this.#processors = spanProcessors
   }
 
   forceFlush () {
     return Promise.all(
-      this._processors.map(p => p.forceFlush())
+      this.#processors.map(p => p.forceFlush())
     )
   }
 
   onStart (span, context) {
-    for (const processor of this._processors) {
+    for (const processor of this.#processors) {
       processor.onStart(span, context)
     }
   }
 
   onEnd (span) {
-    for (const processor of this._processors) {
+    for (const processor of this.#processors) {
       processor.onEnd(span)
     }
   }
 
   shutdown () {
     return Promise.all(
-      this._processors.map(p => p.shutdown())
+      this.#processors.map(p => p.shutdown())
     )
   }
 }

package/packages/dd-trace/src/opentelemetry/tracer_provider.js

@@ -10,46 +10,62 @@ const { MultiSpanProcessor, NoopSpanProcessor } = require('./span_processor')
 const Tracer = require('./tracer')
 
 class TracerProvider {
+  #activeProcessor = new NoopSpanProcessor()
+  #contextManager = new ContextManager()
+  #processors = []
+  #tracers = new Map()
+
   constructor (config = {}) {
     this.config = config
     this.resource = config.resource
 
-    this._processors = []
-    this._tracers = new Map()
-    this._activeProcessor = new NoopSpanProcessor()
-    this._contextManager = new ContextManager()
+    // @opentelemetry/sdk-trace 2.x (used by @opentelemetry/sdk-node 0.220+)
+    // dropped `addSpanProcessor` and hands the processors to the provider
+    // constructor instead. Wire them the same way the 1.x `addSpanProcessor`
+    // path does, so a NodeSDK configured with a trace exporter or custom
+    // processors still delivers onStart/onEnd to them.
+    if (Array.isArray(config.spanProcessors)) {
+      for (const spanProcessor of config.spanProcessors) {
+        this.addSpanProcessor(spanProcessor)
+      }
+    }
   }
 
   getTracer (name = 'opentelemetry', version = '0.0.0', options) {
     const key = `${name}@${version}`
-    if (!this._tracers.has(key)) {
-      this._tracers.set(key, new Tracer(
+    if (!this.#tracers.has(key)) {
+      this.#tracers.set(key, new Tracer(
         { ...options, name, version },
         this.config,
         this
       ))
     }
-    return this._tracers.get(key)
+    return this.#tracers.get(key)
   }
 
+  /**
+   * @param {NoopSpanProcessor} spanProcessor
+   */
   addSpanProcessor (spanProcessor) {
-    if (!this._processors.length) {
-      this._activeProcessor.shutdown()
+    if (this.#processors.includes(spanProcessor)) return
+
+    if (!this.#processors.length) {
+      this.#activeProcessor.shutdown()
     }
-    this._processors.push(spanProcessor)
-    this._activeProcessor = new MultiSpanProcessor(
-      this._processors
+    this.#processors.push(spanProcessor)
+    this.#activeProcessor = new MultiSpanProcessor(
+      this.#processors
     )
   }
 
   getActiveSpanProcessor () {
-    return this._activeProcessor
+    return this.#activeProcessor
   }
 
   // Not actually required by the SDK spec, but the official Node.js SDK does
   // this and the docs reflect that so we should do this too for familiarity.
   register (config = {}) {
-    context.setGlobalContextManager(this._contextManager)
+    context.setGlobalContextManager(this.#contextManager)
     if (!trace.setGlobalTracerProvider(this)) {
       trace.getTracerProvider().setDelegate(this)
     }
@@ -69,11 +85,11 @@ class TracerProvider {
     }
 
     exporter._writer?.flush()
-    return this._activeProcessor.forceFlush()
+    return this.#activeProcessor.forceFlush()
   }
 
   shutdown () {
-    return this._activeProcessor.shutdown()
+    return this.#activeProcessor.shutdown()
   }
 }
 

package/packages/dd-trace/src/opentracing/propagation/log.js

@@ -8,8 +8,13 @@ class LogPropagator {
     this._config = config
   }
 
+  /**
+   * @param {DatadogSpanContext | null | undefined} spanContext
+   * @param {Record<string, unknown>} [carrier]
+   * @returns {Record<string, unknown> | undefined}
+   */
   inject (spanContext, carrier) {
-    if (!carrier) return
+    if (carrier === null) return
 
     const dd = {}
     let hasField = false
@@ -35,7 +40,11 @@ class LogPropagator {
       hasField = true
     }
 
-    if (hasField) carrier.dd = dd
+    if (!hasField) return
+
+    carrier ??= {}
+    carrier.dd = dd
+    return carrier
   }
 
   extract (carrier) {

package/packages/dd-trace/src/opentracing/propagation/text_map.js

@@ -8,6 +8,7 @@ const log = require('../../log')
 const tags = require('../../../../../ext/tags')
 const { getConfiguredEnvName } = require('../../config/helper')
 const { setAllBaggageItems, getAllBaggageItems, removeAllBaggageItems } = require('../../baggage')
+const { hasTraceSourcePropagationTag } = require('../../standalone/tracesource')
 const telemetryMetrics = require('../../telemetry/metrics')
 const { DD_MAJOR } = require('../../../../../version')
 
@@ -119,22 +120,35 @@ class TextMapPropagator {
     return this.#baggageTagKeysSet
   }
 
+  /**
+   * @param {DatadogSpanContext | null | undefined} spanContext
+   * @param {Record<string, string>} [carrier]
+   * @returns {Record<string, string> | undefined}
+   */
   inject (spanContext, carrier) {
-    if (!carrier) return
-    this._injectBaggageItems(spanContext, carrier)
-    if (!spanContext) return
+    if (carrier === null) return
+    let injectedCarrier = this._injectBaggageItems(spanContext, carrier)
+    if (!spanContext) return injectedCarrier
 
-    this._injectDatadog(spanContext, carrier)
-    this._injectB3MultipleHeaders(spanContext, carrier)
-    this._injectB3SingleHeader(spanContext, carrier)
-    this._injectTraceparent(spanContext, carrier)
-
-    if (injectCh.hasSubscribers) {
-      injectCh.publish({ spanContext, carrier })
+    const injectTraceContext = this._config.apmTracingEnabled !== false ||
+      hasTraceSourcePropagationTag(spanContext._trace.tags)
+    if (injectTraceContext) {
+      injectedCarrier = this._injectDatadog(spanContext, injectedCarrier ?? carrier) ?? injectedCarrier
+      injectedCarrier = this._injectB3MultipleHeaders(spanContext, injectedCarrier ?? carrier) ?? injectedCarrier
+      injectedCarrier = this._injectB3SingleHeader(spanContext, injectedCarrier ?? carrier) ?? injectedCarrier
     }
+    injectedCarrier = this
+      ._injectTraceparent(spanContext, injectedCarrier ?? carrier, injectTraceContext) ?? injectedCarrier
+
+    if (injectedCarrier === undefined) return
+
+    carrier = injectedCarrier
+    if (injectCh.hasSubscribers) injectCh.publish({ spanContext, carrier })
 
     // eslint-disable-next-line eslint-rules/eslint-log-printf-style
     log.debug(() => `Inject into carrier: ${JSON.stringify(pick(carrier, logKeys))}.`)
+
+    return carrier
   }
 
   extract (carrier) {
@@ -156,15 +170,23 @@ class TextMapPropagator {
     return spanContext
   }
 
+  /**
+   * @param {DatadogSpanContext} spanContext
+   * @param {Record<string, string>} [carrier]
+   * @returns {Record<string, string> | undefined}
+   */
   _injectDatadog (spanContext, carrier) {
     if (!this._hasPropagationStyle('inject', 'datadog')) return
 
+    carrier ??= {}
     carrier[traceKey] = spanContext.toTraceId()
     carrier[spanKey] = spanContext.toSpanId()
 
     this._injectOrigin(spanContext, carrier)
     this._injectSamplingPriority(spanContext, carrier)
     this._injectTags(spanContext, carrier)
+
+    return carrier
   }
 
   _injectOrigin (spanContext, carrier) {
@@ -183,7 +205,13 @@ class TextMapPropagator {
     }
   }
 
+  /**
+   * @param {DatadogSpanContext | null | undefined} spanContext
+   * @param {Record<string, string>} [carrier]
+   * @returns {Record<string, string> | undefined}
+   */
   _injectBaggageItems (spanContext, carrier) {
+    let injectedCarrier
     if (this._config.legacyBaggageEnabled) {
       const baggageItems = spanContext?._baggageItems
       if (baggageItems) {
@@ -202,7 +230,8 @@ class TextMapPropagator {
           if (invalidHeaderValueCharExpr.test(headerValue)) {
             headerValue = encodeURIComponent(headerValue)
           }
-          carrier[headerName] = headerValue
+          injectedCarrier ??= carrier ?? {}
+          injectedCarrier[headerName] = headerValue
         }
       }
     }
@@ -213,7 +242,6 @@ class TextMapPropagator {
       let byteCounter = 0
 
       const baggageItems = getAllBaggageItems()
-      if (!baggageItems) return
       for (const key of Object.keys(baggageItems)) {
         const baggageKey = key.trim()
         if (!baggageTokenExpr.test(baggageKey)) continue
@@ -242,10 +270,13 @@ class TextMapPropagator {
 
       baggage = baggage.slice(0, -1)
       if (baggage) {
-        carrier.baggage = baggage
+        injectedCarrier ??= carrier ?? {}
+        injectedCarrier.baggage = baggage
         tracerMetrics.count('context_header_style.injected', ['header_style:baggage']).inc()
       }
     }
+
+    return injectedCarrier
   }
 
   _injectTags (spanContext, carrier) {
@@ -278,12 +309,18 @@ class TextMapPropagator {
     }
   }
 
+  /**
+   * @param {DatadogSpanContext} spanContext
+   * @param {Record<string, string>} [carrier]
+   * @returns {Record<string, string> | undefined}
+   */
   _injectB3MultipleHeaders (spanContext, carrier) {
     // v5 also accepts the legacy `'b3'` spelling for multi; v6 routes `'b3'` to single-header.
     const hasB3multi = this._hasPropagationStyle('inject', 'b3multi') ||
       (DD_MAJOR < 6 && this._hasPropagationStyle('inject', 'b3'))
     if (!hasB3multi) return
 
+    carrier ??= {}
     carrier[b3TraceKey] = spanContext._traceId.toTraceIdHex(spanContext._trace.tags['_dd.p.tid'])
     carrier[b3SpanKey] = spanContext._spanId.toString(16)
     carrier[b3SampledKey] = spanContext._sampling.priority >= AUTO_KEEP ? '1' : '0'
@@ -295,14 +332,22 @@ class TextMapPropagator {
     if (spanContext._parentId) {
       carrier[b3ParentKey] = spanContext._parentId.toString(16)
     }
+
+    return carrier
   }
 
+  /**
+   * @param {DatadogSpanContext} spanContext
+   * @param {Record<string, string>} [carrier]
+   * @returns {Record<string, string> | undefined}
+   */
   _injectB3SingleHeader (spanContext, carrier) {
     // v6 keeps `'b3 single header'` as a back-compat alias for callers that bypass parser normalisation.
     const hasB3SingleHeader = this._hasPropagationStyle('inject', 'b3 single header') ||
       (DD_MAJOR >= 6 && this._hasPropagationStyle('inject', 'b3'))
     if (!hasB3SingleHeader) return
 
+    carrier ??= {}
     const traceId = spanContext._traceId.toTraceIdHex(spanContext._trace.tags['_dd.p.tid'])
     const spanId = spanContext._spanId.toString(16)
     const sampled = spanContext._sampling.priority >= AUTO_KEEP ? '1' : '0'
@@ -311,11 +356,30 @@ class TextMapPropagator {
     if (spanContext._parentId) {
       carrier[b3HeaderKey] += '-' + spanContext._parentId.toString(16)
     }
+
+    return carrier
   }
 
-  _injectTraceparent (spanContext, carrier) {
+  /**
+   * @param {DatadogSpanContext} spanContext
+   * @param {Record<string, string> | undefined} carrier
+   * @param {boolean} injectTraceContext
+   * @returns {Record<string, string> | undefined}
+   */
+  _injectTraceparent (spanContext, carrier, injectTraceContext) {
     if (!this._hasPropagationStyle('inject', 'tracecontext')) return
 
+    if (!injectTraceContext) {
+      const tracestate = TraceState.fromString(spanContext._tracestate?.toString())
+      tracestate.delete('dd')
+      const header = tracestate.toString()
+      if (!header) return
+      carrier ??= {}
+      carrier.tracestate = header
+      return carrier
+    }
+
+    carrier ??= {}
     const {
       _sampling: { priority, mechanism },
       _tracestate: ts = new TraceState(),
@@ -363,6 +427,8 @@ class TextMapPropagator {
     })
 
     carrier.tracestate = ts.toString()
+
+    return carrier
   }
 
   _hasPropagationStyle (mode, name) {

package/packages/dd-trace/src/opentracing/propagation/text_map_dsm.js

@@ -13,13 +13,22 @@ class DSMTextMapPropagator {
     this.config = config
   }
 
+  /**
+   * @param {object} ctx DSM pathway context.
+   * @param {Record<string, string>} [carrier]
+   * @returns {Record<string, string> | undefined}
+   */
   inject (ctx, carrier) {
     if (!this.config.dsmEnabled) return
 
-    DsmPathwayCodec.encode(ctx, carrier)
+    const injectedCarrier = DsmPathwayCodec.encode(ctx, carrier)
+    if (injectedCarrier === undefined) return
 
+    carrier = injectedCarrier
     // eslint-disable-next-line eslint-rules/eslint-log-printf-style
     log.debug(() => `Inject into carrier (DSM): ${JSON.stringify(pick(carrier, logKeys))}.`)
+
+    return carrier
   }
 
   extract (carrier) {

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

@@ -101,6 +101,12 @@ class DatadogTracer {
     return span
   }
 
+  /**
+   * @param {Span|SpanContext} context
+   * @param {string} format
+   * @param {object} [carrier]
+   * @returns {object | undefined}
+   */
   inject (context, format, carrier) {
     if (context instanceof Span) {
       context = context.context()
@@ -110,7 +116,7 @@ class DatadogTracer {
       if (format !== 'text_map_dsm' && format !== formats.LOG) {
         this._prioritySampler.sample(context)
       }
-      this._propagators[format].inject(context, carrier)
+      return this._propagators[format].inject(context, carrier)
     } catch (e) {
       log.error('Error injecting trace', e)
       runtimeMetrics.increment('datadog.tracer.node.inject.errors', true)

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

@@ -1454,7 +1454,7 @@ function parseAnnotations (annotations) {
  * Returns 0 when the test is too slow to retry (≥ 5 min).
  *
  * @param {number} durationMs
- * @param {Record<string, number>} slowTestRetries  e.g. { '5s': 10, '10s': 5, '30s': 3, '5m': 2 }
+ * @param {Record<string, number>} slowTestRetries e.g. { '5s': 10, '10s': 5, '30s': 3, '5m': 2 }
  * @returns {number}
  */
 function getEfdRetryCount (durationMs, slowTestRetries) {
@@ -1469,12 +1469,17 @@ function getEfdRetryCount (durationMs, slowTestRetries) {
 /**
  * Returns the maximum retry count configured by the backend for EFD.
  *
- * @param {Record<string, number>} slowTestRetries e.g. { '5s': 10, '10s': 5, '30s': 3, '5m': 2 }
- * @returns {number}
+ * @param {Record<string, number> | undefined} slowTestRetries
+ * @returns {number | undefined}
  */
 function getMaxEfdRetryCount (slowTestRetries) {
+  if (slowTestRetries === undefined) return
+
+  const retryCounts = Object.values(slowTestRetries)
+  if (retryCounts.length === 0) return
+
   let maxRetries = 0
-  for (const retryCount of Object.values(slowTestRetries || {})) {
+  for (const retryCount of retryCounts) {
     if (retryCount > maxRetries) {
       maxRetries = retryCount
     }

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

@@ -185,6 +185,18 @@ const web = {
     return context
   },
 
+  // Key an existing context on the underlying `Http2Stream` so a second request
+  // backed by the same stream resolves to it via the `req.stream` lookup in
+  // `patch`. Only a mixed HTTP/2 server (raw-stream + 'request' listeners) needs
+  // this: it creates the span from a throwaway stream adapter, then the
+  // compatibility layer synthesizes the real `Http2ServerRequest` off the same
+  // stream and must reuse the adapter's span rather than open an orphan context.
+  // Confined to that path so the common single-listener request pays no extra
+  // per-request map write.
+  linkContextToStream (stream, context) {
+    contexts.set(stream, context)
+  },
+
   // Return the request root span.
   root (req) {
     const context = contexts.get(req)

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

@@ -1,6 +1,7 @@
 'use strict'
 
 const NoopProxy = require('./noop/proxy')
+const { features } = require('./feature-registry')
 const DatadogTracer = require('./tracer')
 const getConfig = require('./config')
 const runtimeMetrics = require('./runtime_metrics')
@@ -91,7 +92,10 @@ class Tracer extends NoopProxy {
       iast: new LazyModule(() => require('./appsec/iast')),
       llmobs: new LazyModule(() => require('./llmobs')),
       rewriter: new LazyModule(() => require('./appsec/iast/taint-tracking/rewriter')),
-      openfeature: new LazyModule(() => require('./openfeature')),
+    }
+
+    for (const feature of Object.values(features)) {
+      this._modules[feature.name] = new LazyModule(feature.factory)
     }
   }
 
@@ -114,7 +118,11 @@ class Tracer extends NoopProxy {
       propagationHash.configure(config)
 
       if (config.DD_CRASHTRACKING_ENABLED) {
-        require('./crashtracking').start(config)
+        try {
+          require('./crashtracking').start(config)
+        } catch (e) {
+          log.warn('Crashtracking is not available in this environment', e)
+        }
       }
 
       if (config.DD_HEAP_SNAPSHOT_COUNT > 0) {
@@ -176,8 +184,9 @@ class Tracer extends NoopProxy {
           DynamicInstrumentation.start(config, rc)
         }
 
-        const openfeatureRemoteConfig = require('./openfeature/remote_config')
-        openfeatureRemoteConfig.enable(rc, config, () => this.openfeature)
+        for (const feature of Object.values(features)) {
+          feature.remoteConfig?.(rc, config, this)
+        }
       }
 
       if (config.profiling.DD_PROFILING_ENABLED === 'true') {
@@ -287,14 +296,15 @@ class Tracer extends NoopProxy {
         lazyProxy(this, 'llmobs', () => require('./llmobs/sdk'), this._tracer, this._modules.llmobs, config)
 
         if (config.experimental?.aiguard?.enabled) {
-          this._modules.aiguard.enable(this._tracer, config)
           lazyProxy(this, 'aiguard', () => require('./aiguard/sdk'), this._tracer, config)
         }
         this._tracingInitialized = true
       }
-      if (config.experimental.flaggingProvider.enabled) {
-        this._modules.openfeature.enable(config)
-        lazyProxy(this, 'openfeature', () => require('./openfeature/flagging_provider'), this._tracer, config)
+      for (const feature of Object.values(features)) {
+        feature.enable?.(config, this._tracer, this, lazyProxy)
+      }
+      if (config.experimental?.aiguard?.enabled) {
+        this._modules.aiguard.enable(this._tracer, config)
       }
       if (config.iast.enabled) {
         this._modules.iast.enable(config, this._tracer)
@@ -305,7 +315,9 @@ class Tracer extends NoopProxy {
       this._modules.aiguard.disable()
       this._modules.iast.disable()
       this._modules.llmobs.disable()
-      this._modules.openfeature.disable()
+      for (const feature of Object.values(features)) {
+        this._modules[feature.name].disable()
+      }
     }
 
     if (this._tracingInitialized) {

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

@@ -7,10 +7,16 @@ const os = require('os')
 const process = require('process')
 const { performance, PerformanceObserver, monitorEventLoopDelay } = require('perf_hooks')
 const log = require('../log')
-const { NODE_MAJOR } = require('../../../../version')
+const { NODE_MAJOR, NODE_MINOR } = require('../../../../version')
 const { createMetricsClient } = require('./client')
 
 const eventLoopDelayResolution = 4
+const EVENT_LOOP_SAMPLE_PER_ITERATION_AVAILABLE = NODE_MAJOR > 26 || (NODE_MAJOR === 26 && NODE_MINOR >= 5)
+
+// @datadog/native-metrics is only needed on Node versions where
+// monitorEventLoopDelay's samplePerIteration option is unavailable.
+// TODO: remove @datadog/native-metrics and this branch once Node < 26.5 is no longer supported.
+const NATIVE_METRICS_REQUIRED = !EVENT_LOOP_SAMPLE_PER_ITERATION_AVAILABLE
 
 let nativeMetrics = null
 let gcObserver = null
@@ -45,7 +51,10 @@ module.exports = {
       startGCObserver()
     }
 
-    const useNative = config.runtimeMetrics.native !== false
+    // When per-iteration sampling is available we prefer it over the native
+    // addon: it provides accurate event loop delay measurements and lets us
+    // collect CPU/GC/heap metrics entirely from JS APIs.
+    const useNative = NATIVE_METRICS_REQUIRED && config.runtimeMetrics.native !== false
 
     if (useNative) {
       // Using no-gc prevents the native gc metrics from being tracked. Not
@@ -74,7 +83,10 @@ module.exports = {
       lastCpuUsage = process.cpuUsage()
 
       if (trackEventLoop) {
-        eventLoopDelayObserver = monitorEventLoopDelay({ resolution: eventLoopDelayResolution })
+        eventLoopDelayObserver = monitorEventLoopDelay({
+          resolution: eventLoopDelayResolution,
+          samplePerIteration: EVENT_LOOP_SAMPLE_PER_ITERATION_AVAILABLE,
+        })
         eventLoopDelayObserver.enable()
       }
 
@@ -83,11 +95,6 @@ module.exports = {
         captureCommonMetrics(trackEventLoop)
         captureHeapSpace()
         if (trackEventLoop) {
-          // Experimental: The Node.js implementation deviates from the native metrics.
-          // We normalize the metrics to the same format but the Node.js values
-          // are that way lower than they should be, while they are still nearer
-          // to the native ones that way.
-          // We use these only as fallback values.
           captureEventLoopDelay()
         }
         client.flush()
@@ -195,12 +202,14 @@ function captureEventLoopDelay () {
   eventLoopDelayObserver.disable()
 
   if (eventLoopDelayObserver.count !== 0) {
-    const minimum = eventLoopDelayResolution * 1e6
+    // Node.js versions without iteration-based metrics use the default sampling method,
+    // which is interval-based and requires normalization because its values are much smaller
+    // than those from the original native implementation and iteration-based metrics.
+    const minimum = EVENT_LOOP_SAMPLE_PER_ITERATION_AVAILABLE ? 0 : eventLoopDelayResolution * 1e6
     const avg = Math.max(eventLoopDelayObserver.mean - minimum, 0)
     const sum = Math.round(avg * eventLoopDelayObserver.count)
 
     if (sum !== 0) {
-      // Normalize the metrics to the same format as the native metrics.
       const stats = {
         min: Math.max(eventLoopDelayObserver.min - minimum, 0),
         max: Math.max(eventLoopDelayObserver.max - minimum, 0),
@@ -214,7 +223,7 @@ function captureEventLoopDelay () {
       histogram('runtime.node.event_loop.delay', stats)
     }
   }
-  eventLoopDelayObserver = monitorEventLoopDelay({ resolution: eventLoopDelayResolution })
+  eventLoopDelayObserver.reset()
   eventLoopDelayObserver.enable()
 }