dd-trace 5.87.0 → 5.89.0

package/packages/dd-trace/src/exporters/agentless/writer.js

@@ -0,0 +1,184 @@
+'use strict'
+
+const { getValueFromEnvSources } = require('../../config/helper')
+const log = require('../../log')
+const request = require('../common/request')
+const tracerVersion = require('../../../../../package.json').version
+
+const BaseWriter = require('../common/writer')
+const { AgentlessJSONEncoder } = require('../../encode/agentless-json')
+
+/**
+ * Writer for agentless APM span intake.
+ * Sends spans directly to the Datadog intake endpoint without an agent.
+ */
+class AgentlessWriter extends BaseWriter {
+  #apiKeyMissing = false
+
+  /**
+   * @param {object} options - Writer options
+   * @param {URL} [options.url] - The intake URL. If not provided, constructed from site.
+   * @param {string} [options.site='datadoghq.com'] - The Datadog site
+   */
+  constructor ({ url, site = 'datadoghq.com' }) {
+    super({ url })
+    this._encoder = new AgentlessJSONEncoder()
+
+    if (!url) {
+      try {
+        this._url = new URL(`https://public-trace-http-intake.logs.${site}`)
+      } catch (err) {
+        log.error(
+          'Invalid site value for agentless intake: %s. Cannot construct URL. Error: %s',
+          site,
+          err.message
+        )
+        this._url = null
+      }
+    }
+
+    if (!getValueFromEnvSources('DD_API_KEY')) {
+      this.#apiKeyMissing = true
+      log.error('DD_API_KEY is required for agentless span intake. Set DD_API_KEY. Spans will not be sent.')
+    }
+  }
+
+  /**
+   * Flushes the current trace. Since we flush after each trace, this sends
+   * a single request.
+   * @param {Function} [done] - Callback when send completes
+   */
+  flush (done = () => {}) {
+    if (!request.writable) {
+      this._encoder.reset()
+      done()
+      return
+    }
+
+    const count = this._encoder.count()
+
+    if (count === 0) {
+      done()
+      return
+    }
+
+    const payload = this._encoder.makePayload()
+
+    if (payload.length === 0) {
+      log.debug('Skipping send of empty payload')
+      done()
+      return
+    }
+
+    this._sendPayload(payload, count, done)
+  }
+
+  /**
+   * Sends the encoded payload to the intake endpoint.
+   * @param {Buffer} data - The encoded JSON payload
+   * @param {number} count - Number of spans in the payload
+   * @param {Function} done - Callback when complete
+   */
+  _sendPayload (data, count, done) {
+    if (!data || data.length === 0) {
+      log.debug('Skipping send of empty payload')
+      done()
+      return
+    }
+
+    if (!this._url) {
+      log.debug('Skipping send due to invalid URL configuration')
+      done()
+      return
+    }
+
+    const apiKey = getValueFromEnvSources('DD_API_KEY')
+    if (!apiKey) {
+      if (!this.#apiKeyMissing) {
+        this.#apiKeyMissing = true
+        log.error('DD_API_KEY is required for agentless span intake. Set DD_API_KEY. Spans will not be sent.')
+      }
+      log.debug('Dropping %d span(s) due to missing DD_API_KEY', count)
+      done()
+      return
+    }
+    this.#apiKeyMissing = false
+
+    const options = {
+      path: '/v1/input',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'dd-api-key': apiKey,
+        'Datadog-Meta-Lang': 'nodejs',
+        'Datadog-Meta-Lang-Version': process.version,
+        'Datadog-Meta-Lang-Interpreter': process.versions.bun ? 'JavaScriptCore' : 'v8',
+        'Datadog-Meta-Tracer-Version': tracerVersion,
+      },
+      timeout: 15_000,
+      url: this._url,
+    }
+
+    log.debug('Request to the agentless intake: %j', options)
+
+    request(data, options, (err, res, statusCode) => {
+      if (err) {
+        this._logRequestError(err, statusCode, count)
+        done()
+        return
+      }
+
+      log.debug('Response from the agentless intake: %s', res)
+      done()
+    })
+  }
+
+  /**
+   * Logs request errors with status-specific guidance.
+   * @param {Error} err - The error object
+   * @param {number} statusCode - HTTP status code (if available)
+   * @param {number} count - Number of spans that were being sent
+   */
+  _logRequestError (err, statusCode, count) {
+    if (statusCode === 401 || statusCode === 403) {
+      log.error(
+        'Authentication failed sending %d span(s) (status %s). Verify DD_API_KEY is valid.',
+        count,
+        statusCode
+      )
+    } else if (statusCode === 404) {
+      log.error(
+        'Span intake endpoint not found (status %s). Verify DD_SITE is correctly configured. %d span(s) dropped.',
+        statusCode,
+        count
+      )
+    } else if (statusCode === 429) {
+      log.error(
+        'Rate limited by span intake (status 429). %d span(s) dropped.',
+        count
+      )
+    } else if (statusCode >= 500) {
+      log.error(
+        'Span intake server error (status %s). %d span(s) dropped. This may be transient.',
+        statusCode,
+        count
+      )
+    } else if (statusCode) {
+      log.error(
+        'Error sending agentless payload (status %s): %s. %d span(s) dropped.',
+        statusCode,
+        err.message,
+        count
+      )
+    } else {
+      log.error(
+        'Network error sending %d span(s) to %s: %s',
+        count,
+        this._url?.hostname || 'unknown',
+        err.message
+      )
+    }
+  }
+}
+
+module.exports = AgentlessWriter

package/packages/dd-trace/src/exporters/common/request.js

@@ -88,13 +88,13 @@ function request (data, options, callback) {
           zlib.gunzip(buffer, (err, result) => {
             if (err) {
               log.error('Could not gunzip response: %s', err.message)
-              callback(null, '', res.statusCode)
+              callback(null, '', res.statusCode, res.headers)
             } else {
-              callback(null, result.toString(), res.statusCode)
+              callback(null, result.toString(), res.statusCode, res.headers)
             }
           })
         } else {
-          callback(null, buffer.toString(), res.statusCode)
+          callback(null, buffer.toString(), res.statusCode, res.headers)
         }
       } else {
         let errorMessage = ''
@@ -115,7 +115,7 @@ function request (data, options, callback) {
         const error = new log.NoTransmitError(errorMessage)
         error.status = res.statusCode
 
-        callback(error, null, res.statusCode)
+        callback(error, null, res.statusCode, res.headers)
       }
     })
   }

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

@@ -4,7 +4,7 @@ const { channel } = require('dc-polyfill')
 const BaseLLMObsPlugin = require('../base')
 const { getModelProvider } = require('../../../../../datadog-plugin-ai/src/utils')
 
-const toolCreationCh = channel('dd-trace:vercel-ai:tool')
+const toolCreationCh = channel('tracing:orchestrion:ai:tool:start')
 const setAttributesCh = channel('dd-trace:vercel-ai:span:setAttributes')
 
 const { MODEL_NAME, MODEL_PROVIDER, NAME } = require('../../constants/tags')
@@ -94,8 +94,10 @@ class VercelAILLMObsPlugin extends BaseLLMObsPlugin {
 
     this.#toolCallIdsToName = {}
     this.#availableTools = new Set()
-    toolCreationCh.subscribe(toolArgs => {
-      this.#availableTools.add(toolArgs)
+    toolCreationCh.subscribe(ctx => {
+      const toolArgs = ctx.arguments
+      const tool = toolArgs[0] ?? {}
+      this.#availableTools.add(tool)
     })
 
     setAttributesCh.subscribe(({ ctx, attributes }) => {

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

@@ -2,6 +2,7 @@
 
 const { trace, ROOT_CONTEXT, propagation } = require('@opentelemetry/api')
 const { storage } = require('../../../datadog-core')
+const { getAllBaggageItems, setBaggageItem, removeAllBaggageItems } = require('../baggage')
 
 const tracer = require('../../')
 const SpanContext = require('./span_context')
@@ -19,31 +20,26 @@ class ContextManager {
 
     const storedSpan = store ? trace.getSpan(store) : null
 
+    // Convert DD baggage to OTel format
+    const baggages = getAllBaggageItems()
+    const hasBaggage = Object.keys(baggages).length > 0
+    let otelBaggages
+    if (hasBaggage) {
+      const entries = {}
+      for (const [key, value] of Object.entries(baggages)) {
+        entries[key] = { value }
+      }
+      otelBaggages = propagation.createBaggage(entries)
+    }
+
     // If stored span wraps the active DD span, prefer the stored context
     if (storedSpan && storedSpan._ddSpan === activeSpan) {
-      const baggages = JSON.parse(activeSpan.getAllBaggageItems())
-      if (Object.keys(baggages).length > 0) {
-        const entries = {}
-        for (const [key, value] of Object.entries(baggages)) {
-          entries[key] = { value }
-        }
-        const otelBaggages = propagation.createBaggage(entries)
-        return propagation.setBaggage(store, otelBaggages)
-      }
+      if (otelBaggages) return propagation.setBaggage(store, otelBaggages)
       return store
     }
 
     if (!activeSpan) {
-      const storedBaggageItems = storedSpan?._spanContext?._ddContext?._baggageItems
-      if (storedBaggageItems) {
-        const baggages = storedBaggageItems
-        const entries = {}
-        for (const [key, value] of Object.entries(baggages)) {
-          entries[key] = { value }
-        }
-        const otelBaggages = propagation.createBaggage(entries)
-        return propagation.setBaggage(baseContext, otelBaggages)
-      }
+      if (otelBaggages) return propagation.setBaggage(baseContext, otelBaggages)
       return baseContext
     }
 
@@ -53,18 +49,6 @@ class ContextManager {
       ddContext._otelSpanContext = new SpanContext(ddContext)
     }
 
-    // Convert DD baggage to OTel format
-    const baggages = JSON.parse(activeSpan.getAllBaggageItems())
-    const hasBaggage = Object.keys(baggages).length > 0
-    let otelBaggages
-    if (hasBaggage) {
-      const entries = {}
-      for (const [key, value] of Object.entries(baggages)) {
-        entries[key] = { value }
-      }
-      otelBaggages = propagation.createBaggage(entries)
-    }
-
     if (store && trace.getSpanContext(store) === ddContext._otelSpanContext) {
       return otelBaggages ? propagation.setBaggage(store, otelBaggages) : store
     }
@@ -86,22 +70,11 @@ class ContextManager {
     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
-    const ddContext = span?._spanContext?._ddContext
-    if (ddContext && ddContext._baggageItems) {
-      ddContext._baggageItems = {}
-      for (const baggage of baggageItems) {
-        ddContext._baggageItems[baggage[0]] = baggage[1].value
-      }
+    removeAllBaggageItems()
+    for (const baggage of baggageItems) {
+      setBaggageItem(baggage[0], baggage[1].value)
     }
+    if (span && span._ddSpan) return ddScope.activate(span._ddSpan, run)
     return run()
   }
 

package/packages/dd-trace/src/opentelemetry/otlp/otlp_http_exporter_base.js

@@ -20,7 +20,7 @@ class OtlpHttpExporterBase {
    * Creates a new OtlpHttpExporterBase instance.
    *
    * @param {string} url - OTLP endpoint URL
-   * @param {string} headers - Additional HTTP headers as comma-separated key=value string
+   * @param {string|undefined} headers - Additional HTTP headers as comma-separated key=value string
    * @param {number} timeout - Request timeout in milliseconds
    * @param {string} protocol - OTLP protocol (http/protobuf or http/json)
    * @param {string} defaultPath - Default path to use if URL has no path
@@ -117,11 +117,10 @@ class OtlpHttpExporterBase {
 
   /**
    * Parses additional HTTP headers from a comma-separated string.
-   * @param {string} headersString - Comma-separated key=value pairs
+   * @param {string} [headersString=''] - Comma-separated key=value pairs
    * @returns {Record<string, string>} Parsed headers object
-   * @private
    */
-  #parseAdditionalHeaders (headersString) {
+  #parseAdditionalHeaders (headersString = '') {
     const headers = {}
     let key = ''
     let value = ''

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

@@ -670,10 +670,8 @@ class TextMapPropagator {
     if (!this._hasPropagationStyle('extract', 'baggage')) return
     if (!carrier?.baggage) return
     const baggages = carrier.baggage.split(',')
-    const tagAllKeys = this._config.baggageTagKeys === '*'
-    const keysToSpanTag = tagAllKeys
-      ? undefined
-      : new Set(this._config.baggageTagKeys.split(','))
+    const baggageTagKeys = new Set(this._config.baggageTagKeys)
+    const tagAllKeys = baggageTagKeys.has('*')
     for (const keyValue of baggages) {
       if (!keyValue) continue
 
@@ -707,7 +705,7 @@ class TextMapPropagator {
         return
       }
 
-      if (spanContext && (tagAllKeys || keysToSpanTag?.has(key))) {
+      if (spanContext && (tagAllKeys || baggageTagKeys.has(key))) {
         spanContext._trace.tags['baggage.' + key] = value
       }
       setBaggageItem(key, value)

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

@@ -3,7 +3,6 @@
 // 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 dateNow = Date.now
 const util = require('util')
 const { channel } = require('dc-polyfill')
 const id = require('../id')
@@ -13,12 +12,15 @@ 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 = getValueFromEnvSources('DD_TRACE_EXPERIMENTAL_STATE_TRACKING')
-const DD_TRACE_EXPERIMENTAL_SPAN_COUNTS = getValueFromEnvSources('DD_TRACE_EXPERIMENTAL_SPAN_COUNTS')
+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')
@@ -251,7 +253,7 @@ class DatadogSpan {
       return
     }
 
-    if (DD_TRACE_EXPERIMENTAL_STATE_TRACKING === 'true' && !this._spanContext._tags['service.name']) {
+    if (DD_TRACE_EXPERIMENTAL_STATE_TRACKING && !this._spanContext._tags['service.name']) {
       log.error('Finishing invalid span: %s', this)
     }
 

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

@@ -23,7 +23,7 @@ function findPkg () {
   if (filePath === undefined) return {}
 
   try {
-    return require(filePath)
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'))
   } catch {
     return {}
   }

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

@@ -63,6 +63,8 @@ const {
   getPullRequestDiff,
   getModifiedFilesFromDiff,
   getPullRequestBaseBranch,
+  getSessionRequestErrorTags,
+  DD_CI_LIBRARY_CONFIGURATION_ERROR,
   TEST_IS_TEST_FRAMEWORK_WORKER,
   TEST_IS_NEW,
   TEST_IS_RUM_ACTIVE,
@@ -120,6 +122,7 @@ module.exports = class CiPlugin extends Plugin {
     this.fileLineToProbeId = new Map()
     this.rootDir = process.cwd() // fallback in case :session:start events are not emitted
     this._testSuiteSpansByTestSuite = new Map()
+    this._pendingRequestErrorTags = []
 
     this.addSub(`ci:${this.constructor.id}:library-configuration`, (ctx) => {
       const { onDone, isParallel, frameworkVersion } = ctx
@@ -131,10 +134,15 @@ module.exports = class CiPlugin extends Plugin {
       this.tracer._exporter.getLibraryConfiguration(this.testConfiguration, (err, libraryConfig) => {
         if (err) {
           log.error('Library configuration could not be fetched. %s', err.message)
+          this._addRequestErrorTag(DD_CI_LIBRARY_CONFIGURATION_ERROR, err)
         } else {
           this.libraryConfig = libraryConfig
         }
 
+        const requestErrorTags = this.testSessionSpan
+          ? getSessionRequestErrorTags(this.testSessionSpan)
+          : Object.fromEntries(this._pendingRequestErrorTags.map(({ tag, value }) => [tag, value]))
+
         const libraryCapabilitiesTags = getLibraryCapabilitiesTags(this.constructor.id, isParallel, frameworkVersion)
         const metadataTags = {
           test: {
@@ -142,7 +150,7 @@ module.exports = class CiPlugin extends Plugin {
           },
         }
         this.tracer._exporter.addMetadataTags(metadataTags)
-        onDone({ err, libraryConfig })
+        onDone({ err, libraryConfig, requestErrorTags })
       })
     })
 
@@ -200,6 +208,10 @@ module.exports = class CiPlugin extends Plugin {
         },
         integrationName: this.constructor.id,
       })
+      for (const { tag, value } of this._pendingRequestErrorTags) {
+        this.testSessionSpan.setTag(tag, value)
+      }
+      this._pendingRequestErrorTags = []
       // TODO: add telemetry tag when we can add `is_agentless_log_submission_enabled` for agentless log submission
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_CREATED, 'session')
 
@@ -209,6 +221,7 @@ module.exports = class CiPlugin extends Plugin {
           [COMPONENT]: this.constructor.id,
           ...this.testEnvironmentMetadata,
           ...testModuleSpanMetadata,
+          ...getSessionRequestErrorTags(this.testSessionSpan),
         },
         integrationName: this.constructor.id,
       })
@@ -230,7 +243,10 @@ module.exports = class CiPlugin extends Plugin {
     this.addSub(`ci:${this.constructor.id}:itr:skipped-suites`, ({ skippedSuites, frameworkVersion }) => {
       const testCommand = this.testSessionSpan.context()._tags[TEST_COMMAND]
       for (const testSuite of skippedSuites) {
-        const testSuiteMetadata = getTestSuiteCommonTags(testCommand, frameworkVersion, testSuite, this.constructor.id)
+        const testSuiteMetadata = {
+          ...getTestSuiteCommonTags(testCommand, frameworkVersion, testSuite, this.constructor.id),
+          ...getSessionRequestErrorTags(this.testSessionSpan),
+        }
         if (this.itrCorrelationId) {
           testSuiteMetadata[ITR_CORRELATION_ID] = this.itrCorrelationId
         }
@@ -261,8 +277,10 @@ module.exports = class CiPlugin extends Plugin {
       this.tracer._exporter.getKnownTests(this.testConfiguration, (err, knownTests) => {
         if (err) {
           log.error('Known tests could not be fetched. %s', err.message)
-          this.libraryConfig.isEarlyFlakeDetectionEnabled = false
-          this.libraryConfig.isKnownTestsEnabled = false
+          if (this.libraryConfig) {
+            this.libraryConfig.isEarlyFlakeDetectionEnabled = false
+            this.libraryConfig.isKnownTestsEnabled = false
+          }
         }
         onDone({ err, knownTests })
       })
@@ -279,7 +297,9 @@ module.exports = class CiPlugin extends Plugin {
       this.tracer._exporter.getTestManagementTests(this.testConfiguration, (err, testManagementTests) => {
         if (err) {
           log.error('Test management tests could not be fetched. %s', err.message)
-          this.libraryConfig.isTestManagementEnabled = false
+          if (this.libraryConfig) {
+            this.libraryConfig.isTestManagementEnabled = false
+          }
         }
         onDone({ err, testManagementTests })
       })
@@ -346,8 +366,15 @@ module.exports = class CiPlugin extends Plugin {
             span.meta = {
               ...span.meta,
               ...testSuiteTags,
+              ...getSessionRequestErrorTags(this.testSessionSpan),
             }
           }
+
+          // Jest and Vitest worker test spans are serialized in the worker and may not include
+          // request error tags; add them from the session span in the main process.
+          if ((span.name === 'jest.test' || span.name === 'vitest.test') && this.testSessionSpan) {
+            Object.assign(span.meta, getSessionRequestErrorTags(this.testSessionSpan))
+          }
         }
         this.tracer._exporter.export(trace)
       }
@@ -418,6 +445,30 @@ module.exports = class CiPlugin extends Plugin {
     }
   }
 
+  /**
+   * Adds a hidden _dd tag to the test session span when a test-optimization request fails.
+   * If the session span does not exist yet (e.g. library-configuration failed before session:start),
+   * the tag is queued and applied when the span is created.
+   * @param {string} tag - Tag name (e.g. DD_CI_LIBRARY_CONFIGURATION_ERROR)
+   * @param {Error} err - Request error
+   */
+  _addRequestErrorTag (tag, err) {
+    const value = 'true'
+    if (this.testSessionSpan) {
+      this.testSessionSpan.setTag(tag, value)
+    } else {
+      this._pendingRequestErrorTags.push({ tag, value })
+    }
+  }
+
+  /**
+   * Returns request error tags from the test session span for propagation to module, suite and test spans.
+   * @returns {Record<string, string>}
+   */
+  getSessionRequestErrorTags () {
+    return getSessionRequestErrorTags(this.testSessionSpan)
+  }
+
   configure (config, shouldGetEnvironmentData = true) {
     super.configure(config)
 
@@ -529,6 +580,7 @@ module.exports = class CiPlugin extends Plugin {
         [TEST_SESSION_ID]: testSuiteSpan.context().toTraceId(),
         [TEST_COMMAND]: testSuiteSpan.context()._tags[TEST_COMMAND],
         [TEST_MODULE]: this.constructor.id,
+        ...getSessionRequestErrorTags(this.testSessionSpan),
       }
       if (testSuiteSpan.context()._parentId) {
         suiteTags[TEST_MODULE_ID] = testSuiteSpan.context()._parentId.toString(10)

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

@@ -1,6 +1,7 @@
 'use strict'
 
 const { PEER_SERVICE_KEY, PEER_SERVICE_SOURCE_KEY } = require('../constants')
+const propagationHash = require('../propagation-hash')
 const StoragePlugin = require('./storage')
 
 class DatabasePlugin extends StoragePlugin {
@@ -59,13 +60,25 @@ class DatabasePlugin extends StoragePlugin {
     const dbmService = this.#getDbmServiceName(serviceName, peerData)
     const servicePropagation = this.#createDBMPropagationCommentService(dbmService, span, peerData)
 
+    let dbmComment = servicePropagation
+
+    // Add propagation hash if both process tags and SQL base hash injection are enabled
+    if (propagationHash.isEnabled() && this.config['dbm.injectSqlBaseHash']) {
+      const hashBase64 = propagationHash.getHashBase64()
+      if (hashBase64) {
+        dbmComment += `,ddsh='${hashBase64}'`
+        // Add hash to span meta as a tag
+        span.setTag('_dd.dbm.propagation_hash', hashBase64)
+      }
+    }
+
     if (disableFullMode || mode === 'service') {
-      return servicePropagation
+      return dbmComment
     } else if (mode === 'full') {
       span.setTag('_dd.dbm_trace_injected', 'true')
       span._processor.sample(span)
       const traceparent = span._spanContext.toTraceparent()
-      return `${servicePropagation},traceparent='${traceparent}'`
+      return `${dbmComment},traceparent='${traceparent}'`
     }
   }