dd-trace 5.24.0 → 5.25.0

package/packages/dd-trace/src/llmobs/writers/base.js

@@ -0,0 +1,111 @@
+'use strict'
+
+const request = require('../../exporters/common/request')
+const { URL, format } = require('url')
+
+const logger = require('../../log')
+
+const { encodeUnicode } = require('../util')
+const log = require('../../log')
+
+class BaseLLMObsWriter {
+  constructor ({ interval, timeout, endpoint, intake, eventType, protocol, port }) {
+    this._interval = interval || 1000 // 1s
+    this._timeout = timeout || 5000 // 5s
+    this._eventType = eventType
+
+    this._buffer = []
+    this._bufferLimit = 1000
+    this._bufferSize = 0
+
+    this._url = new URL(format({
+      protocol: protocol || 'https:',
+      hostname: intake,
+      port: port || 443,
+      pathname: endpoint
+    }))
+
+    this._headers = {
+      'Content-Type': 'application/json'
+    }
+
+    this._periodic = setInterval(() => {
+      this.flush()
+    }, this._interval).unref()
+
+    process.once('beforeExit', () => {
+      this.destroy()
+    })
+
+    this._destroyed = false
+
+    logger.debug(`Started ${this.constructor.name} to ${this._url}`)
+  }
+
+  append (event, byteLength) {
+    if (this._buffer.length >= this._bufferLimit) {
+      logger.warn(`${this.constructor.name} event buffer full (limit is ${this._bufferLimit}), dropping event`)
+      return
+    }
+
+    this._bufferSize += byteLength || Buffer.from(JSON.stringify(event)).byteLength
+    this._buffer.push(event)
+  }
+
+  flush () {
+    if (this._buffer.length === 0) {
+      return
+    }
+
+    const events = this._buffer
+    this._buffer = []
+    this._bufferSize = 0
+    const payload = this._encode(this.makePayload(events))
+
+    const options = {
+      headers: this._headers,
+      method: 'POST',
+      url: this._url,
+      timeout: this._timeout
+    }
+
+    log.debug(`Encoded LLMObs payload: ${payload}`)
+
+    request(payload, options, (err, resp, code) => {
+      if (err) {
+        logger.error(
+          `Error sending ${events.length} LLMObs ${this._eventType} events to ${this._url}: ${err.message}`
+        )
+      } else if (code >= 300) {
+        logger.error(
+          `Error sending ${events.length} LLMObs ${this._eventType} events to ${this._url}: ${code}`
+        )
+      } else {
+        logger.debug(`Sent ${events.length} LLMObs ${this._eventType} events to ${this._url}`)
+      }
+    })
+  }
+
+  makePayload (events) {}
+
+  destroy () {
+    if (!this._destroyed) {
+      logger.debug(`Stopping ${this.constructor.name}`)
+      clearInterval(this._periodic)
+      process.removeListener('beforeExit', this.destroy)
+      this.flush()
+      this._destroyed = true
+    }
+  }
+
+  _encode (payload) {
+    return JSON.stringify(payload, (key, value) => {
+      if (typeof value === 'string') {
+        return encodeUnicode(value) // serialize unicode characters
+      }
+      return value
+    }).replace(/\\\\u/g, '\\u') // remove double escaping
+  }
+}
+
+module.exports = BaseLLMObsWriter

package/packages/dd-trace/src/llmobs/writers/evaluations.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const { AGENTLESS_EVALULATIONS_ENDPOINT } = require('../constants/writers')
+const BaseWriter = require('./base')
+
+class LLMObsEvalMetricsWriter extends BaseWriter {
+  constructor (config) {
+    super({
+      endpoint: AGENTLESS_EVALULATIONS_ENDPOINT,
+      intake: `api.${config.site}`,
+      eventType: 'evaluation_metric'
+    })
+
+    this._headers['DD-API-KEY'] = config.apiKey
+  }
+
+  makePayload (events) {
+    return {
+      data: {
+        type: this._eventType,
+        attributes: {
+          metrics: events
+        }
+      }
+    }
+  }
+}
+
+module.exports = LLMObsEvalMetricsWriter

package/packages/dd-trace/src/llmobs/writers/spans/agentProxy.js

@@ -0,0 +1,23 @@
+'use strict'
+
+const {
+  EVP_SUBDOMAIN_HEADER_NAME,
+  EVP_SUBDOMAIN_HEADER_VALUE,
+  EVP_PROXY_AGENT_ENDPOINT
+} = require('../../constants/writers')
+const LLMObsBaseSpanWriter = require('./base')
+
+class LLMObsAgentProxySpanWriter extends LLMObsBaseSpanWriter {
+  constructor (config) {
+    super({
+      intake: config.hostname || 'localhost',
+      protocol: 'http:',
+      endpoint: EVP_PROXY_AGENT_ENDPOINT,
+      port: config.port
+    })
+
+    this._headers[EVP_SUBDOMAIN_HEADER_NAME] = EVP_SUBDOMAIN_HEADER_VALUE
+  }
+}
+
+module.exports = LLMObsAgentProxySpanWriter

package/packages/dd-trace/src/llmobs/writers/spans/agentless.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const { AGENTLESS_SPANS_ENDPOINT } = require('../../constants/writers')
+const LLMObsBaseSpanWriter = require('./base')
+
+class LLMObsAgentlessSpanWriter extends LLMObsBaseSpanWriter {
+  constructor (config) {
+    super({
+      intake: `llmobs-intake.${config.site}`,
+      endpoint: AGENTLESS_SPANS_ENDPOINT
+    })
+
+    this._headers['DD-API-KEY'] = config.apiKey
+  }
+}
+
+module.exports = LLMObsAgentlessSpanWriter

package/packages/dd-trace/src/llmobs/writers/spans/base.js

@@ -0,0 +1,49 @@
+'use strict'
+
+const { EVP_EVENT_SIZE_LIMIT, EVP_PAYLOAD_SIZE_LIMIT } = require('../../constants/writers')
+const { DROPPED_VALUE_TEXT } = require('../../constants/text')
+const { DROPPED_IO_COLLECTION_ERROR } = require('../../constants/tags')
+const BaseWriter = require('../base')
+const logger = require('../../../log')
+
+class LLMObsSpanWriter extends BaseWriter {
+  constructor (options) {
+    super({
+      ...options,
+      eventType: 'span'
+    })
+  }
+
+  append (event) {
+    const eventSizeBytes = Buffer.from(JSON.stringify(event)).byteLength
+    if (eventSizeBytes > EVP_EVENT_SIZE_LIMIT) {
+      logger.warn(`Dropping event input/output because its size (${eventSizeBytes}) exceeds the 1MB event size limit`)
+      event = this._truncateSpanEvent(event)
+    }
+
+    if (this._bufferSize + eventSizeBytes > EVP_PAYLOAD_SIZE_LIMIT) {
+      logger.debug('Flusing queue because queing next event will exceed EvP payload limit')
+      this.flush()
+    }
+
+    super.append(event, eventSizeBytes)
+  }
+
+  makePayload (events) {
+    return {
+      '_dd.stage': 'raw',
+      event_type: this._eventType,
+      spans: events
+    }
+  }
+
+  _truncateSpanEvent (event) {
+    event.meta.input = { value: DROPPED_VALUE_TEXT }
+    event.meta.output = { value: DROPPED_VALUE_TEXT }
+
+    event.collection_errors = [DROPPED_IO_COLLECTION_ERROR]
+    return event
+  }
+}
+
+module.exports = LLMObsSpanWriter

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

@@ -3,16 +3,19 @@
 const NoopTracer = require('./tracer')
 const NoopAppsecSdk = require('../appsec/sdk/noop')
 const NoopDogStatsDClient = require('./dogstatsd')
+const NoopLLMObsSDK = require('../llmobs/noop')
 
 const noop = new NoopTracer()
 const noopAppsec = new NoopAppsecSdk()
 const noopDogStatsDClient = new NoopDogStatsDClient()
+const noopLLMObs = new NoopLLMObsSDK(noop)
 
 class Tracer {
   constructor () {
     this._tracer = noop
     this.appsec = noopAppsec
     this.dogstatsd = noopDogStatsDClient
+    this.llmobs = noopLLMObs
   }
 
   init () {

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

@@ -16,6 +16,9 @@ class NoopSpan {
   setOperationName (name) { return this }
   setBaggageItem (key, value) { return this }
   getBaggageItem (key) {}
+  getAllBaggageItems () {}
+  removeBaggageItem (key) { return this }
+  removeAllBaggageItems () { return this }
   setTag (key, value) { return this }
   addTags (keyValueMap) { return this }
   addLink (link) { return this }

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

@@ -142,7 +142,7 @@ class Span {
       context: spanContext._ddContext,
       startTime,
       hostname: _tracer._hostname,
-      integrationName: 'otel',
+      integrationName: parentTracer?._isOtelLibrary ? 'otel.library' : 'otel',
       tags: {
         [SERVICE_NAME]: _tracer._service,
         [RESOURCE_NAME]: spanName

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

@@ -16,6 +16,7 @@ class Tracer {
     this._tracerProvider = tracerProvider
     // Is there a reason this is public?
     this.instrumentationLibrary = library
+    this._isOtelLibrary = library?.name?.startsWith('@opentelemetry/instrumentation-')
     this._spanLimits = {}
   }
 

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

@@ -53,6 +53,8 @@ class TextMapPropagator {
   }
 
   inject (spanContext, carrier) {
+    if (!spanContext || !carrier) return
+
     this._injectBaggageItems(spanContext, carrier)
     this._injectDatadog(spanContext, carrier)
     this._injectB3MultipleHeaders(spanContext, carrier)
@@ -107,10 +109,35 @@ class TextMapPropagator {
     }
   }
 
+  _encodeOtelBaggageKey (key) {
+    let encoded = encodeURIComponent(key)
+    encoded = encoded.replaceAll('(', '%28')
+    encoded = encoded.replaceAll(')', '%29')
+    return encoded
+  }
+
   _injectBaggageItems (spanContext, carrier) {
-    spanContext._baggageItems && Object.keys(spanContext._baggageItems).forEach(key => {
-      carrier[baggagePrefix + key] = String(spanContext._baggageItems[key])
-    })
+    if (this._config.legacyBaggageEnabled) {
+      spanContext._baggageItems && Object.keys(spanContext._baggageItems).forEach(key => {
+        carrier[baggagePrefix + key] = String(spanContext._baggageItems[key])
+      })
+    }
+    if (this._hasPropagationStyle('inject', 'baggage')) {
+      let baggage = ''
+      let itemCounter = 0
+      let byteCounter = 0
+
+      for (const [key, value] of Object.entries(spanContext._baggageItems)) {
+        const item = `${this._encodeOtelBaggageKey(String(key).trim())}=${encodeURIComponent(String(value).trim())},`
+        itemCounter += 1
+        byteCounter += item.length
+        if (itemCounter > this._config.baggageMaxItems || byteCounter > this._config.baggageMaxBytes) break
+        baggage += item
+      }
+
+      baggage = baggage.slice(0, baggage.length - 1)
+      if (baggage) carrier.baggage = baggage
+    }
   }
 
   _injectTags (spanContext, carrier) {
@@ -299,6 +326,11 @@ class TextMapPropagator {
         default:
           log.warn(`Unknown propagation style: ${extractor}`)
       }
+
+      if (this._config.tracePropagationStyle.extract.includes('baggage') && carrier.baggage) {
+        spanContext = spanContext || new DatadogSpanContext()
+        this._extractBaggageItems(carrier, spanContext)
+      }
     }
 
     return spanContext || this._extractSqsdContext(carrier)
@@ -310,7 +342,7 @@ class TextMapPropagator {
     if (!spanContext) return spanContext
 
     this._extractOrigin(carrier, spanContext)
-    this._extractBaggageItems(carrier, spanContext)
+    this._extractLegacyBaggageItems(carrier, spanContext)
     this._extractSamplingPriority(carrier, spanContext)
     this._extractTags(carrier, spanContext)
 
@@ -383,7 +415,7 @@ class TextMapPropagator {
       return null
     }
     const matches = headerValue.trim().match(traceparentExpr)
-    if (matches.length) {
+    if (matches?.length) {
       const [version, traceId, spanId, flags, tail] = matches.slice(1)
       const traceparent = { version }
       const tracestate = TraceState.fromString(carrier.tracestate)
@@ -444,7 +476,7 @@ class TextMapPropagator {
         }
       })
 
-      this._extractBaggageItems(carrier, spanContext)
+      this._extractLegacyBaggageItems(carrier, spanContext)
       return spanContext
     }
     return null
@@ -528,14 +560,43 @@ class TextMapPropagator {
     }
   }
 
-  _extractBaggageItems (carrier, spanContext) {
-    Object.keys(carrier).forEach(key => {
-      const match = key.match(baggageExpr)
+  _decodeOtelBaggageKey (key) {
+    let decoded = decodeURIComponent(key)
+    decoded = decoded.replaceAll('%28', '(')
+    decoded = decoded.replaceAll('%29', ')')
+    return decoded
+  }
 
-      if (match) {
-        spanContext._baggageItems[match[1]] = carrier[key]
+  _extractLegacyBaggageItems (carrier, spanContext) {
+    if (this._config.legacyBaggageEnabled) {
+      Object.keys(carrier).forEach(key => {
+        const match = key.match(baggageExpr)
+
+        if (match) {
+          spanContext._baggageItems[match[1]] = carrier[key]
+        }
+      })
+    }
+  }
+
+  _extractBaggageItems (carrier, spanContext) {
+    const baggages = carrier.baggage.split(',')
+    for (const keyValue of baggages) {
+      if (!keyValue.includes('=')) {
+        spanContext._baggageItems = {}
+        return
       }
-    })
+      let [key, value] = keyValue.split('=')
+      key = this._decodeOtelBaggageKey(key.trim())
+      value = decodeURIComponent(value.trim())
+      if (!key || !value) {
+        spanContext._baggageItems = {}
+        return
+      }
+      // the current code assumes precedence of ot-baggage- (legacy opentracing baggage) over baggage
+      if (key in spanContext._baggageItems) return
+      spanContext._baggageItems[key] = value
+    }
   }
 
   _extractSamplingPriority (carrier, spanContext) {

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

@@ -145,6 +145,18 @@ class DatadogSpan {
     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

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

@@ -52,8 +52,15 @@ class DatadogTracer {
       ? getContext(options.childOf)
       : getParent(options.references)
 
+    // as per spec, allow the setting of service name through options
     const tags = {
-      'service.name': this._service
+      'service.name': options?.tags?.service ? String(options.tags.service) : this._service
+    }
+
+    // As per unified service tagging spec if a span is created with a service name different from the global
+    // service name it will not inherit the global version value
+    if (options?.tags?.service && options.tags.service !== this._service) {
+      options.tags.version = undefined
     }
 
     const span = new Span(this, this._processor, this._prioritySampler, {

package/packages/dd-trace/src/payload-tagging/config/aws.json

@@ -17,14 +17,82 @@
       "$.Attributes.Token",
       "$.Endpoints.*.Token",
       "$.PhoneNumber",
-      "$.PhoneNumbers",
-      "$.phoneNumbers",
       "$.PlatformApplication.*.PlatformCredential",
       "$.PlatformApplication.*.PlatformPrincipal",
-      "$.Subscriptions.*.Endpoint"
+      "$.Subscriptions.*.Endpoint",
+      "$.PhoneNumbers[*].PhoneNumber",
+      "$.phoneNumbers[*]"
     ],
     "expand": [
       "$.MessageAttributes.*.StringValue"
     ]
+  },
+  "eventbridge": {
+    "request": [
+      "$.AuthParameters.OAuthParameters.OAuthHttpParameters.HeaderParameters[*].Value",
+      "$.AuthParameters.OAuthParameters.OAuthHttpParameters.QueryStringParameters[*].Value",
+      "$.AuthParameters.OAuthParameters.OAuthHttpParameters.BodyParameters[*].Value",
+      "$.AuthParameters.InvocationHttpParameters.HeaderParameters[*].Value",
+      "$.AuthParameters.InvocationHttpParameters.QueryStringParameters[*].Value",
+      "$.AuthParameters.InvocationHttpParameters.BodyParameters[*].Value",
+      "$.Targets[*].RedshiftDataParameters.Sql",
+      "$.Targets[*].RedshiftDataParameters.Sqls",
+      "$.Targets[*].AppSyncParameters.GraphQLOperation",
+      "$.AuthParameters.BasicAuthParameters.Password",
+      "$.AuthParameters.OAuthParameters.ClientParameters.ClientSecret",
+      "$.AuthParameters.ApiKeyAuthParameters.ApiKeyValue"
+    ],
+    "response": [
+      "$.AuthParameters.OAuthParameters.OAuthHttpParameters.HeaderParameters[*].Value",
+      "$.AuthParameters.OAuthParameters.OAuthHttpParameters.QueryStringParameters[*].Value",
+      "$.AuthParameters.OAuthParameters.OAuthHttpParameters.BodyParameters[*].Value",
+      "$.AuthParameters.InvocationHttpParameters.HeaderParameters[*].Value",
+      "$.AuthParameters.InvocationHttpParameters.QueryStringParameters[*].Value",
+      "$.AuthParameters.InvocationHttpParameters.BodyParameters[*].Value",
+      "$.Targets[*].RedshiftDataParameters.Sql",
+      "$.Targets[*].RedshiftDataParameters.Sqls",
+      "$.Targets[*].AppSyncParameters.GraphQLOperation"
+    ],
+    "expand": [
+    ]
+  },
+  "s3": {
+    "request": [
+      "$.SSEKMSKeyId",
+      "$.SSEKMSEncryptionContext",
+      "$.ServerSideEncryptionConfiguration.Rules[*].ApplyServerSideEncryptionByDefault.KMSMasterKeyID",
+      "$.InventoryConfiguration.Destination.S3BucketDestination.Encryption.SSEKMS.KeyId",
+      "$.SSECustomerKey",
+      "$.CopySourceSSECustomerKey",
+      "$.RestoreRequest.OutputLocation.S3.Encryption.KMSKeyId"
+
+    ],
+    "response": [
+      "$.SSEKMSKeyId",
+      "$.SSEKMSEncryptionContext",
+      "$.ServerSideEncryptionConfiguration.Rules[*].ApplyServerSideEncryptionByDefault.KMSMasterKeyID",
+      "$.InventoryConfiguration.Destination.S3BucketDestination.Encryption.SSEKMS.KeyId",
+      "$.Credentials.SecretAccessKey",
+      "$.Credentials.SessionToken",
+      "$.InventoryConfigurationList[*].Destination.S3BucketDestination.Encryption.SSEKMS.KeyId"
+    ],
+    "expand": [
+    ]
+  },
+  "sqs": {
+    "request": [
+    ],
+    "response": [
+    ],
+    "expand": [
+    ]
+  },
+  "kinesis": {
+    "request": [
+    ],
+    "response": [
+    ],
+    "expand": [
+    ]
   }
 }

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

@@ -7,6 +7,7 @@ const {
   PEER_SERVICE_REMAP_KEY
 } = require('../constants')
 const TracingPlugin = require('./tracing')
+const { exitTags } = require('../../../datadog-code-origin')
 
 const COMMON_PEER_SVC_SOURCE_TAGS = [
   'net.peer.name',
@@ -25,6 +26,14 @@ class OutboundPlugin extends TracingPlugin {
     })
   }
 
+  startSpan (...args) {
+    const span = super.startSpan(...args)
+    if (this._tracerConfig.codeOriginForSpans.enabled) {
+      span.addTags(exitTags(this.startSpan))
+    }
+    return span
+  }
+
   getPeerService (tags) {
     /**
      * Compute `peer.service` and associated metadata from available tags, based

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

@@ -108,6 +108,18 @@ class PrioritySampler {
     }
   }
 
+  setPriority (span, samplingPriority, mechanism = SAMPLING_MECHANISM_MANUAL) {
+    if (!span || !this.validate(samplingPriority)) return
+
+    const context = this._getContext(span)
+
+    context._sampling.priority = samplingPriority
+    context._sampling.mechanism = mechanism
+
+    const root = context._trace.started[0]
+    this._addDecisionMaker(root)
+  }
+
   _getContext (span) {
     return typeof span.context === 'function' ? span.context() : span
   }
@@ -201,6 +213,10 @@ class PrioritySampler {
       if (rule.match(span)) return rule
     }
   }
+
+  static keepTrace (span, mechanism) {
+    span?._prioritySampler?.setPriority(span, USER_KEEP, mechanism)
+  }
 }
 
 module.exports = PrioritySampler

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

@@ -14,6 +14,7 @@ const { oomExportStrategies, snapshotKinds } = require('./constants')
 const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../plugins/util/tags')
 const { tagger } = require('./tagger')
 const { isFalse, isTrue } = require('../util')
+const { getAzureTagsFromMetadata, getAzureAppMetadata } = require('../azure_metadata')
 
 class Config {
   constructor (options = {}) {
@@ -71,7 +72,8 @@ class Config {
     this.tags = Object.assign(
       tagger.parse(DD_TAGS),
       tagger.parse(options.tags),
-      tagger.parse({ env, host, service, version, functionname })
+      tagger.parse({ env, host, service, version, functionname }),
+      getAzureTagsFromMetadata(getAzureAppMetadata())
     )
 
     // Add source code integration tags if available

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

@@ -195,11 +195,13 @@ class AgentExporter {
         })
 
         sendRequest(options, form, (err, response) => {
-          if (operation.retry(err)) {
-            this._logger.error(`Error from the agent: ${err.message}`)
-            return
-          } else if (err) {
-            reject(err)
+          if (err) {
+            const { status } = err
+            if ((typeof status !== 'number' || status >= 500 || status === 429) && operation.retry(err)) {
+              this._logger.error(`Error from the agent: ${err.message}`)
+            } else {
+              reject(err)
+            }
             return
           }
 

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

@@ -301,7 +301,8 @@ class NativeWallProfiler {
 
     const labels = { ...getThreadLabels() }
 
-    const { context: { ref: { spanId, rootSpanId, webTags, endpoint } }, timestamp } = context
+    const { context: { ref }, timestamp } = context
+    const { spanId, rootSpanId, webTags, endpoint } = ref ?? {}
 
     if (this._timelineEnabled) {
       // Incoming timestamps are in microseconds, we emit nanos.