dd-trace 5.30.0 → 5.32.0

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

@@ -10,7 +10,7 @@ const noopAppsec = new NoopAppsecSdk()
 const noopDogStatsDClient = new NoopDogStatsDClient()
 const noopLLMObs = new NoopLLMObsSDK(noop)
 
-class Tracer {
+class NoopProxy {
   constructor () {
     this._tracer = noop
     this.appsec = noopAppsec
@@ -91,4 +91,4 @@ class Tracer {
   }
 }
 
-module.exports = Tracer
+module.exports = NoopProxy

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

@@ -6,7 +6,7 @@ const { storage } = require('../../../datadog-core') // TODO: noop storage?
 
 class NoopSpan {
   constructor (tracer, parent) {
-    this._store = storage.getStore()
+    this._store = storage.getHandle()
     this._noopTracer = tracer
     this._noopContext = this._createContext(parent)
   }

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

@@ -1,7 +1,7 @@
 'use strict'
 
 const { storage } = require('../../../datadog-core')
-const { trace, ROOT_CONTEXT } = require('@opentelemetry/api')
+const { trace, ROOT_CONTEXT, propagation } = require('@opentelemetry/api')
 const DataDogSpanContext = require('../opentracing/span_context')
 
 const SpanContext = require('./span_context')
@@ -18,17 +18,40 @@ class ContextManager {
     const context = (activeSpan && activeSpan.context()) || store || ROOT_CONTEXT
 
     if (!(context instanceof DataDogSpanContext)) {
+      const span = trace.getSpan(context)
+      // span instanceof NonRecordingSpan
+      if (span && span._spanContext && span._spanContext._ddContext && span._spanContext._ddContext._baggageItems) {
+        const baggages = span._spanContext._ddContext._baggageItems
+        const entries = {}
+        for (const [key, value] of Object.entries(baggages)) {
+          entries[key] = { value }
+        }
+        const otelBaggages = propagation.createBaggage(entries)
+        return propagation.setBaggage(context, otelBaggages)
+      }
       return context
     }
 
+    const baggages = JSON.parse(activeSpan.getAllBaggageItems())
+    const entries = {}
+    for (const [key, value] of Object.entries(baggages)) {
+      entries[key] = { value }
+    }
+    const otelBaggages = propagation.createBaggage(entries)
+
     if (!context._otelSpanContext) {
       const newSpanContext = new SpanContext(context)
       context._otelSpanContext = newSpanContext
     }
     if (store && trace.getSpanContext(store) === context._otelSpanContext) {
-      return store
+      return otelBaggages
+        ? propagation.setBaggage(store, otelBaggages)
+        : store
     }
-    return trace.setSpanContext(store || ROOT_CONTEXT, context._otelSpanContext)
+    const wrappedContext = trace.setSpanContext(store || ROOT_CONTEXT, context._otelSpanContext)
+    return otelBaggages
+      ? propagation.setBaggage(wrappedContext, otelBaggages)
+      : wrappedContext
   }
 
   with (context, fn, thisArg, ...args) {
@@ -38,9 +61,26 @@ class ContextManager {
       const cb = thisArg == null ? fn : fn.bind(thisArg)
       return this._store.run(context, cb, ...args)
     }
+    const baggages = propagation.getBaggage(context)
+    let baggageItems = []
+    if (baggages) {
+      baggageItems = baggages.getAllEntries()
+    }
     if (span && span._ddSpan) {
+      // does otel always override datadog?
+      span._ddSpan.removeAllBaggageItems()
+      for (const baggage of baggageItems) {
+        span._ddSpan.setBaggageItem(baggage[0], baggage[1].value)
+      }
       return ddScope.activate(span._ddSpan, run)
     }
+    // span instanceof NonRecordingSpan
+    if (span && span._spanContext && span._spanContext._ddContext && span._spanContext._ddContext._baggageItems) {
+      span._spanContext._ddContext._baggageItems = {}
+      for (const baggage of baggageItems) {
+        span._spanContext._ddContext._baggageItems[baggage[0]] = baggage[1].value
+      }
+    }
     return run()
   }
 

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

@@ -14,6 +14,7 @@ const { storage } = require('../../../datadog-core')
 const telemetryMetrics = require('../telemetry/metrics')
 const { channel } = require('dc-polyfill')
 const spanleak = require('../spanleak')
+const util = require('util')
 
 const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
 
@@ -64,7 +65,7 @@ class DatadogSpan {
     this._debug = debug
     this._processor = processor
     this._prioritySampler = prioritySampler
-    this._store = storage.getStore()
+    this._store = storage.getHandle()
     this._duration = undefined
 
     this._events = []
@@ -105,6 +106,15 @@ class DatadogSpan {
     }
   }
 
+  [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'] || ''

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

@@ -1,5 +1,6 @@
 '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
@@ -31,6 +32,17 @@ class DatadogSpanContext {
     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]

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

@@ -23,7 +23,11 @@ const {
   TEST_LEVEL_EVENT_TYPES,
   TEST_SUITE,
   getFileAndLineNumberFromError,
-  getTestSuitePath
+  DI_ERROR_DEBUG_INFO_CAPTURED,
+  DI_DEBUG_ERROR_PREFIX,
+  DI_DEBUG_ERROR_SNAPSHOT_ID_SUFFIX,
+  DI_DEBUG_ERROR_FILE_SUFFIX,
+  DI_DEBUG_ERROR_LINE_SUFFIX
 } = require('./util/test')
 const Plugin = require('./plugin')
 const { COMPONENT } = require('../constants')
@@ -180,14 +184,18 @@ module.exports = class CiPlugin extends Plugin {
     }
   }
 
-  configure (config) {
+  configure (config, shouldGetEnvironmentData = true) {
     super.configure(config)
 
-    if (config.isTestDynamicInstrumentationEnabled) {
+    if (config.isTestDynamicInstrumentationEnabled && !this.di) {
       const testVisibilityDynamicInstrumentation = require('../ci-visibility/dynamic-instrumentation')
       this.di = testVisibilityDynamicInstrumentation
     }
 
+    if (!shouldGetEnvironmentData) {
+      return
+    }
+
     this.testEnvironmentMetadata = getTestEnvironmentMetadata(this.constructor.id, this.config)
 
     const {
@@ -292,37 +300,59 @@ module.exports = class CiPlugin extends Plugin {
     return testSpan
   }
 
-  // TODO: If the test finishes and the probe is not hit, we should remove the breakpoint
-  addDiProbe (err, probe) {
-    const [file, line] = getFileAndLineNumberFromError(err)
+  onDiBreakpointHit ({ snapshot }) {
+    if (!this.activeTestSpan || this.activeTestSpan.context()._isFinished) {
+      // This is unexpected and is caused by a race condition.
+      log.warn('Breakpoint snapshot could not be attached to the active test span')
+      return
+    }
 
-    const relativePath = getTestSuitePath(file, this.repositoryRoot)
+    const stackIndex = this.testErrorStackIndex
+
+    this.activeTestSpan.setTag(DI_ERROR_DEBUG_INFO_CAPTURED, 'true')
+    this.activeTestSpan.setTag(
+      `${DI_DEBUG_ERROR_PREFIX}.${stackIndex}.${DI_DEBUG_ERROR_SNAPSHOT_ID_SUFFIX}`,
+      snapshot.id
+    )
+    this.activeTestSpan.setTag(
+      `${DI_DEBUG_ERROR_PREFIX}.${stackIndex}.${DI_DEBUG_ERROR_FILE_SUFFIX}`,
+      snapshot.probe.location.file
+    )
+    this.activeTestSpan.setTag(
+      `${DI_DEBUG_ERROR_PREFIX}.${stackIndex}.${DI_DEBUG_ERROR_LINE_SUFFIX}`,
+      Number(snapshot.probe.location.lines[0])
+    )
+
+    const activeTestSpanContext = this.activeTestSpan.context()
+
+    this.tracer._exporter.exportDiLogs(this.testEnvironmentMetadata, {
+      debugger: { snapshot },
+      dd: {
+        trace_id: activeTestSpanContext.toTraceId(),
+        span_id: activeTestSpanContext.toSpanId()
+      }
+    })
+  }
 
-    const [
-      snapshotId,
-      setProbePromise,
-      hitProbePromise
-    ] = this.di.addLineProbe({ file: relativePath, line })
+  removeDiProbe (probeId) {
+    return this.di.removeProbe(probeId)
+  }
+
+  addDiProbe (err) {
+    const [file, line, stackIndex] = getFileAndLineNumberFromError(err, this.repositoryRoot)
 
-    if (probe) { // not all frameworks may sync with the set probe promise
-      probe.setProbePromise = setProbePromise
+    if (!file || !Number.isInteger(line)) {
+      log.warn('Could not add breakpoint for dynamic instrumentation')
+      return
     }
 
-    hitProbePromise.then(({ snapshot }) => {
-      // TODO: handle race conditions for this.retriedTestIds
-      const { traceId, spanId } = this.retriedTestIds
-      this.tracer._exporter.exportDiLogs(this.testEnvironmentMetadata, {
-        debugger: { snapshot },
-        dd: {
-          trace_id: traceId,
-          span_id: spanId
-        }
-      })
-    })
+    const [probeId, setProbePromise] = this.di.addLineProbe({ file, line }, this.onDiBreakpointHit.bind(this))
 
     return {
-      snapshotId,
-      file: relativePath,
+      probeId,
+      setProbePromise,
+      stackIndex,
+      file,
       line
     }
   }

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

@@ -88,6 +88,7 @@ const TEST_BROWSER_VERSION = 'test.browser.version'
 // jest worker variables
 const JEST_WORKER_TRACE_PAYLOAD_CODE = 60
 const JEST_WORKER_COVERAGE_PAYLOAD_CODE = 61
+const JEST_WORKER_LOGS_PAYLOAD_CODE = 62
 
 // cucumber worker variables
 const CUCUMBER_WORKER_TRACE_PAYLOAD_CODE = 70
@@ -108,10 +109,10 @@ const TEST_LEVEL_EVENT_TYPES = [
 
 // Dynamic instrumentation - Test optimization integration tags
 const DI_ERROR_DEBUG_INFO_CAPTURED = 'error.debug_info_captured'
-// TODO: for the moment we'll only use a single snapshot id, so `0` is hardcoded
-const DI_DEBUG_ERROR_SNAPSHOT_ID = '_dd.debug.error.0.snapshot_id'
-const DI_DEBUG_ERROR_FILE = '_dd.debug.error.0.file'
-const DI_DEBUG_ERROR_LINE = '_dd.debug.error.0.line'
+const DI_DEBUG_ERROR_PREFIX = '_dd.debug.error'
+const DI_DEBUG_ERROR_SNAPSHOT_ID_SUFFIX = 'snapshot_id'
+const DI_DEBUG_ERROR_FILE_SUFFIX = 'file'
+const DI_DEBUG_ERROR_LINE_SUFFIX = 'line'
 
 module.exports = {
   TEST_CODE_OWNERS,
@@ -134,6 +135,7 @@ module.exports = {
   LIBRARY_VERSION,
   JEST_WORKER_TRACE_PAYLOAD_CODE,
   JEST_WORKER_COVERAGE_PAYLOAD_CODE,
+  JEST_WORKER_LOGS_PAYLOAD_CODE,
   CUCUMBER_WORKER_TRACE_PAYLOAD_CODE,
   MOCHA_WORKER_TRACE_PAYLOAD_CODE,
   TEST_SOURCE_START,
@@ -191,9 +193,11 @@ module.exports = {
   getNumFromKnownTests,
   getFileAndLineNumberFromError,
   DI_ERROR_DEBUG_INFO_CAPTURED,
-  DI_DEBUG_ERROR_SNAPSHOT_ID,
-  DI_DEBUG_ERROR_FILE,
-  DI_DEBUG_ERROR_LINE
+  DI_DEBUG_ERROR_PREFIX,
+  DI_DEBUG_ERROR_SNAPSHOT_ID_SUFFIX,
+  DI_DEBUG_ERROR_FILE_SUFFIX,
+  DI_DEBUG_ERROR_LINE_SUFFIX,
+  getFormattedError
 }
 
 // Returns pkg manager and its version, separated by '-', e.g. npm-8.15.0 or yarn-1.22.19
@@ -650,13 +654,30 @@ function getNumFromKnownTests (knownTests) {
   return totalNumTests
 }
 
-function getFileAndLineNumberFromError (error) {
+const DEPENDENCY_FOLDERS = [
+  'node_modules',
+  'node:',
+  '.pnpm',
+  '.yarn',
+  '.pnp'
+]
+
+function getFileAndLineNumberFromError (error, repositoryRoot) {
   // Split the stack trace into individual lines
   const stackLines = error.stack.split('\n')
 
-  // The top frame is usually the second line
-  const topFrame = stackLines[1]
+  // Remove potential messages on top of the stack that are not frames
+  const frames = stackLines.filter(line => line.includes('at ') && line.includes(repositoryRoot))
+
+  const topRelevantFrameIndex = frames.findIndex(line =>
+    line.includes(repositoryRoot) && !DEPENDENCY_FOLDERS.some(pattern => line.includes(pattern))
+  )
+
+  if (topRelevantFrameIndex === -1) {
+    return []
+  }
 
+  const topFrame = frames[topRelevantFrameIndex]
   // Regular expression to match the file path, line number, and column number
   const regex = /\s*at\s+(?:.*\()?(.+):(\d+):(\d+)\)?/
   const match = topFrame.match(regex)
@@ -664,9 +685,18 @@ function getFileAndLineNumberFromError (error) {
   if (match) {
     const filePath = match[1]
     const lineNumber = Number(match[2])
-    const columnNumber = Number(match[3])
 
-    return [filePath, lineNumber, columnNumber]
+    return [filePath, lineNumber, topRelevantFrameIndex]
   }
   return []
 }
+
+function getFormattedError (error, repositoryRoot) {
+  const newError = new Error(error.message)
+  if (error.stack) {
+    newError.stack = error.stack.split('\n').filter(line => line.includes(repositoryRoot)).join('\n')
+  }
+  newError.name = error.name
+
+  return newError
+}

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

@@ -120,13 +120,18 @@ class PrioritySampler {
     if (!span || !this.validate(samplingPriority)) return
 
     const context = this._getContext(span)
+    const root = context._trace.started[0]
+
+    if (!root) {
+      log.error('Skipping the setPriority on noop span')
+      return // noop span
+    }
 
     context._sampling.priority = samplingPriority
     context._sampling.mechanism = mechanism
 
-    const root = context._trace.started[0]
-
     log.trace(span, samplingPriority, mechanism)
+
     this._addDecisionMaker(root)
   }
 

package/packages/dd-trace/src/profiling/exporters/event_serializer.js

@@ -2,6 +2,22 @@ const os = require('os')
 const perf = require('perf_hooks').performance
 const version = require('../../../../../package.json').version
 
+const libuvThreadPoolSize = (() => {
+  const ss = process.env.UV_THREADPOOL_SIZE
+  if (ss === undefined) {
+    // Backend will apply the default size based on Node version.
+    return undefined
+  }
+  // libuv uses atoi to parse the value, which is almost the same as parseInt, except that parseInt
+  // will return NaN on invalid input, while atoi will return 0. This is handled at return.
+  const s = parseInt(ss)
+  // We dont' interpret the value further here in the library. Backend will interpret the number
+  // based on Node version. In all currently known Node versions, 0 results in 1 worker thread,
+  // negative values (because they're assigned to an unsigned int) become very high positive values,
+  // and the value is finally capped at 1024.
+  return isNaN(s) ? 0 : s
+})()
+
 class EventSerializer {
   constructor ({ env, host, service, version, libraryInjected, activation } = {}) {
     this._env = env
@@ -56,11 +72,16 @@ class EventSerializer {
           version
         },
         runtime: {
+          // os.availableParallelism only available in node 18.14.0/19.4.0 and above
+          available_processors: typeof os.availableParallelism === 'function'
+            ? os.availableParallelism()
+            : os.cpus().length,
           // Using `nodejs` for consistency with the existing `runtime` tag.
           // Note that the event `family` property uses `node`, as that's what's
           // proscribed by the Intake API, but that's an internal enum and is
           // not customer visible.
           engine: 'nodejs',
+          libuv_threadpool_size: libuvThreadPoolSize,
           // strip off leading 'v'. This makes the format consistent with other
           // runtimes (e.g. Ruby) but not with the existing `runtime_version` tag.
           // We'll keep it like this as we want cross-engine consistency. We

package/packages/dd-trace/src/profiling/profiler.js

@@ -6,6 +6,7 @@ const { snapshotKinds } = require('./constants')
 const { threadNamePrefix } = require('./profilers/shared')
 const { isWebServerSpan, endpointNameFromTags, getStartedSpans } = require('./webspan-utils')
 const dc = require('dc-polyfill')
+const crashtracker = require('../crashtracking')
 
 const profileSubmittedChannel = dc.channel('datadog:profiling:profile-submitted')
 const spanFinishedChannel = dc.channel('dd-trace:span:finish')
@@ -197,15 +198,17 @@ class Profiler extends EventEmitter {
         throw new Error('No profile types configured.')
       }
 
-      // collect profiles synchronously so that profilers can be safely stopped asynchronously
-      for (const profiler of this._config.profilers) {
-        const profile = profiler.profile(restart, startDate, endDate)
-        if (!restart) {
-          this._logger.debug(`Stopped ${profiler.type} profiler in ${threadNamePrefix} thread`)
+      crashtracker.withProfilerSerializing(() => {
+        // collect profiles synchronously so that profilers can be safely stopped asynchronously
+        for (const profiler of this._config.profilers) {
+          const profile = profiler.profile(restart, startDate, endDate)
+          if (!restart) {
+            this._logger.debug(`Stopped ${profiler.type} profiler in ${threadNamePrefix} thread`)
+          }
+          if (!profile) continue
+          profiles.push({ profiler, profile })
         }
-        if (!profile) continue
-        profiles.push({ profiler, profile })
-      }
+      })
 
       if (restart) {
         this._capture(this._timeoutInterval, endDate)

package/packages/dd-trace/src/profiling/profilers/events.js

@@ -14,7 +14,23 @@ const pprofValueUnit = 'nanoseconds'
 const dateOffset = BigInt(Math.round(performance.timeOrigin * MS_TO_NS))
 
 function labelFromStr (stringTable, key, valStr) {
-  return new Label({ key, str: stringTable.dedup(valStr) })
+  return new Label({ key, str: stringTable.dedup(safeToString(valStr)) })
+}
+
+// We don't want to invoke toString for objects and functions, rather we'll
+// provide dummy values. These values are not meant to emulate built-in toString
+// behavior.
+function safeToString (val) {
+  switch (typeof val) {
+    case 'string':
+      return val
+    case 'object':
+      return '[object]'
+    case 'function':
+      return '[function]'
+    default:
+      return String(val)
+  }
 }
 
 function labelFromStrStr (stringTable, keyStr, valStr) {

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

@@ -119,7 +119,7 @@ class Tracer extends NoopProxy {
           this._flare.module.send(conf.args)
         })
 
-        if (config.dynamicInstrumentationEnabled) {
+        if (config.dynamicInstrumentation.enabled) {
           DynamicInstrumentation.start(config, rc)
         }
       }
@@ -166,7 +166,10 @@ class Tracer extends NoopProxy {
         if (config.isManualApiEnabled) {
           const TestApiManualPlugin = require('./ci-visibility/test-api-manual/test-api-manual-plugin')
           this._testApiManualPlugin = new TestApiManualPlugin(this)
-          this._testApiManualPlugin.configure({ ...config, enabled: true })
+          // `shouldGetEnvironmentData` is passed as false so that we only lazily calculate it
+          // This is the only place where we need to do this because the rest of the plugins
+          // are lazily configured when the library is imported.
+          this._testApiManualPlugin.configure({ ...config, enabled: true }, false)
         }
       }
       if (config.ciVisAgentlessLogSubmissionEnabled) {
@@ -184,7 +187,7 @@ class Tracer extends NoopProxy {
 
       if (config.isTestDynamicInstrumentationEnabled) {
         const testVisibilityDynamicInstrumentation = require('./ci-visibility/dynamic-instrumentation')
-        testVisibilityDynamicInstrumentation.start()
+        testVisibilityDynamicInstrumentation.start(config)
       }
     } catch (e) {
       log.error('Error initialising tracer', e)

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

@@ -17,7 +17,7 @@ class Scope {
     if (typeof callback !== 'function') return callback
 
     const oldStore = storage.getStore()
-    const newStore = span ? span._store : oldStore
+    const newStore = span ? storage.getStore(span._store) : oldStore
 
     storage.enterWith({ ...newStore, span })
 

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

@@ -307,6 +307,8 @@ function updateConfig (changes, config) {
   if (!config.telemetry.enabled) return
   if (changes.length === 0) return
 
+  logger.trace(changes)
+
   const application = createAppObject(config)
   const host = createHostObject()