@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,317 @@
+'use strict'
+
+const { performance } = require('perf_hooks')
+const api = require('@opentelemetry/api')
+
+const { timeOrigin } = performance
+
+const { timeInputToHrTime } = require('../../../../vendor/dist/@opentelemetry/core')
+
+const tracer = require('../../')
+const DatadogSpan = require('../opentracing/span')
+const { ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK, IGNORE_OTEL_ERROR } = require('../constants')
+const { SERVICE_NAME, RESOURCE_NAME, SPAN_KIND } = require('../../../../ext/tags')
+const kinds = require('../../../../ext/kinds')
+
+const id = require('../id')
+const SpanContext = require('./span_context')
+
+// The one built into OTel rounds so we lose sub-millisecond precision.
+function hrTimeToMilliseconds (time) {
+  return time[0] * 1e3 + time[1] / 1e6
+}
+
+function isTimeInput (startTime) {
+  if (typeof startTime === 'number') {
+    return true
+  }
+  if (startTime instanceof Date) {
+    return true
+  }
+  if (Array.isArray(startTime) && startTime.length === 2 &&
+      typeof startTime[0] === 'number' && typeof startTime[1] === 'number') {
+    return true
+  }
+  return false
+}
+
+const spanKindNames = {
+  [api.SpanKind.INTERNAL]: kinds.INTERNAL,
+  [api.SpanKind.SERVER]: kinds.SERVER,
+  [api.SpanKind.CLIENT]: kinds.CLIENT,
+  [api.SpanKind.PRODUCER]: kinds.PRODUCER,
+  [api.SpanKind.CONSUMER]: kinds.CONSUMER,
+}
+
+/**
+ * Several of these attributes are not yet supported by the Node.js OTel API.
+ * We check for old equivalents where we can, but not all had equivalents.
+ */
+function spanNameMapper (spanName, kind, attributes) {
+  if (spanName) return spanName
+
+  const opName = attributes['operation.name']
+  if (opName) return opName
+
+  const { INTERNAL, SERVER, CLIENT } = api.SpanKind
+
+  // HTTP server and client requests
+  // TODO: Drop http.method when http.request.method is supported.
+  for (const key of ['http.method', 'http.request.method']) {
+    if (key in attributes) {
+      if (kind === SERVER) {
+        return 'http.server.request'
+      }
+      if (kind === CLIENT) {
+        return 'http.client.request'
+      }
+    }
+  }
+
+  // Databases
+  const dbSystem = attributes['db.system']
+  if (dbSystem && kind === CLIENT) {
+    return `${dbSystem}.query`
+  }
+
+  // Messaging
+  const msgSys = attributes['messaging.system']
+  const msgOp = attributes['messaging.operation']
+  if (msgSys && msgOp && kind !== INTERNAL) {
+    return `${msgSys}.${msgOp}`
+  }
+
+  // RPC (and AWS)
+  const rpcSystem = attributes['rpc.system']
+  if (rpcSystem) {
+    if (kind === CLIENT) {
+      return rpcSystem === 'aws-api'
+        ? `aws.${attributes['rpc.service'] || 'client'}.request`
+        : `${rpcSystem}.client.request`
+    }
+    if (kind === SERVER) {
+      return `${rpcSystem}.server.request`
+    }
+  }
+
+  // FaaS
+  const faasProvider = attributes['faas.invoked_provider']
+  const faasName = attributes['faas.invoked_name']
+  const faasTrigger = attributes['faas.trigger']
+  if (kind === CLIENT && faasProvider && faasName) {
+    return `${faasProvider}.${faasName}.invoke`
+  }
+  if (kind === SERVER && faasTrigger) {
+    return `${faasTrigger}.invoke`
+  }
+
+  // GraphQL
+  // NOTE: Not part of Semantic Convention spec yet, but is used in the GraphQL
+  // integration.
+  const isGraphQL = 'graphql.operation.type' in attributes
+  if (isGraphQL) return 'graphql.server.request'
+
+  // Network
+  // TODO: Doesn't exist yet. No equivalent.
+  const protocol = attributes['network.protocol.name']
+  const protocolPrefix = protocol ? `${protocol}.` : ''
+  if (kind === SERVER) return `${protocolPrefix}server.request`
+  if (kind === CLIENT) return `${protocolPrefix}client.request`
+
+  // If all else fails, default to stringified span.kind.
+  return spanKindNames[kind]
+}
+
+class Span {
+  constructor (
+    parentTracer,
+    context,
+    spanName,
+    spanContext,
+    kind,
+    links = [],
+    timeInput,
+    attributes
+  ) {
+    const { _tracer } = tracer
+
+    const hrStartTime = timeInputToHrTime(timeInput || (performance.now() + timeOrigin))
+    const startTime = hrTimeToMilliseconds(hrStartTime)
+
+    this._ddSpan = new DatadogSpan(_tracer, _tracer._processor, _tracer._prioritySampler, {
+      operationName: spanNameMapper(spanName, kind, attributes),
+      context: spanContext._ddContext,
+      startTime,
+      hostname: _tracer._hostname,
+      integrationName: parentTracer?._isOtelLibrary ? 'otel.library' : 'otel',
+      tags: {
+        [SERVICE_NAME]: _tracer._service,
+        [RESOURCE_NAME]: spanName,
+        [SPAN_KIND]: spanKindNames[kind],
+      },
+      links,
+    }, _tracer._debug)
+
+    if (attributes) {
+      this.setAttributes(attributes)
+    }
+
+    this._parentTracer = parentTracer
+    this._context = context
+
+    this._hasStatus = false
+
+    // NOTE: Need to grab the value before setting it on the span because the
+    // math for computing opentracing timestamps is apparently lossy...
+    this.startTime = hrStartTime
+    this.kind = kind
+    this._spanProcessor.onStart(this, context)
+  }
+
+  get parentSpanId () {
+    const { _parentId } = this._ddSpan.context()
+    return _parentId && _parentId.toString(16)
+  }
+
+  // Expected by OTel
+  get resource () {
+    return this._parentTracer.resource
+  }
+
+  get instrumentationLibrary () {
+    return this._parentTracer.instrumentationLibrary
+  }
+
+  get _spanProcessor () {
+    return this._parentTracer.getActiveSpanProcessor()
+  }
+
+  get name () {
+    return this._ddSpan.context()._name
+  }
+
+  spanContext () {
+    return new SpanContext(this._ddSpan.context())
+  }
+
+  setAttribute (key, value) {
+    if (key === 'http.response.status_code') {
+      this._ddSpan.setTag('http.status_code', value.toString())
+    }
+
+    this._ddSpan.setTag(key, value)
+    return this
+  }
+
+  setAttributes (attributes) {
+    if ('http.response.status_code' in attributes) {
+      attributes['http.status_code'] = attributes['http.response.status_code'].toString()
+    }
+
+    this._ddSpan.addTags(attributes)
+    return this
+  }
+
+  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
+    // Extract dd context
+    const ddSpanContext = context._ddContext
+    this._ddSpan.addLink({ context: ddSpanContext, attributes })
+    return this
+  }
+
+  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',
+    }
+    return this.addLink(zeroContext, attributes)
+  }
+
+  setStatus ({ code, message }) {
+    if (!this.ended && !this._hasStatus && code) {
+      this._hasStatus = true
+      if (code === 2) {
+        this._ddSpan.addTags({
+          [ERROR_MESSAGE]: message,
+          [IGNORE_OTEL_ERROR]: false,
+        })
+      }
+    }
+    return this
+  }
+
+  updateName (name) {
+    if (!this.ended) {
+      this._ddSpan.setOperationName(name)
+    }
+    return this
+  }
+
+  end (timeInput) {
+    if (this.ended) {
+      api.diag.error('You can only call end() on a span once.')
+      return
+    }
+
+    const hrEndTime = timeInputToHrTime(timeInput || (performance.now() + timeOrigin))
+    const endTime = hrTimeToMilliseconds(hrEndTime)
+
+    this._ddSpan.finish(endTime)
+    this._spanProcessor.onEnd(this)
+  }
+
+  isRecording () {
+    return this.ended === false
+  }
+
+  addEvent (name, attributesOrStartTime, startTime) {
+    startTime = attributesOrStartTime && isTimeInput(attributesOrStartTime) ? attributesOrStartTime : startTime
+    const hrStartTime = timeInputToHrTime(startTime || (performance.now() + timeOrigin))
+    startTime = hrTimeToMilliseconds(hrStartTime)
+
+    this._ddSpan.addEvent(name, attributesOrStartTime, startTime)
+    return this
+  }
+
+  recordException (exception, timeInput) {
+    this._ddSpan.addTags({
+      [ERROR_TYPE]: exception.name,
+      [ERROR_MESSAGE]: exception.message,
+      [ERROR_STACK]: exception.stack,
+      [IGNORE_OTEL_ERROR]: this._ddSpan.context()._tags[IGNORE_OTEL_ERROR] ?? true,
+    })
+    const attributes = {}
+    if (exception.message) attributes['exception.message'] = exception.message
+    if (exception.type) attributes['exception.type'] = exception.type
+    if (exception.escaped) attributes['exception.escaped'] = exception.escaped
+    if (exception.stack) attributes['exception.stacktrace'] = exception.stack
+    this.addEvent(exception.name, attributes, timeInput)
+  }
+
+  get duration () {
+    return this._ddSpan._duration
+  }
+
+  get ended () {
+    return this.duration !== undefined
+  }
+}
+
+module.exports = Span

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

@@ -0,0 +1,44 @@
+'use strict'
+
+const api = require('@opentelemetry/api')
+const { AUTO_KEEP } = require('../../../../ext/priority')
+const DatadogSpanContext = require('../opentracing/span_context')
+const id = require('../id')
+
+function newContext () {
+  const spanId = id()
+  return new DatadogSpanContext({
+    traceId: spanId,
+    spanId,
+  })
+}
+
+class SpanContext {
+  constructor (context) {
+    if (!(context instanceof DatadogSpanContext)) {
+      context = context
+        ? new DatadogSpanContext(context)
+        : newContext()
+    }
+    this._ddContext = context
+  }
+
+  get traceId () {
+    return this._ddContext.toTraceId(true)
+  }
+
+  get spanId () {
+    return this._ddContext.toSpanId(true)
+  }
+
+  get traceFlags () {
+    return this._ddContext._sampling.priority >= AUTO_KEEP ? 1 : 0
+  }
+
+  get traceState () {
+    const ts = this._ddContext._tracestate
+    return api.createTraceState(ts ? ts.toString() : '')
+  }
+}
+
+module.exports = SpanContext

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

@@ -0,0 +1,50 @@
+'use strict'
+
+class NoopSpanProcessor {
+  forceFlush () {
+    return Promise.resolve()
+  }
+
+  onStart (span, context) {}
+  onEnd (span) {}
+
+  shutdown () {
+    return Promise.resolve()
+  }
+}
+
+class MultiSpanProcessor extends NoopSpanProcessor {
+  constructor (spanProcessors) {
+    super()
+    this._processors = spanProcessors
+  }
+
+  forceFlush () {
+    return Promise.all(
+      this._processors.map(p => p.forceFlush())
+    )
+  }
+
+  onStart (span, context) {
+    for (const processor of this._processors) {
+      processor.onStart(span, context)
+    }
+  }
+
+  onEnd (span) {
+    for (const processor of this._processors) {
+      processor.onEnd(span)
+    }
+  }
+
+  shutdown () {
+    return Promise.all(
+      this._processors.map(p => p.shutdown())
+    )
+  }
+}
+
+module.exports = {
+  MultiSpanProcessor,
+  NoopSpanProcessor,
+}

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

@@ -0,0 +1,226 @@
+'use strict'
+
+const api = require('@opentelemetry/api')
+const { sanitizeAttributes } = require('../../../../vendor/dist/@opentelemetry/core')
+
+const id = require('../id')
+const log = require('../log')
+const DatadogSpanContext = require('../opentracing/span_context')
+const TextMapPropagator = require('../opentracing/propagation/text_map')
+const TraceState = require('../opentracing/propagation/tracestate')
+const SpanContext = require('./span_context')
+const Span = require('./span')
+const Sampler = require('./sampler')
+
+function normalizeLinkContext (context) {
+  if (!context) return
+
+  // OTel API bridge SpanContext wrapper
+  if (context._ddContext) return context._ddContext
+
+  // Datadog span context
+  if (typeof context.toTraceId === 'function' && typeof context.toSpanId === 'function') {
+    return context
+  }
+
+  // Standard OTel SpanContext (traceId/spanId)
+  if (typeof context.traceId !== 'string' || typeof context.spanId !== 'string') {
+    // Invalid
+    return
+  }
+
+  let sampling
+  if (typeof context.traceFlags === 'number') {
+    sampling = { priority: context.traceFlags & 1 }
+  }
+
+  let tracestate
+  if (context.traceState?.serialize) {
+    tracestate = TraceState.fromString(context.traceState.serialize())
+  }
+
+  return new DatadogSpanContext({
+    traceId: id(context.traceId, 16),
+    spanId: id(context.spanId, 16),
+    sampling,
+    tracestate,
+  })
+}
+
+class Tracer {
+  constructor (library, config, tracerProvider) {
+    this._sampler = new Sampler()
+    this._config = config
+    this._tracerProvider = tracerProvider
+    // Is there a reason this is public?
+    this.instrumentationLibrary = library
+    this._isOtelLibrary = library?.name?.startsWith('@opentelemetry/instrumentation-')
+    this._spanLimits = {}
+  }
+
+  get resource () {
+    return this._tracerProvider.resource
+  }
+
+  _createSpanContextFromParent (parentSpanContext) {
+    return new SpanContext({
+      traceId: parentSpanContext._traceId,
+      spanId: id(),
+      parentId: parentSpanContext._spanId,
+      sampling: parentSpanContext._sampling,
+      baggageItems: { ...parentSpanContext._baggageItems },
+      trace: parentSpanContext._trace,
+      tracestate: parentSpanContext._tracestate,
+    })
+  }
+
+  // Extracted method to create span context for a new span
+  _createSpanContextForNewSpan (context) {
+    const { traceId, spanId, traceFlags, traceState } = context
+    return this._convertOtelContextToDatadog(traceId, spanId, traceFlags, traceState)
+  }
+
+  _convertOtelContextToDatadog (traceId, spanId, traceFlag, ts, meta = {}) {
+    const origin = null
+    let samplingPriority = traceFlag
+
+    ts = ts?.traceparent || null
+
+    if (ts) {
+      // Use TraceState.fromString to parse the tracestate header
+      const traceState = TraceState.fromString(ts)
+      let ddTraceStateData = null
+
+      // Extract Datadog specific trace state data
+      traceState.forVendor('dd', (state) => {
+        ddTraceStateData = state
+        return state // You might need to adjust this part based on actual logic needed
+      })
+
+      if (ddTraceStateData) {
+        // 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')
+        // 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
+        )
+      } else {
+        log.debug('no dd list member in tracestate from incoming request:', ts)
+      }
+    }
+
+    const spanContext = new SpanContext({
+      traceId: id(traceId, 16), spanId: id(), tags: meta, parentId: id(spanId, 16),
+    })
+
+    spanContext._sampling = { priority: samplingPriority }
+    spanContext._trace = { origin }
+    return spanContext
+  }
+
+  startSpan (name, options = {}, context = api.context.active()) {
+    // remove span from context in case a root span is requested via options
+    if (options.root) {
+      context = api.trace.deleteSpan(context)
+    }
+    const parentSpan = api.trace.getSpan(context)
+    const parentSpanContext = parentSpan?.spanContext()
+    let spanContext
+    if (parentSpanContext && api.trace.isSpanContextValid(parentSpanContext)) {
+      spanContext = parentSpanContext._ddContext
+        ? this._createSpanContextFromParent(parentSpanContext._ddContext)
+        : this._createSpanContextForNewSpan(parentSpanContext)
+    } else {
+      spanContext = new SpanContext()
+    }
+
+    const spanKind = options.kind || api.SpanKind.INTERNAL
+    const links = []
+    if (options.links?.length) {
+      for (const link of options.links) {
+        const ddContext = normalizeLinkContext(link?.context)
+        if (!ddContext) continue
+
+        links.push({
+          context: ddContext,
+          attributes: sanitizeAttributes(link.attributes),
+        })
+      }
+    }
+    const attributes = sanitizeAttributes(options.attributes)
+
+    // TODO: sampling API is not yet supported
+    // // make sampling decision
+    // const samplingResult = this._sampler.shouldSample(
+    //   context,
+    //   spanContext.traceId,
+    //   name,
+    //   spanKind,
+    //   attributes,
+    //   links
+    // )
+
+    // // Should use new span context
+    // spanContext._ddContext._sampling.priority =
+    //   samplingResult.decision === api.SamplingDecision.RECORD_AND_SAMPLED
+    //     ? AUTO_KEEP
+    //     : AUTO_REJECT
+
+    // if (samplingResult.decision === api.SamplingDecision.NOT_RECORD) {
+    //   api.diag.debug('Recording is off, propagating context in a non-recording span')
+    //   return api.trace.wrapSpanContext(spanContext)
+    // }
+
+    return new Span(
+      this,
+      context,
+      name,
+      spanContext,
+      spanKind,
+      links,
+      options.startTime,
+
+      // Set initial span attributes. The attributes object may have been mutated
+      // by the sampler, so we sanitize the merged attributes before setting them.
+      sanitizeAttributes(attributes)
+    )
+  }
+
+  startActiveSpan (name, options, context, fn) {
+    if (arguments.length === 2) {
+      fn = options
+      context = undefined
+      options = undefined
+    } else if (arguments.length === 3) {
+      fn = context
+      context = undefined
+    } else if (arguments.length !== 4) {
+      return
+    }
+
+    const parentContext = context || api.context.active()
+    const span = this.startSpan(name, options, parentContext)
+    const contextWithSpanSet = api.trace.setSpan(parentContext, span)
+
+    return api.context.with(contextWithSpanSet, fn, undefined, span)
+  }
+
+  getActiveSpanProcessor () {
+    return this._tracerProvider.getActiveSpanProcessor()
+  }
+
+  // not used in our codebase but needed for compatibility. See issue #1244
+  getSpanLimits () {
+    return this._spanLimits
+  }
+}
+
+module.exports = Tracer