@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,47 @@
+'use strict'
+
+const pick = require('../../../../datadog-core/src/utils/src/pick')
+const log = require('../../log')
+
+const { DsmPathwayCodec } = require('../../datastreams')
+
+const base64Key = 'dd-pathway-ctx-base64'
+const logKeys = [base64Key]
+
+class DSMTextMapPropagator {
+  constructor (config) {
+    this.config = config
+  }
+
+  inject (ctx, carrier) {
+    if (!this.config.dsmEnabled) return
+
+    this._injectDatadogDSMContext(ctx, carrier)
+
+    // eslint-disable-next-line eslint-rules/eslint-log-printf-style
+    log.debug(() => `Inject into carrier (DSM): ${JSON.stringify(pick(carrier, logKeys))}.`)
+  }
+
+  extract (carrier) {
+    if (!this.config.dsmEnabled) return
+
+    const dsmContext = this._extractDatadogDSMContext(carrier)
+
+    if (!dsmContext) return dsmContext
+
+    // eslint-disable-next-line eslint-rules/eslint-log-printf-style
+    log.debug(() => `Extract from carrier (DSM): ${JSON.stringify(pick(carrier, logKeys))}.`)
+    return dsmContext
+  }
+
+  _injectDatadogDSMContext (ctx, carrier) {
+    DsmPathwayCodec.encode(ctx, carrier)
+  }
+
+  _extractDatadogDSMContext (carrier) {
+    const ctx = DsmPathwayCodec.decode(carrier)
+    return ctx
+  }
+}
+
+module.exports = DSMTextMapPropagator

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

@@ -0,0 +1,103 @@
+'use strict'
+
+const traceStateRegex = /[ \t]*([^=]+)=([ \t]*[^, \t]+)[ \t]*(,|$)/gim
+const traceStateDataRegex = /([^:]+):([^;]+)(;|$)/gim
+
+function fromString (Type, regex, value) {
+  if (typeof value !== 'string' || !value.length) {
+    return new Type()
+  }
+
+  const values = []
+  for (const row of value.matchAll(regex)) {
+    values.unshift(row.slice(1, 3))
+  }
+
+  return new Type(values)
+}
+
+function toString (map, pairSeparator, fieldSeparator) {
+  let result = ''
+  for (const [key, value] of map) {
+    if (result) {
+      result = `${fieldSeparator}${result}`
+    }
+    result = `${key}${pairSeparator}${value}${result}`
+  }
+  return result
+}
+
+class TraceStateData extends Map {
+  constructor (...args) {
+    super(...args)
+    this.changed = false
+  }
+
+  set (...args) {
+    if (this.has(args[0]) && this.get(args[0]) === args[1]) {
+      return
+    }
+    this.changed = true
+    return super.set(...args)
+  }
+
+  delete (...args) {
+    this.changed = true
+    return super.delete(...args)
+  }
+
+  clear (...args) {
+    this.changed = true
+    return super.clear(...args)
+  }
+
+  static fromString (value) {
+    return fromString(TraceStateData, traceStateDataRegex, value)
+  }
+
+  toString () {
+    return toString(this, ':', ';')
+  }
+}
+
+/**
+ * Pairs are stored in reverse of the serialized format to rely on set ordering
+ * new entries at the end to express update movement.
+ */
+class TraceState extends Map {
+  // Delete entries on update to ensure they're moved to the end of the list
+  set (key, value) {
+    if (this.has(key)) {
+      this.delete(key)
+    }
+
+    return super.set(key, value)
+  }
+
+  forVendor (vendor, handle) {
+    const data = super.get(vendor)
+    const state = TraceStateData.fromString(data)
+    const result = handle(state)
+
+    if (state.changed) {
+      const value = state.toString()
+      if (value) {
+        this.set(vendor, state.toString())
+      } else {
+        this.delete(vendor)
+      }
+    }
+
+    return result
+  }
+
+  static fromString (value) {
+    return fromString(TraceState, traceStateRegex, value)
+  }
+
+  toString () {
+    return toString(this, '=', ',')
+  }
+}
+
+module.exports = TraceState

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

@@ -0,0 +1,412 @@
+'use strict'
+
+// TODO (new internal tracer): use DC events for lifecycle metrics and test them
+const { performance } = require('perf_hooks')
+const now = performance.now.bind(performance)
+const util = require('util')
+const { channel } = require('dc-polyfill')
+const id = require('../id')
+const tagger = require('../tagger')
+const runtimeMetrics = require('../runtime_metrics')
+const log = require('../log')
+const { storage } = require('../../../datadog-core')
+const telemetryMetrics = require('../telemetry/metrics')
+const { getValueFromEnvSources } = require('../config/helper')
+const { isTrue } = require('../util')
+const SpanContext = require('./span_context')
+
+const dateNow = Date.now
+
+const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
+
+const DD_TRACE_EXPERIMENTAL_STATE_TRACKING = isTrue(getValueFromEnvSources('DD_TRACE_EXPERIMENTAL_STATE_TRACKING'))
+const DD_TRACE_EXPERIMENTAL_SPAN_COUNTS = isTrue(getValueFromEnvSources('DD_TRACE_EXPERIMENTAL_SPAN_COUNTS'))
+
+const unfinishedRegistry = createRegistry('unfinished')
+const finishedRegistry = createRegistry('finished')
+
+const OTEL_ENABLED = !!getValueFromEnvSources('DD_TRACE_OTEL_ENABLED')
+const ALLOWED = new Set(['string', 'number', 'boolean'])
+
+const integrationCounters = {
+  spans_created: {},
+  spans_finished: {},
+}
+
+const startCh = channel('dd-trace:span:start')
+const finishCh = channel('dd-trace:span:finish')
+
+function getIntegrationCounter (event, integration) {
+  const counters = integrationCounters[event]
+
+  if (integration in counters) {
+    return counters[integration]
+  }
+
+  const counter = tracerMetrics.count(event, [
+    `integration_name:${integration.toLowerCase()}`,
+    `otel_enabled:${OTEL_ENABLED}`,
+  ])
+
+  integrationCounters[event][integration] = counter
+
+  return counter
+}
+
+class DatadogSpan {
+  constructor (tracer, processor, prioritySampler, fields, debug) {
+    const operationName = fields.operationName
+    const parent = fields.parent || null
+    // TODO(BridgeAR): Investigate why this is causing a performance regression
+    // eslint-disable-next-line prefer-object-spread
+    const tags = Object.assign({}, fields.tags)
+    const hostname = fields.hostname
+
+    this._parentTracer = tracer
+    this._debug = debug
+    this._processor = processor
+    this._prioritySampler = prioritySampler
+    this._store = storage('legacy').getHandle()
+    this._duration = undefined
+
+    this._events = []
+
+    // For internal use only. You probably want `context()._name`.
+    // This name property is not updated when the span name changes.
+    // This is necessary for span count metrics.
+    this._name = operationName
+    this._integrationName = fields.integrationName || 'opentracing'
+
+    getIntegrationCounter('spans_created', this._integrationName).inc()
+
+    this._spanContext = this._createContext(parent, fields)
+    this._spanContext._name = operationName
+    this._spanContext._tags = tags
+    this._spanContext._hostname = hostname
+
+    this._spanContext._trace.started.push(this)
+
+    this._startTime = fields.startTime || this._getTime()
+
+    this._links = fields.links?.map(link => ({
+      context: link.context._ddContext ?? link.context,
+      attributes: this._sanitizeAttributes(link.attributes),
+    })) ?? []
+
+    if (DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
+      runtimeMetrics.increment('runtime.node.spans.unfinished')
+      runtimeMetrics.increment('runtime.node.spans.unfinished.by.name', `span_name:${operationName}`)
+
+      runtimeMetrics.increment('runtime.node.spans.open') // unfinished for real
+      runtimeMetrics.increment('runtime.node.spans.open.by.name', `span_name:${operationName}`)
+
+      unfinishedRegistry.register(this, operationName, this)
+    }
+
+    // Nullish operator is used here because both `tracer` and `tracer._config`
+    // can be null and there are tests passing invalid values to the `Span`
+    // constructor which still succeed today. Part of the problem is that `Span`
+    // stores only the tracer and not the config, so anything that needs the
+    // config has to read it from the tracer stored on the span, including
+    // even `Span` itself in this case.
+    //
+    // TODO: Refactor Tracer/Span + tests to avoid having to do nullish checks.
+    if (tracer?._config?.spanLeakDebug > 0) {
+      require('../spanleak').addSpan(this, operationName)
+    }
+
+    if (startCh.hasSubscribers) {
+      startCh.publish({ span: this, fields })
+    }
+  }
+
+  [util.inspect.custom] () {
+    return {
+      ...this,
+      _parentTracer: `[${this._parentTracer.constructor.name}]`,
+      _prioritySampler: `[${this._prioritySampler.constructor.name}]`,
+      _processor: `[${this._processor.constructor.name}]`,
+    }
+  }
+
+  toString () {
+    const spanContext = this.context()
+    const resourceName = spanContext._tags['resource.name'] || ''
+    const resource = resourceName.length > 100
+      ? `${resourceName.slice(0, 97)}...`
+      : resourceName
+    const json = JSON.stringify({
+      traceId: spanContext._traceId,
+      spanId: spanContext._spanId,
+      parentId: spanContext._parentId,
+      service: spanContext._tags['service.name'],
+      name: spanContext._name,
+      resource,
+    })
+
+    return `Span${json}`
+  }
+
+  /**
+   * @returns {import('../priority_sampler').DatadogSpanContext}
+   */
+  context () {
+    return this._spanContext
+  }
+
+  tracer () {
+    return this._parentTracer
+  }
+
+  setOperationName (name) {
+    this._spanContext._name = name
+    return this
+  }
+
+  setBaggageItem (key, value) {
+    this._spanContext._baggageItems[key] = value
+    return this
+  }
+
+  getBaggageItem (key) {
+    return this._spanContext._baggageItems[key]
+  }
+
+  getAllBaggageItems () {
+    return JSON.stringify(this._spanContext._baggageItems)
+  }
+
+  removeBaggageItem (key) {
+    delete this._spanContext._baggageItems[key]
+  }
+
+  removeAllBaggageItems () {
+    this._spanContext._baggageItems = {}
+  }
+
+  setTag (key, value) {
+    this._addTags({ [key]: value })
+    return this
+  }
+
+  addTags (keyValueMap) {
+    this._addTags(keyValueMap)
+    return this
+  }
+
+  log () {
+    return this
+  }
+
+  logEvent () {}
+
+  addLink (link, attrs) {
+    // TODO: Remove this once we remove addLink(context, attrs) in v6.0.0
+    if (link instanceof SpanContext) {
+      link = { context: link, attributes: attrs ?? {} }
+    }
+
+    const { context, attributes } = link
+
+    this._links.push({
+      context: context._ddContext ?? context,
+      attributes: this._sanitizeAttributes(attributes),
+    })
+  }
+
+  addLinks (links) {
+    for (const link of links) {
+      this.addLink(link)
+    }
+    return this
+  }
+
+  addSpanPointer (ptrKind, ptrDir, ptrHash) {
+    const zeroContext = new SpanContext({
+      traceId: id('0'),
+      spanId: id('0'),
+    })
+    const attributes = {
+      'ptr.kind': ptrKind,
+      'ptr.dir': ptrDir,
+      'ptr.hash': ptrHash,
+      'link.kind': 'span-pointer',
+    }
+    this.addLink({ context: zeroContext, attributes })
+  }
+
+  addEvent (name, attributesOrStartTime, startTime) {
+    const event = { name }
+    if (attributesOrStartTime) {
+      if (typeof attributesOrStartTime === 'object') {
+        event.attributes = this._sanitizeEventAttributes(attributesOrStartTime)
+      } else {
+        startTime = attributesOrStartTime
+      }
+    }
+    event.startTime = startTime || this._getTime()
+    this._events.push(event)
+  }
+
+  finish (finishTime) {
+    if (this._duration !== undefined) {
+      return
+    }
+
+    if (DD_TRACE_EXPERIMENTAL_STATE_TRACKING && !this._spanContext._tags['service.name']) {
+      log.error('Finishing invalid span: %s', this)
+    }
+
+    getIntegrationCounter('spans_finished', this._integrationName).inc()
+    this._spanContext._tags['_dd.integration'] = this._integrationName
+
+    if (DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
+      runtimeMetrics.decrement('runtime.node.spans.unfinished')
+      runtimeMetrics.decrement('runtime.node.spans.unfinished.by.name', `span_name:${this._name}`)
+      runtimeMetrics.increment('runtime.node.spans.finished')
+      runtimeMetrics.increment('runtime.node.spans.finished.by.name', `span_name:${this._name}`)
+
+      runtimeMetrics.decrement('runtime.node.spans.open') // unfinished for real
+      runtimeMetrics.decrement('runtime.node.spans.open.by.name', `span_name:${this._name}`)
+
+      unfinishedRegistry.unregister(this)
+      finishedRegistry.register(this, this._name)
+    }
+
+    finishTime = Number.parseFloat(finishTime) || this._getTime()
+
+    this._duration = finishTime - this._startTime
+    this._spanContext._trace.finished.push(this)
+    this._spanContext._isFinished = true
+    finishCh.publish(this)
+    this._processor.process(this)
+  }
+
+  _sanitizeAttributes (attributes = {}) {
+    const sanitizedAttributes = {}
+
+    const addArrayOrScalarAttributes = (key, maybeArray) => {
+      if (Array.isArray(maybeArray)) {
+        for (const subkey in maybeArray) {
+          addArrayOrScalarAttributes(`${key}.${subkey}`, maybeArray[subkey])
+        }
+      } else {
+        const maybeScalar = maybeArray
+        if (ALLOWED.has(typeof maybeScalar)) {
+          // Wrap the value as a string if it's not already a string
+          sanitizedAttributes[key] = typeof maybeScalar === 'string' ? maybeScalar : String(maybeScalar)
+        } else {
+          log.warn('Dropping span link attribute. It is not of an allowed type')
+        }
+      }
+    }
+
+    for (const [key, value] of Object.entries(attributes)) {
+      addArrayOrScalarAttributes(key, value)
+    }
+    return sanitizedAttributes
+  }
+
+  _sanitizeEventAttributes (attributes = {}) {
+    const sanitizedAttributes = {}
+
+    for (const [key, value] of Object.entries(attributes)) {
+      if (Array.isArray(value)) {
+        const newArray = []
+        for (const subvalue of Object.values(value)) {
+          if (ALLOWED.has(typeof subvalue)) {
+            newArray.push(subvalue)
+          } else {
+            log.warn('Dropping span event attribute. It is not of an allowed type')
+          }
+        }
+        sanitizedAttributes[key] = newArray
+      } else if (ALLOWED.has(typeof value)) {
+        sanitizedAttributes[key] = value
+      } else {
+        log.warn('Dropping span event attribute. It is not of an allowed type')
+      }
+    }
+    return sanitizedAttributes
+  }
+
+  _createContext (parent, fields) {
+    let spanContext
+    let startTime
+
+    let baggage = {}
+    if (parent && parent._isRemote && this._parentTracer?._config?.tracePropagationBehaviorExtract !== 'continue') {
+      baggage = parent._baggageItems
+      parent = null
+    }
+
+    if (fields.context) {
+      spanContext = fields.context
+      if (!spanContext._trace.startTime) {
+        startTime = dateNow()
+      }
+    } else if (parent) {
+      spanContext = new SpanContext({
+        traceId: parent._traceId,
+        spanId: id(),
+        parentId: parent._spanId,
+        sampling: parent._sampling,
+        baggageItems: { ...parent._baggageItems },
+        trace: parent._trace,
+        tracestate: parent._tracestate,
+      })
+
+      if (!spanContext._trace.startTime) {
+        startTime = dateNow()
+      }
+    } else {
+      const spanId = id()
+      startTime = dateNow()
+      spanContext = new SpanContext({
+        traceId: spanId,
+        spanId,
+      })
+      spanContext._trace.startTime = startTime
+
+      if (fields.traceId128BitGenerationEnabled) {
+        spanContext._trace.tags['_dd.p.tid'] = Math.floor(startTime / 1000).toString(16)
+          .padStart(8, '0')
+          .padEnd(16, '0')
+      }
+
+      if (this._parentTracer?._config?.tracePropagationBehaviorExtract === 'restart') {
+        spanContext._baggageItems = baggage
+      }
+    }
+
+    spanContext._trace.ticks = spanContext._trace.ticks || now()
+    if (startTime) {
+      spanContext._trace.startTime = startTime
+    }
+    // SpanContext was NOT propagated from a remote parent
+    spanContext._isRemote = false
+
+    return spanContext
+  }
+
+  _getTime () {
+    const { startTime, ticks } = this._spanContext._trace
+
+    return startTime + now() - ticks
+  }
+
+  _addTags (keyValuePairs) {
+    tagger.add(this._spanContext._tags, keyValuePairs)
+
+    this._prioritySampler.sample(this, false)
+  }
+}
+
+function createRegistry (type) {
+  return new global.FinalizationRegistry(name => {
+    runtimeMetrics.decrement(`runtime.node.spans.${type}`)
+    runtimeMetrics.decrement(`runtime.node.spans.${type}.by.name`, [`span_name:${name}`])
+  })
+}
+
+module.exports = DatadogSpan

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

@@ -0,0 +1,75 @@
+'use strict'
+
+const util = require('util')
+const { AUTO_KEEP } = require('../../../../ext/priority')
+
+// the lowercase, hex encoded upper 64 bits of a 128-bit trace id, if present
+const TRACE_ID_128 = '_dd.p.tid'
+
+class DatadogSpanContext {
+  constructor (props) {
+    props = props || {}
+
+    this._traceId = props.traceId
+    this._spanId = props.spanId
+    this._isRemote = props.isRemote ?? true
+    this._parentId = props.parentId || null
+    this._name = props.name
+    this._isFinished = props.isFinished || false
+    this._tags = props.tags || {}
+    this._sampling = props.sampling || {}
+    this._spanSampling = undefined
+    this._links = props.links || []
+    this._baggageItems = props.baggageItems || {}
+    this._traceparent = props.traceparent
+    this._tracestate = props.tracestate
+    this._noop = props.noop || null
+    this._trace = props.trace || {
+      started: [],
+      finished: [],
+      tags: {},
+    }
+    this._otelSpanContext = undefined
+  }
+
+  [util.inspect.custom] () {
+    return {
+      ...this,
+      _trace: {
+        ...this._trace,
+        started: '[Array]',
+        finished: '[Array]',
+      },
+    }
+  }
+
+  toTraceId (get128bitId = false) {
+    if (get128bitId) {
+      return this._traceId.toBuffer().length <= 8 && this._trace.tags[TRACE_ID_128]
+        ? this._trace.tags[TRACE_ID_128] + this._traceId.toString(16).padStart(16, '0')
+        : this._traceId.toString(16).padStart(32, '0')
+    }
+    return this._traceId.toString(10)
+  }
+
+  toSpanId (get128bitId = false) {
+    if (get128bitId) {
+      return this._spanId.toString(16).padStart(16, '0')
+    }
+    return this._spanId.toString(10)
+  }
+
+  toBigIntSpanId () {
+    return this._spanId.toBigInt()
+  }
+
+  toTraceparent () {
+    const flags = this._sampling.priority >= AUTO_KEEP ? '01' : '00'
+    const traceId = this.toTraceId(true)
+    const spanId = this.toSpanId(true)
+    const version = (this._traceparent && this._traceparent.version) || '00'
+    return `${version}-${traceId}-${spanId}-${flags}`
+  }
+}
+
+module.exports = DatadogSpanContext