dd-trace 6.12.0 → 6.14.0

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

@@ -1,42 +1,55 @@
 'use strict'
 
+const { createAgentlessExporter } = require('@datadog/libdatadog')
+
+const { storage } = require('../../../../datadog-core')
 const getConfig = require('../../config')
 const log = require('../../log')
-const request = require('../common/request')
 const tracerVersion = require('../../../../../package.json').version
 
+const { canSendApiKey } = require('../common/url')
 const BaseWriter = require('../common/writer')
-const { AgentlessJSONEncoder } = require('../../encode/agentless-json')
+const { AgentEncoder } = require('../../encode/0.4')
 const { computeIntakeUrl, INTAKE_PATH } = require('./intake')
 
+const legacyStorage = storage('legacy')
+
 /**
  * Writer for agentless APM trace intake.
- * Sends traces directly to the Datadog intake endpoint without an agent.
+ * Encodes traces as v0.4 MessagePack and delegates transformation and delivery
+ * to the APM data pipeline.
  */
 class AgentlessWriter extends BaseWriter {
   #apiKeyMissing = false
+  #apiKeyUnsafeReceiver = false
+  #exporter
+  #exporterApiKey
+  #exporterEnv
+  #exporterRuntimeId
+  #metadata
   #urlMissing = false
 
   /**
    * @param {object} options - Writer options
    * @param {URL} [options.url] - The intake URL. If not provided, constructed from site.
    * @param {string} [options.site] - The Datadog site
-   * @param {object} [options.metadata] - Metadata to pass to the encoder (hostname, env, etc.)
+   * @param {object} [options.metadata] - Metadata to pass to the data pipeline
    */
   constructor ({ url, site = 'datadoghq.com', metadata = {} }) {
     super({ url })
-    this._encoder = new AgentlessJSONEncoder(this, metadata)
+    this.#metadata = metadata
+    this._encoder = new AgentEncoder(this)
 
     if (!url) {
       try {
         this._url = new URL(computeIntakeUrl(site))
-      } catch (err) {
+      } catch (error) {
         log.error(
           'Invalid site value for agentless intake: %s. Cannot construct URL. Error: %s',
           site,
-          err.message
+          error.message
         )
-        this._url = null
+        this._url = undefined
       }
     }
 
@@ -46,59 +59,23 @@ class AgentlessWriter extends BaseWriter {
     }
   }
 
+  /**
+   * @param {URL} url - The new intake URL.
+   */
   setUrl (url) {
     super.setUrl(url)
+    this.#closeExporter()
     if (url) {
       this.#urlMissing = false
     }
   }
 
   /**
-   * Flushes accumulated traces to the intake as a single request.
-   * @param {Function} [done] - Callback when send completes
-   */
-  flush (done = () => {}) {
-    if (!request.writable) {
-      const count = this._encoder.count()
-      if (count > 0) {
-        log.error('Maximum number of active requests reached. Dropping %d trace(s).', count)
-      }
-      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 traces in the payload
-   * @param {Function} done - Callback when complete
+   * @param {Buffer} data - v0.4 MessagePack payload.
+   * @param {number} count - Number of traces in the payload.
+   * @param {() => void} done - Callback invoked after delivery completes or fails.
    */
   _sendPayload (data, count, done) {
-    if (!data || data.length === 0) {
-      log.debug('Skipping send of empty payload')
-      done()
-      return
-    }
-
     if (!this._url) {
       if (!this.#urlMissing) {
         this.#urlMissing = true
@@ -121,81 +98,86 @@ class AgentlessWriter extends BaseWriter {
     }
     this.#apiKeyMissing = false
 
-    const options = {
-      path: INTAKE_PATH,
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'dd-api-key': DD_API_KEY,
-        'X-Datadog-Trace-Count': String(count),
-        '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,
+    // The WASM transport performs its HTTP request in JavaScript. Keep that
+    // internal request out of the instrumented application's traces.
+    try {
+      legacyStorage.run({ noop: true }, () => {
+        const exporter = this.#applyConfiguration(DD_API_KEY)
+        if (exporter) {
+          exporter.sendV04(data, done, log)
+        } else {
+          done()
+        }
+      })
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      log.error('Failed to send %d trace(s) to the agentless intake: %s', count, message)
+      done()
     }
+  }
 
-    log.debug('Request to the agentless intake: %j', options)
+  /**
+   * @returns {string} The full agentless intake endpoint.
+   */
+  #endpoint () {
+    const endpoint = new URL(this._url)
+    endpoint.pathname = INTAKE_PATH
+    endpoint.search = ''
+    endpoint.hash = ''
+    return endpoint.href
+  }
 
-    request(data, options, (err, res, statusCode) => {
-      if (err) {
-        this.#logRequestError(err, statusCode, count)
-        done()
-        return
+  /**
+   * @param {string} apiKey - Datadog API key.
+   * @returns {import('@datadog/libdatadog').AgentlessExporter|undefined}
+   */
+  #applyConfiguration (apiKey) {
+    if (!canSendApiKey(this._url.protocol, this._url.hostname)) {
+      if (!this.#apiKeyUnsafeReceiver) {
+        this.#apiKeyUnsafeReceiver = true
+        log.warn('DD_API_KEY will not be sent because the configured receiver is neither HTTPS nor loopback.')
       }
+      return
+    }
+    this.#apiKeyUnsafeReceiver = false
+
+    const { env, runtimeID } = this.#metadata
+    if (
+      this.#exporter &&
+      this.#exporterApiKey === apiKey &&
+      this.#exporterEnv === env &&
+      this.#exporterRuntimeId === runtimeID
+    ) {
+      return this.#exporter
+    }
 
-      log.debug('Response from the agentless intake: %s', res)
-      done()
+    this.#closeExporter()
+    const config = getConfig()
+    this.#exporter = createAgentlessExporter({
+      endpoint: this.#endpoint(),
+      apiKey,
+      hostname: this.#metadata.hostname,
+      env,
+      service: config.service,
+      version: config.version,
+      runtimeId: runtimeID,
+      containerId: this.#metadata.containerId,
+      tracerVersion,
+      languageVersion: process.version,
+      languageInterpreter: process.versions.bun ? 'JavaScriptCore' : 'v8',
     })
+    this.#exporterApiKey = apiKey
+    this.#exporterEnv = env
+    this.#exporterRuntimeId = runtimeID
+    return this.#exporter
   }
 
-  /**
-   * 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 traces that were being sent
-   */
-  #logRequestError (err, statusCode, count) {
-    if (statusCode === 401 || statusCode === 403) {
-      log.error(
-        'Authentication failed sending %d trace(s) (status %s). Verify DD_API_KEY is valid.',
-        count,
-        statusCode
-      )
-    } else if (statusCode === 404) {
-      log.error(
-        'Trace intake endpoint not found (status %s). Verify DD_SITE is correctly configured. %d trace(s) dropped.',
-        statusCode,
-        count
-      )
-    } else if (statusCode === 429) {
-      log.error(
-        'Rate limited by trace intake (status 429). %d trace(s) dropped.',
-        count
-      )
-    } else if (statusCode >= 500) {
-      log.error(
-        'Trace intake server error (status %s). %d trace(s) dropped. This may be transient.',
-        statusCode,
-        count
-      )
-    } else if (statusCode) {
-      log.error(
-        'Error sending agentless payload (status %s): %s. %d trace(s) dropped.',
-        statusCode,
-        err.message,
-        count
-      )
-    } else {
-      log.error(
-        'Network error sending %d trace(s) to %s: %s',
-        count,
-        this._url?.hostname || 'unknown',
-        err.message
-      )
-    }
+  #closeExporter () {
+    this.#exporter?.close()
+    this.#exporter = undefined
+    this.#exporterApiKey = undefined
+    this.#exporterEnv = undefined
+    this.#exporterRuntimeId = undefined
   }
 }
 

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

@@ -7,9 +7,15 @@ const { storage } = require('../../../../datadog-core')
 const legacyStorage = storage('legacy')
 
 const keepAlive = true
-const maxSockets = 1
 
-function createAgentClass (BaseAgent) {
+/**
+ * Creates an agent class that suppresses tracing around socket lifecycle operations.
+ *
+ * @param {typeof http.Agent|typeof https.Agent} BaseAgent
+ * @param {number} maxSockets
+ * @returns {typeof http.Agent|typeof https.Agent}
+ */
+function createAgentClass (BaseAgent, maxSockets) {
   class CustomAgent extends BaseAgent {
     constructor () {
       super({ keepAlive, maxSockets })
@@ -35,10 +41,26 @@ function createAgentClass (BaseAgent) {
   return CustomAgent
 }
 
-const HttpAgent = createAgentClass(http.Agent)
-const HttpsAgent = createAgentClass(https.Agent)
+/**
+ * Creates isolated HTTP and HTTPS agents with a bounded connection pool.
+ *
+ * @param {number} maxSockets
+ * @returns {{ httpAgent: http.Agent, httpsAgent: https.Agent }}
+ */
+function createAgents (maxSockets) {
+  const HttpAgent = createAgentClass(http.Agent, maxSockets)
+  const HttpsAgent = createAgentClass(https.Agent, maxSockets)
+
+  return {
+    httpAgent: new HttpAgent(),
+    httpsAgent: new HttpsAgent(),
+  }
+}
+
+const { httpAgent, httpsAgent } = createAgents(1)
 
 module.exports = {
-  httpAgent: new HttpAgent(),
-  httpsAgent: new HttpsAgent(),
+  createAgents,
+  httpAgent,
+  httpsAgent,
 }

package/packages/dd-trace/src/exporters/common/buffering-exporter.js

@@ -25,10 +25,10 @@ class BufferingExporter {
   }
 
   _export (payload, writer = this._writer, timerKey = '_timer', deferImmediateFlush = false) {
-    if (this._config.isCiVisibility) {
+    const appended = writer.append(payload)
+    if (this._config.isCiVisibility && appended !== false) {
       incrementCountMetric(TELEMETRY_EVENTS_ENQUEUED_FOR_SERIALIZATION, {}, payload.length)
     }
-    const appended = writer.append(payload)
 
     const { flushInterval } = this._config
 

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

@@ -0,0 +1,191 @@
+'use strict'
+
+/**
+ * @typedef {Record<string, unknown> & { deadline?: number, signal?: AbortSignal }} RequestOptions
+ */
+
+/**
+ * @typedef {object} FinalFlush
+ * @property {number} deadline
+ * @property {(error?: Error) => void} done
+ * @property {Error | undefined} error
+ * @property {Set<PendingRequest>} requests
+ * @property {ReturnType<typeof setTimeout> | undefined} timeoutId
+ * @property {boolean} writerDone
+ */
+
+/**
+ * @typedef {object} PendingRequest
+ * @property {AbortController} controller
+ * @property {Set<FinalFlush>} finalFlushes
+ * @property {RequestOptions} options
+ */
+
+class FinalFlushRequestTracker {
+  #flush
+  #createTimeoutError
+  /** @type {Set<PendingRequest>} */
+  #pendingRequests = new Set()
+  /** @type {Set<FinalFlush>} */
+  #finalFlushes = new Set()
+  /** @type {FinalFlush | undefined} */
+  #activeFinalFlush
+
+  /**
+   * @param {(done?: (error?: Error) => void, options?: { deadline?: number }) => void} flush
+   * @param {() => Error} createTimeoutError
+   */
+  constructor (flush, createTimeoutError) {
+    this.#flush = flush
+    this.#createTimeoutError = createTimeoutError
+  }
+
+  /**
+   * Flushes queued payloads and waits for requests that were already in flight.
+   *
+   * @param {(error?: Error) => void} [done]
+   * @param {{ deadline?: number }} [options]
+   * @returns {void}
+   */
+  flush (done, options) {
+    if (options?.deadline === undefined) {
+      this.#flush(done, options)
+      return
+    }
+
+    /** @type {FinalFlush} */
+    const finalFlush = {
+      deadline: options.deadline,
+      done: done || (() => {}),
+      error: undefined,
+      requests: new Set(),
+      timeoutId: undefined,
+      writerDone: false,
+    }
+    this.#finalFlushes.add(finalFlush)
+
+    for (const pendingRequest of this.#pendingRequests) {
+      this.#attachRequest(finalFlush, pendingRequest)
+    }
+
+    const remaining = Math.max(0, options.deadline - Date.now())
+    finalFlush.timeoutId = setTimeout(() => {
+      const error = this.#createTimeoutError()
+
+      finalFlush.error ||= error
+      finalFlush.writerDone = true
+
+      for (const pendingRequest of finalFlush.requests) {
+        pendingRequest.finalFlushes.delete(finalFlush)
+        if (pendingRequest.finalFlushes.size === 0) {
+          pendingRequest.controller.abort(error)
+          this.#pendingRequests.delete(pendingRequest)
+        } else {
+          this.#updateRequestDeadline(pendingRequest)
+        }
+      }
+      finalFlush.requests.clear()
+      this.#finishFinalFlush(finalFlush)
+    }, remaining)
+
+    const previousFinalFlush = this.#activeFinalFlush
+    this.#activeFinalFlush = finalFlush
+    try {
+      this.#flush((error) => {
+        finalFlush.error ||= error
+        finalFlush.writerDone = true
+        this.#finishFinalFlush(finalFlush)
+      }, options)
+    } finally {
+      this.#activeFinalFlush = previousFinalFlush
+    }
+    this.#finishFinalFlush(finalFlush)
+  }
+
+  /**
+   * Sends and tracks a request so a later final flush can wait for or abort it.
+   *
+   * @param {(data: Buffer|string|object, options: RequestOptions,
+   *   callback: (error: Error|null, result?: string|null, statusCode?: number,
+   *   headers?: import('node:http').IncomingHttpHeaders) => void) => void} request
+   * @param {Buffer|string|object} data
+   * @param {RequestOptions} options
+   * @param {(error: Error|null, result?: string|null, statusCode?: number,
+   *   headers?: import('node:http').IncomingHttpHeaders) => void} callback
+   * @returns {void}
+   */
+  send (request, data, options, callback) {
+    const controller = new AbortController()
+    const requestOptions = { ...options, signal: controller.signal }
+    const pendingRequest = { controller, finalFlushes: new Set(), options: requestOptions }
+    this.#pendingRequests.add(pendingRequest)
+    if (this.#activeFinalFlush) this.#attachRequest(this.#activeFinalFlush, pendingRequest)
+
+    try {
+      request(data, requestOptions, (error, result, statusCode, headers) => {
+        if (error) {
+          for (const finalFlush of pendingRequest.finalFlushes) finalFlush.error ||= error
+        }
+
+        try {
+          callback(error, result, statusCode, headers)
+        } finally {
+          this.#dropRequest(pendingRequest)
+        }
+      })
+    } catch (error) {
+      this.#dropRequest(pendingRequest)
+      throw error
+    }
+  }
+
+  /**
+   * @param {PendingRequest} pendingRequest
+   * @returns {void}
+   */
+  #dropRequest (pendingRequest) {
+    this.#pendingRequests.delete(pendingRequest)
+    for (const finalFlush of pendingRequest.finalFlushes) {
+      finalFlush.requests.delete(pendingRequest)
+      this.#finishFinalFlush(finalFlush)
+    }
+    pendingRequest.finalFlushes.clear()
+  }
+
+  /**
+   * @param {FinalFlush} finalFlush
+   * @param {PendingRequest} pendingRequest
+   * @returns {void}
+   */
+  #attachRequest (finalFlush, pendingRequest) {
+    finalFlush.requests.add(pendingRequest)
+    pendingRequest.finalFlushes.add(finalFlush)
+    this.#updateRequestDeadline(pendingRequest)
+  }
+
+  /**
+   * @param {PendingRequest} pendingRequest
+   * @returns {void}
+   */
+  #updateRequestDeadline (pendingRequest) {
+    let deadline = 0
+    for (const finalFlush of pendingRequest.finalFlushes) {
+      deadline = Math.max(deadline, finalFlush.deadline)
+    }
+    pendingRequest.options.deadline = deadline
+  }
+
+  /**
+   * @param {FinalFlush} finalFlush
+   * @returns {void}
+   */
+  #finishFinalFlush (finalFlush) {
+    if (!this.#finalFlushes.has(finalFlush) || !finalFlush.writerDone || finalFlush.requests.size !== 0) return
+
+    this.#finalFlushes.delete(finalFlush)
+    clearTimeout(finalFlush.timeoutId)
+    finalFlush.done(finalFlush.error)
+  }
+}
+
+module.exports = FinalFlushRequestTracker

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

@@ -10,7 +10,7 @@ const zlib = require('zlib')
 
 const { storage } = require('../../../../datadog-core')
 const log = require('../../log')
-const { isLoopbackHost, parseUrl } = require('./url')
+const { canSendApiKey, parseUrl } = require('./url')
 const docker = require('./docker')
 const { httpAgent, httpsAgent } = require('./agents')
 const {
@@ -30,7 +30,7 @@ let activeBufferSize = 0
  * @param {Buffer|string|Readable|Array<Buffer|string>} data
  * @param {object} options
  * @param {(error: Error|null, result?: string|null, statusCode?: number,
- *   headers?: import('node:http').IncomingHttpHeaders) => void} callback
+ *   headers?: import('node:http').IncomingHttpHeaders, dropped?: boolean) => void} callback
  */
 function request (data, options, callback) {
   if (!options.headers) {
@@ -54,7 +54,7 @@ function request (data, options, callback) {
   // rather than drop the request: the agent proxies telemetry with its own key, while an https
   // intake URL is required to authenticate agentless traffic.
   const hasApiKey = options.headers['dd-api-key'] !== undefined || options.headers['DD-API-KEY'] !== undefined
-  if (hasApiKey && options.protocol === 'http:' && !isLoopbackHost(options.hostname)) {
+  if (hasApiKey && !canSendApiKey(options.protocol, options.hostname)) {
     log.error(
       'Not sending the Datadog API key over a non-TLS connection to %s. Configure an https intake URL.',
       options.hostname
@@ -89,7 +89,8 @@ function request (data, options, callback) {
   if (!Array.isArray(data)) {
     dataArray = [data]
   }
-  options.headers['Content-Length'] = byteLength(dataArray)
+  const contentLength = byteLength(dataArray)
+  options.headers['Content-Length'] = contentLength
 
   docker.inject(options.headers)
 
@@ -172,20 +173,23 @@ function request (data, options, callback) {
   // outside AsyncContextFrame, so a synchronous re-entry would lose the store.
   /** @param {number} attemptIndex */
   const attempt = attemptIndex => {
-    if (!request.writable) {
-      log.debug('Maximum number of active requests reached: payload is discarded.')
-      return callback(null)
+    if (activeBufferSize + contentLength > maxActiveBufferSize) {
+      const error = new log.NoTransmitError('Maximum active request buffer size reached: payload is discarded.')
+      error.code = 'ERR_DD_REQUEST_BUFFER_FULL'
+      log.debug(error.message)
+      return callback(error, undefined, undefined, undefined, true)
     }
 
-    activeBufferSize += options.headers['Content-Length'] ?? 0
+    activeBufferSize += contentLength
 
     legacyStorage.run({ noop: true }, () => {
       let finished = false
       let settled = false
+      let timeoutImmediate
       const finalize = () => {
         if (finished) return
         finished = true
-        activeBufferSize -= options.headers['Content-Length'] ?? 0
+        activeBufferSize -= contentLength
       }
 
       /**
@@ -197,6 +201,7 @@ function request (data, options, callback) {
       const complete = (error, result, statusCode, headers) => {
         if (settled) return
         settled = true
+        clearImmediate(timeoutImmediate)
         finalize()
         callback(error, result, statusCode, headers)
       }
@@ -206,6 +211,7 @@ function request (data, options, callback) {
        */
       const handleError = (error) => {
         if (settled) return
+        clearImmediate(timeoutImmediate)
 
         if (options.retry !== false &&
             attemptIndex < getMaxAttempts(options) &&
@@ -224,10 +230,11 @@ function request (data, options, callback) {
       const req = client.request(connectionOptions, (res) => onResponse(res, complete, handleError))
 
       req.once('close', finalize)
-      req.once('timeout', finalize)
+      if (!options.deferTimeoutAbort) req.once('timeout', finalize)
       req.once('error', handleError)
 
-      req.setTimeout(timeout, () => {
+      const abortRequest = () => {
+        if (settled) return
         try {
           if (typeof req.abort === 'function') {
             req.abort()
@@ -237,6 +244,19 @@ function request (data, options, callback) {
         } catch {
           // ignore
         }
+      }
+
+      req.setTimeout(timeout, () => {
+        if (!options.deferTimeoutAbort) {
+          abortRequest()
+          return
+        }
+
+        timeoutImmediate = setImmediate(() => {
+          abortRequest()
+          finalize()
+        })
+        if (!options.keepProcessAlive) timeoutImmediate.unref?.()
       })
 
       for (const buffer of dataArray) req.write(buffer)