dd-trace 5.109.0 → 5.111.0

package/packages/dd-trace/src/llmobs/tagger.js

@@ -1,6 +1,8 @@
 'use strict'
 
 const log = require('../log')
+const Sampler = require('../sampler')
+const { formatKnuthRate } = require('../util')
 const {
   MODEL_NAME,
   MODEL_PROVIDER,
@@ -41,6 +43,12 @@ const {
   ROUTING_SITE,
   PROMPT_TRACKING_INSTRUMENTATION_METHOD,
   INSTRUMENTATION_METHOD_ANNOTATED,
+  SAMPLE_RATE,
+  SAMPLING_DECISION,
+  SAMPLING_DECISION_SAMPLED,
+  SAMPLING_DECISION_DROPPED,
+  PROPAGATED_SAMPLE_RATE_KEY,
+  PROPAGATED_SAMPLING_DECISION_KEY,
 } = require('./constants/tags')
 const { storage } = require('./storage')
 const { findGenAIAncestorSpanId, validateCostTags, writeBridgeTags, validateToolDefinitions } = require('./util')
@@ -53,12 +61,31 @@ class LLMObsTagger {
   /** @type {import('../config/config-base')} */
   #config
 
+  /** @type {import('../sampler') | null} */
+  #sampler = null
+
   constructor (config, softFail = false) {
     this.#config = config
 
     this.softFail = softFail
   }
 
+  /**
+   * The sampler reads its rate from `config.llmobs.sampleRate`, which can change
+   * at runtime (e.g. via remote config). Rebuild the sampler whenever the rate
+   * changes so decisions reflect the current config, while reusing the existing
+   * sampler when it hasn't.
+   *
+   * @returns {import('../sampler')}
+   */
+  #getSampler () {
+    const rate = this.#config.llmobs?.sampleRate ?? 1
+    if (this.#sampler === null || rate !== this.#sampler.rate()) {
+      this.#sampler = new Sampler(rate)
+    }
+    return this.#sampler
+  }
+
   static get tagMap () {
     return registry
   }
@@ -78,7 +105,7 @@ class LLMObsTagger {
     integration,
     _decorator,
   } = {}) {
-    if (!this.#config.llmobs.enabled) return
+    if (!this.#config.llmobs.DD_LLMOBS_ENABLED) return
     if (!kind) return // do not register it in the map if it doesn't have an llmobs span kind
 
     const spanMlApp =
@@ -124,6 +151,8 @@ class LLMObsTagger {
       ROOT_PARENT_ID
     this._setTag(span, PARENT_ID_KEY, parentId)
 
+    this.#tagSamplingDecision(span, parent)
+
     // apply annotation context
     const annotationContext = storage.getStore()?.annotationContext
 
@@ -153,6 +182,32 @@ class LLMObsTagger {
     }
   }
 
+  #tagSamplingDecision (span, parent) {
+    const traceTags = span.context()._trace.tags
+    const parentTags = registry.get(parent)
+
+    let sampleRate, samplingDecision
+    if (parentTags) {
+      // Local LLMObs parent: inherit its decision.
+      sampleRate = parentTags[SAMPLE_RATE]
+      samplingDecision = parentTags[SAMPLING_DECISION]
+    } else if (traceTags[PROPAGATED_PARENT_ID_KEY]) {
+      // Distributed LLMObs parent: inherit whatever was propagated. This may be
+      // absent if the upstream service predates sampling propagation, in which
+      // case we make no decision here rather than starting a divergent one.
+      sampleRate = traceTags[PROPAGATED_SAMPLE_RATE_KEY]
+      samplingDecision = traceTags[PROPAGATED_SAMPLING_DECISION_KEY]
+    } else {
+      // Root span: make the trace's one sampling decision.
+      const sampler = this.#getSampler()
+      sampleRate = formatKnuthRate(sampler.rate())
+      samplingDecision = sampler.isSampled(span) ? SAMPLING_DECISION_SAMPLED : SAMPLING_DECISION_DROPPED
+    }
+
+    if (sampleRate != null) this._setTag(span, SAMPLE_RATE, sampleRate)
+    if (samplingDecision != null) this._setTag(span, SAMPLING_DECISION, samplingDecision)
+  }
+
   // TODO: similarly for the following `tag` methods,
   // how can we transition from a span weakmap to core API functionality
   tagLLMIO (span, inputData, outputData) {
@@ -679,7 +734,7 @@ class LLMObsTagger {
   }
 
   _register (span) {
-    if (!this.#config.llmobs.enabled) return
+    if (!this.#config.llmobs.DD_LLMOBS_ENABLED) return
     if (registry.has(span)) {
       this.#handleFailure(`LLMObs Span "${span._name}" already registered.`)
       return
@@ -689,7 +744,7 @@ class LLMObsTagger {
   }
 
   _setTag (span, key, value) {
-    if (!this.#config.llmobs.enabled) return
+    if (!this.#config.llmobs.DD_LLMOBS_ENABLED) return
     if (!registry.has(span)) {
       this.#handleFailure(`Span "${span._name}" must be an LLMObs generated span.`)
       return

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

@@ -87,6 +87,7 @@ function recordLLMObsEnabled (startTime, config, value = 1) {
     site: config.site,
     auto: Number(autoEnabled),
     ml_app: config.llmobs.mlApp,
+    sample_rate: config.llmobs.sampleRate,
   }
   llmobsMetrics.count('product_enabled', tags).inc(value)
   llmobsMetrics.distribution('init_time', tags).track(initTimeMs)

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

@@ -229,7 +229,7 @@ class BaseLLMObsWriter {
     }
 
     if (this._agentless) {
-      options.headers['DD-API-KEY'] = this._config.apiKey || ''
+      options.headers['DD-API-KEY'] = this._config.DD_API_KEY || ''
     } else {
       options.headers[EVP_SUBDOMAIN_HEADER_NAME] = this._intake
     }

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

@@ -2,19 +2,16 @@
 
 const { inspect } = require('util')
 
-const { defaults } = require('../config/defaults')
-const { isTrue } = require('../util')
 const { getValueFromEnvSources } = require('../config/helper')
+// Eager require restores the original startup module-load order: pulling `config/defaults` here
+// also installs the instrumented `dns` it transitively loads before the tracer/agent connects.
+// `config/defaults` defers its own `dns` require until after it exports, so this no longer hits
+// the `config/defaults` <-> log parse cycle that motivated the lazy require below.
+const { defaults } = require('../config/defaults')
 const { traceChannel, debugChannel, infoChannel, warnChannel, errorChannel } = require('./channels')
 const logWriter = require('./writer')
 const { Log, LogConfig, NoTransmitError } = require('./log')
 
-const config = {
-  enabled: defaults.DD_TRACE_DEBUG,
-  logger: undefined,
-  logLevel: defaults.logLevel,
-}
-
 // In most places where we know we want to mute a log we use log.error() directly
 const NO_TRANSMIT = new LogConfig(false)
 
@@ -77,19 +74,17 @@ const log = {
   },
 
   configure (options) {
-    config.logger = options.logger
-    config.logLevel = options.logLevel ??
-        getValueFromEnvSources('DD_TRACE_LOG_LEVEL') ??
-        config.logLevel
-    config.enabled = isTrue(
-      getValueFromEnvSources('DD_TRACE_DEBUG') ??
+    const logger = options.logger
+    const logLevel = options.logLevel ??
+        getValueFromEnvSources('DD_TRACE_LOG_LEVEL', true) ??
+        defaults?.logLevel
+    const enabled = getValueFromEnvSources('DD_TRACE_DEBUG', true) ??
       // TODO: Handle this by adding a log buffer so that configure may be called with the actual configurations.
       // eslint-disable-next-line eslint-rules/eslint-process-env
-      (process.env.OTEL_LOG_LEVEL === 'debug' || config.enabled)
-    )
-    logWriter.configure(config.enabled, config.logLevel, options.logger)
+      (process.env.OTEL_LOG_LEVEL === 'debug' || defaults?.DD_TRACE_DEBUG)
+    logWriter.configure(enabled, logLevel, logger)
 
-    return config.enabled
+    return enabled
   },
 }
 
@@ -113,6 +108,9 @@ function getErrorLog (err) {
   return err
 }
 
-log.configure({})
-
+// Assign before the bootstrap configure() call: an invalid DD_TRACE_LOG_LEVEL
+// makes config/defaults re-require this module to warn, which must observe the
+// fully built log object rather than a half-initialized one.
 module.exports = log
+
+log.configure({})

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

@@ -1,18 +1,13 @@
 'use strict'
 
 const { channel } = require('dc-polyfill')
+const requireOptionalPeer = require('../../../datadog-instrumentations/src/helpers/require-optional-peer')
 const log = require('../log')
 const { EXPOSURE_CHANNEL } = require('./constants/constants')
 const EvalMetricsHook = require('./eval-metrics-hook')
 const SpanEnrichmentHook = require('./span-enrichment-hook')
 
-// Bundler-opaque require for the optional peer chain
-// `@datadog/openfeature-node-server` -> `@openfeature/server-sdk` ->
-// `@openfeature/core`. Same shape as `helpers/rewriter/compiler.js`.
-// Refs: https://github.com/DataDog/dd-trace-js/issues/8635
-// eslint-disable-next-line camelcase, no-undef
-const runtimeRequire = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : require
-const { DatadogNodeServerProvider } = runtimeRequire(['@datadog/openfeature', 'node', 'server'].join('-'))
+const { DatadogNodeServerProvider } = requireOptionalPeer('@datadog/openfeature-node-server')
 
 /**
  * OpenFeature provider that integrates with Datadog's feature flagging system.

package/packages/dd-trace/src/opentelemetry/bridge-span-base.js

@@ -30,6 +30,7 @@ class BridgeSpanBase {
    */
   constructor (ddSpan) {
     this._ddSpan = ddSpan
+    this._otelTraceSemanticsEnabled = false
   }
 
   get ended () {
@@ -45,7 +46,7 @@ class BridgeSpanBase {
    * @param {import('@opentelemetry/api').AttributeValue} value
    */
   setAttribute (key, value) {
-    setOtelAttribute(this._ddSpan, key, value)
+    setOtelAttribute(this._ddSpan, key, value, this._otelTraceSemanticsEnabled)
     return this
   }
 
@@ -53,7 +54,7 @@ class BridgeSpanBase {
    * @param {import('@opentelemetry/api').Attributes} attributes
    */
   setAttributes (attributes) {
-    setOtelAttributes(this._ddSpan, attributes)
+    setOtelAttributes(this._ddSpan, attributes, this._otelTraceSemanticsEnabled)
     return this
   }
 
@@ -91,14 +92,14 @@ class BridgeSpanBase {
    * @param {import('@opentelemetry/api').TimeInput} [timeInput]
    */
   recordException (exception, timeInput) {
-    recordException(this._ddSpan, exception, timeInput)
+    recordException(this._ddSpan, exception, timeInput, this._otelTraceSemanticsEnabled)
   }
 
   /**
    * @param {import('@opentelemetry/api').SpanStatus} status
    */
   setStatus (status) {
-    this.#statusCode = applyOtelStatus(this._ddSpan, this.#statusCode, status)
+    this.#statusCode = applyOtelStatus(this._ddSpan, this.#statusCode, status, this._otelTraceSemanticsEnabled)
     return this
   }
 }

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

@@ -2,6 +2,14 @@
 
 const os = require('os')
 
+const { metrics } = require('@opentelemetry/api')
+
+const { VERSION } = require('../../../../../version')
+const processTags = require('../../process-tags')
+const MeterProvider = require('./meter_provider')
+const PeriodicMetricReader = require('./periodic_metric_reader')
+const OtlpHttpMetricExporter = require('./otlp_http_metric_exporter')
+
 /**
  * @typedef {import('../../config')} Config
  */
@@ -28,11 +36,6 @@ const os = require('os')
  * @package
  */
 
-const { metrics } = require('@opentelemetry/api')
-const MeterProvider = require('./meter_provider')
-const PeriodicMetricReader = require('./periodic_metric_reader')
-const OtlpHttpMetricExporter = require('./otlp_http_metric_exporter')
-
 /**
  * Initializes OpenTelemetry Metrics support
  * @param {import('../../config/config-base')} config - Tracer configuration instance
@@ -75,7 +78,53 @@ function initializeOpenTelemetryMetrics (config) {
   metrics.setGlobalMeterProvider(meterProvider)
 }
 
+function buildResourceAttributes (tags, { reportHostname, otelSemanticsEnabled, service, env, serviceVersion } = {}) {
+  const attrs = {
+    'telemetry.sdk.name': 'datadog',
+    'telemetry.sdk.language': 'nodejs',
+    'telemetry.sdk.version': VERSION,
+  }
+  if (service) attrs['service.name'] = service
+  if (serviceVersion) attrs['service.version'] = serviceVersion
+  if (env) attrs['deployment.environment.name'] = env
+  if (reportHostname) attrs['host.name'] = os.hostname()
+
+  if (!otelSemanticsEnabled) {
+    if (tags?.['runtime-id']) attrs['datadog.runtime_id'] = tags['runtime-id']
+    const processTagsObject = processTags.tagsObject
+    if (processTagsObject) {
+      for (const key of Object.keys(processTagsObject)) {
+        attrs[`datadog.${key}`] = processTagsObject[key]
+      }
+    }
+  }
+  return attrs
+}
+
+function createOtlpSpanStatsExporter (config) {
+  const { OtlpStatsExporter } = require('./otlp_span_stats_exporter')
+  const protocol = config.OTEL_EXPORTER_OTLP_METRICS_PROTOCOL || 'http/json'
+  const resourceAttributes = buildResourceAttributes(config.tags, {
+    reportHostname: config.reportHostname,
+    otelSemanticsEnabled: config.DD_TRACE_OTEL_SEMANTICS_ENABLED,
+    service: config.service,
+    env: config.env,
+    serviceVersion: config.version,
+  })
+  return new OtlpStatsExporter(
+    config.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT,
+    protocol,
+    resourceAttributes,
+    config.DD_TRACE_OTEL_SEMANTICS_ENABLED,
+    config.service,
+    config.OTEL_EXPORTER_OTLP_METRICS_HEADERS,
+    config.OTEL_EXPORTER_OTLP_METRICS_TIMEOUT
+  )
+}
+
 module.exports = {
   MeterProvider,
   initializeOpenTelemetryMetrics,
+  buildResourceAttributes,
+  createOtlpSpanStatsExporter,
 }

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

@@ -2,6 +2,7 @@
 
 const { sanitizeAttributes } = require('../../../../../vendor/dist/@opentelemetry/core')
 const { METRIC_TYPES } = require('./constants')
+const { nowUnixNano } = require('./time')
 
 /**
  * @typedef {import('@opentelemetry/api').Attributes} Attributes
@@ -62,7 +63,7 @@ class Instrument {
       type,
       value,
       attributes: sanitizeAttributes(attributes),
-      timestamp: Number(process.hrtime.bigint()),
+      timestamp: nowUnixNano(),
     }
   }
 }

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

@@ -0,0 +1,40 @@
+'use strict'
+
+const log = require('../../log')
+const OtlpHttpExporterBase = require('../otlp/otlp_http_exporter_base')
+const OtlpStatsTransformer = require('./otlp_span_stats_transformer')
+
+class OtlpStatsExporter extends OtlpHttpExporterBase {
+  #transformer
+
+  /**
+   * @param {string} url
+   * @param {string} protocol
+   * @param {import('@opentelemetry/api').Attributes} resourceAttributes
+   * @param {boolean} [otelSemanticsEnabled]
+   * @param {string} [defaultService]
+   * @param {Record<string, string>} [headers]
+   * @param {number} [timeout]
+   */
+  constructor (url, protocol, resourceAttributes, otelSemanticsEnabled = false, defaultService = '',
+    headers, timeout = 10_000) {
+    super(url, headers, timeout, protocol, 'span-stats')
+    this.#transformer = new OtlpStatsTransformer(resourceAttributes, protocol, otelSemanticsEnabled, defaultService)
+  }
+
+  /**
+   * @param {Array<{timeNs: number, bucket: import('../../span_stats').SpanBuckets}>} drained
+   * @param {number} bucketSizeNs
+   */
+  export (drained, bucketSizeNs) {
+    if (drained.length === 0) return
+    const payload = this.#transformer.transform(drained, bucketSizeNs)
+    this.sendPayload(payload, (result) => {
+      if (result.code !== 0) {
+        log.error('Failed to export span stats: %s', result.error?.message)
+      }
+    })
+  }
+}
+
+module.exports = { OtlpStatsExporter }

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

@@ -0,0 +1,169 @@
+'use strict'
+
+const { LogCollapsingLowestDenseDDSketch } = require('../../../../../vendor/dist/@datadog/sketches-js')
+const OtlpTransformerBase = require('../otlp/otlp_transformer_base')
+const { getProtobufTypes } = require('../otlp/protobuf_loader')
+
+const NS_PER_S = 1e9
+
+// Must match libdatadog's EXPLICIT_BOUNDS_SECONDS and OTel spanmetrics connector defaults.
+const EXPLICIT_BOUNDS_SECONDS = [
+  0.002, 0.004, 0.006, 0.008, 0.01, 0.05, 0.1, 0.2, 0.4, 0.8, 1, 1.4, 2, 5, 10, 15,
+]
+
+/**
+ * @param {object} sketch
+ * @returns {number[]}
+ */
+function sketchToFixedHistogram (sketch) {
+  const bucketCounts = new Array(EXPLICIT_BOUNDS_SECONDS.length + 1).fill(0)
+  if (sketch.zeroCount > 0) bucketCounts[0] += sketch.zeroCount
+  const { store, mapping } = sketch
+  for (let key = store.minKey; key <= store.maxKey; key++) {
+    const weight = store.bins[key - store.offset]
+    if (!weight) continue
+    const seconds = mapping.value(key) / NS_PER_S
+    let idx = EXPLICIT_BOUNDS_SECONDS.findIndex((bound) => seconds <= bound)
+    if (idx === -1) idx = EXPLICIT_BOUNDS_SECONDS.length
+    bucketCounts[idx] += weight
+  }
+  return bucketCounts.map((weight) => Math.round(weight))
+}
+
+let _deltaTemporality
+
+function getDeltaTemporality () {
+  if (_deltaTemporality === undefined) {
+    const { protoAggregationTemporality } = getProtobufTypes()
+    _deltaTemporality = protoAggregationTemporality.values.AGGREGATION_TEMPORALITY_DELTA
+  }
+  return _deltaTemporality
+}
+
+const ERROR_STATUS_ATTR = { key: 'status.code', value: { intValue: 2 } }
+
+class OtlpStatsTransformer extends OtlpTransformerBase {
+  #otelSemanticsEnabled
+  #defaultService
+
+  /**
+   * @param {import('@opentelemetry/api').Attributes} resourceAttributes
+   * @param {string} protocol
+   * @param {boolean} [otelSemanticsEnabled]
+   * @param {string} [defaultService]
+   */
+  constructor (resourceAttributes, protocol, otelSemanticsEnabled = false, defaultService = '') {
+    super(resourceAttributes, protocol, 'span-stats')
+    this.#otelSemanticsEnabled = otelSemanticsEnabled
+    this.#defaultService = defaultService
+  }
+
+  /**
+   * @param {Array<{timeNs: number, bucket: import('../../span_stats').SpanBuckets}>} drained
+   * @param {number} bucketSizeNs
+   */
+  transform (drained, bucketSizeNs) {
+    const isJson = this.protocol === 'http/json'
+    const data = {
+      resourceMetrics: [{
+        resource: this.transformResource(),
+        scopeMetrics: this.#buildScopeMetrics(drained, bucketSizeNs, isJson),
+      }],
+    }
+    return isJson
+      ? this.serializeToJson(data)
+      : this.serializeToProtobuf(getProtobufTypes().protoMetricsService, data)
+  }
+
+  #buildScopeMetrics (drained, bucketSizeNs, isJson) {
+    const temporality = isJson ? 'AGGREGATION_TEMPORALITY_DELTA' : getDeltaTemporality()
+
+    const dataPoints = []
+
+    for (const { timeNs, bucket } of drained) {
+      const endTimeNs = timeNs + bucketSizeNs
+      const startNano = isJson ? String(timeNs) : timeNs
+      const endNano = isJson ? String(endTimeNs) : endTimeNs
+
+      for (const aggStats of bucket.values()) {
+        const baseAttrs = this.#buildAttributes(aggStats.aggKey)
+
+        if (this.#otelSemanticsEnabled) {
+          const okDist = new LogCollapsingLowestDenseDDSketch()
+          okDist.merge(aggStats.topLevelOkDistribution)
+          okDist.merge(aggStats.nonTopLevelOkDistribution)
+          const errDist = new LogCollapsingLowestDenseDDSketch()
+          errDist.merge(aggStats.topLevelErrorDistribution)
+          errDist.merge(aggStats.nonTopLevelErrorDistribution)
+          this.#pushPoint(dataPoints, okDist, startNano, endNano, baseAttrs)
+          this.#pushPoint(dataPoints, errDist, startNano, endNano, [...baseAttrs, ERROR_STATUS_ATTR])
+        } else {
+          const tlAttrs = [...baseAttrs, { key: 'datadog.span.top_level', value: { boolValue: true } }]
+          const ntlAttrs = [...baseAttrs, { key: 'datadog.span.top_level', value: { boolValue: false } }]
+          this.#pushPoint(dataPoints, aggStats.topLevelOkDistribution, startNano, endNano, tlAttrs)
+          this.#pushPoint(dataPoints, aggStats.topLevelErrorDistribution, startNano, endNano,
+            [...tlAttrs, ERROR_STATUS_ATTR])
+          this.#pushPoint(dataPoints, aggStats.nonTopLevelOkDistribution, startNano, endNano, ntlAttrs)
+          this.#pushPoint(dataPoints, aggStats.nonTopLevelErrorDistribution, startNano, endNano,
+            [...ntlAttrs, ERROR_STATUS_ATTR])
+        }
+      }
+    }
+
+    if (dataPoints.length === 0) return []
+    return [{
+      metrics: [
+        {
+          name: 'traces.span.sdk.metrics.duration',
+          unit: 's',
+          histogram: { dataPoints, aggregationTemporality: temporality },
+        },
+      ],
+    }]
+  }
+
+  #pushPoint (points, sketch, startNano, endNano, attributes) {
+    if (!sketch || sketch.count === 0) return
+    points.push({
+      attributes,
+      startTimeUnixNano: startNano,
+      timeUnixNano: endNano,
+      count: sketch.count,
+      sum: sketch.sum / NS_PER_S,
+      min: sketch.min / NS_PER_S,
+      max: sketch.max / NS_PER_S,
+      bucketCounts: sketchToFixedHistogram(sketch),
+      explicitBounds: EXPLICIT_BOUNDS_SECONDS,
+    })
+  }
+
+  /**
+   * @param {import('../../span_stats').SpanAggKey} aggKey
+   */
+  #buildAttributes (aggKey) {
+    const raw = { 'span.name': aggKey.resource }
+
+    if (aggKey.service && aggKey.service !== this.#defaultService) {
+      raw['service.name'] = aggKey.service
+    }
+
+    if (aggKey.spanKind) raw['span.kind'] = aggKey.spanKind
+    if (aggKey.statusCode) raw['http.response.status_code'] = Number(aggKey.statusCode)
+    if (aggKey.method) raw['http.request.method'] = aggKey.method
+    if (aggKey.endpoint) raw['http.route'] = aggKey.endpoint
+    if (aggKey.rpcStatusCode !== '') {
+      raw['rpc.response.status_code'] = String(aggKey.rpcStatusCode).toUpperCase()
+    }
+
+    if (!this.#otelSemanticsEnabled) {
+      raw['datadog.operation.name'] = aggKey.name
+      if (aggKey.type) raw['datadog.span.type'] = aggKey.type
+      if (aggKey.synthetics) raw['datadog.origin'] = 'synthetics'
+    }
+
+    return this.transformAttributes(raw)
+  }
+}
+
+module.exports = OtlpStatsTransformer
+module.exports.EXPLICIT_BOUNDS_SECONDS = EXPLICIT_BOUNDS_SECONDS

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

@@ -6,6 +6,7 @@ const {
   METRIC_TYPES, TEMPORALITY, DEFAULT_HISTOGRAM_BUCKETS, DEFAULT_MAX_MEASUREMENT_QUEUE_SIZE,
 } = require('./constants')
 const { ObservableInstrument } = require('./instruments')
+const { nowUnixNano } = require('./time')
 
 /**
  * @typedef {import('@opentelemetry/api').Attributes} Attributes
@@ -309,7 +310,7 @@ class PeriodicMetricReader {
  *
  */
 class MetricAggregator {
-  #startTime = Number(process.hrtime.bigint())
+  #startTime = nowUnixNano()
   #temporalityPreference
   #maxBatchedQueueSize
 
@@ -444,8 +445,8 @@ class MetricAggregator {
    */
   #isDeltaType (type) {
     return type === METRIC_TYPES.COUNTER ||
-           type === METRIC_TYPES.OBSERVABLECOUNTER ||
-           type === METRIC_TYPES.HISTOGRAM
+          type === METRIC_TYPES.OBSERVABLECOUNTER ||
+          type === METRIC_TYPES.HISTOGRAM
   }
 
   /**

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

@@ -0,0 +1,19 @@
+'use strict'
+
+const { timeOrigin } = performance
+
+/**
+ * Current wall-clock time as UNIX epoch nanoseconds, the unit OTLP requires for
+ * `timeUnixNano` / `startTimeUnixNano`. `process.hrtime.bigint()` is a monotonic
+ * clock with an arbitrary origin, so its values decode as 1970 timestamps that
+ * the Datadog Agent silently drops. Anchoring on `performance.timeOrigin` puts
+ * 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)
+}
+
+module.exports = { nowUnixNano }

package/packages/dd-trace/src/opentelemetry/otlp/common.proto

@@ -68,7 +68,7 @@ message KeyValue {
 }
 
 // InstrumentationScope is a message representing the instrumentation scope information
-// such as the fully qualified name and version. 
+// such as the fully qualified name and version.
 message InstrumentationScope {
   // An empty instrumentation scope name means the name is unknown.
   string name = 1;
@@ -113,4 +113,4 @@ message EntityRef {
   // These attribute keys are not part of entity's identity.
   // These keys MUST exist in the containing {message}.attributes.
   repeated string description_keys = 4;
-}
+}

package/packages/dd-trace/src/opentelemetry/otlp/logs.proto

@@ -223,4 +223,4 @@ message LogRecord {
   //
   // [Optional].
   string event_name = 12;
-}
+}

package/packages/dd-trace/src/opentelemetry/otlp/logs_service.proto

@@ -75,4 +75,4 @@ message ExportLogsPartialSuccess {
   // error_message is an optional field. An error_message with an empty value
   // is equivalent to it not being set.
   string error_message = 2;
-}
+}

package/packages/dd-trace/src/opentelemetry/otlp/metrics.proto

@@ -717,4 +717,4 @@ message Exemplar {
   // trace_id may be missing if the measurement is not recorded inside a trace
   // or if the trace is not sampled.
   bytes trace_id = 5;
-}
+}

package/packages/dd-trace/src/opentelemetry/otlp/metrics_service.proto

@@ -75,4 +75,4 @@ message ExportMetricsPartialSuccess {
   // error_message is an optional field. An error_message with an empty value
   // is equivalent to it not being set.
   string error_message = 2;
-}
+}