dd-trace 5.97.0 → 5.98.0

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

@@ -0,0 +1,66 @@
+'use strict'
+
+const OtlpHttpExporterBase = require('../otlp/otlp_http_exporter_base')
+const { SAMPLING_PRIORITY_KEY } = require('../../constants')
+const { AUTO_KEEP } = require('../../../../../ext/priority')
+const OtlpTraceTransformer = require('./otlp_transformer')
+
+/**
+ * OtlpHttpTraceExporter exports DD-formatted spans via OTLP over HTTP/JSON.
+ *
+ * This implementation follows the OTLP HTTP v1.7.0 specification:
+ * https://opentelemetry.io/docs/specs/otlp/#otlphttp
+ *
+ * It receives DD-formatted spans (from span_format.js), transforms them
+ * to OTLP ExportTraceServiceRequest JSON format, and sends them to the
+ * configured OTLP endpoint via HTTP POST.
+ *
+ * @class OtlpHttpTraceExporter
+ * @augments OtlpHttpExporterBase
+ */
+class OtlpHttpTraceExporter extends OtlpHttpExporterBase {
+  #transformer
+
+  /**
+   * Creates a new OtlpHttpTraceExporter instance.
+   *
+   * @param {string} url - OTLP endpoint URL
+   * @param {string} headers - Additional HTTP headers as comma-separated key=value string
+   * @param {number} timeout - Request timeout in milliseconds
+   * @param {import('@opentelemetry/api').Attributes} resourceAttributes - Resource attributes
+   */
+  constructor (url, headers, timeout, resourceAttributes) {
+    super(url, headers, timeout, 'http/json', '/v1/traces', 'traces')
+    this.#transformer = new OtlpTraceTransformer(resourceAttributes)
+  }
+
+  /**
+   * Exports DD-formatted spans via OTLP over HTTP.
+   *
+   * @param {import('./otlp_transformer').DDFormattedSpan[]} spans - Array of DD-formatted spans to export
+   * @returns {void}
+   */
+  export (spans) {
+    if (spans.length === 0) {
+      return
+    }
+
+    // Drop unsampled traces — OTLP endpoints have no agent-side sampling.
+    const priority = spans[0]?.metrics?.[SAMPLING_PRIORITY_KEY]
+    if (priority !== undefined && priority < AUTO_KEEP) {
+      return
+    }
+
+    const additionalTags = [`spans:${spans.length}`]
+    this.recordTelemetry('otel.traces_export_attempts', 1, additionalTags)
+
+    const payload = this.#transformer.transformSpans(spans)
+    this.sendPayload(payload, (result) => {
+      if (result.code === 0) {
+        this.recordTelemetry('otel.traces_export_successes', 1, additionalTags)
+      }
+    })
+  }
+}
+
+module.exports = OtlpHttpTraceExporter

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

@@ -0,0 +1,332 @@
+'use strict'
+
+const OtlpTransformerBase = require('../otlp/otlp_transformer_base')
+const { getProtobufTypes } = require('../otlp/protobuf_loader')
+const { VERSION } = require('../../../../../version')
+
+const { protoSpanKind } = getProtobufTypes()
+const SPAN_KIND_UNSPECIFIED = protoSpanKind.values.SPAN_KIND_UNSPECIFIED
+const SPAN_KIND_INTERNAL = protoSpanKind.values.SPAN_KIND_INTERNAL
+const SPAN_KIND_SERVER = protoSpanKind.values.SPAN_KIND_SERVER
+const SPAN_KIND_CLIENT = protoSpanKind.values.SPAN_KIND_CLIENT
+const SPAN_KIND_PRODUCER = protoSpanKind.values.SPAN_KIND_PRODUCER
+const SPAN_KIND_CONSUMER = protoSpanKind.values.SPAN_KIND_CONSUMER
+
+/**
+ * @typedef {object} DDFormattedSpan
+ * @property {import('../../id')} trace_id - DD Identifier for trace ID
+ * @property {import('../../id')} span_id - DD Identifier for span ID
+ * @property {import('../../id')} parent_id - DD Identifier for parent span ID
+ * @property {string} name - Span operation name
+ * @property {string} resource - Resource name
+ * @property {string} [service] - Service name
+ * @property {string} [type] - Span type
+ * @property {number} error - Error flag (0 or 1)
+ * @property {{[key: string]: string}} meta - String key-value tags
+ * @property {{[key: string]: number}} metrics - Numeric key-value tags
+ * @property {number} start - Start time in nanoseconds since epoch
+ * @property {number} duration - Duration in nanoseconds
+ * @property {object[]} [span_events] - Span events
+ */
+
+// Map DD span.kind string values to OTLP SpanKind numeric values
+const SPAN_KIND_MAP = {
+  internal: SPAN_KIND_INTERNAL,
+  server: SPAN_KIND_SERVER,
+  client: SPAN_KIND_CLIENT,
+  producer: SPAN_KIND_PRODUCER,
+  consumer: SPAN_KIND_CONSUMER,
+}
+
+// OTLP StatusCode values (from trace.proto Status.StatusCode enum)
+const STATUS_CODE_UNSET = 0
+const STATUS_CODE_ERROR = 2
+
+// DD meta keys that are mapped to dedicated OTLP span fields and should not appear as attributes
+const EXCLUDED_META_KEYS = new Set([
+  '_dd.span_links',
+  'span.kind',
+])
+
+/**
+ * OtlpTraceTransformer transforms DD-formatted spans to OTLP trace JSON format.
+ *
+ * This implementation follows the OTLP Trace v1.7.0 Data Model specification:
+ * https://opentelemetry.io/docs/specs/otlp/#trace-data-model
+ *
+ * It receives DD-formatted spans (from span_format.js) and produces
+ * an ExportTraceServiceRequest serialized as JSON (http/json protocol only).
+ *
+ * @class OtlpTraceTransformer
+ * @augments OtlpTransformerBase
+ */
+class OtlpTraceTransformer extends OtlpTransformerBase {
+  /**
+   * Creates a new OtlpTraceTransformer instance.
+   *
+   * @param {import('@opentelemetry/api').Attributes} resourceAttributes - Resource attributes
+   */
+  constructor (resourceAttributes) {
+    super(resourceAttributes, 'http/json', 'traces')
+  }
+
+  /**
+   * Transforms DD-formatted spans to OTLP JSON format.
+   *
+   * @param {DDFormattedSpan[]} spans - Array of DD-formatted spans to transform
+   * @returns {Buffer} JSON-encoded trace data
+   */
+  transformSpans (spans) {
+    const traceData = {
+      resourceSpans: [{
+        resource: this.transformResource(),
+        scopeSpans: this.#transformScopeSpans(spans),
+      }],
+    }
+    return this.serializeToJson(traceData)
+  }
+
+  /**
+   * Creates scope spans. DD spans do not carry instrumentation scope info,
+   * so all spans are placed under a single default scope.
+   *
+   * @param {DDFormattedSpan[]} spans - Array of DD-formatted spans
+   * @returns {object[]} Array of scope span objects
+   */
+  #transformScopeSpans (spans) {
+    return [{
+      scope: {
+        name: 'dd-trace-js',
+        version: VERSION,
+        attributes: [],
+        droppedAttributesCount: 0,
+      },
+      schemaUrl: '',
+      spans: spans.map(span => this.#transformSpan(span)),
+    }]
+  }
+
+  /**
+   * Transforms a single DD-formatted span to an OTLP Span object.
+   *
+   * @param {DDFormattedSpan} span - DD-formatted span to transform
+   * @returns {object} OTLP Span object
+   */
+  #transformSpan (span) {
+    const parentId = span.parent_id
+    const links = this.#extractLinks(span.meta?.['_dd.span_links'])
+
+    return {
+      traceId: this.#idToBytes(span.trace_id, 16),
+      spanId: this.#idToBytes(span.span_id, 8),
+      parentSpanId: (parentId && !this.#isZeroId(parentId)) ? this.#idToBytes(parentId, 8) : undefined,
+      name: span.resource,
+      kind: this.#mapSpanKind(span.meta?.['span.kind']),
+      startTimeUnixNano: span.start,
+      endTimeUnixNano: span.start + span.duration,
+      attributes: this.#buildAttributes(span),
+      droppedAttributesCount: 0,
+      events: span.span_events?.length ? span.span_events.map(event => this.#transformEvent(event)) : undefined,
+      droppedEventsCount: 0,
+      links: links.length ? links : undefined,
+      droppedLinksCount: 0,
+      status: this.#mapStatus(span),
+    }
+  }
+
+  /**
+   * Builds OTLP attributes from DD span fields.
+   * Merges top-level DD fields (service, resource, type), meta (string tags),
+   * and metrics (numeric tags) into a single OTLP KeyValue array.
+   *
+   * @param {DDFormattedSpan} span - DD-formatted span
+   * @returns {object[]} Array of OTLP KeyValue objects
+   */
+  #buildAttributes (span) {
+    const attributes = []
+
+    // Add top-level DD span fields as OTLP attributes
+    if (span.service) {
+      attributes.push({ key: 'service.name', value: { stringValue: span.service } })
+    }
+    if (span.name) {
+      attributes.push({ key: 'operation.name', value: { stringValue: span.name } })
+    }
+    if (span.resource) {
+      attributes.push({ key: 'resource.name', value: { stringValue: span.resource } })
+    }
+    if (span.type) {
+      attributes.push({ key: 'span.type', value: { stringValue: span.type } })
+    }
+
+    // Add meta string tags, skipping keys that map to dedicated OTLP fields
+    if (span.meta) {
+      for (const [key, value] of Object.entries(span.meta)) {
+        if (EXCLUDED_META_KEYS.has(key)) continue
+        attributes.push({ key, value: { stringValue: value } })
+      }
+    }
+
+    // Add metrics as numeric attributes
+    if (span.metrics) {
+      for (const [key, value] of Object.entries(span.metrics)) {
+        if (Number.isInteger(value)) {
+          attributes.push({ key, value: { intValue: value } })
+        } else {
+          attributes.push({ key, value: { doubleValue: value } })
+        }
+      }
+    }
+
+    // Add meta_struct as bytesValue attributes (JSON-serialized, base64-encoded per proto JSON mapping)
+    if (span.meta_struct) {
+      for (const [key, value] of Object.entries(span.meta_struct)) {
+        const bytes = Buffer.from(JSON.stringify(value))
+        attributes.push({ key, value: { bytesValue: bytes.toString('base64') } })
+      }
+    }
+
+    return attributes
+  }
+
+  /**
+   * Maps a DD span.kind string to an OTLP SpanKind enum value.
+   *
+   * @param {string | undefined} kind - DD span kind string
+   * @returns {number} OTLP SpanKind enum value
+   */
+  #mapSpanKind (kind) {
+    if (!kind) return SPAN_KIND_UNSPECIFIED
+    return SPAN_KIND_MAP[kind] ?? SPAN_KIND_UNSPECIFIED
+  }
+
+  /**
+   * Maps DD span error state to an OTLP Status object.
+   *
+   * @param {DDFormattedSpan} span - DD-formatted span
+   * @returns {object} OTLP Status object with code and message
+   */
+  #mapStatus (span) {
+    if (span.error === 1) {
+      return {
+        code: STATUS_CODE_ERROR,
+        message: span.meta?.['error.message'] || '',
+      }
+    }
+    return { code: STATUS_CODE_UNSET, message: '' }
+  }
+
+  /**
+   * Transforms a DD span event to an OTLP Event object.
+   *
+   * @param {object} event - DD span event with name, time_unix_nano, and attributes
+   * @returns {object} OTLP Event object
+   */
+  #transformEvent (event) {
+    return {
+      timeUnixNano: event.time_unix_nano,
+      name: event.name || '',
+      attributes: event.attributes && Object.keys(event.attributes).length > 0
+        ? this.transformAttributes(event.attributes)
+        : [],
+      droppedAttributesCount: 0,
+    }
+  }
+
+  /**
+   * Extracts and transforms span links from the DD _dd.span_links meta JSON string.
+   *
+   * @param {string | undefined} spanLinksJson - JSON-encoded array of DD span links
+   * @returns {object[]} Array of OTLP Link objects
+   */
+  #extractLinks (spanLinksJson) {
+    if (!spanLinksJson) return []
+
+    let parsedLinks
+    try {
+      parsedLinks = JSON.parse(spanLinksJson)
+    } catch {
+      return []
+    }
+
+    if (!Array.isArray(parsedLinks)) return []
+
+    return parsedLinks.map(link => this.#transformLink(link))
+  }
+
+  /**
+   * Transforms a single DD span link to an OTLP Link object.
+   *
+   * @param {object} link - DD span link with trace_id, span_id, attributes, flags, tracestate
+   * @returns {object} OTLP Link object
+   */
+  #transformLink (link) {
+    return {
+      traceId: this.#hexToBytes(link.trace_id, 16),
+      spanId: this.#hexToBytes(link.span_id, 8),
+      traceState: link.tracestate || '',
+      attributes: link.attributes && Object.keys(link.attributes).length > 0
+        ? this.transformAttributes(link.attributes)
+        : [],
+      droppedAttributesCount: 0,
+      flags: link.flags,
+    }
+  }
+
+  /**
+   * Converts a DD Identifier object to a hex-encoded string of the specified byte length.
+   * Pads with leading zeros if the identifier buffer is shorter than the target.
+   * Per the OTLP http/json spec, trace-ids and span-ids must be hex-encoded strings.
+   *
+   * @param {object} identifier - DD Identifier object with toBuffer() method
+   * @param {number} targetLength - Target byte length (16 for trace ID, 8 for span ID)
+   * @returns {string} Hex-encoded string of the specified length
+   */
+  #idToBytes (identifier, targetLength) {
+    const buffer = identifier.toBuffer()
+    if (buffer.length === targetLength) {
+      return Buffer.from(buffer).toString('hex')
+    }
+    if (buffer.length > targetLength) {
+      return Buffer.from(buffer.slice(buffer.length - targetLength)).toString('hex')
+    }
+    // Pad with leading zeros to reach target length
+    const result = Buffer.alloc(targetLength)
+    const offset = targetLength - buffer.length
+    for (let i = 0; i < buffer.length; i++) {
+      result[offset + i] = buffer[i]
+    }
+    return result.toString('hex')
+  }
+
+  /**
+   * Checks if a DD Identifier represents a zero ID (all bytes are 0).
+   *
+   * @param {object} identifier - DD Identifier object with toBuffer() method
+   * @returns {boolean} True if the identifier is all zeros
+   */
+  #isZeroId (identifier) {
+    const buffer = identifier.toBuffer()
+    for (let i = 0; i < buffer.length; i++) {
+      if (buffer[i] !== 0) return false
+    }
+    return true
+  }
+
+  /**
+   * Normalizes a hex string to the specified byte length.
+   * Pads with leading zeros if the hex string is shorter than expected.
+   * Per the OTLP http/json spec, trace-ids and span-ids must be hex-encoded strings.
+   *
+   * @param {string | undefined} hexString - Hex string to normalize
+   * @param {number} targetLength - Target byte length
+   * @returns {string} Hex-encoded string of the specified length
+   */
+  #hexToBytes (hexString, targetLength) {
+    if (!hexString) return '0'.repeat(targetLength * 2)
+    const cleanHex = hexString.startsWith('0x') ? hexString.slice(2) : hexString
+    return cleanHex.padStart(targetLength * 2, '0')
+  }
+}
+
+module.exports = OtlpTraceTransformer

package/packages/dd-trace/src/opentracing/tracer.js

@@ -20,9 +20,7 @@ const REFERENCE_CHILD_OF = 'child_of'
 const REFERENCE_FOLLOWS_FROM = 'follows_from'
 
 class DatadogTracer {
-  constructor (config, prioritySampler) {
-    const Exporter = getExporter(config.experimental.exporter)
-
+  constructor (config, prioritySampler, exporter) {
     this._config = config
     this._service = config.service
     this._version = config.version
@@ -30,7 +28,14 @@ class DatadogTracer {
     this._logInjection = config.logInjection
     this._debug = config.debug
     this._prioritySampler = prioritySampler ?? new PrioritySampler(config.env, config.sampler)
-    this._exporter = new Exporter(config, this._prioritySampler)
+
+    if (exporter) {
+      this._exporter = exporter
+    } else {
+      const Exporter = getExporter(config.experimental.exporter)
+      this._exporter = new Exporter(config, this._prioritySampler)
+    }
+
     this._processor = new SpanProcessor(this._exporter, this._prioritySampler, config)
     this._url = this._exporter._url
     this._enableGetRumData = config.experimental.enableGetRumData

package/packages/dd-trace/src/plugins/log_plugin.js

@@ -13,6 +13,9 @@ function messageProxy (message, holder) {
 
       return target[key]
     },
+    set (target, key, value) {
+      return Reflect.set(target, key, value)
+    },
     ownKeys (target) {
       const ownKeys = Reflect.ownKeys(target)
       if (!Object.hasOwn(target, 'dd') && Reflect.isExtensible(target)) {

package/packages/dd-trace/src/plugins/plugin.js

@@ -106,12 +106,6 @@ module.exports = class Plugin {
     storage('legacy').enterWith({ ...store, span })
   }
 
-  // TODO: Implement filters on resource name for all plugins.
-  /** Prevents creation of spans here and for all async descendants. */
-  skip () {
-    storage('legacy').enterWith({ noop: true })
-  }
-
   /**
    * Subscribe to a diagnostic channel with automatic error handling and enable/disable lifecycle.
    *
@@ -157,8 +151,9 @@ module.exports = class Plugin {
 
     if (!store || !store.span) return
 
-    if (!store.span._spanContext._tags.error) {
-      store.span.setTag('error', error || 1)
+    const span = /** @type {import('../opentracing/span')} */ (store.span)
+    if (!span._spanContext._tags.error) {
+      span.setTag('error', error || 1)
     }
   }
 
@@ -167,12 +162,12 @@ module.exports = class Plugin {
    *
    * TODO: Remove the overloading with `enabled` and use the config object directly.
    *
-   * @param {boolean|import('../config/config-base')} config Either a boolean to enable/disable
-   * or a configuration object containing at least `{ enabled: boolean }`.
+   * @param {boolean | import('../config/config-base') & {enabled: boolean}} config Either a boolean to
+   * enable/disable or a configuration object containing at least `{ enabled: boolean }`.
    */
   configure (config) {
     if (typeof config === 'boolean') {
-      config = { enabled: config }
+      config = /** @type {import('../config/config-base') & {enabled: boolean}} */ ({ enabled: config })
     }
     this.config = config
     if (config.enabled) {

package/packages/dd-trace/src/plugins/storage.js

@@ -12,8 +12,8 @@ class StoragePlugin extends ClientPlugin {
   }
 
   startSpan (name, options, ctx) {
-    if (!options.service && this.system) {
-      options.service = `${this.tracer._service}-${this.system}`
+    if (!options.service?.name && this.system) {
+      options.service = { name: `${this.tracer._service}-${this.system}`, source: this.system }
     }
 
     return super.startSpan(name, options, ctx)

package/packages/dd-trace/src/plugins/tracing.js

@@ -2,7 +2,7 @@
 
 const { storage } = require('../../../datadog-core')
 const analyticsSampler = require('../analytics_sampler')
-const { COMPONENT } = require('../constants')
+const { COMPONENT, SVC_SRC_KEY } = require('../constants')
 const Plugin = require('./plugin')
 
 class TracingPlugin extends Plugin {
@@ -26,7 +26,7 @@ class TracingPlugin extends Plugin {
    * @param {string} [opts.type]
    * @param {string} [opts.id]
    * @param {string} [opts.kind]
-   * @returns {string}
+   * @returns {{ name: string, source: string | undefined }}
    */
   serviceName (opts = {}) {
     const {
@@ -157,7 +157,8 @@ class TracingPlugin extends Plugin {
    * @param {string} [options.kind] - The kind of the span.
    * @param {object} [options.meta] - The meta data for the span.
    * @param {object} [options.metrics] - The metrics for the span.
-   * @param {string} [options.service] - The service name.
+   * @param {string | { name: string, source?: string }} [options.service] - The service name, or an object with
+   *   name and source.
    * @param {number} [options.startTime] - The start time of the span.
    * @param {string} [options.resource] - The resource name.
    * @param {string} [options.type] - The type of the span.
@@ -180,24 +181,40 @@ class TracingPlugin extends Plugin {
       resource,
       type,
     } = options
-
+    let serviceSource
     const tracer = options.tracer || this.tracer
     const config = options.config || this.config
 
+    if (service && typeof service === 'object') {
+      serviceSource = service.source
+      service = service.name
+    } else if (service !== undefined) {
+      // service is a plain value returned by service naming/config logic
+      serviceSource = service ? 'opt.plugin' : undefined
+    }
+
     const store = storage('legacy').getStore()
     if (store && childOf === undefined) {
       childOf = /** @type {import('../opentracing/span') | undefined} */ (store.span)
     }
 
+    // clear service source if service is the same as tracer._service
+    const serviceName = service || meta?.service
+
+    if (!serviceName || serviceName === tracer._service) {
+      serviceSource = undefined
+    }
+
     const span = tracer.startSpan(name, {
       startTime,
       childOf,
       tags: {
         [COMPONENT]: component,
-        'service.name': service || meta?.service || tracer._service,
+        'service.name': serviceName || tracer._service,
         'resource.name': resource,
         'span.kind': kind,
         'span.type': type,
+        ...(serviceSource === undefined ? undefined : { [SVC_SRC_KEY]: serviceSource }),
         ...meta,
         ...metrics,
       },

package/packages/dd-trace/src/plugins/util/test.js

@@ -137,6 +137,7 @@ const JEST_WORKER_TRACE_PAYLOAD_CODE = 60
 const JEST_WORKER_COVERAGE_PAYLOAD_CODE = 61
 const JEST_WORKER_LOGS_PAYLOAD_CODE = 62
 const JEST_WORKER_TELEMETRY_PAYLOAD_CODE = 63
+const JEST_WORKER_QUARANTINE_PAYLOAD_CODE = 64
 
 // cucumber worker variables
 const CUCUMBER_WORKER_TRACE_PAYLOAD_CODE = 70
@@ -262,6 +263,7 @@ module.exports = {
   JEST_WORKER_COVERAGE_PAYLOAD_CODE,
   JEST_WORKER_LOGS_PAYLOAD_CODE,
   JEST_WORKER_TELEMETRY_PAYLOAD_CODE,
+  JEST_WORKER_QUARANTINE_PAYLOAD_CODE,
   CUCUMBER_WORKER_TRACE_PAYLOAD_CODE,
   MOCHA_WORKER_TRACE_PAYLOAD_CODE,
   PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE,