dd-trace 6.3.0 → 6.5.0

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

@@ -0,0 +1,369 @@
+'use strict'
+
+const crypto = require('node:crypto')
+const fs = require('node:fs')
+const path = require('node:path')
+
+const { MAX_OUTPUT_BYTES, msgpackToJson } = require('./msgpack-to-json')
+const { projectTestCyclePayload } = require('./payload-projection')
+
+const MAX_OUTPUT_FILES = 10_000
+const MAX_SAMPLED_TESTS = 8
+const MAX_SUMMARY_ERRORS = 20
+const SUMMARY_PREFIX = 'DD_TEST_OPTIMIZATION_VALIDATION_V1 '
+
+let payloadFileSequence = 0
+
+class CiValidationSink {
+  #bytesWritten = 0
+  #captureMode
+  #completionDirectory
+  #errors = []
+  #eventsObserved = 0
+  #eventsRetained = 0
+  #fileCount = 0
+  #inputs = Object.create(null)
+  #outputRoot
+  #outputRootDirectory
+  #payloadsDirectory
+  #processId = crypto.randomBytes(16).toString('hex')
+  #sampledLifecycle = new Map()
+  #sampledTests = []
+  #summaryWritten = false
+  #testsDirectory
+  #testsObserved = 0
+  #testPayloadFileCount = 0
+
+  /**
+   * Creates a bounded payload-file sink under a validator-owned output root.
+   *
+   * @param {string} outputRoot absolute validator-owned output directory
+   * @param {object} [options] sink options
+   * @param {'sample'|'strict'} [options.captureMode] evidence retention mode
+   */
+  constructor (outputRoot, { captureMode = 'strict' } = {}) {
+    if (typeof outputRoot !== 'string' || !path.isAbsolute(outputRoot)) {
+      throw new Error('Offline Test Optimization validation output root must be absolute.')
+    }
+
+    if (!['sample', 'strict'].includes(captureMode)) {
+      throw new Error('Offline Test Optimization validation capture mode is invalid.')
+    }
+    this.#captureMode = captureMode
+    this.#outputRoot = outputRoot
+    this.#outputRootDirectory = captureDirectory(outputRoot, 'output root')
+    const payloadsRoot = path.join(outputRoot, 'payloads')
+    this.#payloadsDirectory = createDirectory(outputRoot, this.#outputRootDirectory, payloadsRoot, 'payloads')
+    this.#testsDirectory = createDirectory(
+      payloadsRoot,
+      this.#payloadsDirectory,
+      path.join(payloadsRoot, 'tests'),
+      'tests'
+    )
+    this.#completionDirectory = createDirectory(
+      outputRoot,
+      this.#outputRootDirectory,
+      path.join(outputRoot, 'completions'),
+      'completions'
+    )
+  }
+
+  /**
+   * Converts and writes one Test Optimization payload using the Bazel-compatible JSON layout.
+   *
+   * @param {Buffer} payload encoded Test Optimization payload
+   */
+  writeTestCycle (payload) {
+    let decoded
+    try {
+      decoded = JSON.parse(msgpackToJson(payload).toString('utf8'))
+    } catch {
+      this.#fail('output_payload_decode_failed')
+      return
+    }
+
+    let projected
+    try {
+      projected = projectTestCyclePayload(decoded)
+    } catch {
+      this.#fail('output_payload_projection_failed')
+      return
+    }
+
+    this.#eventsObserved += projected.events.length
+    if (this.#captureMode === 'sample') {
+      this.#retainSample(projected.events)
+      return
+    }
+
+    const json = Buffer.from(JSON.stringify(projected))
+    if (this.#writePayloadFile(json)) {
+      this.#eventsRetained += projected.events.length
+      this.#testPayloadFileCount++
+    }
+  }
+
+  /**
+   * Records whether a control-plane fixture was loaded from the filesystem cache.
+   *
+   * @param {string} name fixed fixture name
+   * @param {Error|undefined|null} error cache-load error
+   */
+  writeInputResult (name, error) {
+    if (error) this.#addError(`invalid_${name}`)
+    this.#inputs[name] = { status: error ? 'error' : 'loaded' }
+  }
+
+  /**
+   * Records an exporter failure in the bounded validation summary.
+   *
+   * @param {string} code stable failure code
+   */
+  recordError (code) {
+    this.#fail(code)
+  }
+
+  /**
+   * Emits this process's single bounded stderr summary for validator aggregation.
+   */
+  writeSummary () {
+    if (this.#summaryWritten) return
+    this.#summaryWritten = true
+    if (this.#captureMode === 'sample') this.#writeSampledEvents()
+    const summary = {
+      events: this.#eventsRetained,
+      payloadFiles: this.#testPayloadFileCount,
+      input: 'filesystem-cache',
+      inputs: this.#inputs,
+      errors: this.#errors,
+    }
+    if (!this.#writeCompletionRecord()) this.#fail('completion_write_failed')
+    process.stderr.write(`${SUMMARY_PREFIX}${JSON.stringify(summary)}\n`)
+  }
+
+  /**
+   * Retains bounded first/late test evidence and the latest lifecycle event of each type.
+   *
+   * @param {object[]} events projected events
+   */
+  #retainSample (events) {
+    for (const event of events) {
+      if (event.type !== 'test') {
+        this.#sampledLifecycle.set(event.type, event)
+        continue
+      }
+      this.#testsObserved++
+      if (this.#sampledTests.length < MAX_SAMPLED_TESTS) {
+        this.#sampledTests.push(event)
+      } else {
+        const lateIndex = Math.floor(MAX_SAMPLED_TESTS / 2) +
+          (this.#testsObserved % Math.ceil(MAX_SAMPLED_TESTS / 2))
+        this.#sampledTests[lateIndex] = event
+      }
+    }
+  }
+
+  /**
+   * Persists the final bounded CI-replay sample after all process-local events have been observed.
+   */
+  #writeSampledEvents () {
+    const events = [...this.#sampledTests, ...this.#sampledLifecycle.values()]
+    if (events.length === 0) return
+    const payload = Buffer.from(JSON.stringify({ version: 1, events }))
+    if (this.#writePayloadFile(payload)) {
+      this.#eventsRetained = events.length
+      this.#testPayloadFileCount++
+    }
+  }
+
+  /**
+   * Atomically publishes this process's bounded completion evidence.
+   *
+   * @returns {boolean} whether the record was published
+   */
+  #writeCompletionRecord () {
+    const directoryPath = path.join(this.#outputRoot, 'completions')
+    const filename = path.join(directoryPath, `completion-${this.#processId}.json`)
+    const temporary = `${filename}.tmp`
+    const completion = Buffer.from(JSON.stringify({
+      version: 1,
+      processId: this.#processId,
+      captureMode: this.#captureMode,
+      counts: {
+        eventsObserved: this.#eventsObserved,
+        eventsRetained: this.#eventsRetained,
+        payloadFiles: this.#testPayloadFileCount,
+      },
+      inputs: this.#inputs,
+      errors: this.#errors,
+    }))
+
+    try {
+      assertDirectoryUnchanged(this.#outputRoot, this.#outputRootDirectory, 'output root')
+      assertDirectoryUnchanged(directoryPath, this.#completionDirectory, 'completions')
+      writeNewFile(temporary, completion)
+      assertDirectoryUnchanged(directoryPath, this.#completionDirectory, 'completions')
+      fs.renameSync(temporary, filename)
+      return true
+    } catch {
+      removePartialFile(temporary, directoryPath, this.#completionDirectory)
+      return false
+    }
+  }
+
+  /**
+   * Writes one completed JSON payload to a unique file.
+   *
+   * @param {Buffer} payload JSON payload
+   * @returns {boolean} whether the payload was written
+   */
+  #writePayloadFile (payload) {
+    if (this.#fileCount >= MAX_OUTPUT_FILES) {
+      this.#fail('output_file_limit_exceeded')
+      return false
+    }
+    if (this.#bytesWritten + payload.length > MAX_OUTPUT_BYTES) {
+      this.#fail('output_byte_limit_exceeded')
+      return false
+    }
+
+    const directoryPath = path.join(this.#outputRoot, 'payloads', 'tests')
+    const sequence = ++payloadFileSequence
+    const timestamp = BigInt(Date.now()) * 1_000_000n + process.hrtime.bigint() % 1_000_000n
+    const filename = path.join(
+      directoryPath,
+      `tests-${this.#processId}-${timestamp}-${process.pid}-${sequence}.json`
+    )
+    let writeFailed = false
+    try {
+      assertDirectoryUnchanged(this.#outputRoot, this.#outputRootDirectory, 'output root')
+      assertDirectoryUnchanged(path.join(this.#outputRoot, 'payloads'), this.#payloadsDirectory, 'payloads')
+      assertDirectoryUnchanged(directoryPath, this.#testsDirectory, 'tests')
+      writeNewFile(filename, payload)
+    } catch {
+      writeFailed = true
+    }
+    if (writeFailed) {
+      this.#fail('output_write_failed')
+      removePartialFile(filename, directoryPath, this.#testsDirectory)
+      return false
+    }
+
+    this.#bytesWritten += payload.length
+    this.#fileCount++
+    return true
+  }
+
+  /**
+   * Records a sink failure and makes the process unsuccessful.
+   *
+   * @param {string} code stable failure code
+   */
+  #fail (code) {
+    this.#addError(code)
+    process.exitCode = 1
+  }
+
+  /**
+   * Adds one unique bounded summary error.
+   *
+   * @param {string} code stable failure code
+   */
+  #addError (code) {
+    if (this.#errors.length >= MAX_SUMMARY_ERRORS || this.#errors.includes(code)) return
+    this.#errors.push(code)
+  }
+}
+
+/**
+ * Writes one new private regular file and rejects hard links or non-files.
+ *
+ * @param {string} filename output filename
+ * @param {Buffer} payload output bytes
+ */
+function writeNewFile (filename, payload) {
+  const flags = fs.constants.O_WRONLY |
+    fs.constants.O_CREAT |
+    fs.constants.O_EXCL |
+    (fs.constants.O_NOFOLLOW || 0)
+  const file = fs.openSync(filename, flags, 0o600)
+  try {
+    const stat = fs.fstatSync(file)
+    if (!stat.isFile() || stat.nlink !== 1) {
+      throw new Error('Offline Test Optimization output is not a private regular file.')
+    }
+    fs.writeFileSync(file, payload)
+  } finally {
+    fs.closeSync(file)
+  }
+}
+
+/**
+ * Captures the identity of one existing non-symbolic directory.
+ *
+ * @param {string} directory directory path
+ * @param {string} label directory label
+ * @returns {{dev: number, ino: number}} stable directory identity
+ */
+function captureDirectory (directory, label) {
+  const stat = fs.lstatSync(directory)
+  if (!stat.isDirectory() || stat.isSymbolicLink()) {
+    throw new Error(`Offline Test Optimization validation ${label} must be a regular directory.`)
+  }
+  return { dev: stat.dev, ino: stat.ino }
+}
+
+/**
+ * Creates or validates one child directory without accepting symbolic links.
+ *
+ * @param {string} parent parent directory path
+ * @param {{dev: number, ino: number}} parentIdentity expected parent identity
+ * @param {string} directory child directory path
+ * @param {string} label directory label
+ * @returns {{dev: number, ino: number}} stable child identity
+ */
+function createDirectory (parent, parentIdentity, directory, label) {
+  assertDirectoryUnchanged(parent, parentIdentity, 'parent output')
+  try {
+    fs.mkdirSync(directory, { mode: 0o700 })
+  } catch (error) {
+    if (error.code !== 'EEXIST') throw error
+  }
+  return captureDirectory(directory, `${label} output directory`)
+}
+
+/**
+ * Rejects a directory that changed after sink construction.
+ *
+ * @param {string} directory directory path
+ * @param {{dev: number, ino: number}} identity expected directory identity
+ * @param {string} label directory label
+ */
+function assertDirectoryUnchanged (directory, identity, label) {
+  const current = captureDirectory(directory, label)
+  if (current.dev !== identity.dev || current.ino !== identity.ino) {
+    throw new Error(`Offline Test Optimization validation ${label} changed during execution.`)
+  }
+}
+
+/**
+ * Removes a partially written final path without following symbolic links.
+ *
+ * @param {string} filename partial payload path
+ * @param {string} directory expected parent directory
+ * @param {{dev: number, ino: number}} identity expected parent identity
+ */
+function removePartialFile (filename, directory, identity) {
+  try {
+    assertDirectoryUnchanged(directory, identity, 'partial-file parent')
+    const stat = fs.lstatSync(filename)
+    if (stat.isFile() || stat.isSymbolicLink()) fs.unlinkSync(filename)
+  } catch {}
+}
+
+module.exports = {
+  CiValidationSink,
+  MAX_OUTPUT_BYTES,
+  MAX_OUTPUT_FILES,
+  SUMMARY_PREFIX,
+}

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

@@ -0,0 +1,60 @@
+'use strict'
+
+const { AgentlessCiVisibilityEncoder } = require('../../../encode/agentless-ci-visibility')
+
+class CiValidationWriter {
+  /**
+   * Creates an offline writer that preserves CI Visibility event encoding.
+   *
+   * @param {object} options writer options
+   * @param {object} options.sink bounded validation sink
+   * @param {object} options.tags tracer tags
+   */
+  constructor ({ sink, tags }) {
+    const { 'runtime-id': runtimeId, env, service } = tags
+    this._sink = sink
+    this._encoder = new AgentlessCiVisibilityEncoder(this, { runtimeId, env, service })
+  }
+
+  /**
+   * Encodes a CI Visibility trace without using an HTTP writer.
+   *
+   * @param {object[]} trace formatted trace
+   */
+  append (trace) {
+    this._encoder.encode(trace)
+  }
+
+  /**
+   * Flushes encoded events synchronously to an offline payload file.
+   *
+   * @param {Function} [done] completion callback
+   */
+  flush (done = () => {}) {
+    if (this._encoder.count() > 0) {
+      let payload
+      try {
+        payload = this._encoder.makePayload()
+      } catch (error) {
+        if (error.code !== 'ERR_MSGPACK_CHUNK_OVERFLOW') throw error
+        this._encoder.reset()
+        this._sink.recordError('output_payload_too_large')
+        done()
+        return
+      }
+      this._sink.writeTestCycle(payload)
+    }
+    done()
+  }
+
+  /**
+   * Adds CI event metadata before the next payload is encoded.
+   *
+   * @param {object} tags metadata grouped by event type
+   */
+  addMetadataTags (tags) {
+    this._encoder.addMetadataTags(tags)
+  }
+}
+
+module.exports = CiValidationWriter

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

@@ -13,6 +13,7 @@ const { writeSettingsToCache } = require('../test-optimization-cache')
 const { CACHE_MISS, TestOptimizationHttpCache } = require('../test-optimization-http-cache')
 const { uploadCoverageReport: uploadCoverageReportRequest } = require('../requests/upload-coverage-report')
 const { uploadTestScreenshot: uploadTestScreenshotRequest } = require('../requests/upload-test-screenshot')
+const { parsers } = require('../../config/parsers')
 const log = require('../../log')
 const BufferingExporter = require('../../exporters/common/buffering-exporter')
 const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../../plugins/util/tags')
@@ -41,6 +42,7 @@ function getIsTestSessionTrace (trace) {
 
 const GIT_UPLOAD_TIMEOUT = 60_000 // 60 seconds
 const CAN_USE_CI_VIS_PROTOCOL_TIMEOUT = GIT_UPLOAD_TIMEOUT
+const MAX_COVERAGE_REPORT_FLAGS = 32
 
 function appendLogTag (tags, key, value) {
   if (value !== undefined) {
@@ -71,13 +73,24 @@ function getLogTags (logMessage, { env, version }, gitRepositoryUrl, gitCommitSh
 }
 
 class CiVisibilityExporter extends BufferingExporter {
-  constructor (config) {
+  constructor (config, options = {}) {
     super(config)
     this._timer = undefined
     this._coverageTimer = undefined
     this._logsTimer = undefined
     this._coverageBuffer = []
-    this._testOptimizationHttpCache = new TestOptimizationHttpCache()
+    this._testOptimizationHttpCache = options.testOptimizationHttpCache || new TestOptimizationHttpCache()
+    this._isTestOptimizationCacheOnly = options.cacheOnly === true
+    const coverageReportFlags = parsers.ARRAY(config?.testOptimization?.DD_CODE_COVERAGE_FLAGS)
+    if (coverageReportFlags?.length > MAX_COVERAGE_REPORT_FLAGS) {
+      log.warn(
+        'Maximum of %d coverage report flags allowed, but %d flags were provided. Omitting coverage report flags.',
+        MAX_COVERAGE_REPORT_FLAGS,
+        coverageReportFlags.length
+      )
+    } else if (coverageReportFlags?.length) {
+      this._coverageReportFlags = [...coverageReportFlags]
+    }
     // The library can use new features like ITR and test suite level visibility
     // AKA CI Vis Protocol
     this._canUseCiVisProtocol = false
@@ -181,6 +194,9 @@ class CiVisibilityExporter extends BufferingExporter {
       const { skippableSuites, correlationId, coverage } = cachedSkippableSuites
       return callback(null, skippableSuites, correlationId, coverage)
     }
+    if (this._isTestOptimizationCacheOnly) {
+      return callback(this._getCacheOnlyError('skippable tests'), [])
+    }
 
     this._gitUploadPromise.then(gitUploadError => {
       if (gitUploadError) {
@@ -198,6 +214,9 @@ class CiVisibilityExporter extends BufferingExporter {
     if (cachedKnownTests !== CACHE_MISS) {
       return callback(null, cachedKnownTests)
     }
+    if (this._isTestOptimizationCacheOnly) {
+      return callback(this._getCacheOnlyError('known tests'))
+    }
     getKnownTestsRequest(this.getRequestConfiguration(testConfiguration), callback)
   }
 
@@ -209,6 +228,9 @@ class CiVisibilityExporter extends BufferingExporter {
     if (cachedTestManagementTests !== CACHE_MISS) {
       return callback(null, cachedTestManagementTests)
     }
+    if (this._isTestOptimizationCacheOnly) {
+      return callback(this._getCacheOnlyError('test management tests'))
+    }
     getTestManagementTestsRequest(this.getRequestConfiguration(testConfiguration), callback)
   }
 
@@ -241,6 +263,10 @@ class CiVisibilityExporter extends BufferingExporter {
         return callback(null, this._libraryConfig)
       }
 
+      if (this._isTestOptimizationCacheOnly) {
+        return callback(this._getCacheOnlyError('settings'), {})
+      }
+
       this.sendGitMetadata(repositoryUrl)
       getLibraryConfigurationRequest(configuration, (err, libraryConfig) => {
         /**
@@ -270,6 +296,17 @@ class CiVisibilityExporter extends BufferingExporter {
     })
   }
 
+  /**
+   * Returns the deterministic cache error for offline exporters.
+   *
+   * @param {string} input required cache input
+   * @returns {Error} cache error
+   */
+  _getCacheOnlyError (input) {
+    return this._testOptimizationHttpCache.getLastError?.() ||
+      new Error(`Offline Test Optimization validation requires a valid ${input} cache fixture.`)
+  }
+
   // Takes into account potential kill switches
   filterConfiguration (remoteConfiguration) {
     if (!remoteConfiguration) {
@@ -293,6 +330,9 @@ class CiVisibilityExporter extends BufferingExporter {
       isCoverageReportUploadEnabled,
     } = remoteConfiguration
     const { testOptimization } = this._config
+    const earlyFlakeDetectionRetryCount =
+      testOptimization.DD_TEST_EARLY_FLAKE_DETECTION_RETRY_COUNT
+    const hasEarlyFlakeDetectionRetryCount = earlyFlakeDetectionRetryCount !== undefined
     return {
       isCodeCoverageEnabled,
       isSuitesSkippingEnabled,
@@ -300,8 +340,16 @@ class CiVisibilityExporter extends BufferingExporter {
       requireGit,
       isEarlyFlakeDetectionEnabled:
         isEarlyFlakeDetectionEnabled && testOptimization.DD_CIVISIBILITY_EARLY_FLAKE_DETECTION_ENABLED,
-      earlyFlakeDetectionNumRetries,
-      earlyFlakeDetectionSlowTestRetries,
+      earlyFlakeDetectionNumRetries:
+        hasEarlyFlakeDetectionRetryCount ? earlyFlakeDetectionRetryCount : earlyFlakeDetectionNumRetries,
+      earlyFlakeDetectionSlowTestRetries: hasEarlyFlakeDetectionRetryCount
+        ? {
+            '5s': earlyFlakeDetectionRetryCount,
+            '10s': earlyFlakeDetectionRetryCount,
+            '30s': earlyFlakeDetectionRetryCount,
+            '5m': earlyFlakeDetectionRetryCount,
+          }
+        : earlyFlakeDetectionSlowTestRetries,
       earlyFlakeDetectionFaultyThreshold,
       isFlakyTestRetriesEnabled: isFlakyTestRetriesEnabled && testOptimization.DD_CIVISIBILITY_FLAKY_RETRY_ENABLED,
       flakyTestRetriesCount: testOptimization.DD_CIVISIBILITY_FLAKY_RETRY_COUNT,
@@ -318,6 +366,7 @@ class CiVisibilityExporter extends BufferingExporter {
 
   sendGitMetadata (repositoryUrl) {
     if (!this._config.testOptimization.DD_CIVISIBILITY_GIT_UPLOAD_ENABLED) {
+      this._resolveGit()
       return
     }
     this._canUseCiVisProtocolPromise.then((canUseCiVisProtocol) => {
@@ -475,7 +524,7 @@ class CiVisibilityExporter extends BufferingExporter {
    * @param {string} options.filePath - Path to the coverage report file
    * @param {string} options.format - Format of the coverage report
    * @param {object} options.testEnvironmentMetadata - Test environment metadata containing git/CI tags
-   * @param {Function} callback - Callback function (err)
+   * @param {(error: Error|null) => void} callback - Callback function
    */
   uploadCoverageReport ({ filePath, format, testEnvironmentMetadata }, callback) {
     if (!this._codeCoverageReportUrl) {
@@ -485,6 +534,7 @@ class CiVisibilityExporter extends BufferingExporter {
     uploadCoverageReportRequest({
       filePath,
       format,
+      flags: this._coverageReportFlags,
       testEnvironmentMetadata,
       url: this._codeCoverageReportUrl,
       isEvpProxy: !!this._isUsingEvpProxy,

package/packages/dd-trace/src/ci-visibility/exporters/test-worker/index.js

@@ -102,14 +102,30 @@ class TestWorkerCiVisibilityExporter {
     this._logsWriter.append({ testEnvironmentMetadata, logMessage })
   }
 
-  // TODO: add to other writers
+  /**
+   * @param {() => void} [onDone]
+   */
   flush (onDone) {
-    this._writer.flush(onDone)
-    this._coverageWriter.flush()
-    this._logsWriter.flush()
-    if (this._telemetryWriter) {
-      this._telemetryWriter.flush()
+    if (!onDone) {
+      this._writer.flush()
+      this._coverageWriter.flush()
+      this._logsWriter.flush()
+      if (this._telemetryWriter) {
+        this._telemetryWriter.flush()
+      }
+      return
+    }
+
+    let pendingWriters = this._telemetryWriter ? 4 : 3
+    const onWriterFlushed = () => {
+      pendingWriters--
+      if (pendingWriters === 0) onDone()
     }
+
+    this._writer.flush(onWriterFlushed)
+    this._coverageWriter.flush(onWriterFlushed)
+    this._logsWriter.flush(onWriterFlushed)
+    this._telemetryWriter?.flush(onWriterFlushed)
   }
 }
 

package/packages/dd-trace/src/ci-visibility/exporters/test-worker/writer.js

@@ -15,6 +15,9 @@ class Writer {
     this._interprocessCode = interprocessCode
   }
 
+  /**
+   * @param {() => void} [onDone]
+   */
   flush (onDone) {
     const count = this._encoder.count()
 
@@ -22,6 +25,8 @@ class Writer {
       const payload = this._encoder.makePayload()
 
       this._sendPayload(payload, onDone)
+    } else {
+      onDone?.()
     }
   }