dd-trace 5.84.0 → 5.85.0

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

@@ -12,7 +12,7 @@ const telemetry = require('../telemetry')
 const log = require('../../log')
 const {
   EVP_SUBDOMAIN_HEADER_NAME,
-  EVP_PROXY_AGENT_BASE_PATH
+  EVP_PROXY_AGENT_BASE_PATH,
 } = require('../constants/writers')
 const { getAgentUrl } = require('../../agent/url')
 const { parseResponseAndLog } = require('./util')
@@ -133,15 +133,15 @@ class BaseLLMObsWriter {
       const options = {
         headers: {
           'Content-Type': 'application/json',
-          'DD-API-KEY': apiKey
+          'DD-API-KEY': apiKey,
         },
         method: 'POST',
         timeout: this._timeout,
         url: new URL(format({
           protocol: 'https:',
-          hostname: `${this._intake}.${site}`
+          hostname: `${this._intake}.${site}`,
         })),
-        path: this._baseEndpoint
+        path: this._baseEndpoint,
       }
       const url = this.#buildUrl(options.url.href, options.path)
       const maskedApiKey = apiKey ? `****${apiKey.slice(-4)}` : ''
@@ -193,9 +193,9 @@ class BaseLLMObsWriter {
       return {
         url: new URL(format({
           protocol: 'https:',
-          hostname: `${this._intake}.${site}`
+          hostname: `${this._intake}.${site}`,
         })),
-        endpoint: this._endpoint
+        endpoint: this._endpoint,
       }
     }
 
@@ -205,19 +205,19 @@ class BaseLLMObsWriter {
 
     return {
       url: base,
-      endpoint: path.join(EVP_PROXY_AGENT_BASE_PATH, this._endpoint)
+      endpoint: path.join(EVP_PROXY_AGENT_BASE_PATH, this._endpoint),
     }
   }
 
   _getOptions () {
     const options = {
       headers: {
-        'Content-Type': 'application/json'
+        'Content-Type': 'application/json',
       },
       method: 'POST',
       timeout: this._timeout,
       url: this._baseUrl,
-      path: this._endpoint
+      path: this._endpoint,
     }
 
     if (this._agentless) {

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

@@ -3,7 +3,7 @@
 const {
   EVALUATIONS_ENDPOINT,
   EVALUATIONS_EVENT_TYPE,
-  EVALUATIONS_INTAKE
+  EVALUATIONS_INTAKE,
 } = require('../constants/writers')
 const BaseWriter = require('./base')
 
@@ -13,7 +13,7 @@ class LLMObsEvalMetricsWriter extends BaseWriter {
       config,
       intake: EVALUATIONS_INTAKE,
       eventType: EVALUATIONS_EVENT_TYPE,
-      endpoint: EVALUATIONS_ENDPOINT
+      endpoint: EVALUATIONS_ENDPOINT,
     })
   }
 
@@ -22,9 +22,9 @@ class LLMObsEvalMetricsWriter extends BaseWriter {
       data: {
         type: this._eventType,
         attributes: {
-          metrics: events
-        }
-      }
+          metrics: events,
+        },
+      },
     }
   }
 }

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

@@ -5,7 +5,7 @@ const {
   EVP_PAYLOAD_SIZE_LIMIT,
   SPANS_ENDPOINT,
   SPANS_EVENT_TYPE,
-  SPANS_INTAKE
+  SPANS_INTAKE,
 } = require('../constants/writers')
 const { DROPPED_VALUE_TEXT } = require('../constants/text')
 const { DROPPED_IO_COLLECTION_ERROR } = require('../constants/tags')
@@ -20,7 +20,7 @@ class LLMObsSpanWriter extends BaseWriter {
       config,
       eventType: SPANS_EVENT_TYPE,
       intake: SPANS_INTAKE,
-      endpoint: SPANS_ENDPOINT
+      endpoint: SPANS_ENDPOINT,
     })
   }
 
@@ -53,7 +53,7 @@ class LLMObsSpanWriter extends BaseWriter {
       '_dd.stage': 'raw',
       '_dd.tracer_version': tracerVersion,
       event_type: this._eventType,
-      spans: [event]
+      spans: [event],
     }))
   }
 

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

@@ -50,5 +50,5 @@ function parseResponseAndLog (err, code, eventsLength, url, eventType) {
 
 module.exports = {
   setAgentStrategy,
-  parseResponseAndLog
+  parseResponseAndLog,
 }

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

@@ -9,7 +9,7 @@ const Level = {
   warn: 40,
   error: 50,
   critical: 50,
-  off: 100
+  off: 100,
 }
 
 const traceChannel = channel('datadog:log:trace')
@@ -74,5 +74,5 @@ module.exports = {
   debugChannel,
   infoChannel,
   warnChannel,
-  errorChannel
+  errorChannel,
 }

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

@@ -10,7 +10,7 @@ const { memoize } = require('./utils')
 const config = {
   enabled: false,
   logger: undefined,
-  logLevel: 'debug'
+  logLevel: 'debug',
 }
 
 // in most places where we know we want to mute a log we use log.error() directly
@@ -127,7 +127,7 @@ const log = {
       getValueFromEnvSources('OTEL_LOG_LEVEL') ??
       localStableConfigValue ??
       config.logLevel
-  }
+  },
 }
 
 function publishFormatted (ch, formatter, ...args) {

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

@@ -44,7 +44,7 @@ class Log {
     if (firstArg) {
       if (typeof firstArg === 'string') {
         message = firstArg
-      } else if (typeof firstArg === 'object') { // eslint-disable-line eslint-rules/eslint-safe-typeof-object
+      } else if (typeof firstArg === 'object') {
         message = String(firstArg.message || firstArg)
       } else if (typeof firstArg === 'function') {
         delegate = firstArg

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

@@ -6,7 +6,7 @@ const defaultLogger = {
   debug: msg => console.debug(msg), /* eslint-disable-line no-console */
   info: msg => console.info(msg), /* eslint-disable-line no-console */
   warn: msg => console.warn(msg), /* eslint-disable-line no-console */
-  error: msg => console.error(msg) /* eslint-disable-line no-console */
+  error: msg => console.error(msg), /* eslint-disable-line no-console */
 }
 
 let enabled = false

package/packages/dd-trace/src/noop/span.js

@@ -37,12 +37,12 @@ class NoopSpan {
         traceId: parent._traceId,
         spanId,
         parentId: parent._spanId,
-        baggageItems: { ...parent._baggageItems }
+        baggageItems: { ...parent._baggageItems },
       })
       : new NoopSpanContext({
         noop: this,
         traceId: spanId,
-        spanId
+        spanId,
       })
   }
 }

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

@@ -47,5 +47,5 @@ module.exports = {
    * @constant
    * @type {string} Reason code for noop provider evaluations
    */
-  NOOP_REASON: 'STATIC'
+  NOOP_REASON: 'STATIC',
 }

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

@@ -18,14 +18,14 @@ class FlaggingProvider extends DatadogNodeServerProvider {
     // Call parent constructor with required options and timeout
     super({
       exposureChannel: channel(EXPOSURE_CHANNEL),
-      initializationTimeoutMs: config.experimental.flaggingProvider.initializationTimeoutMs
+      initializationTimeoutMs: config.experimental.flaggingProvider.initializationTimeoutMs,
     })
 
     this._tracer = tracer
     this._config = config
 
-    log.debug(this.constructor.name + ' created with timeout: ' +
-      config.experimental.flaggingProvider.initializationTimeoutMs + 'ms')
+    log.debug('%s created with timeout: %dms', this.constructor.name,
+      config.experimental.flaggingProvider.initializationTimeoutMs)
   }
 
   /**
@@ -40,7 +40,7 @@ class FlaggingProvider extends DatadogNodeServerProvider {
     if (typeof this.setConfiguration === 'function') {
       this.setConfiguration(ufc)
     }
-    log.debug(this.constructor.name + ' provider configuration updated')
+    log.debug('%s provider configuration updated', this.constructor.name)
   }
 }
 

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

@@ -36,7 +36,7 @@ function _handleFlush () {
  */
 function enable (config) {
   if (exposuresWriter) {
-    log.warn(exposuresWriter.constructor.name + ' already enabled')
+    log.warn('%s already enabled', exposuresWriter.constructor.name)
     return
   }
 
@@ -73,5 +73,5 @@ function disable () {
 
 module.exports = {
   enable,
-  disable
+  disable,
 }

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

@@ -29,7 +29,7 @@ class NoopFlaggingProvider {
   resolveBooleanEvaluation (flagKey, defaultValue, context, logger) {
     return Promise.resolve({
       value: defaultValue,
-      reason: NOOP_REASON
+      reason: NOOP_REASON,
     })
   }
 
@@ -43,7 +43,7 @@ class NoopFlaggingProvider {
   resolveStringEvaluation (flagKey, defaultValue, context, logger) {
     return Promise.resolve({
       value: defaultValue,
-      reason: NOOP_REASON
+      reason: NOOP_REASON,
     })
   }
 
@@ -71,7 +71,7 @@ class NoopFlaggingProvider {
   resolveObjectEvaluation (flagKey, defaultValue, context, logger) {
     return Promise.resolve({
       value: defaultValue,
-      reason: NOOP_REASON
+      reason: NOOP_REASON,
     })
   }
 

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

@@ -27,5 +27,5 @@ function enable (rc, config, getOpenfeatureProxy) {
 }
 
 module.exports = {
-  enable
+  enable,
 }

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

@@ -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)
       }
     }
   }

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

@@ -34,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) }