dd-trace 6.8.0 → 6.10.0

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

@@ -0,0 +1,356 @@
+'use strict'
+
+/** @typedef {Record<string, unknown>} Carrier */
+/** @typedef {string | Buffer} PathwayValue */
+
+const FIELD_READ = 1
+const FIELD_WRITE = 2
+const FIELD_HAS = 4
+const FIELD_DELETE = 8
+const FIELD_NAME_LENGTH = 16
+
+/** @type {Record<string, unknown>} */
+const carrierOperations = {}
+
+/**
+ * @typedef {object} CarrierCapability
+ * @property {unknown} [read]
+ * @property {unknown} [write]
+ * @property {unknown} [has]
+ * @property {unknown} [delete]
+ * @property {unknown} [nameLength]
+ */
+
+/**
+ * @template Value
+ * @typedef {object} CarrierField
+ * @property {(carrier: Carrier) => Value | undefined} read
+ * @property {(carrier: Carrier, value: Value) => void} write
+ * @property {(carrier: Carrier) => boolean} has
+ * @property {(carrier: Carrier) => void} delete
+ * @property {(carrier: Carrier, target: Carrier) => void} copy
+ * @property {number} nameLength
+ */
+
+/**
+ * @template {CarrierCapability} Capability
+ * @param {string} name
+ * @param {number} operations
+ * @param {Capability} capability
+ * @returns {Capability}
+ */
+function defineCapability (name, operations, capability) {
+  const suffix = name[0].toUpperCase() + name.slice(1)
+  if (operations & FIELD_READ) carrierOperations[`read${suffix}`] = capability.read
+  if (operations & FIELD_WRITE) carrierOperations[`write${suffix}`] = capability.write
+  if (operations & FIELD_HAS) carrierOperations[`has${suffix}`] = capability.has
+  if (operations & FIELD_DELETE) carrierOperations[`delete${suffix}`] = capability.delete
+  if (operations & FIELD_NAME_LENGTH) carrierOperations[`${name}NameLength`] = capability.nameLength
+  return capability
+}
+
+/**
+ * @template Value
+ * @param {string} fieldName
+ * @param {string} headerName
+ * @param {(value: unknown) => Value | undefined} resolve
+ * @param {number} operations
+ * @returns {CarrierField<Value>}
+ */
+function defineField (fieldName, headerName, resolve, operations) {
+  return defineCapability(fieldName, operations, {
+    /**
+     * @param {Carrier} carrier
+     * @returns {Value | undefined}
+     */
+    read (carrier) {
+      return resolve(carrier[headerName])
+    },
+
+    /**
+     * @param {Carrier} carrier
+     * @param {Value} value
+     * @returns {void}
+     */
+    write (carrier, value) {
+      carrier[headerName] = value
+    },
+
+    /**
+     * @param {Carrier} carrier
+     * @returns {boolean}
+     */
+    has (carrier) {
+      return headerName in carrier
+    },
+
+    /**
+     * @param {Carrier} carrier
+     * @returns {void}
+     */
+    delete (carrier) {
+      delete carrier[headerName]
+    },
+
+    /**
+     * @param {Carrier} carrier
+     * @param {Carrier} target
+     * @returns {void}
+     */
+    copy (carrier, target) {
+      if (Object.hasOwn(carrier, headerName)) target[headerName] = carrier[headerName]
+    },
+
+    nameLength: headerName.length,
+  })
+}
+
+/**
+ * Skipping non-strings keeps a Symbol or a throwing `toString` from aborting
+ * extraction, which discards the whole context rather than one field.
+ *
+ * @param {unknown} value
+ * @returns {string | undefined}
+ */
+function readListText (value) {
+  if (typeof value === 'string') return value
+  if (!Array.isArray(value)) return
+
+  let joined = ''
+  let first = true
+
+  for (const item of value) {
+    if (typeof item !== 'string') continue
+    if (first) {
+      joined = item
+      first = false
+    } else {
+      joined += `,${item}`
+    }
+  }
+
+  return joined
+}
+
+/**
+ * @param {unknown} value
+ * @returns {string | undefined}
+ */
+function readLastText (value) {
+  if (typeof value === 'string') return value
+  if (!Array.isArray(value)) return
+
+  let result
+  for (let i = value.length - 1; i >= 0; i--) {
+    if (typeof value[i] === 'string') {
+      result = value[i]
+      break
+    }
+  }
+  return result
+}
+
+/**
+ * @param {unknown} value
+ * @returns {string | undefined}
+ */
+function readUniqueText (value) {
+  let result
+  if (typeof value === 'string') {
+    result = value
+  } else if (Array.isArray(value) && value.length === 1 && typeof value[0] === 'string') {
+    result = value[0]
+  }
+  return result
+}
+
+/**
+ * @param {unknown} value
+ * @returns {PathwayValue | undefined}
+ */
+function readLastPathway (value) {
+  if (typeof value === 'string' || Buffer.isBuffer(value)) return value
+  if (!Array.isArray(value)) return
+
+  let result
+  for (let i = value.length - 1; i >= 0; i--) {
+    const item = value[i]
+    if (typeof item === 'string' || Buffer.isBuffer(item)) {
+      result = item
+      break
+    }
+  }
+  return result
+}
+
+const datadogTraceId = defineField(
+  'datadogTraceId',
+  'x-datadog-trace-id',
+  readLastText,
+  FIELD_READ | FIELD_WRITE
+)
+const datadogParentId = defineField(
+  'datadogParentId',
+  'x-datadog-parent-id',
+  readLastText,
+  FIELD_READ | FIELD_WRITE | FIELD_DELETE
+)
+const datadogOrigin = defineField(
+  'datadogOrigin',
+  'x-datadog-origin',
+  readLastText,
+  FIELD_READ | FIELD_WRITE
+)
+const datadogSamplingPriority = defineField(
+  'datadogSamplingPriority',
+  'x-datadog-sampling-priority',
+  readLastText,
+  FIELD_READ | FIELD_WRITE
+)
+defineField('datadogTags', 'x-datadog-tags', readListText, FIELD_READ | FIELD_WRITE)
+defineField('baggage', 'baggage', readListText, FIELD_READ | FIELD_WRITE)
+const b3TraceId = defineField('b3TraceId', 'x-b3-traceid', readLastText, FIELD_READ | FIELD_WRITE)
+const b3SpanId = defineField('b3SpanId', 'x-b3-spanid', readLastText, FIELD_READ | FIELD_WRITE)
+const b3ParentId = defineField('b3ParentId', 'x-b3-parentspanid', readLastText, FIELD_WRITE)
+const b3Sampled = defineField('b3Sampled', 'x-b3-sampled', readLastText, FIELD_READ | FIELD_WRITE)
+const b3Flags = defineField('b3Flags', 'x-b3-flags', readLastText, FIELD_READ | FIELD_WRITE)
+const b3 = defineField('b3', 'b3', readLastText, FIELD_READ | FIELD_WRITE)
+defineField('sqsd', 'x-aws-sqsd-attr-_datadog', readLastText, FIELD_READ)
+const traceparent = defineField('traceparent', 'traceparent', readUniqueText, FIELD_READ | FIELD_WRITE)
+const tracestate = defineField('tracestate', 'tracestate', readListText, FIELD_READ | FIELD_WRITE)
+const dsmBase64 = defineField(
+  'dsmBase64',
+  'dd-pathway-ctx-base64',
+  readLastPathway,
+  FIELD_READ | FIELD_WRITE | FIELD_HAS | FIELD_NAME_LENGTH
+)
+const dsmBinary = defineField('dsmBinary', 'dd-pathway-ctx', readLastPathway, FIELD_READ | FIELD_HAS)
+
+const legacyBaggagePrefix = 'ot-baggage-'
+// RFC 7230 `token`, compatible with Node.js header-name validation.
+const httpHeaderNameExpr = /^[0-9A-Za-z!#$%&'*+\-.^_`|~]+$/
+
+defineCapability('legacyBaggage', FIELD_READ | FIELD_WRITE, {
+  /**
+   * @param {Record<string, string> | undefined} carrier
+   * @param {string} key
+   * @param {string} value
+   * @returns {Record<string, string> | undefined}
+   */
+  write (carrier, key, value) {
+    const name = legacyBaggagePrefix + key
+    if (!httpHeaderNameExpr.test(name)) return
+
+    carrier ??= {}
+    carrier[name] = value
+    return carrier
+  },
+
+  /**
+   * @param {Carrier} carrier
+   * @param {Record<string, string>} target
+   * @returns {void}
+   */
+  read (carrier, target) {
+    for (const name of Object.keys(carrier)) {
+      if (!name.startsWith(legacyBaggagePrefix)) continue
+      const key = name.slice(legacyBaggagePrefix.length)
+      if (!key) continue
+      const value = readLastText(carrier[name])
+      if (value !== undefined) target[key] = value
+    }
+  },
+})
+
+const textMapLogFields = [
+  datadogTraceId,
+  datadogParentId,
+  datadogSamplingPriority,
+  datadogOrigin,
+  b3TraceId,
+  b3SpanId,
+  b3ParentId,
+  b3Sampled,
+  b3Flags,
+  b3,
+  traceparent,
+  tracestate,
+]
+const dsmLogFields = [dsmBinary, dsmBase64]
+
+/**
+ * @param {Carrier} carrier
+ * @param {Array<Pick<CarrierField<unknown>, 'copy'>>} selectedFields
+ * @returns {Carrier}
+ */
+function pick (carrier, selectedFields) {
+  /** @type {Carrier} */
+  const result = {}
+  for (const field of selectedFields) field.copy(carrier, result)
+  return result
+}
+
+/**
+ * @param {Carrier} carrier
+ * @returns {Carrier}
+ */
+function pickTextMap (carrier) {
+  return pick(carrier, textMapLogFields)
+}
+
+/**
+ * @param {Carrier} carrier
+ * @returns {Carrier}
+ */
+function pickDsm (carrier) {
+  return pick(carrier, dsmLogFields)
+}
+
+/**
+ * @typedef {object} CarrierOperations
+ * @property {typeof datadogParentId.delete} deleteDatadogParentId
+ * @property {typeof dsmBase64.nameLength} dsmBase64NameLength
+ * @property {typeof dsmBase64.has} hasDsmBase64
+ * @property {typeof dsmBinary.has} hasDsmBinary
+ * @property {typeof pickDsm} pickDsm
+ * @property {typeof pickTextMap} pickTextMap
+ * @property {(carrier: Carrier) => string | undefined} readBaggage
+ * @property {typeof b3.read} readB3
+ * @property {typeof b3Flags.read} readB3Flags
+ * @property {typeof b3Sampled.read} readB3Sampled
+ * @property {typeof b3SpanId.read} readB3SpanId
+ * @property {typeof b3TraceId.read} readB3TraceId
+ * @property {typeof datadogOrigin.read} readDatadogOrigin
+ * @property {typeof datadogParentId.read} readDatadogParentId
+ * @property {typeof datadogSamplingPriority.read} readDatadogSamplingPriority
+ * @property {(carrier: Carrier) => string | undefined} readDatadogTags
+ * @property {typeof datadogTraceId.read} readDatadogTraceId
+ * @property {typeof dsmBase64.read} readDsmBase64
+ * @property {typeof dsmBinary.read} readDsmBinary
+ * @property {(carrier: Carrier, target: Record<string, string>) => void} readLegacyBaggage
+ * @property {(carrier: Carrier) => string | undefined} readSqsd
+ * @property {typeof traceparent.read} readTraceparent
+ * @property {typeof tracestate.read} readTracestate
+ * @property {(carrier: Carrier, value: string) => void} writeBaggage
+ * @property {typeof b3.write} writeB3
+ * @property {typeof b3Flags.write} writeB3Flags
+ * @property {typeof b3ParentId.write} writeB3ParentId
+ * @property {typeof b3Sampled.write} writeB3Sampled
+ * @property {typeof b3SpanId.write} writeB3SpanId
+ * @property {typeof b3TraceId.write} writeB3TraceId
+ * @property {typeof datadogOrigin.write} writeDatadogOrigin
+ * @property {typeof datadogParentId.write} writeDatadogParentId
+ * @property {typeof datadogSamplingPriority.write} writeDatadogSamplingPriority
+ * @property {(carrier: Carrier, value: string) => void} writeDatadogTags
+ * @property {typeof datadogTraceId.write} writeDatadogTraceId
+ * @property {typeof dsmBase64.write} writeDsmBase64
+ * @property {(carrier: Record<string, string> | undefined, key: string, value: string) =>
+ *   Record<string, string> | undefined} writeLegacyBaggage
+ * @property {typeof traceparent.write} writeTraceparent
+ * @property {typeof tracestate.write} writeTracestate
+ */
+
+carrierOperations.pickDsm = pickDsm
+carrierOperations.pickTextMap = pickTextMap
+
+module.exports = /** @type {CarrierOperations} */ (carrierOperations)

package/packages/dd-trace/src/ci-visibility/coverage-report-discovery.js

@@ -5,6 +5,8 @@ const path = require('node:path')
 
 const log = require('../log')
 
+const BIGINT_LSTAT_OPTIONS = { bigint: true, throwIfNoEntry: false }
+
 /**
  * Coverage report file patterns to search for
  * Each entry contains the relative path from root and the format identifier
@@ -38,7 +40,7 @@ const COVERAGE_REPORT_PATTERNS = [
 /**
  * Discovers code coverage report files in the given root directory
  * @param {string} rootDir - The root directory to search for coverage reports
- * @returns {Array<{filePath: string, format: string}>} Array of discovered coverage reports
+ * @returns {Array<{filePath: string, fileDevice: bigint, fileInode: bigint, format: string}>}
  */
 function discoverCoverageReports (rootDir) {
   if (!rootDir) {
@@ -46,27 +48,57 @@ function discoverCoverageReports (rootDir) {
     return []
   }
 
+  let resolvedRoot
+  try {
+    const unresolvedRoot = path.resolve(rootDir)
+    const rootStats = fs.lstatSync(unresolvedRoot, BIGINT_LSTAT_OPTIONS)
+    if (rootStats?.isSymbolicLink() || !rootStats?.isDirectory()) {
+      log.debug('Coverage report root is not a regular directory: %s', unresolvedRoot)
+      return []
+    }
+    resolvedRoot = fs.realpathSync(unresolvedRoot)
+    const resolvedRootStats = fs.lstatSync(resolvedRoot, BIGINT_LSTAT_OPTIONS)
+    if (!resolvedRootStats || resolvedRootStats.dev !== rootStats.dev || resolvedRootStats.ino !== rootStats.ino) {
+      log.debug('Coverage report root changed while resolving it: %s', unresolvedRoot)
+      return []
+    }
+  } catch (error) {
+    log.debug('Error checking coverage report root %s: %s', rootDir, error.message)
+    return []
+  }
+
   const discoveredReports = []
 
   for (const pattern of COVERAGE_REPORT_PATTERNS) {
-    const fullPath = path.join(rootDir, pattern.path)
+    let currentPath = resolvedRoot
 
     try {
-      if (fs.existsSync(fullPath)) {
-        const stats = fs.statSync(fullPath)
-
-        // Only include regular files, not directories or symlinks
-        if (stats.isFile()) {
-          discoveredReports.push({
-            filePath: fullPath,
-            format: pattern.format,
-          })
-          log.debug('Found coverage report: %s (format: %s)', fullPath, pattern.format)
+      let stats
+      for (const pathSegment of pattern.path.split('/')) {
+        currentPath = path.join(currentPath, pathSegment)
+        stats = fs.lstatSync(currentPath, BIGINT_LSTAT_OPTIONS)
+        if (!stats || stats.isSymbolicLink()) break
+      }
+
+      // A hard link can name a file outside the root without changing its real path.
+      if (stats?.isFile() && stats.nlink === 1n) {
+        const resolvedPath = fs.realpathSync(currentPath)
+        const pathFromRoot = path.relative(resolvedRoot, resolvedPath)
+        if (pathFromRoot === '..' || pathFromRoot.startsWith(`..${path.sep}`) || path.isAbsolute(pathFromRoot)) {
+          log.debug('Coverage report resolved outside the root directory: %s', currentPath)
+          continue
         }
+        discoveredReports.push({
+          filePath: resolvedPath,
+          fileDevice: stats.dev,
+          fileInode: stats.ino,
+          format: pattern.format,
+        })
+        log.debug('Found coverage report: %s (format: %s)', resolvedPath, pattern.format)
       }
-    } catch (err) {
+    } catch (error) {
       // Log but don't fail if we can't access a file
-      log.debug('Error checking coverage report path %s: %s', fullPath, err.message)
+      log.debug('Error checking coverage report path %s: %s', currentPath, error.message)
     }
   }
 

package/packages/dd-trace/src/ci-visibility/efd-retry-policy.js

@@ -0,0 +1,89 @@
+'use strict'
+
+const EARLY_FLAKE_DETECTION_RETRY_THRESHOLDS = [
+  { limitMs: 5000, key: '5s' },
+  { limitMs: 10_000, key: '10s' },
+  { limitMs: 30_000, key: '30s' },
+  { limitMs: 300_000, key: '5m' },
+]
+
+// A bucket the settings validator accepts but this module ignores silently loses its retries.
+const EARLY_FLAKE_DETECTION_RETRY_BUCKETS =
+  Object.freeze(EARLY_FLAKE_DETECTION_RETRY_THRESHOLDS.map(({ key }) => key))
+
+/**
+ * @typedef {object} EfdDurationRetryCount
+ * @property {number} durationLimitMs
+ * @property {number} retryCount
+ */
+
+/**
+ * @typedef {object} EfdRetryPolicy
+ * @property {readonly EfdDurationRetryCount[]} durationRetryCounts
+ * @property {number} schedulingRetryCount
+ */
+
+/**
+ * @param {number} durationMs
+ * @param {EfdRetryPolicy} retryPolicy
+ * @returns {number}
+ */
+function getEfdRetryCountForDuration (durationMs, retryPolicy) {
+  for (const { durationLimitMs, retryCount } of retryPolicy.durationRetryCounts) {
+    if (durationMs < durationLimitMs) {
+      return retryCount
+    }
+  }
+  return 0
+}
+
+/**
+ * @param {Record<string, unknown> | undefined} retriesByDuration
+ * @returns {EfdRetryPolicy}
+ */
+function createEfdRetryPolicy (retriesByDuration = {}) {
+  const durationRetryCounts = []
+  let schedulingRetryCount = 0
+  for (const { limitMs: durationLimitMs, key } of EARLY_FLAKE_DETECTION_RETRY_THRESHOLDS) {
+    const configuredRetryCount = retriesByDuration[key]
+    const retryCount = Number.isSafeInteger(configuredRetryCount) && configuredRetryCount >= 0
+      ? configuredRetryCount
+      : 0
+    durationRetryCounts.push(Object.freeze({ durationLimitMs, retryCount }))
+    if (retryCount > schedulingRetryCount) {
+      schedulingRetryCount = retryCount
+    }
+  }
+  return Object.freeze({
+    durationRetryCounts: Object.freeze(durationRetryCounts),
+    schedulingRetryCount,
+  })
+}
+
+/**
+ * @param {EfdRetryPolicy | undefined} retryPolicy
+ * @returns {boolean}
+ */
+function hasEfdRetries (retryPolicy) {
+  return (retryPolicy?.schedulingRetryCount ?? 0) > 0
+}
+
+/**
+ * @param {number} retryIndex
+ * @param {number | undefined} retryCount
+ * @returns {boolean}
+ */
+function shouldSkipEfdRetry (retryIndex, retryCount) {
+  return retryCount !== undefined && retryIndex > retryCount
+}
+
+const EMPTY_EFD_RETRY_POLICY = createEfdRetryPolicy()
+
+module.exports = {
+  EARLY_FLAKE_DETECTION_RETRY_BUCKETS,
+  EMPTY_EFD_RETRY_POLICY,
+  createEfdRetryPolicy,
+  getEfdRetryCountForDuration,
+  hasEfdRetries,
+  shouldSkipEfdRetry,
+}

package/packages/dd-trace/src/ci-visibility/exporters/ci-visibility-exporter.js

@@ -4,6 +4,7 @@ const { hostname: getHostname } = require('node:os')
 const URL = require('url').URL
 
 const { version: tracerVersion } = require('../../../../../package.json')
+const { EMPTY_EFD_RETRY_POLICY, createEfdRetryPolicy } = require('../efd-retry-policy')
 const { getLibraryConfiguration: getLibraryConfigurationRequest } = require('../requests/get-library-configuration')
 const { getSkippableSuites: getSkippableSuitesRequest } = require('../intelligent-test-runner/get-skippable-suites')
 const { getKnownTests: getKnownTestsRequest } = require('../early-flake-detection/get-known-tests')
@@ -23,6 +24,18 @@ const { sendGitMetadata: sendGitMetadataRequest } = require('./git/git_metadata'
 const hostname = getHostname()
 const EMPTY_SETTINGS = Object.freeze({})
 
+/**
+ * Test session identity sent with every request. Fields are optional because the CI provider,
+ * the git repository or the runtime may not expose them.
+ *
+ * @typedef {{
+ *   repositoryUrl?: string, sha?: string, branch?: string, tag?: string, testLevel?: string,
+ *   osVersion?: string, osPlatform?: string, osArchitecture?: string,
+ *   runtimeName?: string, runtimeVersion?: string, commitMessage?: string,
+ *   pullRequestBaseSha?: string, commitHeadSha?: string, commitHeadMessage?: string,
+ * }} TestConfiguration
+ */
+
 function getTestConfigurationTags (tags) {
   if (!tags) {
     return {}
@@ -190,6 +203,7 @@ class CiVisibilityExporter extends BufferingExporter {
     const cachedSkippableSuites = this._testOptimizationHttpCache.readSkippableSuites({
       testLevel: requestConfiguration.testLevel,
       isCoverageReportUploadEnabled: requestConfiguration.isCoverageReportUploadEnabled,
+      isLineCoverageSupported: requestConfiguration.isLineCoverageSupported,
     })
     if (cachedSkippableSuites !== CACHE_MISS) {
       const { skippableSuites, correlationId, coverage } = cachedSkippableSuites
@@ -238,6 +252,10 @@ class CiVisibilityExporter extends BufferingExporter {
   /**
    * We can't request library configuration until we know whether we can use the
    * CI Visibility Protocol, hence the this._canUseCiVisProtocol promise.
+   *
+   * @param {TestConfiguration} testConfiguration
+   * @param {(error: Error | null, libraryConfig?: Readonly<Record<string, unknown>>) => void} callback
+   * @returns {void}
    */
   getLibraryConfiguration (testConfiguration, callback) {
     const { repositoryUrl } = testConfiguration
@@ -321,21 +339,14 @@ class CiVisibilityExporter extends BufferingExporter {
       DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES: configuredAttemptToFixRetries = 0,
       DD_TEST_MANAGEMENT_ENABLED: isTestManagementAllowed,
     } = testOptimization
-    const hasEarlyFlakeDetectionRetryCount = earlyFlakeDetectionRetryCount !== undefined
-    const configuredSlowTestRetries = remoteConfiguration.earlyFlakeDetectionSlowTestRetries ?? EMPTY_SETTINGS
-    const earlyFlakeDetectionSlowTestRetries = hasEarlyFlakeDetectionRetryCount
-      ? Object.freeze({
+    const earlyFlakeDetectionRetryPolicy = earlyFlakeDetectionRetryCount === undefined
+      ? remoteConfiguration.earlyFlakeDetectionRetryPolicy ?? EMPTY_EFD_RETRY_POLICY
+      : createEfdRetryPolicy({
         '5s': earlyFlakeDetectionRetryCount,
         '10s': earlyFlakeDetectionRetryCount,
         '30s': earlyFlakeDetectionRetryCount,
         '5m': earlyFlakeDetectionRetryCount,
       })
-      : Object.isFrozen(configuredSlowTestRetries)
-        ? configuredSlowTestRetries
-        : Object.freeze({ ...configuredSlowTestRetries })
-    const earlyFlakeDetectionNumRetries = hasEarlyFlakeDetectionRetryCount
-      ? earlyFlakeDetectionRetryCount
-      : remoteConfiguration.earlyFlakeDetectionNumRetries ?? 0
     const testManagementAttemptToFixRetries =
       remoteConfiguration.testManagementAttemptToFixRetries ?? configuredAttemptToFixRetries
 
@@ -346,8 +357,7 @@ class CiVisibilityExporter extends BufferingExporter {
       requireGit: remoteConfiguration.requireGit === true,
       isEarlyFlakeDetectionEnabled:
         remoteConfiguration.isEarlyFlakeDetectionEnabled === true && isEarlyFlakeDetectionAllowed === true,
-      earlyFlakeDetectionNumRetries,
-      earlyFlakeDetectionSlowTestRetries,
+      earlyFlakeDetectionRetryPolicy,
       earlyFlakeDetectionFaultyThreshold: remoteConfiguration.earlyFlakeDetectionFaultyThreshold ?? 30,
       isFlakyTestRetriesEnabled:
         remoteConfiguration.isFlakyTestRetriesEnabled === true && isFlakyTestRetriesAllowed === true,
@@ -521,17 +531,21 @@ class CiVisibilityExporter extends BufferingExporter {
    * Uploads a single coverage report to the CI intake.
    * @param {object} options - Upload options
    * @param {string} options.filePath - Path to the coverage report file
+   * @param {bigint} options.fileDevice - Device containing the discovered report
+   * @param {bigint} options.fileInode - Inode of the discovered report
    * @param {string} options.format - Format of the coverage report
    * @param {object} options.testEnvironmentMetadata - Test environment metadata containing git/CI tags
    * @param {(error: Error|null) => void} callback - Callback function
    */
-  uploadCoverageReport ({ filePath, format, testEnvironmentMetadata }, callback) {
+  uploadCoverageReport ({ filePath, fileDevice, fileInode, format, testEnvironmentMetadata }, callback) {
     if (!this._codeCoverageReportUrl) {
       return callback(new Error('Coverage report upload URL not configured'))
     }
 
     uploadCoverageReportRequest({
       filePath,
+      fileDevice,
+      fileInode,
       format,
       flags: this._coverageReportFlags,
       testEnvironmentMetadata,

package/packages/dd-trace/src/ci-visibility/exporters/git/git_metadata.js

@@ -32,6 +32,9 @@ const {
   TELEMETRY_GIT_REQUESTS_OBJECT_PACKFILES_BYTES,
 } = require('../../../ci-visibility/telemetry')
 
+/** @typedef {{ isEvpProxy: boolean, evpProxyPrefix: string }} EvpProxyConfiguration */
+/** @typedef {EvpProxyConfiguration & { url: URL, repositoryUrl: string }} GitUploadTarget */
+
 const isValidSha1 = (sha) => /^[0-9a-f]{40}$/.test(sha)
 const isValidSha256 = (sha) => /^[0-9a-f]{64}$/.test(sha)
 
@@ -62,6 +65,10 @@ function getCommonRequestOptions (url) {
  * This function posts the SHAs of the commits of the last month
  * The response are the commits for which the backend already has information
  * This response is used to know which commits can be ignored from there on
+ *
+ * @param {GitUploadTarget & { latestCommits: string[] }} options
+ * @param {(error: Error | null, commitsToUpload?: string[]) => void} callback
+ * @returns {void}
  */
 function getCommitsToUpload ({ url, repositoryUrl, latestCommits, isEvpProxy, evpProxyPrefix }, callback) {
   const commonOptions = getCommonRequestOptions(url)
@@ -127,6 +134,10 @@ function getCommitsToUpload ({ url, repositoryUrl, latestCommits, isEvpProxy, ev
 
 /**
  * This function uploads a git packfile
+ *
+ * @param {GitUploadTarget & { packFileToUpload: string, headCommit: string }} options
+ * @param {(error: Error | null, uploadSize?: number) => void} callback
+ * @returns {void}
  */
 function uploadPackFile ({ url, isEvpProxy, evpProxyPrefix, packFileToUpload, repositoryUrl, headCommit }, callback) {
   const form = new FormData()
@@ -245,6 +256,12 @@ function generateAndUploadPackFiles ({
 
 /**
  * This function uploads git metadata to CI Visibility's backend.
+ *
+ * @param {URL} url
+ * @param {EvpProxyConfiguration} evpProxyConfiguration
+ * @param {string | undefined} configRepositoryUrl repository URL from the configuration, if set
+ * @param {(error?: Error | null) => void} callback
+ * @returns {void}
  */
 function sendGitMetadata (url, { isEvpProxy, evpProxyPrefix }, configRepositoryUrl, callback) {
   if (!isGitAvailable()) {