dd-trace 5.97.0 → 5.99.0

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

@@ -0,0 +1,342 @@
+'use strict'
+
+const OtlpTransformerBase = require('../otlp/otlp_transformer_base')
+const { getProtobufTypes } = require('../otlp/protobuf_loader')
+const { VERSION } = require('../../../../../version')
+const id = require('../../id')
+
+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
+
+// Cached zero Identifier used to detect zero IDs without re-allocating per span.
+const ZERO_ID = id('0')
+
+/**
+ * @typedef {import('../../id').Identifier} Identifier
+ *
+ * @typedef {object} DDSpanLink
+ * @property {string} trace_id - Hex-encoded trace ID
+ * @property {string} span_id - Hex-encoded span ID
+ * @property {Record<string, string | number | boolean>} [attributes] - Link attributes
+ * @property {number} [flags] - Trace flags
+ * @property {string} [tracestate] - W3C trace state
+ *
+ * @typedef {object} DDSpanEvent
+ * @property {string} name - Event name
+ * @property {number} time_unix_nano - Event time in nanoseconds since epoch
+ * @property {Record<string, string | number | boolean>} [attributes] - Event attributes
+ *
+ * @typedef {object} DDFormattedSpan
+ * @property {Identifier} trace_id - DD Identifier for trace ID
+ * @property {Identifier} span_id - DD Identifier for span ID
+ * @property {Identifier} 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 {{[key: string]: object}} [meta_struct] - Structured tags (JSON-serialized, bytes in protobuf)
+ * @property {number} start - Start time in nanoseconds since epoch
+ * @property {number} duration - Duration in nanoseconds
+ * @property {DDSpanEvent[]} [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 data model:
+ * 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 && !parentId.equals(ZERO_ID)) ? 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 } })
+        }
+      }
+    }
+
+    // TODO: meta_struct values are logically raw bytes. The OTLP http/json spec encodes the bytesValue
+    // field as base64, but when http/protobuf or gRPC support is added the payload should be sent as
+    // raw bytes directly (no JSON.stringify + base64). The backend decoding side will need to be
+    // updated in parallel to accept the unencoded bytes.
+    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.
+   * Combines error.type and error.message when both are present so error type
+   * information is preserved on the OTel side.
+   *
+   * @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_UNSET, message: '' }
+    }
+    const errorType = span.meta?.['error.type']
+    const errorMessage = span.meta?.['error.message']
+    let message = ''
+    if (errorType && errorMessage) {
+      message = `${errorType}: ${errorMessage}`
+    } else if (errorType) {
+      message = errorType
+    } else if (errorMessage) {
+      message = errorMessage
+    }
+    return { code: STATUS_CODE_ERROR, message }
+  }
+
+  /**
+   * Transforms a DD span event to an OTLP Event object.
+   *
+   * @param {DDSpanEvent} event - DD span event
+   * @returns {object} OTLP Event object
+   */
+  #transformEvent (event) {
+    return {
+      timeUnixNano: event.time_unix_nano,
+      name: event.name || '',
+      attributes: 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 {DDSpanLink} link - DD span link
+   * @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: 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 {Identifier} identifier - DD Identifier
+   * @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)
+    Buffer.from(buffer).copy(result, targetLength - buffer.length)
+    return result.toString('hex')
+  }
+
+  /**
+   * 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/opentelemetry/tracer.js

@@ -81,10 +81,10 @@ class Tracer {
   }
 
   _convertOtelContextToDatadog (traceId, spanId, traceFlag, ts, meta = {}) {
-    const origin = null
+    let origin = null
     let samplingPriority = traceFlag
 
-    ts = ts?.traceparent || null
+    ts = ts?.traceparent
 
     if (ts) {
       // Use TraceState.fromString to parse the tracestate header
@@ -101,19 +101,17 @@ class Tracer {
         // Assuming ddTraceStateData is now a Map or similar structure containing Datadog trace state data
         // Extract values as needed, similar to the original logic
         const samplingPriorityTs = ddTraceStateData.get('s')
-        const origin = ddTraceStateData.get('o')
+        origin = ddTraceStateData.get('o') ?? null
         // Convert Map to object for meta
         const otherPropagatedTags = Object.fromEntries(ddTraceStateData.entries())
 
         // Update meta and samplingPriority based on extracted values
         Object.assign(meta, otherPropagatedTags)
-        samplingPriority = TextMapPropagator._getSamplingPriority(
-          traceFlag,
-          Number.parseInt(samplingPriorityTs, 10),
-          origin
-        )
+        // Guard against an undefined/empty `s:` field that would result in NaN.
+        const tracestateSamplingPriority = samplingPriorityTs ? Math.trunc(samplingPriorityTs) : undefined
+        samplingPriority = TextMapPropagator._getSamplingPriority(traceFlag, tracestateSamplingPriority, origin)
       } else {
-        log.debug('no dd list member in tracestate from incoming request:', ts)
+        log.debug('No dd list member in tracestate from incoming request:', ts)
       }
     }
 
@@ -121,8 +119,8 @@ class Tracer {
       traceId: id(traceId, 16), spanId: id(), tags: meta, parentId: id(spanId, 16),
     })
 
-    spanContext._sampling = { priority: samplingPriority }
-    spanContext._trace = { origin }
+    spanContext._ddContext._sampling = { priority: samplingPriority }
+    spanContext._ddContext._trace = { ...spanContext._ddContext._trace, origin }
     return spanContext
   }
 

package/packages/dd-trace/src/opentracing/propagation/text_map.js

@@ -802,18 +802,25 @@ class TextMapPropagator {
     return spanContext._traceId.toString(16)
   }
 
-  static _getSamplingPriority (traceparentSampled, tracestateSamplingPriority, origin = null) {
+  /**
+   * @param {number} traceparentSampled
+   * @param {number|undefined} tracestateSamplingPriority
+   * @param {string|null} origin
+   * @returns {import('../../priority_sampler').SamplingPriority}
+   */
+  static _getSamplingPriority (traceparentSampled, tracestateSamplingPriority, origin) {
     const fromRumWithoutPriority = !tracestateSamplingPriority && origin === 'rum'
 
-    let samplingPriority
-    if (!fromRumWithoutPriority && traceparentSampled === 0 &&
-    (!tracestateSamplingPriority || tracestateSamplingPriority >= 0)) {
-      samplingPriority = 0
-    } else if (!fromRumWithoutPriority && traceparentSampled === 1 &&
-    (!tracestateSamplingPriority || tracestateSamplingPriority < 0)) {
-      samplingPriority = 1
-    } else {
-      samplingPriority = tracestateSamplingPriority
+    let samplingPriority =
+      /** @type {import('../../priority_sampler').SamplingPriority} */ (tracestateSamplingPriority ?? AUTO_KEEP)
+    if (!fromRumWithoutPriority) {
+      if (traceparentSampled === 0 &&
+          (!tracestateSamplingPriority || tracestateSamplingPriority >= 0)) {
+        samplingPriority = AUTO_REJECT
+      } else if (traceparentSampled === 1 &&
+                 (!tracestateSamplingPriority || tracestateSamplingPriority < 0)) {
+        samplingPriority = AUTO_KEEP
+      }
     }
 
     return samplingPriority

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

@@ -149,7 +149,7 @@ class DatadogSpan {
   }
 
   /**
-   * @returns {import('../priority_sampler').DatadogSpanContext}
+   * @returns {import('./span_context')}
    */
   context () {
     return this._spanContext

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

@@ -21,8 +21,6 @@ const REFERENCE_FOLLOWS_FROM = 'follows_from'
 
 class DatadogTracer {
   constructor (config, prioritySampler) {
-    const Exporter = getExporter(config.experimental.exporter)
-
     this._config = config
     this._service = config.service
     this._version = config.version
@@ -30,7 +28,21 @@ 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)
+
+    // OTEL_TRACES_EXPORTER=otlp should not replace the Test Optimization
+    // exporter when the tracer is running in Test Optimization mode. Test spans
+    // (test_session/test_module/ test_suite/test) belong on the citestcycle
+    // endpoint, not on an OTLP traces endpoint — otherwise users with OTEL_*
+    // vars set in their environment (e.g. for a separate telemetry integration)
+    // silently lose all test spans.
+    if (config.OTEL_TRACES_EXPORTER === 'otlp' && !config.isCiVisibility) {
+      const { createOtlpTraceExporter } = require('../opentelemetry/trace')
+      this._exporter = createOtlpTraceExporter(config)
+    } 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
@@ -38,7 +50,7 @@ class DatadogTracer {
     this._propagators = {
       [formats.TEXT_MAP]: new TextMapPropagator(config),
       [formats.HTTP_HEADERS]: new HttpPropagator(config),
-      [formats.BINARY]: new BinaryPropagator(config),
+      [formats.BINARY]: new BinaryPropagator(),
       [formats.LOG]: new LogPropagator(config),
       [formats.TEXT_MAP_DSM]: new DSMTextMapPropagator(config),
     }
@@ -111,7 +123,7 @@ class DatadogTracer {
  * Get the span context from a span or a span context.
  *
  * @param {Span|SpanContext} spanContext
- * @returns {SpanContext}
+ * @returns {SpanContext|null}
  */
 function getContext (spanContext) {
   if (spanContext instanceof Span) {

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

@@ -6,6 +6,7 @@ const plugins = {
   get '@aws-sdk/smithy-client' () { return require('../../../datadog-plugin-aws-sdk/src') },
   get '@azure/event-hubs' () { return require('../../../datadog-plugin-azure-event-hubs/src') },
   get '@azure/functions' () { return require('../../../datadog-plugin-azure-functions/src') },
+  get '@modelcontextprotocol/sdk' () { return require('../../../datadog-plugin-modelcontextprotocol-sdk/src') },
   get 'durable-functions' () { return require('../../../datadog-plugin-azure-durable-functions/src') },
   get '@azure/service-bus' () { return require('../../../datadog-plugin-azure-service-bus/src') },
   get '@cucumber/cucumber' () { return require('../../../datadog-plugin-cucumber/src') },

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,
       },