dd-trace 5.83.0 → 5.85.0

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

@@ -1,8 +1,8 @@
 'use strict'
 
-const { URL, format } = require('node:url')
 const request = require('../../exporters/common/request')
 const { safeJSONStringify } = require('../../exporters/common/util')
+const { getAgentUrl } = require('../../agent/url')
 
 const log = require('../../log')
 
@@ -45,12 +45,12 @@ class BaseFFEWriter {
     this._requestOptions = {
       headers: {
         ...this._headers,
-        'Content-Type': 'application/json'
+        'Content-Type': 'application/json',
       },
       method: 'POST',
       timeout: this._timeout,
       url: this._baseUrl,
-      path: this._endpoint
+      path: this._endpoint,
     }
 
     this._periodic = setInterval(() => {
@@ -73,7 +73,7 @@ class BaseFFEWriter {
 
     for (const event of eventArray) {
       if (this._buffer.length >= this._bufferLimit) {
-        log.warn(`${this.constructor.name} event buffer full (limit is ${this._bufferLimit}), dropping event`)
+        log.warn('%s event buffer full (limit is %d), dropping event', this.constructor.name, this._bufferLimit)
         this._droppedEvents++
         continue
       }
@@ -82,16 +82,15 @@ class BaseFFEWriter {
 
       // Check individual event size limit if configured
       if (this._eventSizeLimit && eventSizeBytes > this._eventSizeLimit) {
-        log.warn(`${this.constructor.name} event size
-          ${eventSizeBytes} bytes exceeds limit ${this._eventSizeLimit}, dropping event`)
+        log.warn('%s event size %d bytes exceeds limit %d, dropping event',
+          this.constructor.name, eventSizeBytes, this._eventSizeLimit)
         this._droppedEvents++
         continue
       }
 
       // Check if adding this event would exceed payload size limit if configured
       if (this._payloadSizeLimit && this._bufferSize + eventSizeBytes > this._payloadSizeLimit) {
-        log.debug(() => `${this.constructor.name}
-        buffer size would exceed ${this._payloadSizeLimit} bytes, flushing first`)
+        log.debug('%s buffer size would exceed %d bytes, flushing first', this.constructor.name, this._payloadSizeLimit)
         this.flush()
       }
 
@@ -113,15 +112,16 @@ class BaseFFEWriter {
 
     const payload = this._encode(this.makePayload(events))
 
+    // eslint-disable-next-line eslint-rules/eslint-log-printf-style
     log.debug(() => `${this.constructor.name} flushing payload: ${safeJSONStringify(payload)}`)
 
     request(payload, this._requestOptions, (err, resp, code) => {
       if (err) {
-        log.error(`Failed to send events to ${this._baseUrl.href}${this._endpoint}: ${err.message}`)
+        log.error('Failed to send events to %s%s', this._baseUrl.href, this._endpoint, err)
       } else if (code >= 200 && code < 300) {
-        log.debug(() => `Successfully sent ${events.length} events`)
+        log.debug('Successfully sent %d events', events.length)
       } else {
-        log.warn(`Events request returned status ${code}`)
+        log.warn('Events request returned status %d', code)
       }
     })
   }
@@ -141,14 +141,14 @@ class BaseFFEWriter {
    */
   destroy () {
     if (this.#destroyer) {
-      log.debug(() => `Stopping ${this.constructor.name}`)
+      log.debug('Stopping %s', this.constructor.name)
       clearInterval(this._periodic)
       this.flush()
       globalThis[Symbol.for('dd-trace')].beforeExitHandlers.delete(this.#destroyer)
       this.#destroyer = undefined
 
       if (this._droppedEvents > 0) {
-        log.warn(`${this.constructor.name} dropped ${this._droppedEvents} events due to buffer overflow`)
+        log.warn('%s dropped %d events due to buffer overflow', this.constructor.name, this._droppedEvents)
       }
     }
   }
@@ -158,13 +158,7 @@ class BaseFFEWriter {
    * @returns {URL} Constructs agent URL from config
    */
   _getAgentUrl () {
-    const { hostname, port } = this._config
-
-    return this._config.url ?? new URL(format({
-      protocol: 'http:',
-      hostname: hostname || 'localhost',
-      port: port || 8126
-    }))
+    return getAgentUrl(this._config)
   }
 
   /**

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

@@ -6,7 +6,7 @@ const {
   EVP_SUBDOMAIN_HEADER_NAME,
   EVP_SUBDOMAIN_VALUE,
   EVP_PAYLOAD_SIZE_LIMIT,
-  EVP_EVENT_SIZE_LIMIT
+  EVP_EVENT_SIZE_LIMIT,
 } = require('../constants/constants')
 const BaseFFEWriter = require('./base')
 
@@ -57,8 +57,8 @@ class ExposuresWriter extends BaseFFEWriter {
       payloadSizeLimit: EVP_PAYLOAD_SIZE_LIMIT,
       eventSizeLimit: EVP_EVENT_SIZE_LIMIT,
       headers: {
-        [EVP_SUBDOMAIN_HEADER_NAME]: EVP_SUBDOMAIN_VALUE
-      }
+        [EVP_SUBDOMAIN_HEADER_NAME]: EVP_SUBDOMAIN_VALUE,
+      },
     })
     this._enabled = false // Start disabled until agent strategy is set
     this._pendingEvents = [] // Buffer events until enabled
@@ -116,7 +116,7 @@ class ExposuresWriter extends BaseFFEWriter {
 
     return {
       context: this._context,
-      exposures: formattedEvents
+      exposures: formattedEvents,
     }
   }
 
@@ -127,7 +127,7 @@ class ExposuresWriter extends BaseFFEWriter {
    */
   _buildContext () {
     const context = {
-      service: this._config.service || 'unknown'
+      service: this._config.service || 'unknown',
     }
 
     // Only include version and env if they are defined
@@ -152,19 +152,19 @@ class ExposuresWriter extends BaseFFEWriter {
     const formattedEvent = {
       timestamp: event.timestamp || Date.now(),
       allocation: {
-        key: event.allocation?.key || event['allocation.key']
+        key: event.allocation?.key || event['allocation.key'],
       },
       flag: {
-        key: event.flag?.key || event['flag.key']
+        key: event.flag?.key || event['flag.key'],
       },
       variant: {
-        key: event.variant?.key || event['variant.key']
+        key: event.variant?.key || event['variant.key'],
       },
       subject: {
         id: event.subject?.id || event['subject.id'],
         type: event.subject?.type,
-        attributes: event.subject?.attributes
-      }
+        attributes: event.subject?.attributes,
+      },
     }
     return formattedEvent
   }

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

@@ -2,9 +2,8 @@
 
 const logger = require('../../log')
 const { EVP_PROXY_AGENT_BASE_PATH } = require('../constants/constants')
-
-const AgentInfoExporter = require('../../exporters/common/agent-info-exporter')
-let agentInfoExporter
+const { fetchAgentInfo } = require('../../agent/info')
+const { getAgentUrl } = require('../../agent/url')
 
 /**
  * Determines if the agent supports EVP proxy and sets the writer enabled state accordingly
@@ -12,11 +11,7 @@ let agentInfoExporter
  * @param {Function} setWriterEnabledValue - Callback to set the writer enabled state
  */
 function setAgentStrategy (config, setWriterEnabledValue) {
-  if (!agentInfoExporter) {
-    agentInfoExporter = new AgentInfoExporter(config)
-  }
-
-  agentInfoExporter.getAgentInfo((err, agentInfo) => {
+  fetchAgentInfo(getAgentUrl(config), (err, agentInfo) => {
     if (err) {
       logger.debug('FFE Writer disabled - error getting agent info:', err.message)
       setWriterEnabledValue(false)
@@ -39,5 +34,5 @@ function setAgentStrategy (config, setWriterEnabledValue) {
 }
 
 module.exports = {
-  setAgentStrategy
+  setAgentStrategy,
 }

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

@@ -2,7 +2,6 @@
 
 const { trace, ROOT_CONTEXT, propagation } = require('@opentelemetry/api')
 const { storage } = require('../../../datadog-core')
-const DataDogSpanContext = require('../opentracing/span_context')
 
 const tracer = require('../../')
 const SpanContext = require('./span_context')
@@ -14,45 +13,64 @@ class ContextManager {
 
   // converts dd to otel
   active () {
-    const activeSpan = tracer.scope().active()
     const store = this._store.getStore()
-    const context = (activeSpan && activeSpan.context()) || store || ROOT_CONTEXT
+    const baseContext = store || ROOT_CONTEXT
+    const activeSpan = tracer.scope().active()
+
+    const storedSpan = store ? trace.getSpan(store) : null
 
-    if (!(context instanceof DataDogSpanContext)) {
-      const span = trace.getSpan(context)
-      // span instanceof NonRecordingSpan
-      if (span && span._spanContext && span._spanContext._ddContext && span._spanContext._ddContext._baggageItems) {
-        const baggages = span._spanContext._ddContext._baggageItems
+    // If stored span wraps the active DD span, prefer the stored context
+    if (storedSpan && storedSpan._ddSpan === activeSpan) {
+      const baggages = JSON.parse(activeSpan.getAllBaggageItems())
+      if (Object.keys(baggages).length > 0) {
         const entries = {}
         for (const [key, value] of Object.entries(baggages)) {
           entries[key] = { value }
         }
         const otelBaggages = propagation.createBaggage(entries)
-        return propagation.setBaggage(context, otelBaggages)
+        return propagation.setBaggage(store, otelBaggages)
       }
-      return context
+      return store
     }
 
-    const baggages = JSON.parse(activeSpan.getAllBaggageItems())
-    const entries = {}
-    for (const [key, value] of Object.entries(baggages)) {
-      entries[key] = { value }
+    if (!activeSpan) {
+      const storedBaggageItems = storedSpan?._spanContext?._ddContext?._baggageItems
+      if (storedBaggageItems) {
+        const baggages = storedBaggageItems
+        const entries = {}
+        for (const [key, value] of Object.entries(baggages)) {
+          entries[key] = { value }
+        }
+        const otelBaggages = propagation.createBaggage(entries)
+        return propagation.setBaggage(baseContext, otelBaggages)
+      }
+      return baseContext
+    }
+
+    const ddContext = activeSpan.context()
+
+    if (!ddContext._otelSpanContext) {
+      ddContext._otelSpanContext = new SpanContext(ddContext)
     }
-    const otelBaggages = propagation.createBaggage(entries)
 
-    if (!context._otelSpanContext) {
-      const newSpanContext = new SpanContext(context)
-      context._otelSpanContext = newSpanContext
+    // Convert DD baggage to OTel format
+    const baggages = JSON.parse(activeSpan.getAllBaggageItems())
+    const hasBaggage = Object.keys(baggages).length > 0
+    let otelBaggages
+    if (hasBaggage) {
+      const entries = {}
+      for (const [key, value] of Object.entries(baggages)) {
+        entries[key] = { value }
+      }
+      otelBaggages = propagation.createBaggage(entries)
     }
-    if (store && trace.getSpanContext(store) === context._otelSpanContext) {
-      return otelBaggages
-        ? propagation.setBaggage(store, otelBaggages)
-        : store
+
+    if (store && trace.getSpanContext(store) === ddContext._otelSpanContext) {
+      return otelBaggages ? propagation.setBaggage(store, otelBaggages) : store
     }
-    const wrappedContext = trace.setSpanContext(store || ROOT_CONTEXT, context._otelSpanContext)
-    return otelBaggages
-      ? propagation.setBaggage(wrappedContext, otelBaggages)
-      : wrappedContext
+
+    const wrappedContext = trace.setSpanContext(baseContext, ddContext._otelSpanContext)
+    return otelBaggages ? propagation.setBaggage(wrappedContext, otelBaggages) : wrappedContext
   }
 
   // converts otel to dd
@@ -77,10 +95,11 @@ class ContextManager {
       return ddScope.activate(span._ddSpan, run)
     }
     // span instanceof NonRecordingSpan
-    if (span && span._spanContext && span._spanContext._ddContext && span._spanContext._ddContext._baggageItems) {
-      span._spanContext._ddContext._baggageItems = {}
+    const ddContext = span?._spanContext?._ddContext
+    if (ddContext && ddContext._baggageItems) {
+      ddContext._baggageItems = {}
       for (const baggage of baggageItems) {
-        span._spanContext._ddContext._baggageItems[baggage[0]] = baggage[1].value
+        ddContext._baggageItems[baggage[0]] = baggage[1].value
       }
     }
     return run()

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

@@ -40,7 +40,7 @@ function initializeOpenTelemetryLogs (config) {
   const resourceAttributes = {
     'service.name': config.service,
     'service.version': config.version,
-    'deployment.environment': config.env
+    'deployment.environment': config.env,
   }
 
   // Add all tracer tags (includes DD_TAGS, OTEL_RESOURCE_ATTRIBUTES, DD_TRACE_TAGS, etc.)
@@ -83,5 +83,5 @@ function initializeOpenTelemetryLogs (config) {
 
 module.exports = {
   LoggerProvider,
-  initializeOpenTelemetryLogs
+  initializeOpenTelemetryLogs,
 }

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

@@ -111,14 +111,14 @@ class LoggerProvider {
     return {
       instrumentationScope: {
         name: 'dd-trace-js',
-        version: ''
+        version: '',
       },
       emit: () => {},
       debug: () => {},
       info: () => {},
       warn: () => {},
       error: () => {},
-      fatal: () => {}
+      fatal: () => {},
     }
   }
 }

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

@@ -35,7 +35,7 @@ const SEVERITY_MAP = {
   [SeverityNumber.FATAL]: 'SEVERITY_NUMBER_FATAL',
   [SeverityNumber.FATAL2]: 'SEVERITY_NUMBER_FATAL2',
   [SeverityNumber.FATAL3]: 'SEVERITY_NUMBER_FATAL3',
-  [SeverityNumber.FATAL4]: 'SEVERITY_NUMBER_FATAL4'
+  [SeverityNumber.FATAL4]: 'SEVERITY_NUMBER_FATAL4',
 }
 
 /**
@@ -82,7 +82,7 @@ class OtlpTransformer extends OtlpTransformerBase {
       resourceLogs: [{
         resource: this.transformResource(),
         scopeLogs: this.#transformScope(logRecords),
-      }]
+      }],
     }
 
     return this.serializeToProtobuf(protoLogsService, logsData)
@@ -97,8 +97,8 @@ class OtlpTransformer extends OtlpTransformerBase {
     const logsData = {
       resourceLogs: [{
         resource: this.transformResource(),
-        scopeLogs: this.#transformScope(logRecords)
-      }]
+        scopeLogs: this.#transformScope(logRecords),
+      }],
     }
     return this.serializeToJson(logsData)
   }
@@ -119,10 +119,10 @@ class OtlpTransformer extends OtlpTransformerBase {
           name: records[0]?.instrumentationScope?.name || 'dd-trace-js',
           version: records[0]?.instrumentationScope?.version || '',
           attributes: [],
-          droppedAttributesCount: 0
+          droppedAttributesCount: 0,
         },
         schemaUrl,
-        logRecords: records.map(record => this.#transformLogRecord(record))
+        logRecords: records.map(record => this.#transformLogRecord(record)),
       })
     }
 
@@ -139,7 +139,7 @@ class OtlpTransformer extends OtlpTransformerBase {
 
     const result = {
       timeUnixNano: logRecord.timestamp,
-      body: this.#transformBody(logRecord.body)
+      body: this.#transformBody(logRecord.body),
     }
 
     // Add optional fields only if they are set
@@ -233,9 +233,9 @@ class OtlpTransformer extends OtlpTransformerBase {
         kvlistValue: {
           values: Object.entries(body).map(([key, value]) => ({
             key,
-            value: this.transformAnyValue(value)
-          }))
-        }
+            value: this.transformAnyValue(value),
+          })),
+        },
       }
     }
     return { stringValue: String(body) }

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

@@ -7,7 +7,7 @@ const METRIC_TYPES = {
   UPDOWNCOUNTER: 'updowncounter',
   OBSERVABLECOUNTER: 'observable-counter',
   OBSERVABLEUPDOWNCOUNTER: 'observable-updowncounter',
-  GAUGE: 'gauge'
+  GAUGE: 'gauge',
 }
 
 // Temporality constants
@@ -15,7 +15,7 @@ const TEMPORALITY = {
   DELTA: 'DELTA',
   CUMULATIVE: 'CUMULATIVE',
   GAUGE: 'GAUGE',
-  LOWMEMORY: 'LOWMEMORY'
+  LOWMEMORY: 'LOWMEMORY',
 }
 
 // Default histogram bucket boundaries (in milliseconds for latency metrics)
@@ -30,5 +30,5 @@ module.exports = {
   METRIC_TYPES,
   TEMPORALITY,
   DEFAULT_HISTOGRAM_BUCKETS,
-  DEFAULT_MAX_MEASUREMENT_QUEUE_SIZE
+  DEFAULT_MAX_MEASUREMENT_QUEUE_SIZE,
 }

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

@@ -41,7 +41,7 @@ function initializeOpenTelemetryMetrics (config) {
   const resourceAttributes = {
     'service.name': config.service,
     'service.version': config.version,
-    'deployment.environment': config.env
+    'deployment.environment': config.env,
   }
 
   if (config.tags) {
@@ -77,5 +77,5 @@ function initializeOpenTelemetryMetrics (config) {
 
 module.exports = {
   MeterProvider,
-  initializeOpenTelemetryMetrics
+  initializeOpenTelemetryMetrics,
 }

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

@@ -62,7 +62,7 @@ class Instrument {
       type,
       value,
       attributes: sanitizeAttributes(attributes),
-      timestamp: Number(process.hrtime.bigint())
+      timestamp: Number(process.hrtime.bigint()),
     }
   }
 }
@@ -165,7 +165,7 @@ class ObservableInstrument extends Instrument {
     const observableResult = {
       observe: (value, attributes = {}) => {
         observations.push(this.createMeasurement(this.#type, value, attributes))
-      }
+      },
     }
 
     for (const callback of this.#callbacks) {
@@ -221,5 +221,5 @@ module.exports = {
   Gauge,
   ObservableGauge,
   ObservableCounter,
-  ObservableUpDownCounter
+  ObservableUpDownCounter,
 }

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

@@ -3,7 +3,7 @@
 const { VERSION: packageVersion } = require('../../../../../version')
 const log = require('../../log')
 const {
-  Counter, UpDownCounter, Histogram, Gauge, ObservableGauge, ObservableCounter, ObservableUpDownCounter
+  Counter, UpDownCounter, Histogram, Gauge, ObservableGauge, ObservableCounter, ObservableUpDownCounter,
 } = require('./instruments')
 const { METRIC_TYPES } = require('./constants')
 

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

@@ -59,7 +59,7 @@ class OtlpTransformer extends OtlpTransformerBase {
       resourceMetrics: [{
         resource: this.transformResource(),
         scopeMetrics: this.#transformScope(metrics),
-      }]
+      }],
     }
 
     return this.serializeToProtobuf(protoMetricsService, metricsData)
@@ -75,8 +75,8 @@ class OtlpTransformer extends OtlpTransformerBase {
     const metricsData = {
       resourceMetrics: [{
         resource: this.transformResource(),
-        scopeMetrics: this.#transformScope(metrics, true)
-      }]
+        scopeMetrics: this.#transformScope(metrics, true),
+      }],
     }
     return this.serializeToJson(metricsData)
   }
@@ -100,7 +100,7 @@ class OtlpTransformer extends OtlpTransformerBase {
       const scope = {
         name,
         version,
-        droppedAttributesCount: 0
+        droppedAttributesCount: 0,
       }
 
       if (attributes) {
@@ -113,7 +113,7 @@ class OtlpTransformer extends OtlpTransformerBase {
       scopeMetrics.push({
         scope,
         schemaUrl,
-        metrics: metricsInScope.map(metric => this.#transformMetric(metric, isJson))
+        metrics: metricsInScope.map(metric => this.#transformMetric(metric, isJson)),
       })
     }
 
@@ -131,7 +131,7 @@ class OtlpTransformer extends OtlpTransformerBase {
     const result = {
       name: metric.name,
       description: metric.description || '',
-      unit: metric.unit || ''
+      unit: metric.unit || '',
     }
 
     const isCumulative = metric.temporality === TEMPORALITY.CUMULATIVE
@@ -146,7 +146,7 @@ class OtlpTransformer extends OtlpTransformerBase {
       case METRIC_TYPES.HISTOGRAM:
         result.histogram = {
           dataPoints: Array.from(metric.dataPointMap.values(), dp => this.#transformHistogramDataPoint(dp, isJson)),
-          aggregationTemporality: temporality
+          aggregationTemporality: temporality,
         }
         break
 
@@ -157,13 +157,13 @@ class OtlpTransformer extends OtlpTransformerBase {
         result.sum = {
           dataPoints: Array.from(metric.dataPointMap.values(), dp => this.#transformNumberDataPoint(dp, isJson)),
           aggregationTemporality: temporality,
-          isMonotonic: metric.type === METRIC_TYPES.COUNTER || metric.type === METRIC_TYPES.OBSERVABLECOUNTER
+          isMonotonic: metric.type === METRIC_TYPES.COUNTER || metric.type === METRIC_TYPES.OBSERVABLECOUNTER,
         }
         break
 
       case METRIC_TYPES.GAUGE:
         result.gauge = {
-          dataPoints: Array.from(metric.dataPointMap.values(), dp => this.#transformNumberDataPoint(dp, isJson))
+          dataPoints: Array.from(metric.dataPointMap.values(), dp => this.#transformNumberDataPoint(dp, isJson)),
         }
         break
     }
@@ -192,7 +192,7 @@ class OtlpTransformer extends OtlpTransformerBase {
       bucketCounts: dp.bucketCounts || [],
       explicitBounds: dp.explicitBounds || [],
       min: dp.min,
-      max: dp.max
+      max: dp.max,
     }
 
     if (isJson) {
@@ -221,7 +221,7 @@ class OtlpTransformer extends OtlpTransformerBase {
 
     const result = {
       attributes,
-      timeUnixNano
+      timeUnixNano,
     }
 
     if (dataPoint.startTimeUnixNano) {