dd-trace 6.13.0 → 6.14.0

package/packages/dd-trace/src/ci-visibility/requests/fs-cache.js

@@ -50,13 +50,25 @@ function getLockPath (cacheKey) {
   return path.join(tmpdir(), `dd-${cacheKey}.lock`)
 }
 
+/**
+ * Checks whether a filesystem cache timestamp can be safely compared with the current time.
+ *
+ * @param {unknown} timestamp - Timestamp read from a cache or lock file.
+ * @param {number} now - Current Unix timestamp in milliseconds.
+ * @returns {timestamp is number}
+ */
+function isValidTimestamp (timestamp, now) {
+  return Number.isSafeInteger(timestamp) && timestamp >= 0 && timestamp <= now
+}
+
 /**
  * Attempts to read cached data from the filesystem.
  *
  * @param {string} cacheKey
+ * @param {number} [cacheTtlMs] - Maximum cache age in milliseconds.
  * @returns {{ data: unknown } | undefined}
  */
-function readFromCache (cacheKey) {
+function readFromCache (cacheKey, cacheTtlMs = CACHE_TTL_MS) {
   const cachePath = getCachePath(cacheKey)
   try {
     const raw = fs.readFileSync(cachePath, 'utf8')
@@ -66,8 +78,14 @@ function readFromCache (cacheKey) {
       return
     }
     const { timestamp, data } = parsed
-    if (Date.now() - timestamp > CACHE_TTL_MS) {
-      log.debug('%s cache expired (age: %d ms)', cacheKey, Date.now() - timestamp)
+    const now = Date.now()
+    if (!isValidTimestamp(timestamp, now)) {
+      log.debug('%s cache file has an invalid timestamp, ignoring', cacheKey)
+      return
+    }
+    const age = now - timestamp
+    if (age > cacheTtlMs) {
+      log.debug('%s cache expired (age: %d ms)', cacheKey, age)
       return
     }
     log.debug('%s cache hit', cacheKey)
@@ -101,7 +119,7 @@ function writeToCache (cacheKey, data) {
  * Attempts to acquire an exclusive lock using O_CREAT|O_EXCL.
  *
  * @param {string} cacheKey
- * @returns {boolean}
+ * @returns {boolean|undefined}
  */
 function tryAcquireLock (cacheKey) {
   const lockPath = getLockPath(cacheKey)
@@ -110,8 +128,9 @@ function tryAcquireLock (cacheKey) {
     fs.writeSync(fd, String(Date.now()))
     fs.closeSync(fd)
     return true
-  } catch {
-    return false
+  } catch (err) {
+    if (err.code === 'EEXIST') return false
+    log.debug('%s lock cannot be created, bypassing cache: %s', cacheKey, err.message)
   }
 }
 
@@ -119,9 +138,15 @@ function tryAcquireLock (cacheKey) {
  * Removes the lock file.
  *
  * @param {string} cacheKey
+ * @returns {boolean}
  */
 function releaseLock (cacheKey) {
-  try { fs.unlinkSync(getLockPath(cacheKey)) } catch { /* ignore */ }
+  try {
+    fs.unlinkSync(getLockPath(cacheKey))
+    return true
+  } catch (err) {
+    return err.code === 'ENOENT'
+  }
 }
 
 /**
@@ -165,7 +190,9 @@ function startLockHeartbeat (cacheKey) {
 function isLockStale (cacheKey) {
   try {
     const content = fs.readFileSync(getLockPath(cacheKey), 'utf8')
-    return Date.now() - Number(content) > CACHE_LOCK_TIMEOUT_MS
+    const timestamp = Number(content)
+    const now = Date.now()
+    return !isValidTimestamp(timestamp, now) || now - timestamp > CACHE_LOCK_TIMEOUT_MS
   } catch {
     return true
   }
@@ -175,30 +202,37 @@ function isLockStale (cacheKey) {
  * Polls until the cache file appears or the timeout is reached.
  *
  * @param {string} cacheKey
- * @param {Function} fetchFn - function(done) that fetches from the API
+ * @param {Function} fetchFn - function(cacheKey, done) that fetches from the API
  * @param {Function} done - callback(err, ...results)
+ * @param {number} cacheTtlMs - Maximum cache age in milliseconds.
  */
-function waitForCache (cacheKey, fetchFn, done) {
+function waitForCache (cacheKey, fetchFn, done, cacheTtlMs) {
   const poll = () => {
-    const cached = readFromCache(cacheKey)
+    const cached = readFromCache(cacheKey, cacheTtlMs)
     if (cached) {
       return done(null, cached.data)
     }
     if (isLockStale(cacheKey)) {
       log.debug('%s lock is stale, attempting takeover', cacheKey)
-      releaseLock(cacheKey)
-      if (!tryAcquireLock(cacheKey)) {
+      if (!releaseLock(cacheKey)) {
+        return fetchFn(null, done)
+      }
+      const isLockOwner = tryAcquireLock(cacheKey)
+      if (isLockOwner === undefined) {
+        return fetchFn(null, done)
+      }
+      if (!isLockOwner) {
         return setTimeout(poll, CACHE_LOCK_POLL_MS)
       }
 
-      const cachedAfterTakeover = readFromCache(cacheKey)
+      const cachedAfterTakeover = readFromCache(cacheKey, cacheTtlMs)
       if (cachedAfterTakeover) {
         releaseLock(cacheKey)
         return done(null, cachedAfterTakeover.data)
       }
 
       const stopHeartbeat = startLockHeartbeat(cacheKey)
-      return fetchFn((err, ...results) => {
+      return fetchFn(cacheKey, (err, ...results) => {
         stopHeartbeat()
         done(err, ...results)
       })
@@ -218,14 +252,15 @@ function waitForCache (cacheKey, fetchFn, done) {
  * @param {Function} fetchFn - function(cacheKey, done) that performs the API request.
  *   Must call writeToCache(cacheKey, data) on success before calling done(null, data).
  * @param {Function} done - callback(err, ...results)
+ * @param {number} [cacheTtlMs] - Maximum cache age in milliseconds.
  */
-function withCache (cacheKey, fetchFn, done) {
+function withCache (cacheKey, fetchFn, done, cacheTtlMs = CACHE_TTL_MS) {
   if (!isCacheEnabled()) {
     return fetchFn(null, done)
   }
 
   // Fast path: cache hit
-  const cached = readFromCache(cacheKey)
+  const cached = readFromCache(cacheKey, cacheTtlMs)
   if (cached) {
     return done(null, cached.data)
   }
@@ -233,9 +268,13 @@ function withCache (cacheKey, fetchFn, done) {
   // Try to become the fetcher (lock owner)
   const isLockOwner = tryAcquireLock(cacheKey)
 
+  if (isLockOwner === undefined) {
+    return fetchFn(null, done)
+  }
+
   if (!isLockOwner) {
     log.debug('%s lock held by another process, waiting for cache', cacheKey)
-    return waitForCache(cacheKey, (cb) => fetchFn(cacheKey, cb), done)
+    return waitForCache(cacheKey, fetchFn, done, cacheTtlMs)
   }
 
   // This process owns the lock — start heartbeat and fetch

package/packages/dd-trace/src/ci-visibility/requests/get-library-configuration.js

@@ -14,7 +14,6 @@ const {
   TELEMETRY_GIT_REQUESTS_SETTINGS_ERRORS,
   TELEMETRY_GIT_REQUESTS_SETTINGS_RESPONSE,
 } = require('../telemetry')
-const { writeSettingsToCache } = require('../test-optimization-cache')
 const { MAX_RETRIES, validateSettingsResponse } = require('../test-optimization-http-cache-schema')
 const request = require('./request')
 
@@ -286,8 +285,6 @@ function getLibraryConfiguration ({
 
         incrementCountMetric(TELEMETRY_GIT_REQUESTS_SETTINGS_RESPONSE, settings)
 
-        writeSettingsToCache(settings)
-
         done(null, settings)
       } catch (err) {
         done(err)

package/packages/dd-trace/src/ci-visibility/requests/upload-test-screenshot.js

@@ -1,21 +1,28 @@
 'use strict'
 
-const { readFileSync } = require('node:fs')
+const { createReadStream, readFileSync, statSync } = require('node:fs')
 const { extname } = require('node:path')
 
 const getConfig = require('../../config')
 const { EVP_SUBDOMAIN_HEADER_NAME } = require('../../evp_proxy/constants')
 const { joinEVPProxyPath } = require('../../evp_proxy/path')
 const log = require('../../log')
+const { getAgent, getMediaAgent } = require('../exporters/agents')
 const request = require('../exporters/request')
+const videoRequest = require('./video-request')
 
 const UPLOAD_TIMEOUT_MS = 30_000
-const TEST_SCREENSHOT_ENDPOINT_PREFIX = '/api/v2/ci/test-runs/'
-const TEST_SCREENSHOT_ENDPOINT_SUFFIX = '/media'
+const TEST_RUN_MEDIA_ENDPOINT_PREFIX = '/api/v2/ci/test-runs/'
+const TEST_SUITE_MEDIA_ENDPOINT_PREFIX = '/api/v2/ci/test-suites/'
+const MEDIA_ENDPOINT_SUFFIX = '/media'
+const MAX_VIDEO_SIZE_BYTES = 200 * 1024 * 1024
 const UINT64_MAX = 18_446_744_073_709_551_615n
 
-function getContentType (filePath) {
-  const extension = extname(filePath).toLowerCase()
+function getContentType (filePath, kind) {
+  const extension = filePath ? extname(filePath).toLowerCase() : ''
+  if (kind === 'video') {
+    return extension === '.mp4' ? 'video/mp4' : 'video/webm'
+  }
   if (extension === '.gif') {
     return 'image/gif'
   }
@@ -28,135 +35,221 @@ function getContentType (filePath) {
   return 'image/png'
 }
 
-function isValidTraceId (traceId) {
-  if (!/^[1-9]\d*$/.test(traceId)) {
+function isValidId (value) {
+  if (!/^[1-9]\d*$/.test(value)) {
     return false
   }
-  return BigInt(traceId) <= UINT64_MAX
+  return BigInt(value) <= UINT64_MAX
 }
 
 /**
- * Renders the idempotency key (`${traceId}:${basename(filePath)}`) into a value safe to carry in
- * the upload's query string. The Agent's evp_proxy validates the forwarded query against a
- * restrictive charset and rejects a raw Cypress filename (spaces, parens, non-ASCII), so the
- * filename part is hex-encoded to [0-9a-f]; the decimal trace id and ':' separator are already in
- * the allowed set and stay readable. Deterministic, so a retried upload reproduces the same key
- * and the backend's UUIDv5 overwrite-on-retry holds.
+ * Renders an idempotency key into a value safe to carry in the upload's query string.
  *
- * @param {string} idempotencyKey - The raw idempotency key (`<traceId>:<filename>`)
- * @returns {string} A query-safe, deterministic representation of the key
+ * @param {string} idempotencyKey - Raw per-artifact idempotency key
+ * @returns {string} Query-safe, deterministic representation of the key
  */
 function toIdempotencyQueryValue (idempotencyKey) {
   const separatorIndex = idempotencyKey.indexOf(':')
   if (separatorIndex === -1) {
     return Buffer.from(idempotencyKey, 'utf8').toString('hex')
   }
-  const traceIdPart = idempotencyKey.slice(0, separatorIndex)
-  const filenamePart = idempotencyKey.slice(separatorIndex + 1)
-  return `${traceIdPart}:${Buffer.from(filenamePart, 'utf8').toString('hex')}`
+  const idPart = idempotencyKey.slice(0, separatorIndex)
+  const artifactPart = idempotencyKey.slice(separatorIndex + 1)
+  return `${idPart}:${Buffer.from(artifactPart, 'utf8').toString('hex')}`
 }
 
 /**
- * Uploads a single test screenshot to the Test Optimization media intake.
- * The trace id is included in the request path and the body is the raw image bytes.
- *
- * The media service requires two values from the tracer, sent as query params so they
- * survive the Agent's evp_proxy (which forwards only an allow-listed header set and would
- * otherwise strip the metadata, leaving the backend with an empty idempotency key):
- * - `idempotencyKey`: stable per artifact and reused on retry, so a retried
- *   upload overwrites the same stored object instead of creating a duplicate.
- * - `capturedAtMs`: the capture time in epoch milliseconds, stamped once at
- *   capture and resent unchanged on retry (it is part of the stored object key).
+ * Uploads one screenshot or video to the Test Optimization media intake.
  *
  * @param {object} options - Upload options
- * @param {string} options.filePath - Path to the screenshot file
- * @param {string} options.traceId - Test trace id used as the screenshot key
+ * @param {string} [options.filePath] - Path to the media file
+ * @param {Buffer} [options.content] - In-memory screenshot content
+ * @param {'screenshot'|'video'} options.kind - Media kind
+ * @param {string} [options.traceId] - Test trace id for test-scoped media
+ * @param {string} [options.testSessionId] - Test session id for suite-scoped media
+ * @param {string} [options.testSuiteId] - Test suite id for suite-scoped media
  * @param {string} options.idempotencyKey - Stable per-artifact key, reused on retry
  * @param {number} options.capturedAtMs - Capture time in epoch milliseconds
- * @param {URL} options.url - The base URL for the screenshot upload
+ * @param {URL} options.url - Base URL for the media upload
  * @param {boolean} [options.isEvpProxy] - Whether to upload through the Agent's evp_proxy
- * @param {string} [options.evpProxyPrefix] - The evp_proxy path prefix (e.g. '/evp_proxy/v4')
+ * @param {string} [options.evpProxyPrefix] - evp_proxy path prefix
  * @param {number} [options.deadline] - Absolute finalization deadline in epoch milliseconds
  * @param {AbortSignal} [options.signal] - Signal used to cancel the upload
  * @param {Function} callback - Callback function (err)
+ * @returns {void}
  */
-function uploadTestScreenshot (
-  { filePath, traceId, idempotencyKey, capturedAtMs, url, isEvpProxy, evpProxyPrefix, deadline, signal },
-  callback
-) {
+function uploadTestMedia (options, callback) {
+  const {
+    filePath,
+    content,
+    kind,
+    traceId,
+    testSessionId,
+    testSuiteId,
+    idempotencyKey,
+    capturedAtMs,
+    url,
+    isEvpProxy,
+    evpProxyPrefix,
+    deadline,
+    signal,
+  } = options
   const { DD_API_KEY } = getConfig()
+  const isSuiteScoped = testSessionId !== undefined || testSuiteId !== undefined
+  let basePath
 
-  if (!isValidTraceId(traceId)) {
-    return callback(new Error('A non-zero decimal uint64 trace_id is required for test screenshot upload'))
+  if (kind !== 'screenshot' && kind !== 'video') {
+    return callback(new Error('A supported media kind is required for test media upload'))
+  }
+  if (isSuiteScoped) {
+    if (!isValidId(testSessionId) || !isValidId(testSuiteId)) {
+      return callback(new Error(
+        'Non-zero decimal uint64 test_session_id and test_suite_id are required for test suite media upload'
+      ))
+    }
+    basePath = `${TEST_SUITE_MEDIA_ENDPOINT_PREFIX}${testSessionId}/${testSuiteId}${MEDIA_ENDPOINT_SUFFIX}`
+  } else {
+    if (!isValidId(traceId)) {
+      return callback(new Error('A non-zero decimal uint64 trace_id is required for test media upload'))
+    }
+    basePath = `${TEST_RUN_MEDIA_ENDPOINT_PREFIX}${traceId}${MEDIA_ENDPOINT_SUFFIX}`
   }
   if (!DD_API_KEY && !isEvpProxy) {
-    return callback(new Error('DD_API_KEY is required for test screenshot upload'))
+    return callback(new Error('DD_API_KEY is required for test media upload'))
   }
   if (!idempotencyKey) {
-    return callback(new Error('An idempotency key is required for test screenshot upload'))
+    return callback(new Error('An idempotency key is required for test media upload'))
   }
   if (!Number.isInteger(capturedAtMs) || capturedAtMs <= 0) {
-    return callback(new Error('A positive captured-at timestamp (epoch ms) is required for test screenshot upload'))
+    return callback(new Error('A positive captured-at timestamp (epoch ms) is required for test media upload'))
   }
 
+  let fileSize
   let screenshotContent
   try {
-    screenshotContent = readFileSync(filePath)
-  } catch (err) {
-    return callback(new Error(`Failed to read screenshot at ${filePath}: ${err.message}`))
+    if (kind === 'video') {
+      fileSize = statSync(filePath).size
+    } else if (content === undefined) {
+      screenshotContent = readFileSync(filePath)
+      fileSize = screenshotContent.length
+    } else {
+      if (!Buffer.isBuffer(content)) {
+        return callback(new Error('In-memory screenshot content must be a Buffer'))
+      }
+      screenshotContent = content
+      fileSize = content.length
+    }
+  } catch (error) {
+    const action = kind === 'video' ? 'inspect video' : 'read screenshot'
+    return callback(new Error(`Failed to ${action} at ${filePath}: ${error.message}`))
   }
-  if (screenshotContent.length === 0) {
-    return callback(new Error(`Screenshot at ${filePath} is empty`))
+  if (fileSize === 0) {
+    return callback(new Error(`${kind === 'video' ? 'Video' : 'Screenshot'} at ${filePath} is empty`))
+  }
+  if (kind === 'video' && fileSize > MAX_VIDEO_SIZE_BYTES) {
+    const error = new Error(
+      `Video at ${filePath} is ${fileSize} bytes and exceeds the ${MAX_VIDEO_SIZE_BYTES}-byte upload limit`
+    )
+    log.warn('Skipping test video upload: %s', error.message)
+    return callback(error)
   }
 
-  // Metadata rides the query string, not X-Dd-* headers: the Agent's evp_proxy strips
-  // non-allow-listed headers, so header-borne metadata reached the backend empty. The key is
-  // rendered proxy-safe (see toIdempotencyQueryValue) because evp_proxy also validates the
-  // forwarded query against a restrictive charset. capturedAtMs is a plain integer and part of the
-  // stored object key, so it (and the key) must stay stable across retries.
+  // Metadata must use query params because the Agent's evp_proxy strips non-allow-listed headers.
   const query = new URLSearchParams({
     idempotency_key: toIdempotencyQueryValue(idempotencyKey),
     captured_at_ms: String(capturedAtMs),
   }).toString()
-  const basePath = `${TEST_SCREENSHOT_ENDPOINT_PREFIX}${traceId}${TEST_SCREENSHOT_ENDPOINT_SUFFIX}`
-
-  const contentType = getContentType(filePath)
-  const options = {
+  const contentType = getContentType(filePath, kind)
+  const requestOptions = {
     method: 'POST',
     headers: {
+      'Content-Length': fileSize,
       'Content-Type': contentType,
     },
     path: `${basePath}?${query}`,
     timeout: UPLOAD_TIMEOUT_MS,
     url,
+    agent: kind === 'video' ? getMediaAgent(url) : getAgent(url),
     deadline,
+    retryUntilDeadline: false,
     signal,
   }
 
   if (isEvpProxy) {
-    // Agent mode: prefix the evp_proxy path, tell the proxy which subdomain to forward to, and
-    // drop the API key — the Agent injects it. The query params survive the proxy.
-    options.path = `${joinEVPProxyPath(evpProxyPrefix, basePath)}?${query}`
-    options.headers[EVP_SUBDOMAIN_HEADER_NAME] = 'api'
+    requestOptions.path = `${joinEVPProxyPath(evpProxyPrefix, basePath)}?${query}`
+    requestOptions.headers[EVP_SUBDOMAIN_HEADER_NAME] = 'api'
   } else {
-    options.headers['DD-API-KEY'] = DD_API_KEY
+    requestOptions.headers['DD-API-KEY'] = DD_API_KEY
   }
 
-  log.debug('Uploading test screenshot %s to %s', filePath, new URL(options.path, url).href)
+  log.debug(
+    'Uploading test %s %s to %s',
+    kind,
+    filePath || 'from memory',
+    new URL(requestOptions.path, url).href
+  )
 
-  request(screenshotContent, options, (err, res, statusCode) => {
-    if (err) {
-      log.error('Error uploading test screenshot: %s', err.message)
-      return callback(err)
+  const onResponse = (error, response, statusCode) => {
+    if (error) {
+      log.error('Error uploading test %s: %s', kind, error.message)
+      return callback(error)
     }
     if (statusCode === undefined) {
-      const uploadError = new Error('Test screenshot upload request was dropped before it was sent')
-      log.error('Error uploading test screenshot: %s', uploadError.message)
+      const uploadError = new Error(`Test ${kind} upload request was dropped before it was sent`)
+      log.error('Error uploading test %s: %s', kind, uploadError.message)
       return callback(uploadError)
     }
-    log.debug('Test screenshot uploaded successfully (status: %d)', statusCode)
+    log.debug('Test %s uploaded successfully (status: %d)', kind, statusCode)
     callback(null)
-  })
+  }
+
+  if (kind === 'video') {
+    requestOptions.transport = videoRequest
+    request(() => createReadStream(filePath), requestOptions, onResponse)
+  } else {
+    request(screenshotContent, requestOptions, onResponse)
+  }
+}
+
+/**
+ * Uploads a test-scoped failure screenshot.
+ *
+ * @param {object} options - Upload options
+ * @param {Function} callback - Callback function (err)
+ * @returns {void}
+ */
+function uploadTestScreenshot (options, callback) {
+  uploadTestMedia({ ...options, kind: 'screenshot' }, callback)
 }
 
-module.exports = { TEST_SCREENSHOT_ENDPOINT_PREFIX, TEST_SCREENSHOT_ENDPOINT_SUFFIX, uploadTestScreenshot }
+/**
+ * Uploads a test-scoped failure video.
+ *
+ * @param {object} options - Upload options
+ * @param {Function} callback - Callback function (err)
+ * @returns {void}
+ */
+function uploadTestVideo (options, callback) {
+  uploadTestMedia({ ...options, kind: 'video' }, callback)
+}
+
+/**
+ * Uploads a suite-scoped failure video.
+ *
+ * @param {object} options - Upload options
+ * @param {Function} callback - Callback function (err)
+ * @returns {void}
+ */
+function uploadTestSuiteVideo (options, callback) {
+  uploadTestMedia({ ...options, kind: 'video' }, callback)
+}
+
+module.exports = {
+  MAX_VIDEO_SIZE_BYTES,
+  MEDIA_ENDPOINT_SUFFIX,
+  TEST_RUN_MEDIA_ENDPOINT_PREFIX,
+  TEST_SUITE_MEDIA_ENDPOINT_PREFIX,
+  uploadTestScreenshot,
+  uploadTestSuiteVideo,
+  uploadTestVideo,
+}

package/packages/dd-trace/src/ci-visibility/requests/video-request.js

@@ -0,0 +1,176 @@
+'use strict'
+
+const http = require('node:http')
+const https = require('node:https')
+
+const { storage } = require('../../../../datadog-core')
+const log = require('../../log')
+const { markEndpointReached } = require('../../exporters/common/retry')
+const { isLoopbackHost, parseUrl } = require('../../exporters/common/url')
+
+const legacyStorage = storage('legacy')
+const MAX_ACTIVE_REQUESTS = 16
+
+let activeRequests = 0
+
+/**
+ * Streams one video request attempt. Test Optimization retry policy stays in the exporter request wrapper.
+ *
+ * @param {import('node:stream').Readable} body - Video stream for this attempt
+ * @param {object} options - HTTP request options
+ * @param {(error: Error|null, result?: string|null, statusCode?: number,
+ *   headers?: import('node:http').IncomingHttpHeaders) => void} callback
+ * @returns {void}
+ */
+function requestVideo (body, options, callback) {
+  if (activeRequests >= MAX_ACTIVE_REQUESTS) {
+    if (!body.destroyed) body.destroy()
+    const error = new log.NoTransmitError('Maximum active video request count reached.')
+    error.code = 'ERR_DD_VIDEO_REQUEST_LIMIT'
+    callback(error)
+    return
+  }
+
+  let requestOptions
+  try {
+    requestOptions = getRequestOptions(options)
+  } catch (error) {
+    if (!body.destroyed) body.destroy()
+    callback(error)
+    return
+  }
+
+  activeRequests++
+  legacyStorage.run({ noop: true }, () => {
+    const timeout = options.timeout || 2000
+    const client = requestOptions.protocol === 'https:' ? https : http
+    let finished = false
+    let req = null
+
+    const complete = (error, result, statusCode, headers) => {
+      if (finished) return
+      finished = true
+      activeRequests--
+      options.signal?.removeEventListener('abort', onAbort)
+      body.unpipe(req)
+      if (!body.destroyed) body.destroy()
+      if (req && !req.destroyed && (error || !req.writableFinished)) req.destroy()
+      callback(error, result, statusCode, headers)
+    }
+    const onAbort = () => complete(getAbortError(options.signal))
+
+    try {
+      req = client.request(requestOptions, res => {
+        markEndpointReached(requestOptions)
+        const chunks = []
+
+        res.setTimeout(timeout)
+        res.on('data', chunk => chunks.push(chunk))
+        res.once('aborted', () => complete(Object.assign(new Error('Response aborted'), { code: 'ECONNRESET' })))
+        res.once('error', complete)
+        res.once('timeout', () => complete(Object.assign(new Error('Response timed out'), { code: 'ETIMEDOUT' })))
+        res.once('end', () => {
+          const result = Buffer.concat(chunks).toString()
+          if (res.statusCode >= 200 && res.statusCode <= 299) {
+            complete(null, result, res.statusCode, res.headers)
+          } else {
+            complete(buildError(res, result, requestOptions), null, res.statusCode, res.headers)
+          }
+        })
+      })
+    } catch (error) {
+      activeRequests--
+      if (!body.destroyed) body.destroy()
+      callback(error)
+      return
+    }
+
+    req.once('error', complete)
+    req.setTimeout(timeout, () => complete(Object.assign(new Error('Request timed out'), { code: 'ETIMEDOUT' })))
+    body.once('error', error => {
+      error.retryable = false
+      complete(error)
+    })
+    options.signal?.addEventListener('abort', onAbort, { once: true })
+    if (options.signal?.aborted) return onAbort()
+    body.pipe(req)
+  })
+}
+
+/**
+ * @param {object} options
+ * @returns {object}
+ */
+function getRequestOptions (options) {
+  const requestOptions = {
+    ...options,
+    headers: options.headers ? { ...options.headers } : {},
+  }
+
+  if (options.url) {
+    const url = parseUrl(options.url)
+    if (url.protocol === 'unix:') {
+      requestOptions.socketPath = url.pathname
+    } else {
+      requestOptions.protocol = url.protocol
+      requestOptions.hostname = url.hostname
+      requestOptions.port = url.port
+      requestOptions.path ??= url.path
+    }
+  }
+
+  const hasApiKey = requestOptions.headers['dd-api-key'] !== undefined ||
+    requestOptions.headers['DD-API-KEY'] !== undefined
+  if (hasApiKey && requestOptions.protocol === 'http:' && !isLoopbackHost(requestOptions.hostname)) {
+    log.error(
+      'Not sending the Datadog API key over a non-TLS connection to %s. Configure an https intake URL.',
+      requestOptions.hostname
+    )
+    delete requestOptions.headers['dd-api-key']
+    delete requestOptions.headers['DD-API-KEY']
+  }
+
+  delete requestOptions.deadline
+  delete requestOptions.retry
+  delete requestOptions.retryUntilDeadline
+  delete requestOptions.signal
+  delete requestOptions.url
+  return requestOptions
+}
+
+/**
+ * @param {AbortSignal} signal
+ * @returns {Error}
+ */
+function getAbortError (signal) {
+  return signal?.reason || Object.assign(new Error('Request aborted'), { code: 'ABORT_ERR' })
+}
+
+/**
+ * @param {import('node:http').IncomingMessage} res
+ * @param {string} responseData
+ * @param {object} options
+ * @returns {Error}
+ */
+function buildError (res, responseData, options) {
+  let errorMessage = ''
+  try {
+    const port = options.port ? `:${options.port}` : ''
+    const baseUrl = `${options.protocol || 'http:'}//${options.hostname || 'localhost'}${port}`
+    const fullUrl = new URL(options.path, baseUrl).href
+    errorMessage = `Error from ${fullUrl}: ${res.statusCode} ${http.STATUS_CODES[res.statusCode]}.`
+  } catch {
+    // ignore
+  }
+  if (responseData) errorMessage += ` Response from the endpoint: "${responseData}"`
+
+  const error = new log.NoTransmitError(errorMessage)
+  error.status = res.statusCode
+  return error
+}
+
+Object.defineProperty(requestVideo, 'writable', {
+  get () { return activeRequests < MAX_ACTIVE_REQUESTS },
+})
+
+module.exports = requestVideo