dd-trace 5.100.0 → 5.102.0

package/packages/dd-trace/src/msgpack/chunk.js

@@ -8,11 +8,13 @@ const DEFAULT_MIN_SIZE = 2 * 1024 * 1024 // 2MB
  * either.
  */
 class MsgpackChunk {
+  #minSize
+
   constructor (minSize = DEFAULT_MIN_SIZE) {
     this.buffer = Buffer.allocUnsafe(minSize)
     this.view = new DataView(this.buffer.buffer)
     this.length = 0
-    this._minSize = minSize
+    this.#minSize = minSize
   }
 
   write (value) {
@@ -50,13 +52,14 @@ class MsgpackChunk {
 
   reserve (size) {
     if (this.length + size > this.buffer.length) {
-      this._resize(this._minSize * Math.ceil((this.length + size) / this._minSize))
+      const minSize = this.#minSize
+      this.#resize(minSize * Math.ceil((this.length + size) / minSize))
     }
 
     this.length += size
   }
 
-  _resize (size) {
+  #resize (size) {
     const oldBuffer = this.buffer
 
     this.buffer = Buffer.allocUnsafe(size)

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

@@ -2,6 +2,18 @@
 
 const { NOOP_REASON } = require('./constants/constants')
 
+/**
+ * @template T
+ * @param {T} defaultValue
+ * @returns {Promise<{value: T, reason: string}>}
+ */
+function resolveDefault (defaultValue) {
+  return Promise.resolve({
+    value: defaultValue,
+    reason: NOOP_REASON,
+  })
+}
+
 /**
  * No-op implementation of OpenFeature provider that always returns default values.
  * Used when the OpenFeature provider is not initialized or disabled.
@@ -20,59 +32,51 @@ class NoopFlaggingProvider {
   }
 
   /**
-   * @param {string} flagKey - Flag key
-   * @param {boolean} defaultValue - Default value to return
-   * @param {object} context - Evaluation context
-   * @param {object} logger - Logger instance
-   * @returns {Promise<{value: boolean, reason: string}>} Resolution details
+   * @template T
+   * @param {string} flagKey
+   * @param {T} defaultValue
+   * @param {object} context
+   * @param {object} logger
+   * @returns {Promise<{value: T, reason: string}>}
    */
   resolveBooleanEvaluation (flagKey, defaultValue, context, logger) {
-    return Promise.resolve({
-      value: defaultValue,
-      reason: NOOP_REASON,
-    })
+    return resolveDefault(defaultValue)
   }
 
   /**
-   * @param {string} flagKey - Flag key
-   * @param {string} defaultValue - Default value to return
-   * @param {object} context - Evaluation context
-   * @param {object} logger - Logger instance
-   * @returns {Promise<{value: string, reason: string}>} Resolution details
+   * @template T
+   * @param {string} flagKey
+   * @param {T} defaultValue
+   * @param {object} context
+   * @param {object} logger
+   * @returns {Promise<{value: T, reason: string}>}
    */
   resolveStringEvaluation (flagKey, defaultValue, context, logger) {
-    return Promise.resolve({
-      value: defaultValue,
-      reason: NOOP_REASON,
-    })
+    return resolveDefault(defaultValue)
   }
 
   /**
-   * @param {string} flagKey - Flag key
-   * @param {number} defaultValue - Default value to return
-   * @param {object} context - Evaluation context
-   * @param {object} logger - Logger instance
-   * @returns {Promise<{value: number, reason: string}>} Resolution details
+   * @template T
+   * @param {string} flagKey
+   * @param {T} defaultValue
+   * @param {object} context
+   * @param {object} logger
+   * @returns {Promise<{value: T, reason: string}>}
    */
   resolveNumberEvaluation (flagKey, defaultValue, context, logger) {
-    return Promise.resolve({
-      value: defaultValue,
-      reason: NOOP_REASON,
-    })
+    return resolveDefault(defaultValue)
   }
 
   /**
-   * @param {string} flagKey - Flag key
-   * @param {object} defaultValue - Default value to return
-   * @param {object} context - Evaluation context
-   * @param {object} logger - Logger instance
-   * @returns {Promise<{value: object, reason: string}>} Resolution details
+   * @template T
+   * @param {string} flagKey
+   * @param {T} defaultValue
+   * @param {object} context
+   * @param {object} logger
+   * @returns {Promise<{value: T, reason: string}>}
    */
   resolveObjectEvaluation (flagKey, defaultValue, context, logger) {
-    return Promise.resolve({
-      value: defaultValue,
-      reason: NOOP_REASON,
-    })
+    return resolveDefault(defaultValue)
   }
 
   /**

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

@@ -43,7 +43,7 @@ const BaseFFEWriter = require('./base')
  */
 class ExposuresWriter extends BaseFFEWriter {
   /**
-   * @param {import('../../config')} config - Tracer configuration object
+   * @param {import('../../config/config-base')} config - Tracer configuration object
    */
   constructor (config) {
     // Build full EVP endpoint path
@@ -62,7 +62,19 @@ class ExposuresWriter extends BaseFFEWriter {
     })
     this._enabled = false // Start disabled until agent strategy is set
     this._pendingEvents = [] // Buffer events until enabled
-    this._context = this._buildContext()
+
+    const context = {
+      service: config.service,
+    }
+    // Only include version and env if they are defined
+    if (config.version !== undefined) {
+      context.version = config.version
+    }
+    if (config.env !== undefined) {
+      context.env = config.env
+    }
+
+    this._context = context
   }
 
   /**
@@ -112,62 +124,31 @@ class ExposuresWriter extends BaseFFEWriter {
    * @returns {ExposureEventPayload} Formatted payload with service context
    */
   makePayload (events) {
-    const formattedEvents = events.map(event => this._formatExposureEvent(event))
+    const formattedEvents = events.map(event => {
+      return {
+        timestamp: event.timestamp || Date.now(),
+        allocation: {
+          key: event.allocation?.key || event['allocation.key'],
+        },
+        flag: {
+          key: event.flag?.key || event['flag.key'],
+        },
+        variant: {
+          key: event.variant?.key || event['variant.key'],
+        },
+        subject: {
+          id: event.subject?.id || event['subject.id'],
+          type: event.subject?.type,
+          attributes: event.subject?.attributes,
+        },
+      }
+    })
 
     return {
       context: this._context,
       exposures: formattedEvents,
     }
   }
-
-  /**
-   * Builds service context metadata
-   * @private
-   * @returns {ExposureContext} Service context
-   */
-  _buildContext () {
-    const context = {
-      service: this._config.service || 'unknown',
-    }
-
-    // Only include version and env if they are defined
-    if (this._config.version !== undefined) {
-      context.version = this._config.version
-    }
-
-    if (this._config.env !== undefined) {
-      context.env = this._config.env
-    }
-
-    return context
-  }
-
-  /**
-   * @private
-   * @param {ExposureEvent} event - Raw exposure event
-   * @returns {ExposureEvent} Formatted exposure event
-   */
-  _formatExposureEvent (event) {
-    // Ensure the event matches the expected schema
-    const formattedEvent = {
-      timestamp: event.timestamp || Date.now(),
-      allocation: {
-        key: event.allocation?.key || event['allocation.key'],
-      },
-      flag: {
-        key: event.flag?.key || event['flag.key'],
-      },
-      variant: {
-        key: event.variant?.key || event['variant.key'],
-      },
-      subject: {
-        id: event.subject?.id || event['subject.id'],
-        type: event.subject?.type,
-        attributes: event.subject?.attributes,
-      },
-    }
-    return formattedEvent
-  }
 }
 
 module.exports = ExposuresWriter

package/packages/dd-trace/src/opentelemetry/active-span-proxy.js

@@ -0,0 +1,42 @@
+'use strict'
+
+const BridgeSpanBase = require('./bridge-span-base')
+const { setOtelResource } = require('./span-helpers')
+
+/**
+ * OTel `Span`-compatible proxy around an already-active Datadog span.
+ *
+ * Makes `trace.getActiveSpan()` forward attribute/link/event/status/exception writes onto
+ * the Datadog span. `end()` is intentionally a no-op: the span's lifecycle belongs to
+ * whoever created it. Mutation methods all bail out once the underlying Datadog span has
+ * finished (gated inside the helpers), matching OTel `Span` semantics.
+ */
+class ActiveSpanProxy extends BridgeSpanBase {
+  /** @type {import('./span_context')} */
+  #otelSpanContext
+
+  /**
+   * @param {import('../opentracing/span')} ddSpan
+   * @param {import('./span_context')} otelSpanContext
+   */
+  constructor (ddSpan, otelSpanContext) {
+    super(ddSpan)
+    this.#otelSpanContext = otelSpanContext
+  }
+
+  spanContext () {
+    return this.#otelSpanContext
+  }
+
+  /**
+   * @param {string} name
+   */
+  updateName (name) {
+    setOtelResource(this._ddSpan, name)
+    return this
+  }
+
+  end () {}
+}
+
+module.exports = ActiveSpanProxy

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

@@ -0,0 +1,106 @@
+'use strict'
+
+const {
+  addOtelEvent,
+  addOtelLink,
+  addOtelLinks,
+  applyOtelStatus,
+  recordException,
+  setOtelAttribute,
+  setOtelAttributes,
+} = require('./span-helpers')
+
+/**
+ * Shared base for the OTel-bridge span classes (`Span` and `ActiveSpanProxy`). Subclasses
+ * pass the underlying Datadog span to `super(ddSpan)` and provide `spanContext()`, `end()`,
+ * and `updateName()`. The writable-span gate lives in the helpers in `span-helpers.js`,
+ * so neither bridge can drift from it.
+ *
+ * `_ddSpan` is left as a `_underscore` field rather than `#private` so the bridge does not
+ * expand its published API to expose the underlying DD span. External callers that need
+ * the reference (`ContextManager` proxy-cache check, OTLP serialization, tests) reach in
+ * via `_ddSpan`, matching the existing convention for "internal, may break".
+ */
+class BridgeSpanBase {
+  // OTel SpanStatusCode: 0 = UNSET, 1 = OK, 2 = ERROR. Tracked for OK-is-final precedence.
+  #statusCode = 0
+
+  /**
+   * @param {import('../opentracing/span')} ddSpan
+   */
+  constructor (ddSpan) {
+    this._ddSpan = ddSpan
+  }
+
+  get ended () {
+    return this._ddSpan._duration !== undefined
+  }
+
+  isRecording () {
+    return !this.ended
+  }
+
+  /**
+   * @param {string} key
+   * @param {import('@opentelemetry/api').AttributeValue} value
+   */
+  setAttribute (key, value) {
+    setOtelAttribute(this._ddSpan, key, value)
+    return this
+  }
+
+  /**
+   * @param {import('@opentelemetry/api').Attributes} attributes
+   */
+  setAttributes (attributes) {
+    setOtelAttributes(this._ddSpan, attributes)
+    return this
+  }
+
+  /**
+   * @param {string} name
+   * @param {import('@opentelemetry/api').Attributes | import('@opentelemetry/api').TimeInput} [attributesOrStartTime]
+   * @param {import('@opentelemetry/api').TimeInput} [startTime]
+   */
+  addEvent (name, attributesOrStartTime, startTime) {
+    addOtelEvent(this._ddSpan, name, attributesOrStartTime, startTime)
+    return this
+  }
+
+  /**
+   * Accepts the OTel `Link` shape and the deprecated `(SpanContext, Attributes)` form.
+   *
+   * @param {import('@opentelemetry/api').Link | import('@opentelemetry/api').SpanContext} link
+   * @param {import('@opentelemetry/api').Attributes} [attrs]
+   */
+  addLink (link, attrs) {
+    addOtelLink(this._ddSpan, link, attrs)
+    return this
+  }
+
+  /**
+   * @param {import('@opentelemetry/api').Link[]} links
+   */
+  addLinks (links) {
+    addOtelLinks(this._ddSpan, links)
+    return this
+  }
+
+  /**
+   * @param {import('@opentelemetry/api').Exception} exception
+   * @param {import('@opentelemetry/api').TimeInput} [timeInput]
+   */
+  recordException (exception, timeInput) {
+    recordException(this._ddSpan, exception, timeInput)
+  }
+
+  /**
+   * @param {import('@opentelemetry/api').SpanStatus} status
+   */
+  setStatus (status) {
+    this.#statusCode = applyOtelStatus(this._ddSpan, this.#statusCode, status)
+    return this
+  }
+}
+
+module.exports = BridgeSpanBase

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

@@ -4,6 +4,7 @@ const { trace, ROOT_CONTEXT, propagation } = require('@opentelemetry/api')
 const { storage } = require('../../../datadog-core')
 const { getAllBaggageItems, setAllBaggageItems, removeAllBaggageItems } = require('../baggage')
 
+const ActiveSpanProxy = require('./active-span-proxy')
 const SpanContext = require('./span_context')
 
 class ContextManager {
@@ -48,11 +49,19 @@ class ContextManager {
       ddContext._otelSpanContext = new SpanContext(ddContext)
     }
 
-    if (store && trace.getSpanContext(store) === ddContext._otelSpanContext) {
+    // Cache the active-span proxy next to the bridge span context. This lets
+    // `trace.getActiveSpan()` forward attribute/status/link/exception writes
+    // onto the active Datadog span rather than returning a NonRecordingSpan
+    // whose mutation methods are silent no-ops.
+    if (!ddContext._otelActiveSpan) {
+      ddContext._otelActiveSpan = new ActiveSpanProxy(activeSpan, ddContext._otelSpanContext)
+    }
+
+    if (store && trace.getSpan(store) === ddContext._otelActiveSpan) {
       return otelBaggages ? propagation.setBaggage(store, otelBaggages) : store
     }
 
-    const wrappedContext = trace.setSpanContext(baseContext, ddContext._otelSpanContext)
+    const wrappedContext = trace.setSpan(baseContext, ddContext._otelActiveSpan)
     return otelBaggages ? propagation.setBaggage(wrappedContext, otelBaggages) : wrappedContext
   }
 

package/packages/dd-trace/src/opentelemetry/otlp/otlp_transformer_base.js

@@ -141,8 +141,7 @@ class OtlpTransformerBase {
    */
   serializeToProtobuf (protoType, data) {
     const message = protoType.create(data)
-    const buffer = protoType.encode(message).finish()
-    return buffer
+    return protoType.encode(message).finish()
   }
 
   /**