dd-trace 6.16.0 → 6.18.0

package/packages/dd-trace/src/openfeature/writers/base.js

@@ -1,9 +1,14 @@
 'use strict'
 
 const request = require('../../exporters/common/request')
-const { safeJSONStringify } = require('../../exporters/common/util')
 
 const log = require('../../log')
+const tracerVersion = require('../../../../../package.json').version
+
+const EVP_ORIGIN_HEADERS = {
+  'DD-EVP-ORIGIN': 'dd-trace-js',
+  'DD-EVP-ORIGIN-VERSION': tracerVersion,
+}
 
 /**
  * @typedef {object} BaseFFEWriterOptions
@@ -23,6 +28,8 @@ const log = require('../../log')
  * @property {string} endpoint - Route endpoint
  * @property {object} headers - Route-specific headers
  * @property {import('node:https').Agent} [agent] - Optional HTTPS proxy agent
+ * @property {Function} [onFallback] - Called after direct fallback becomes active
+ * @property {Function} [onUnavailable] - Called after the local route becomes unavailable
  */
 
 /**
@@ -30,6 +37,8 @@ const log = require('../../log')
  * @property {URL} url - Route base URL
  * @property {string} endpoint - Route endpoint
  * @property {object} requestOptions - HTTP request options
+ * @property {Function} [onFallback] - Called after direct fallback becomes active
+ * @property {Function} [onUnavailable] - Called after the local route becomes unavailable
  */
 
 /**
@@ -37,22 +46,32 @@ const log = require('../../log')
  *
  * @param {Error | null} error - Request error
  * @param {number | undefined} statusCode - HTTP response status
- * @returns {boolean} Whether direct retry is safe
  */
-function isDefinitiveRejection (error, statusCode) {
+function isSafeToReplay (error, statusCode) {
   return error?.code === 'EAI_AGAIN' || error?.code === 'ECONNREFUSED' ||
     error?.code === 'ENOENT' || error?.code === 'ENOTFOUND' ||
-    statusCode === 403 || statusCode === 404 || statusCode === 405
+    statusCode === 404 || statusCode === 405
 }
 
 /**
- * Tests whether a local route can have accepted an event batch before failing.
+ * Tests whether a local route failed without an authoritative HTTP response.
  *
  * @param {Error | null} error - Request error
- * @returns {boolean} Whether the delivery result is ambiguous
+ * @param {number | undefined} statusCode - HTTP response status
+ */
+function isTransportFailure (error, statusCode) {
+  // SDK backpressure says nothing about the local receiver's health.
+  return error !== null && error !== undefined && statusCode === undefined &&
+    error.code !== 'ERR_DD_REQUEST_BUFFER_FULL'
+}
+
+/**
+ * Tests whether an HTTP response should move only future Agentless batches.
+ *
+ * @param {number | undefined} statusCode - HTTP response status
  */
-function isAmbiguousNetworkFailure (error) {
-  return error?.code === 'ECONNRESET' || error?.code === 'EPIPE' || error?.code === 'ETIMEDOUT'
+function shouldSwitchFutureRoute (statusCode) {
+  return statusCode === 403 || statusCode === 429 || statusCode >= 500 && statusCode < 600
 }
 
 /**
@@ -83,10 +102,11 @@ class BaseFFEWriter {
     this._requestOptions = {
       headers: {
         ...this._headers,
+        ...EVP_ORIGIN_HEADERS,
         'Content-Type': 'application/json',
       },
       method: 'POST',
-      retry: true,
+      retry: false,
       timeout: this._timeout,
       url: this._baseUrl,
       path: this._endpoint,
@@ -152,11 +172,10 @@ class BaseFFEWriter {
 
     const payload = this._encode(this.makePayload(events))
 
+    // Keep byte counting behind the debug callback because payloads can be several megabytes.
     // eslint-disable-next-line eslint-rules/eslint-log-printf-style
-    log.debug(() => `${this.constructor.name} flushing payload: ${safeJSONStringify(payload)}`)
-
-    const route = this.#createActiveRoute()
-    this.#sendRequest(payload, events.length, route, this._fallbackRoute)
+    log.debug(() => `${this.constructor.name} flushing ${events.length} events (${Buffer.byteLength(payload)} bytes)`)
+    this._sendPayload(payload, events.length)
   }
 
   /**
@@ -189,18 +208,28 @@ class BaseFFEWriter {
   /**
    * @private
    * @param {Array<object>} payload - Payload to encode
-   * @returns {string} JSON-stringified payload
    */
   _encode (payload) {
     return JSON.stringify(payload)
   }
 
+  /**
+   * Sends one encoded event batch through a snapshot of the selected routes.
+   *
+   * @protected
+   * @param {string} payload - Encoded event batch
+   * @param {number} eventCount - Event count
+   */
+  _sendPayload (payload, eventCount) {
+    const route = this.#createActiveRoute()
+    this.#sendRequest(payload, eventCount, route, this._fallbackRoute)
+  }
+
   /**
    * Applies the active route and an optional direct fallback route.
    *
    * @param {WriterRoute} route - Active route
    * @param {WriterRoute} [fallbackRoute] - Direct fallback route
-   * @returns {void}
    */
   _setRoutes (route, fallbackRoute) {
     this.#activateRoute(this.#createRoute(route))
@@ -217,10 +246,11 @@ class BaseFFEWriter {
     const requestOptions = {
       headers: {
         ...route.headers,
+        ...EVP_ORIGIN_HEADERS,
         'Content-Type': 'application/json',
       },
       method: 'POST',
-      retry: true,
+      retry: false,
       timeout: this._timeout,
       url: route.url,
       path: route.endpoint,
@@ -231,6 +261,8 @@ class BaseFFEWriter {
       url: route.url,
       endpoint: route.endpoint,
       requestOptions,
+      onFallback: route.onFallback,
+      onUnavailable: route.onUnavailable,
     }
   }
 
@@ -244,6 +276,8 @@ class BaseFFEWriter {
       url: this._baseUrl,
       endpoint: this._endpoint,
       requestOptions: this._requestOptions,
+      onFallback: this._onFallback,
+      onUnavailable: this._onUnavailable,
     }
   }
 
@@ -251,26 +285,26 @@ class BaseFFEWriter {
    * Makes a route active for future event batches.
    *
    * @param {ActiveWriterRoute} route - Route state
-   * @returns {void}
    */
   #activateRoute (route) {
     this._baseUrl = route.url
     this._endpoint = route.endpoint
     this._requestOptions = route.requestOptions
+    this._onFallback = route.onFallback
+    this._onUnavailable = route.onUnavailable
   }
 
   /**
-   * Sends an encoded batch and retries it through direct intake after a local route failure.
+   * Sends an encoded batch once per route and applies safe local fallback semantics.
    *
    * @param {string} payload - Encoded event batch
    * @param {number} eventCount - Event count
    * @param {ActiveWriterRoute} route - Selected route
    * @param {ActiveWriterRoute} [fallbackRoute] - Direct fallback route
-   * @returns {void}
    */
   #sendRequest (payload, eventCount, route, fallbackRoute) {
     request(payload, route.requestOptions, (error, response, statusCode) => {
-      if (fallbackRoute && isDefinitiveRejection(error, statusCode)) {
+      if (fallbackRoute && isSafeToReplay(error, statusCode)) {
         log.debug(
           '%s switching from %s%s to direct intake after definitive rejection',
           this.constructor.name,
@@ -279,20 +313,53 @@ class BaseFFEWriter {
         )
         this.#activateRoute(fallbackRoute)
         this._fallbackRoute = undefined
+        route.onFallback?.()
         this.#sendRequest(payload, eventCount, fallbackRoute)
         return
       }
 
-      if (fallbackRoute && isAmbiguousNetworkFailure(error)) {
+      if (fallbackRoute && isTransportFailure(error, statusCode)) {
         log.debug(
-          '%s retrying through direct intake and switching future batches from %s%s after ambiguous failure',
+          '%s switching future batches from %s%s to direct intake after an ambiguous failure without replay',
           this.constructor.name,
           route.url.href,
           route.endpoint
         )
         this.#activateRoute(fallbackRoute)
         this._fallbackRoute = undefined
-        this.#sendRequest(payload, eventCount, fallbackRoute)
+        route.onFallback?.()
+        log.error('Failed to send events to %s%s: %s', route.url.href, route.endpoint, error.message)
+        return
+      }
+
+      if (fallbackRoute && shouldSwitchFutureRoute(statusCode)) {
+        log.debug(
+          '%s switching future batches from %s%s to direct intake after status %d without replay',
+          this.constructor.name,
+          route.url.href,
+          route.endpoint,
+          statusCode
+        )
+        this.#activateRoute(fallbackRoute)
+        this._fallbackRoute = undefined
+        route.onFallback?.()
+        log.warn('Events request returned status %d', statusCode)
+        return
+      }
+
+      if (
+        !fallbackRoute &&
+        route.onUnavailable &&
+        (isSafeToReplay(error, statusCode) ||
+          isTransportFailure(error, statusCode) ||
+          shouldSwitchFutureRoute(statusCode))
+      ) {
+        route.onUnavailable()
+        if (error) {
+          log.error('Failed to send events to %s%s: %s', route.url.href, route.endpoint, error.message)
+        } else {
+          log.warn('Events request returned status %d', statusCode)
+        }
         return
       }
 

package/packages/dd-trace/src/openfeature/writers/exposures.js

@@ -26,6 +26,8 @@ const PENDING_MAX_EVENTS = 1000
  * @property {object} [headers] - Route-specific headers
  * @property {import('node:https').Agent} [agent] - Optional HTTPS proxy agent
  * @property {ExposureRoute} [fallback] - Optional direct fallback route
+ * @property {Function} [onFallback] - Called after direct fallback becomes active
+ * @property {Function} [onUnavailable] - Called after the local route becomes unavailable
  */
 
 /**
@@ -114,7 +116,6 @@ class ExposuresWriter extends BaseFFEWriter {
   /**
    * @param {boolean} enabled - Whether to enable the writer
    * @param {ExposureRoute} [route] - Selected EVP route
-   * @returns {void}
    */
   setEnabled (enabled, route) {
     if (route) {
@@ -134,7 +135,6 @@ class ExposuresWriter extends BaseFFEWriter {
    * Applies caller-supplied route data without performing discovery.
    *
    * @param {ExposureRoute} route - Selected EVP route
-   * @returns {void}
    */
   #setRoute (route) {
     const fallbackRoute = route.fallback && {
@@ -152,6 +152,8 @@ class ExposuresWriter extends BaseFFEWriter {
       endpoint: joinEVPProxyPath(route.basePath, EXPOSURES_ENDPOINT),
       headers,
       agent: route.agent,
+      onFallback: route.onFallback,
+      onUnavailable: route.onUnavailable,
     }, fallbackRoute)
   }
 
@@ -180,9 +182,6 @@ class ExposuresWriter extends BaseFFEWriter {
     }
   }
 
-  /**
-   * @returns {number} Cumulative number of exposure events dropped due to buffer overflow.
-   */
   get droppedEventCount () {
     return this._droppedEvents
   }

package/packages/dd-trace/src/openfeature/writers/util.js

@@ -2,6 +2,8 @@
 
 const {
   EVP_EVENT_PLATFORM_SUBDOMAIN,
+  EVP_ORIGIN_HEADER_NAME,
+  EVP_ORIGIN_VERSION_HEADER_NAME,
   EVP_PROXY_PATH_V2,
   EVP_PROXY_PATH_V4,
   EVP_SUBDOMAIN_HEADER_NAME,
@@ -10,12 +12,15 @@ const { createDirectEVPRoute } = require('../../evp_proxy/direct')
 const { discoverEVPProxy } = require('../../evp_proxy/discovery')
 const logger = require('../../log')
 
+const ROUTE_DISCOVERY_COOLDOWN_MS = 60_000
+const REQUIRED_LOCAL_HEADERS = [EVP_ORIGIN_HEADER_NAME, EVP_ORIGIN_VERSION_HEADER_NAME]
+const STOP_NOOP = () => {}
+
 let missingRouteWarningLogged = false
 
 /**
  * Logs the unavailable exposure-delivery warning once.
  *
- * @returns {void}
  */
 function warnExposureDeliveryUnavailable () {
   if (missingRouteWarningLogged) return
@@ -27,11 +32,10 @@ function warnExposureDeliveryUnavailable () {
 }
 
 /**
- * Preserves Agent exposure delivery for the Remote Configuration source.
+ * Preserves the one-time EVP v2 capability check for the Remote Configuration source.
  *
  * @param {import('../../config')} config - Tracer configuration object
  * @param {Function} setWriterEnabledValue - Callback to set the writer enabled state
- * @returns {void}
  */
 function setAgentStrategy (config, setWriterEnabledValue) {
   discoverEVPProxy(config.url, {
@@ -51,6 +55,7 @@ function setAgentStrategy (config, setWriterEnabledValue) {
       setWriterEnabledValue(false)
     }
   })
+  return STOP_NOOP
 }
 
 /**
@@ -61,59 +66,121 @@ function setAgentStrategy (config, setWriterEnabledValue) {
  *
  * @param {import('../../config')} config - Tracer configuration object
  * @param {Function} setWriterEnabledValue - Callback to set the writer enabled state
- * @returns {void}
  */
 function setAgentlessStrategy (config, setWriterEnabledValue) {
   const directRoute = createDirectEVPRoute(config, EVP_EVENT_PLATFORM_SUBDOMAIN)
+  let discovering = false
+  let recoveryTimer
+  let state = 'unknown'
+  let stopped = false
 
-  discoverEVPProxy(config.url, {
-    supportedPaths: [EVP_PROXY_PATH_V4, EVP_PROXY_PATH_V2],
-  }, (error, localRoute) => {
-    if (localRoute) {
-      const route = {
-        ...localRoute,
-        headers: {
-          [EVP_SUBDOMAIN_HEADER_NAME]: EVP_EVENT_PLATFORM_SUBDOMAIN,
-        },
-      }
-      if (directRoute) route.fallback = directRoute
-      logger.debug('FFE Writer enabled with local EVP route %s', route.basePath)
-      setWriterEnabledValue(true, route)
-      return
+  const stop = () => {
+    stopped = true
+    clearTimeout(recoveryTimer)
+    recoveryTimer = undefined
+  }
+
+  const scheduleRecovery = () => {
+    if (stopped || state !== 'unavailable' || recoveryTimer !== undefined) return
+
+    recoveryTimer = setTimeout(discover, ROUTE_DISCOVERY_COOLDOWN_MS)
+    recoveryTimer.unref?.()
+  }
+
+  const markUnavailable = () => {
+    if (stopped || state === 'direct') return
+    if (state !== 'unavailable') {
+      state = 'unavailable'
+      setWriterEnabledValue(false)
     }
+    scheduleRecovery()
+  }
 
+  const activateDirect = () => {
+    if (stopped || state === 'direct' || directRoute === undefined) return
+    state = 'direct'
+    clearTimeout(recoveryTimer)
+    recoveryTimer = undefined
+    setWriterEnabledValue(true, directRoute)
+  }
+
+  /**
+   * @param {{url: URL, basePath: string}} localRoute - Discovered local route
+   */
+  const activateLocal = localRoute => {
+    state = 'local'
+    const route = {
+      ...localRoute,
+      headers: {
+        [EVP_SUBDOMAIN_HEADER_NAME]: EVP_EVENT_PLATFORM_SUBDOMAIN,
+      },
+    }
     if (directRoute) {
+      route.fallback = directRoute
+      route.onFallback = activateDirect
+    } else {
+      route.onUnavailable = markUnavailable
+    }
+    logger.debug('FFE Writer enabled with local EVP route %s', route.basePath)
+    setWriterEnabledValue(true, route)
+  }
+
+  function discover () {
+    recoveryTimer = undefined
+    if (stopped || state === 'direct' || discovering) return
+    discovering = true
+
+    discoverEVPProxy(config.url, {
+      requiredHeaders: REQUIRED_LOCAL_HEADERS,
+      supportedPaths: [EVP_PROXY_PATH_V4, EVP_PROXY_PATH_V2],
+      // Agentless owns fallback and unavailable-state recovery; do not delay them with HTTP retries.
+      retry: false,
+    }, (error, localRoute) => {
+      discovering = false
+      if (stopped || state === 'direct') return
+
+      if (localRoute) {
+        activateLocal(localRoute)
+        return
+      }
+
+      if (directRoute) {
+        if (error) {
+          logger.debug('FFE Writer using direct EVP intake after local discovery failed: %s', error.message)
+        } else {
+          logger.debug('FFE Writer using direct EVP intake because no compatible local route was advertised')
+        }
+        activateDirect()
+        return
+      }
+
       if (error) {
-        logger.debug('FFE Writer using direct EVP intake after local discovery failed: %s', error.message)
-      } else {
-        logger.debug('FFE Writer using direct EVP intake because no compatible local route was advertised')
+        logger.debug('FFE Writer disabled - error getting local receiver info: %s', error.message)
       }
-      setWriterEnabledValue(true, directRoute)
-      return
-    }
+      warnExposureDeliveryUnavailable()
+      markUnavailable()
+    })
+  }
 
-    if (error) {
-      logger.debug('FFE Writer disabled - error getting local receiver info: %s', error.message)
-    }
-    warnExposureDeliveryUnavailable()
-    setWriterEnabledValue(false)
-  })
+  discover()
+  return stop
 }
 
 /**
- * Applies the exposure-delivery strategy for the configured Feature Flags source.
+ * Applies one event-delivery strategy that can be shared by all Feature Flags writers.
  *
  * @param {import('../../config')} config - Tracer configuration object
  * @param {Function} setWriterEnabledValue - Callback to set the writer enabled state
- * @returns {void}
  */
-function setExposureDeliveryStrategy (config, setWriterEnabledValue) {
+function setEventDeliveryStrategy (config, setWriterEnabledValue) {
   if (config.featureFlags?.DD_FEATURE_FLAGS_CONFIGURATION_SOURCE === 'agentless') {
-    setAgentlessStrategy(config, setWriterEnabledValue)
-    return
+    return setAgentlessStrategy(config, setWriterEnabledValue)
   }
 
-  setAgentStrategy(config, setWriterEnabledValue)
+  return setAgentStrategy(config, setWriterEnabledValue)
 }
 
-module.exports = { setExposureDeliveryStrategy }
+module.exports = {
+  setEventDeliveryStrategy,
+  setExposureDeliveryStrategy: setEventDeliveryStrategy,
+}

package/packages/dd-trace/src/opentelemetry/logs/logger.js

@@ -112,7 +112,6 @@ class Logger {
    * Emits a log record.
    *
    * @param {LogRecord} logRecord - The log record to emit
-   * @returns {void}
    */
   emit (logRecord) {
     if (this.loggerProvider.isShutdown || !this.loggerProvider.processor) {

package/packages/dd-trace/src/opentelemetry/logs/logger_provider.js

@@ -97,7 +97,6 @@ class LoggerProvider {
 
   /**
    * Shuts down the logger provider and all associated processors.
-   * @returns {undefined} Promise that resolves when shutdown is complete
    */
   shutdown () {
     if (!this.isShutdown) {

package/packages/dd-trace/src/opentelemetry/logs/otlp_http_log_exporter.js

@@ -49,7 +49,6 @@ class OtlpHttpLogExporter extends OtlpHttpExporterBase {
    * @param {LogRecord[]} logRecords - Array of enriched log records to export
    * @param {Function} resultCallback - Callback function for export result
    *
-   * @returns {void}
    */
   export (logRecords, resultCallback) {
     if (logRecords.length === 0) {

package/packages/dd-trace/src/opentelemetry/logs/otlp_transformer.js

@@ -43,7 +43,6 @@ const NANOSECONDS_PER_SECOND = 1_000_000_000n
 /**
  * Converts an OpenTelemetry HrTime to an exact OTLP uint64 decimal string.
  * @param {import('@opentelemetry/api').HrTime} hrTime
- * @returns {string}
  */
 function encodeHrTime (hrTime) {
   return (BigInt(hrTime[0]) * NANOSECONDS_PER_SECOND + BigInt(hrTime[1])).toString()
@@ -205,7 +204,6 @@ class OtlpTransformer extends OtlpTransformerBase {
   /**
    * Maps OpenTelemetry severity number to protobuf severity number.
    * @param {number} severityNumber - OpenTelemetry severity number
-   * @returns {number} Protobuf severity number
    */
   #mapSeverityNumber (severityNumber) {
     const { protoSeverityNumber } = getProtobufTypes()

package/packages/dd-trace/src/opentelemetry/metrics/meter_provider.js

@@ -52,7 +52,6 @@ class MeterProvider {
 
   /**
    * @param {(error: Error | null) => void} [done] Called after shutdown completes
-   * @returns {void}
    */
   shutdown (done) {
     if (this.reader) this.reader.shutdown(done)

package/packages/dd-trace/src/opentelemetry/metrics/otlp_span_stats_transformer.js

@@ -148,7 +148,6 @@ class OtlpStatsTransformer extends OtlpTransformerBase {
    * @param {string} baseKey
    * @param {boolean} topLevel
    * @param {string} statusCode
-   * @returns {void}
    */
   #addDistribution (distributions, sketch, startNano, endNano, baseAttributes, baseKey, topLevel, statusCode) {
     if (!sketch || sketch.count === 0) return

package/packages/dd-trace/src/opentelemetry/metrics/otlp_transformer.js

@@ -237,7 +237,6 @@ class OtlpTransformer extends OtlpTransformerBase {
    *
    * @param {NumberDataPoint} dataPoint - The number data point to assign a value to
    * @param {number} value - The value to assign
-   * @returns {void}
    */
   #assignNumberValue (dataPoint, value) {
     if (Number.isInteger(value)) {

package/packages/dd-trace/src/opentelemetry/metrics/periodic_metric_reader.js

@@ -178,9 +178,9 @@ class PeriodicMetricReader {
   }
 
   /**
+   * Returns the matching index, or `-1` when no batch callback matches.
    * @param {Function} callback
    * @param {Set} instruments
-   * @returns {number} index in #batchCallbacks, or -1
    */
   #findBatchCallback (callback, instruments) {
     return this.#batchCallbacks.findIndex(record =>
@@ -215,7 +215,6 @@ class PeriodicMetricReader {
   /**
    * Forces an immediate collection and export of all metrics.
    * @param {(error: Error | null) => void} [done] Called after the metric export completes
-   * @returns {void}
    */
   forceFlush (done) {
     if (this.#isShutdown) {
@@ -230,7 +229,6 @@ class PeriodicMetricReader {
   /**
    * Shuts down the reader and stops periodic collection.
    * @param {(error: Error | null) => void} [done] Called after the final export and exporter shutdown complete
-   * @returns {void}
    */
   shutdown (done) {
     if (this.#isShutdown) {
@@ -273,14 +271,12 @@ class PeriodicMetricReader {
   /**
    * @param {boolean} flushExporter Whether to flush the exporter after export
    * @param {(error: Error | null) => void} [done] Called when the queued export completes
-   * @returns {void}
    */
   #enqueueExport (flushExporter, done) {
     this.#exportQueue.push({ flushExporter, done })
     this.#drainExportQueue()
   }
 
-  /** @returns {void} */
   #drainExportQueue () {
     if (this.#isExporting || this.#exportQueue.length === 0) return
 
@@ -318,7 +314,6 @@ class PeriodicMetricReader {
 
   /**
    * @param {Error} [exportError] Error from the final export
-   * @returns {void}
    */
   #shutdownExporter (exportError) {
     let completed = false
@@ -425,7 +420,6 @@ class MetricAggregator {
    * Gets the temporality for a given metric type.
    *
    * @param {string} type - Metric type from METRIC_TYPES
-   * @returns {string} Temporality from TEMPORALITY
    */
   #getTemporality (type) {
     // UpDownCounter and Observable UpDownCounter always use CUMULATIVE
@@ -520,7 +514,6 @@ class MetricAggregator {
    * Gets unique identifier for a given instrumentation scope.
    *
    * @param {InstrumentationScope} instrumentationScope - The instrumentation scope
-   * @returns {string} - The scope identifier
    */
   #getScopeKey (instrumentationScope) {
     return `${instrumentationScope.name}@${instrumentationScope.version}@${instrumentationScope.schemaUrl}`
@@ -533,7 +526,6 @@ class MetricAggregator {
    * @param {string} name - The metric name
    * @param {string} type - The metric type from METRIC_TYPES
    * @param {string} attrKey - The attribute key
-   * @returns {string} - The metric identifier
    */
   #getStateKey (scopeKey, name, type, attrKey) {
     return `${scopeKey}:${name}:${type}:${attrKey}`
@@ -543,7 +535,6 @@ class MetricAggregator {
    * Checks if a given metric type is a delta type.
    *
    * @param {string} type - The metric type from METRIC_TYPES
-   * @returns {boolean} - True if the metric type is a delta type
    */
   #isDeltaType (type) {
     return type === METRIC_TYPES.COUNTER ||
@@ -556,7 +547,6 @@ class MetricAggregator {
    *
    * @param {Iterable<AggregatedMetric>} metrics - The metrics to apply delta temporality to
    * @param {Map<string, LastExportedStateValue>} lastExportedState - The last exported state of the metrics
-   * @returns {void}
    */
   #applyDeltaTemporality (metrics, lastExportedState) {
     for (const metric of metrics) {
@@ -681,7 +671,6 @@ class MetricAggregator {
    * @param {number} timestamp - The timestamp of the measurement
    * @param {string} stateKey - The state key
    * @param {Map<string, CumulativeStateValue>} cumulativeState - The cumulative state of the metrics
-   * @returns {void}
    */
   #aggregateHistogram (metric, value, attributes, attrKey, timestamp, stateKey, cumulativeState) {
     if (!cumulativeState.has(stateKey)) {
@@ -733,7 +722,6 @@ class MetricAggregator {
 
 /**
  * @param {object} x
- * @returns {boolean}
  */
 function isObservableInstrument (x) {
   return x instanceof ObservableInstrument
@@ -742,7 +730,6 @@ function isObservableInstrument (x) {
 /**
  * @param {Set} a
  * @param {Set} b
- * @returns {boolean}
  */
 function setEquals (a, b) {
   if (a.size !== b.size) return false

package/packages/dd-trace/src/opentelemetry/metrics/time.js

@@ -10,7 +10,6 @@ const { timeOrigin } = performance
  * the value on the epoch while `performance.now()` keeps it monotonic, so a
  * backward wall-clock jump can't make `timeUnixNano` precede `startTimeUnixNano`.
  *
- * @returns {number} Nanoseconds since the UNIX epoch
  */
 function nowUnixNano () {
   return Math.round((timeOrigin + performance.now()) * 1e6)