dd-trace 5.19.0 → 5.21.0

package/packages/dd-trace/src/datastreams/pathway.js

@@ -17,11 +17,13 @@ function shaHash (checkpointString) {
 }
 
 function computeHash (service, env, edgeTags, parentHash) {
-  const key = `${service}${env}` + edgeTags.join('') + parentHash.toString()
+  const hashableEdgeTags = edgeTags.filter(item => item !== 'manual_checkpoint:true')
+
+  const key = `${service}${env}` + hashableEdgeTags.join('') + parentHash.toString()
   if (cache.get(key)) {
     return cache.get(key)
   }
-  const currentHash = shaHash(`${service}${env}` + edgeTags.join(''))
+  const currentHash = shaHash(`${service}${env}` + hashableEdgeTags.join(''))
   const buf = Buffer.concat([currentHash, parentHash], 16)
   const val = shaHash(buf.toString())
   cache.set(key, val)

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

@@ -1,5 +1,7 @@
 'use strict'
 
+const coalesce = require('koalas')
+const { isTrue } = require('../util')
 const { debugChannel, infoChannel, warnChannel, errorChannel } = require('./channels')
 const logWriter = require('./writer')
 
@@ -20,13 +22,29 @@ function processMsg (msg) {
   return typeof msg === 'function' ? msg() : msg
 }
 
+const config = {
+  enabled: false,
+  logger: undefined,
+  logLevel: 'debug'
+}
+
 const log = {
+  /**
+   * @returns Read-only version of logging config. To modify config, call `log.use` and `log.toggle`
+   */
+  getConfig () {
+    return { ...config }
+  },
+
   use (logger) {
+    config.logger = logger
     logWriter.use(logger)
     return this
   },
 
   toggle (enabled, logLevel) {
+    config.enabled = enabled
+    config.logLevel = logLevel
     logWriter.toggle(enabled, logLevel)
     return this
   },
@@ -76,4 +94,18 @@ const log = {
 
 log.reset()
 
+const enabled = isTrue(coalesce(
+  process.env.DD_TRACE_DEBUG,
+  process.env.OTEL_LOG_LEVEL === 'debug',
+  config.enabled
+))
+
+const logLevel = coalesce(
+  process.env.DD_TRACE_LOG_LEVEL,
+  process.env.OTEL_LOG_LEVEL,
+  config.logLevel
+)
+
+log.toggle(enabled, logLevel)
+
 module.exports = log

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

@@ -2,61 +2,46 @@
 
 const { AsyncLocalStorage } = require('async_hooks')
 const { trace, ROOT_CONTEXT } = require('@opentelemetry/api')
+const DataDogSpanContext = require('../opentracing/span_context')
 
 const SpanContext = require('./span_context')
 const tracer = require('../../')
 
-// Horrible hack to acquire the otherwise inaccessible SPAN_KEY so we can redirect it...
-// This is used for getting the current span context in OpenTelemetry, but the SPAN_KEY value is
-// not exposed as it's meant to be read-only from outside the module. We want to hijack this logic
-// so we can instead get the span context from the datadog context manager instead.
-let SPAN_KEY
-trace.getSpan({
-  getValue (key) {
-    SPAN_KEY = key
-  }
-})
-
-// Whenever a value is acquired from the context map we should mostly delegate to the real getter,
-// but when accessing the current span we should hijack that access to instead provide a fake span
-// which we can use to get an OTel span context wrapping the datadog active scope span context.
-function wrappedGetValue (target) {
-  return (key) => {
-    if (key === SPAN_KEY) {
-      return {
-        spanContext () {
-          const activeSpan = tracer.scope().active()
-          const context = activeSpan && activeSpan.context()
-          return new SpanContext(context)
-        }
-      }
-    }
-    return target.getValue(key)
-  }
-}
-
 class ContextManager {
   constructor () {
     this._store = new AsyncLocalStorage()
   }
 
   active () {
-    const active = this._store.getStore() || ROOT_CONTEXT
+    const activeSpan = tracer.scope().active()
+    const store = this._store.getStore()
+    const context = (activeSpan && activeSpan.context()) || store || ROOT_CONTEXT
 
-    return new Proxy(active, {
-      get (target, key) {
-        return key === 'getValue' ? wrappedGetValue(target) : target[key]
-      }
-    })
+    if (!(context instanceof DataDogSpanContext)) {
+      return context
+    }
+
+    if (!context._otelSpanContext) {
+      const newSpanContext = new SpanContext(context)
+      context._otelSpanContext = newSpanContext
+    }
+    if (store && trace.getSpanContext(store) === context._otelSpanContext) {
+      return store
+    }
+    return trace.setSpanContext(store || ROOT_CONTEXT, context._otelSpanContext)
   }
 
   with (context, fn, thisArg, ...args) {
     const span = trace.getSpan(context)
     const ddScope = tracer.scope()
-    return ddScope.activate(span._ddSpan, () => {
+    const run = () => {
       const cb = thisArg == null ? fn : fn.bind(thisArg)
       return this._store.run(context, cb, ...args)
-    })
+    }
+    if (span && span._ddSpan) {
+      return ddScope.activate(span._ddSpan, run)
+    }
+    return run()
   }
 
   bind (context, target) {
@@ -66,9 +51,7 @@ class ContextManager {
     }
   }
 
-  // Not part of the spec but the Node.js API expects these
   enable () {}
   disable () {}
 }
-
 module.exports = ContextManager

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

@@ -24,11 +24,11 @@ class SpanContext {
   }
 
   get traceId () {
-    return this._ddContext._traceId.toString(16)
+    return this._ddContext.toTraceId(true)
   }
 
   get spanId () {
-    return this._ddContext._spanId.toString(16)
+    return this._ddContext.toSpanId(true)
   }
 
   get traceFlags () {

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

@@ -7,6 +7,7 @@ const Sampler = require('./sampler')
 const Span = require('./span')
 const id = require('../id')
 const SpanContext = require('./span_context')
+const TextMapPropagator = require('../opentracing/propagation/text_map')
 
 class Tracer {
   constructor (library, config, tracerProvider) {
@@ -22,6 +23,24 @@ class Tracer {
     return this._tracerProvider.resource
   }
 
+  _createSpanContextFromParent (parentSpanContext) {
+    return new SpanContext({
+      traceId: parentSpanContext._traceId,
+      spanId: id(),
+      parentId: parentSpanContext._spanId,
+      sampling: parentSpanContext._sampling,
+      baggageItems: Object.assign({}, 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 TextMapPropagator._convertOtelContextToDatadog(traceId, spanId, traceFlags, traceState)
+  }
+
   startSpan (name, options = {}, context = api.context.active()) {
     // remove span from context in case a root span is requested via options
     if (options.root) {
@@ -29,21 +48,11 @@ class Tracer {
     }
     const parentSpan = api.trace.getSpan(context)
     const parentSpanContext = parentSpan && parentSpan.spanContext()
-
     let spanContext
-    // TODO: Need a way to get 128-bit trace IDs for the validity check API to work...
-    // if (parent && api.trace.isSpanContextValid(parent)) {
-    if (parentSpanContext && parentSpanContext.traceId) {
-      const parent = parentSpanContext._ddContext
-      spanContext = new SpanContext({
-        traceId: parent._traceId,
-        spanId: id(),
-        parentId: parent._spanId,
-        sampling: parent._sampling,
-        baggageItems: Object.assign({}, parent._baggageItems),
-        trace: parent._trace,
-        tracestate: parent._tracestate
-      })
+    if (parentSpanContext && api.trace.isSpanContextValid(parentSpanContext)) {
+      spanContext = parentSpanContext._ddContext
+        ? this._createSpanContextFromParent(parentSpanContext._ddContext)
+        : this._createSpanContextForNewSpan(parentSpanContext)
     } else {
       spanContext = new SpanContext()
     }

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

@@ -1,6 +1,7 @@
 'use strict'
 
-const { trace, context } = require('@opentelemetry/api')
+const { trace, context, propagation } = require('@opentelemetry/api')
+const { W3CTraceContextPropagator } = require('@opentelemetry/core')
 
 const tracer = require('../../')
 
@@ -52,6 +53,13 @@ class TracerProvider {
     if (!trace.setGlobalTracerProvider(this)) {
       trace.getTracerProvider().setDelegate(this)
     }
+    // The default propagator used is the W3C Trace Context propagator, users should be able to pass in others
+    // as needed
+    if (config.propagator) {
+      propagation.setGlobalPropagator(config.propagator)
+    } else {
+      propagation.setGlobalPropagator(new W3CTraceContextPropagator())
+    }
   }
 
   forceFlush () {

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

@@ -15,7 +15,7 @@ class LogPropagator {
 
     if (spanContext) {
       if (this._config.traceId128BitLoggingEnabled && spanContext._trace.tags['_dd.p.tid']) {
-        carrier.dd.trace_id = spanContext._trace.tags['_dd.p.tid'] + spanContext._traceId.toString(16)
+        carrier.dd.trace_id = spanContext.toTraceId(true)
       } else {
         carrier.dd.trace_id = spanContext.toTraceId()
       }

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

@@ -3,6 +3,7 @@
 const pick = require('../../../../datadog-core/src/utils/src/pick')
 const id = require('../../id')
 const DatadogSpanContext = require('../span_context')
+const OtelSpanContext = require('../../opentelemetry/span_context')
 const log = require('../../log')
 const TraceState = require('./tracestate')
 const tags = require('../../../../../ext/tags')
@@ -618,6 +619,65 @@ class TextMapPropagator {
 
     return spanContext._traceId.toString(16)
   }
+
+  static _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, parseInt(samplingPriorityTs, 10), origin)
+      } else {
+        log.debug(`no dd list member in tracestate from incoming request: ${ts}`)
+      }
+    }
+
+    const spanContext = new OtelSpanContext({
+      traceId: id(traceId, 16), spanId: id(), tags: meta, parentId: id(spanId, 16)
+    })
+
+    spanContext._sampling = { priority: samplingPriority }
+    spanContext._trace = { origin }
+    return spanContext
+  }
+
+  static _getSamplingPriority (traceparentSampled, tracestateSamplingPriority, origin = null) {
+    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
+    }
+
+    return samplingPriority
+  }
 }
 
 module.exports = TextMapPropagator

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

@@ -0,0 +1,43 @@
+const pick = require('../../../../datadog-core/src/utils/src/pick')
+const log = require('../../log')
+
+const { DsmPathwayCodec } = require('../../datastreams/pathway')
+
+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)
+
+    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
+
+    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/span_context.js

@@ -27,6 +27,7 @@ class DatadogSpanContext {
       finished: [],
       tags: {}
     }
+    this._otelSpanContext = undefined
   }
 
   toTraceId (get128bitId = false) {

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

@@ -5,6 +5,7 @@ const Span = require('./span')
 const SpanProcessor = require('../span_processor')
 const PrioritySampler = require('../priority_sampler')
 const TextMapPropagator = require('./propagation/text_map')
+const DSMTextMapPropagator = require('./propagation/text_map_dsm')
 const HttpPropagator = require('./propagation/http')
 const BinaryPropagator = require('./propagation/binary')
 const LogPropagator = require('./propagation/log')
@@ -38,7 +39,8 @@ class DatadogTracer {
       [formats.TEXT_MAP]: new TextMapPropagator(config),
       [formats.HTTP_HEADERS]: new HttpPropagator(config),
       [formats.BINARY]: new BinaryPropagator(config),
-      [formats.LOG]: new LogPropagator(config)
+      [formats.LOG]: new LogPropagator(config),
+      [formats.TEXT_MAP_DSM]: new DSMTextMapPropagator(config)
     }
     if (config.reportHostname) {
       this._hostname = os.hostname()
@@ -71,14 +73,16 @@ class DatadogTracer {
     return span
   }
 
-  inject (spanContext, format, carrier) {
-    if (spanContext instanceof Span) {
-      spanContext = spanContext.context()
+  inject (context, format, carrier) {
+    if (context instanceof Span) {
+      context = context.context()
     }
 
     try {
-      this._prioritySampler.sample(spanContext)
-      this._propagators[format].inject(spanContext, carrier)
+      if (format !== 'text_map_dsm') {
+        this._prioritySampler.sample(context)
+      }
+      this._propagators[format].inject(context, carrier)
     } catch (e) {
       log.error(e)
       runtimeMetrics.increment('datadog.tracer.node.inject.errors', true)

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

@@ -16,7 +16,8 @@ const {
   getTestSuiteCommonTags,
   TEST_STATUS,
   TEST_SKIPPED_BY_ITR,
-  ITR_CORRELATION_ID
+  ITR_CORRELATION_ID,
+  TEST_SOURCE_FILE
 } = require('./util/test')
 const Plugin = require('./plugin')
 const { COMPONENT } = require('../constants')
@@ -144,7 +145,7 @@ module.exports = class CiPlugin extends Plugin {
         incrementCountMetric(name, {
           testLevel,
           testFramework,
-          isUnsupportedCIProvider: this.isUnsupportedCIProvider,
+          isUnsupportedCIProvider: !this.ciProviderName,
           ...tags
         })
       },
@@ -178,7 +179,7 @@ module.exports = class CiPlugin extends Plugin {
 
     this.codeOwnersEntries = getCodeOwnersFileEntries(repositoryRoot)
 
-    this.isUnsupportedCIProvider = !ciProviderName
+    this.ciProviderName = ciProviderName
 
     this.testConfiguration = {
       repositoryUrl,
@@ -207,7 +208,13 @@ module.exports = class CiPlugin extends Plugin {
       ...extraTags
     }
 
-    const codeOwners = getCodeOwnersForFilename(testSuite, this.codeOwnersEntries)
+    const { [TEST_SOURCE_FILE]: testSourceFile } = extraTags
+    // We'll try with the test source file if available (it could be different from the test suite)
+    let codeOwners = getCodeOwnersForFilename(testSourceFile, this.codeOwnersEntries)
+    if (!codeOwners) {
+      codeOwners = getCodeOwnersForFilename(testSuite, this.codeOwnersEntries)
+    }
+
     if (codeOwners) {
       testTags[TEST_CODE_OWNERS] = codeOwners
     }

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

@@ -69,6 +69,7 @@ module.exports = {
   get 'node:http2' () { return require('../../../datadog-plugin-http2/src') },
   get 'node:https' () { return require('../../../datadog-plugin-http/src') },
   get 'node:net' () { return require('../../../datadog-plugin-net/src') },
+  get nyc () { return require('../../../datadog-plugin-nyc/src') },
   get oracledb () { return require('../../../datadog-plugin-oracledb/src') },
   get openai () { return require('../../../datadog-plugin-openai/src') },
   get paperplane () { return require('../../../datadog-plugin-paperplane/src') },

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

@@ -3,6 +3,7 @@
 // TODO: move anything related to tracing to TracingPlugin instead
 
 const dc = require('dc-polyfill')
+const logger = require('../log')
 const { storage } = require('../../../datadog-core')
 
 class Subscription {
@@ -72,7 +73,17 @@ module.exports = class Plugin {
   }
 
   addSub (channelName, handler) {
-    this._subscriptions.push(new Subscription(channelName, handler))
+    const plugin = this
+    const wrappedHandler = function () {
+      try {
+        return handler.apply(this, arguments)
+      } catch (e) {
+        logger.error('Error in plugin handler:', e)
+        logger.info('Disabling plugin:', plugin.id)
+        plugin.configure(false)
+      }
+    }
+    this._subscriptions.push(new Subscription(channelName, wrappedHandler))
   }
 
   addBind (channelName, transform) {

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

@@ -77,6 +77,18 @@ function isDirectory (path) {
   }
 }
 
+function isGitAvailable () {
+  const isWindows = os.platform() === 'win32'
+  const command = isWindows ? 'where' : 'which'
+  try {
+    cp.execFileSync(command, ['git'], { stdio: 'pipe' })
+    return true
+  } catch (e) {
+    incrementCountMetric(TELEMETRY_GIT_COMMAND_ERRORS, { command: 'check_git', exitCode: 'missing' })
+    return false
+  }
+}
+
 function isShallowRepository () {
   return sanitizedExec(
     'git',
@@ -342,5 +354,6 @@ module.exports = {
   getCommitsRevList,
   GIT_REV_LIST_MAX_BUFFER,
   isShallowRepository,
-  unshallowRepository
+  unshallowRepository,
+  isGitAvailable
 }

package/packages/dd-trace/src/proxy.js

@@ -181,6 +181,7 @@ class Tracer extends NoopProxy {
       if (!this._tracingInitialized) {
         const prioritySampler = appsecStandalone.configure(config)
         this._tracer = new DatadogTracer(config, prioritySampler)
+        this.dataStreamsCheckpointer = this._tracer.dataStreamsCheckpointer
         this.appsec = new AppsecSdk(this._tracer, config)
         this._tracingInitialized = true
       }

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

@@ -317,7 +317,7 @@ function updateConfig (changes, config) {
     'sampler.rules': 'DD_TRACE_SAMPLING_RULES'
   }
 
-  const namesNeedFormatting = new Set(['DD_TAGS', 'peerServiceMapping'])
+  const namesNeedFormatting = new Set(['DD_TAGS', 'peerServiceMapping', 'serviceMapping'])
 
   const configuration = []
   const names = [] // list of config names whose values have been changed

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

@@ -11,6 +11,7 @@ const { DataStreamsProcessor } = require('./datastreams/processor')
 const { DsmPathwayCodec } = require('./datastreams/pathway')
 const { DD_MAJOR } = require('../../../version')
 const DataStreamsContext = require('./data_streams_context')
+const { DataStreamsCheckpointer } = require('./data_streams')
 const { flushStartupLogs } = require('../../datadog-instrumentations/src/check_require_cache')
 const log = require('./log/writer')
 
@@ -23,6 +24,7 @@ class DatadogTracer extends Tracer {
   constructor (config, prioritySampler) {
     super(config, prioritySampler)
     this._dataStreamsProcessor = new DataStreamsProcessor(config)
+    this.dataStreamsCheckpointer = new DataStreamsCheckpointer(this)
     this._scope = new Scope()
     setStartupLogConfig(config)
     flushStartupLogs(log)