dd-trace 6.12.0 → 6.14.0

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

@@ -1,6 +1,7 @@
 'use strict'
 
 const net = require('node:net')
+const { format } = require('node:url')
 
 const { urlToHttpOptions } = require('./url-to-http-options-polyfill')
 
@@ -16,6 +17,44 @@ function isLoopbackHost (hostname) {
     (hostname.startsWith('127.') && net.isIPv4(hostname))
 }
 
+/**
+ * @param {string|undefined} protocol
+ * @param {string|undefined} hostname
+ * @returns {boolean}
+ */
+function canSendApiKey (protocol, hostname) {
+  return protocol === 'https:' || protocol === 'unix:' ||
+    typeof hostname === 'string' && isLoopbackHost(hostname)
+}
+
+/**
+ * @param {string} site
+ * @param {string} [intake]
+ * @returns {URL | undefined}
+ */
+function createSiteUrl (site, intake) {
+  const hostname = `${intake === undefined ? '' : `${intake}.`}${site}`.toLowerCase()
+
+  try {
+    const url = new URL(format({
+      protocol: 'https:',
+      hostname,
+    }))
+    if (
+      url.hostname !== hostname ||
+      url.username ||
+      url.password ||
+      url.port ||
+      url.pathname !== '/' ||
+      url.search ||
+      url.hash
+    ) {
+      return
+    }
+    return url
+  } catch {}
+}
+
 /**
  * Convert an agent/intake URL into Node http(s) request options.
  *
@@ -43,4 +82,4 @@ function parseUrl (urlObjOrString) {
   return url
 }
 
-module.exports = { isLoopbackHost, parseUrl }
+module.exports = { canSendApiKey, createSiteUrl, isLoopbackHost, parseUrl }

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

@@ -8,19 +8,44 @@ const request = require('./request')
 const { safeJSONStringify } = require('./util')
 
 const firstFlushChannel = channel('dd-trace:exporter:first-flush')
+const noop = () => {}
 
 class Writer {
-  constructor ({ url, beforeFirstFlush }) {
+  #deliveryTracker
+  #retainOnBackpressure
+
+  constructor ({ url, beforeFirstFlush, deliveryTracker, retainOnBackpressure = false }) {
     this._url = url
     this._beforeFirstFlush = beforeFirstFlush
+    this.#retainOnBackpressure = retainOnBackpressure
+    this.#deliveryTracker = deliveryTracker
   }
 
   #isFirstFlush = true
 
-  flush (done = () => {}, options) {
+  /**
+   * Flushes queued telemetry, retaining delivery on supported serverless platforms.
+   * @param {(error?: Error) => void} [done]
+   * @param {{ deadline?: number }} [options]
+   * @returns {void}
+   */
+  flush (done, options) {
+    if (this.#deliveryTracker) {
+      return this.#deliveryTracker.track(callback => this.flushDirect(callback, options), done)
+    }
+    this.flushDirect(done, options)
+  }
+
+  /**
+   * Flushes queued telemetry without registering serverless delivery retention.
+   * @param {(error?: Error) => void} [done]
+   * @param {{ deadline?: number }} [options]
+   * @returns {void}
+   */
+  flushDirect (done = noop, options) {
     const count = this._encoder.count()
 
-    if (!request.writable && options?.deadline === undefined) {
+    if (!request.writable && options?.deadline === undefined && !this.#retainOnBackpressure) {
       this._encoder.reset()
       done()
     } else if (count > 0) {
@@ -55,7 +80,7 @@ class Writer {
   }
 
   append (payload, options) {
-    if (!request.writable && options?.deadline === undefined) {
+    if (!request.writable && options?.deadline === undefined && !this.#retainOnBackpressure) {
       // eslint-disable-next-line eslint-rules/eslint-log-printf-style
       log.debug(() => `Maximum number of active requests reached. Payload discarded: ${safeJSONStringify(payload)}`)
       return false
@@ -64,12 +89,11 @@ class Writer {
     // eslint-disable-next-line eslint-rules/eslint-log-printf-style
     log.debug(() => `Encoding payload: ${safeJSONStringify(payload)}`)
 
-    this._encode(payload)
-    return true
+    return this._encode(payload) !== false
   }
 
   _encode (payload) {
-    this._encoder.encode(payload)
+    return this._encoder.encode(payload)
   }
 
   setUrl (url) {

package/packages/dd-trace/src/exporters/span-stats/index.js

@@ -1,16 +1,35 @@
 'use strict'
 
+const log = require('../../log')
+const { createServerlessDeliveryTracker } = require('../../serverless')
 const { Writer } = require('./writer')
 
 class SpanStatsExporter {
+  #serverlessDeliveryTracker
+
   constructor (config) {
+    this.#serverlessDeliveryTracker = createServerlessDeliveryTracker()
     this._url = config.url
-    this._writer = new Writer({ url: this._url })
+    this._writer = new Writer({
+      url: this._url,
+      deliveryTracker: this.#serverlessDeliveryTracker,
+    })
+  }
+
+  export (payload, done) {
+    try {
+      this._writer.append(payload)
+      this._writer.flush(this.#serverlessDeliveryTracker ? undefined : done)
+    } catch (error) {
+      if (!done) throw error
+      log.error('Failed to flush span stats: %s', error.message)
+    }
+    this.#serverlessDeliveryTracker?.waitForIdle(done)
   }
 
-  export (payload) {
-    this._writer.append(payload)
-    this._writer.flush()
+  flush (done) {
+    this._writer.flush(this.#serverlessDeliveryTracker ? undefined : done)
+    this.#serverlessDeliveryTracker?.waitForIdle(done)
   }
 }
 

package/packages/dd-trace/src/external-logger/src/index.js

@@ -33,11 +33,12 @@ class ExternalLogger {
   }
 
   static tagString (tags) {
-    const tagArray = []
+    let tagString = ''
     for (const key in tags) {
-      tagArray.push(key + ':' + tags[key])
+      if (tagString) tagString += ','
+      tagString += key + ':' + tags[key]
     }
-    return tagArray.join(',')
+    return tagString
   }
 
   // Parses and enqueues a log

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

@@ -0,0 +1,105 @@
+'use strict'
+
+const log = require('./log')
+const { supportsServerlessTelemetryRetention } = require('./serverless')
+
+/**
+ * @typedef {(done: () => void) => void} TelemetryFlusher
+ */
+
+/** @type {Set<TelemetryFlusher>} */
+const telemetryFlushers = new Set()
+const postTraceTelemetryFlushers = new Set()
+
+/**
+ * @typedef {{
+ *   trace?: TelemetryFlusher,
+ *   spanStats?: TelemetryFlusher
+ * }} TraceFlushers
+ */
+
+/**
+ * Registers a configured telemetry pipeline so serverless lifecycle retention
+ * waits for its final export alongside trace delivery.
+ * @param {TelemetryFlusher} flusher
+ * @param {{ afterTrace?: boolean }} [options]
+ * @returns {() => void} Removes this pipeline when its provider is replaced.
+ */
+function registerTelemetryFlusher (flusher, options) {
+  if (!supportsServerlessTelemetryRetention()) return () => {}
+
+  const flushers = options?.afterTrace ? postTraceTelemetryFlushers : telemetryFlushers
+  flushers.add(flusher)
+  // Avoid retaining a replaced provider or flushing it alongside the new one.
+  return () => flushers.delete(flusher)
+}
+
+/**
+ * Coordinates the configured telemetry flushers for a serverless lifecycle.
+ *
+ * Trace-owned flushers are supplied by DatadogTracer so this module does not
+ * depend on its private implementation details.
+ * @param {() => void} [done]
+ * @param {{ timeout?: number }} [options]
+ * @param {TraceFlushers} [traceFlushers]
+ */
+function flushServerlessTelemetry (done, options, traceFlushers) {
+  const traceFlusher = traceFlushers?.trace
+  const spanStatsFlusher = traceFlushers?.spanStats
+  // TODO: Include DSM after DataStreamsProcessor exposes a completion-aware flush API.
+  let pending = telemetryFlushers.size + postTraceTelemetryFlushers.size +
+    (typeof traceFlusher === 'function' ? 1 : 0) +
+    (typeof spanStatsFlusher === 'function' ? 1 : 0)
+
+  if (pending === 0) return done?.()
+
+  let completed = false
+  let timeout
+
+  const finish = () => {
+    if (completed) return
+    completed = true
+    clearTimeout(timeout)
+    done?.()
+  }
+  const complete = () => {
+    if (--pending === 0) finish()
+  }
+
+  if (options?.timeout) {
+    timeout = setTimeout(() => {
+      log.warn('Timed out waiting for telemetry flush after %dms', options.timeout)
+      finish()
+    }, options.timeout)
+  }
+
+  const flush = (flusher, afterFlushed) => {
+    let flushed = false
+    const onFlushed = error => {
+      if (flushed) return
+      flushed = true
+      if (error) log.error('Error flushing telemetry pipeline:', error)
+      afterFlushed?.()
+      complete()
+    }
+    try {
+      flusher(onFlushed)
+    } catch (error) {
+      onFlushed(error)
+    }
+  }
+
+  if (typeof traceFlusher === 'function') {
+    flush(traceFlusher, () => {
+      for (const flusher of postTraceTelemetryFlushers) flush(flusher)
+    })
+  } else {
+    for (const flusher of postTraceTelemetryFlushers) flush(flusher)
+  }
+  if (typeof spanStatsFlusher === 'function') {
+    flush(spanStatsFlusher)
+  }
+  for (const flusher of telemetryFlushers) flush(flusher)
+}
+
+module.exports = { flushServerlessTelemetry, registerTelemetryFlusher }

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

@@ -2,6 +2,8 @@
 
 const { randomFillSync } = require('crypto')
 
+const { channel } = require('dc-polyfill')
+
 const UINT_MAX = 4_294_967_296
 
 const data = new Uint8Array(8 * 8192)
@@ -9,6 +11,8 @@ const zeroId = new Uint8Array(8)
 
 let batch = 0
 
+channel('datadog:identity:update').subscribe(reseed)
+
 // Internal representation of a trace or span ID.
 class Identifier {
   /** @type {number[] | Uint8Array} */
@@ -254,6 +258,16 @@ function writeUInt32BE (buffer, value, offset) {
   buffer[0 + offset] = value & 255
 }
 
+/**
+ * Resets the batch cursor, forcing the next ID batch to draw a fresh
+ * randomFillSync() call on MicroVM clone resume. Node's crypto RNG is
+ * re-seeded from the kernel CSPRNG on snapshot resume, so re-invoking it
+ * is sufficient — no need to read /dev/urandom directly.
+ */
+function reseed () {
+  batch = 0
+}
+
 /**
  * @param {string} [value]
  * @param {number} [radix]

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

@@ -1,6 +1,7 @@
 'use strict'
 
-const { getValueFromEnvSources } = require('./config/helper')
+const { getEnvironmentVariable, getValueFromEnvSources } = require('./config/helper')
+const { isTrue } = require('./util')
 
 // Global `jest` is only present in Jest workers.
 const inJestWorker = typeof jest !== 'undefined'
@@ -8,8 +9,10 @@ const inJestWorker = typeof jest !== 'undefined'
 // skipDefault: distinguish an unset DD_TRACE_ENABLED (fall back to the OTel signal) from an
 // explicit value; the registered default would otherwise mask the OTEL_TRACES_EXPORTER check.
 const ddTraceEnabled = getValueFromEnvSources('DD_TRACE_ENABLED', true)
+const agentlessTracingEnabled = getValueFromEnvSources('DD_AGENTLESS_ENABLED') ||
+  isTrue(getEnvironmentVariable('_DD_APM_TRACING_AGENTLESS_ENABLED'))
 const ddTraceDisabled = ddTraceEnabled === undefined
-  ? getValueFromEnvSources('OTEL_TRACES_EXPORTER') === 'none'
+  ? !agentlessTracingEnabled && getValueFromEnvSources('OTEL_TRACES_EXPORTER') === 'none'
   : ddTraceEnabled === false
 
 module.exports = ddTraceDisabled || inJestWorker

package/packages/dd-trace/src/llmobs/experiments/client.js

@@ -108,6 +108,10 @@ class ExperimentsClient {
     return this.#site
   }
 
+  get projectName () {
+    return this.#projectName
+  }
+
   // Dashboard URL base for the configured site, e.g. https://app.datadoghq.com
   get appBase () {
     return `https://${appHost(this.#site)}`

package/packages/dd-trace/src/llmobs/experiments/dataset.js

@@ -1,8 +1,18 @@
 'use strict'
 
 const { randomUUID } = require('node:crypto')
+const createRfdc = require('../../../../../vendor/dist/rfdc')
+const snapshotPayload = createRfdc({ proto: false, circles: false })
 
 /** @typedef {{add?: string[], remove?: string[], replace?: string[]}} TagOperations */
+/**
+ * @typedef {object} DatasetRecordNew
+ * @property {string} [id]
+ * @property {unknown} inputData
+ * @property {unknown} [expectedOutput]
+ * @property {Record<string, unknown>} [metadata]
+ * @property {string[]} [tags]
+ */
 /**
  * @typedef {object} PendingBatch
  * @property {object} attributes
@@ -114,6 +124,9 @@ function updateFromInsertedRecord (recordId, record, payload) {
     update.expectedOutput = record.expectedOutput
   }
   if (!valuesAreEqual(record.metadata, payload.metadata)) update.metadata = record.metadata
+  if (!valuesAreEqual(record.tags, payload.tags ?? [])) {
+    update.tagOperations = { replace: [...record.tags] }
+  }
   return update
 }
 
@@ -173,6 +186,36 @@ class Dataset {
     return this
   }
 
+  /**
+   * Add multiple records to a dataset.
+   * @param {DatasetRecordNew[]} records
+   * @returns {Dataset} This dataset for chaining.
+   */
+  addRecords (records) {
+    const newRecords = []
+    const recordIds = new Set(this.#recordsById.keys())
+
+    // Construct and validate the entire batch before mutating the dataset.
+    for (const record of records) {
+      if (record.id !== undefined && (typeof record.id !== 'string' || record.id.length === 0)) {
+        throw new Error('record id must be a non-empty string')
+      }
+      const newRecord = new DatasetRecord(
+        record.inputData,
+        record.expectedOutput,
+        record.metadata,
+        record.id,
+        record.tags
+      )
+      if (recordIds.has(newRecord.id)) throw new Error(`Duplicate record id '${newRecord.id}'`)
+      recordIds.add(newRecord.id)
+      newRecords.push(newRecord)
+    }
+
+    for (const record of newRecords) this.#addRecord(record)
+    return this
+  }
+
   /**
    * Add tags to a dataset record.
    * @param {number} index Dataset record index.
@@ -336,6 +379,10 @@ class Dataset {
     return this.#projectId
   }
 
+  projectName () {
+    return this.#client.projectName
+  }
+
   version () {
     return this.#version
   }
@@ -416,7 +463,7 @@ class Dataset {
     const insertRecords = []
     const insertPayloads = new Map()
     for (const [recordId, record] of this.#newRecordsById) {
-      const payload = serializedRecord(record)
+      const payload = snapshotPayload(serializedRecord(record))
       insertRecords.push(payload)
       insertPayloads.set(recordId, payload)
     }
@@ -427,7 +474,7 @@ class Dataset {
       const tagOperations = this.#pendingTagOperations.get(recordId)
       if (tagOperations) update.tagOperations = tagOperations
       else delete update.tagOperations
-      const payload = serializedRecordUpdate(update)
+      const payload = snapshotPayload(serializedRecordUpdate(update))
       updateRecords.push(payload)
       updatePayloads.set(recordId, payload)
     }
@@ -522,6 +569,9 @@ class Dataset {
         updateFromInsertedRecord(recordId, current, payload)
       const queuedOperations = this.#pendingTagOperations.get(recordId)
       if (queuedOperations) update.tagOperations = queuedOperations
+      if (update.tagOperations) {
+        this.#pendingTagOperations.set(recordId, copyTagOperations(update.tagOperations))
+      }
       this.#updatedRecordsById.set(recordId, update)
     }