dd-trace 6.10.0 → 6.11.0

package/packages/datadog-plugin-playwright/src/index.js

@@ -79,6 +79,9 @@ function isPlaywrightFailureScreenshot (attachment) {
 class PlaywrightPlugin extends CiPlugin {
   static id = 'playwright'
 
+  #isFinalizingAfterError = false
+  #pendingTestFinishCallbacks = new Map()
+
   constructor (...args) {
     super(...args)
 
@@ -99,6 +102,7 @@ class PlaywrightPlugin extends CiPlugin {
     })
 
     this.addSub('ci:playwright:session:start', ({ isFailureScreenshotEnabled }) => {
+      this.#isFinalizingAfterError = false
       if (!getConfig().testOptimization.DD_TEST_FAILURE_SCREENSHOTS_ENABLED) return
 
       if (!isFailureScreenshotEnabled) {
@@ -127,8 +131,21 @@ class PlaywrightPlugin extends CiPlugin {
       isEarlyFlakeDetectionEnabled,
       isEarlyFlakeDetectionFaulty,
       isTestManagementTestsEnabled,
+      error,
       onDone,
     }) => {
+      if (error) {
+        this.#isFinalizingAfterError = true
+        for (const testSuiteSpan of this._testSuiteSpansByTestSuiteAbsolutePath.values()) {
+          testSuiteSpan.setTag(TEST_STATUS, 'fail')
+          testSuiteSpan.setTag('error', error)
+        }
+        for (const [finishTest, abortController] of this.#pendingTestFinishCallbacks) {
+          finishTest(SCREENSHOT_UPLOAD_RESULT_ERROR)
+          abortController.abort()
+        }
+      }
+
       const finishSession = () => {
         this.testModuleSpan.setTag(TEST_STATUS, status)
         this.testSessionSpan.setTag(TEST_STATUS, status)
@@ -139,20 +156,24 @@ class PlaywrightPlugin extends CiPlugin {
         if (isEarlyFlakeDetectionFaulty) {
           this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ABORT_REASON, 'faulty')
         }
-        if (status === 'fail' && this.numFailedSuites > 0) {
+        let sessionError = error
+        if (!sessionError && status === 'fail' && this.numFailedSuites > 0) {
           let errorMessage = `Test suites failed: ${this.numFailedSuites}.`
           if (this.numFailedTests > 0) {
             errorMessage += ` Tests failed: ${this.numFailedTests}`
           }
-          const error = new Error(errorMessage)
-          this.testModuleSpan.setTag('error', error)
-          this.testSessionSpan.setTag('error', error)
+          sessionError = new Error(errorMessage)
+        }
+        if (sessionError) {
+          this.testModuleSpan.setTag('error', sessionError)
+          this.testSessionSpan.setTag('error', sessionError)
         }
 
         if (isTestManagementTestsEnabled) {
           this.testSessionSpan.setTag(TEST_MANAGEMENT_ENABLED, 'true')
         }
 
+        this.tracer._exporter.exportDeferredTestSuiteSpans?.()
         this.testModuleSpan.finish()
         this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
         this.testSessionSpan.finish()
@@ -234,6 +255,7 @@ class PlaywrightPlugin extends CiPlugin {
         this.numFailedSuites++
       }
 
+      this.tracer._exporter.deferTestSuiteSpan?.(testSuiteSpan)
       testSuiteSpan.finish()
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
     })
@@ -304,16 +326,16 @@ class PlaywrightPlugin extends CiPlugin {
         }
       }
 
-      if (!formattedTestSpan || !screenshots) {
+      if (!formattedTestSpan || !screenshots || this.#isFinalizingAfterError) {
         exportTraces()
         return
       }
 
       this.pendingTestFinishes++
-      const uploadStarted = this.uploadTestScreenshots({
-        screenshots,
-        traceId: formattedTestSpan.trace_id.toString(10),
-      }, (screenshotUploadResult) => {
+      const abortController = new AbortController()
+      const finishTest = (screenshotUploadResult) => {
+        if (!this.#pendingTestFinishCallbacks.delete(finishTest)) return
+
         const screenshotUploadTag = getScreenshotUploadTag(screenshotUploadResult)
         if (screenshotUploadTag) {
           formattedTestSpan.meta[screenshotUploadTag] = 'true'
@@ -323,11 +345,16 @@ class PlaywrightPlugin extends CiPlugin {
         if (this.pendingTestFinishes === 0 && this.finishSession) {
           this.finishSession()
         }
-      })
+      }
+      this.#pendingTestFinishCallbacks.set(finishTest, abortController)
+      const uploadStarted = this.uploadTestScreenshots({
+        screenshots,
+        traceId: formattedTestSpan.trace_id.toString(10),
+        signal: abortController.signal,
+      }, finishTest)
       if (uploadStarted) return
 
-      this.pendingTestFinishes--
-      exportTraces()
+      finishTest()
     })
 
     this.addBind('ci:playwright:test:start', (ctx) => {
@@ -552,10 +579,11 @@ class PlaywrightPlugin extends CiPlugin {
    * @param {object} options - Upload options
    * @param {Array<object>} options.screenshots - Playwright test attachments
    * @param {string} options.traceId - Test trace id used as the screenshot key
+   * @param {AbortSignal} options.signal - Signal used to cancel uploads during error finalization
    * @param {(result: string|undefined) => void} onDone - Completion callback
    * @returns {boolean} Whether at least one upload was started
    */
-  uploadTestScreenshots ({ screenshots, traceId }, onDone) {
+  uploadTestScreenshots ({ screenshots, traceId, signal }, onDone) {
     const exporter = this.tracer?._exporter
     if (!Array.isArray(screenshots) || !screenshots.length ||
       !exporter?.canUploadTestScreenshots?.() ||
@@ -581,6 +609,7 @@ class PlaywrightPlugin extends CiPlugin {
         traceId,
         idempotencyKey: `${traceId}:${basename(filePath)}`,
         capturedAtMs: getScreenshotCapturedAtMs(filePath, filePath),
+        signal,
       }, (error, uploaded = true) => {
         if (uploaded) {
           uploadResults[resultIndex] = error

package/packages/datadog-plugin-vitest/src/index.js

@@ -523,6 +523,7 @@ class VitestPlugin extends CiPlugin {
           this.telemetry.ciVisEvent(TELEMETRY_CODE_COVERAGE_FINISHED, 'suite', { library: coverageLibrary })
           this.telemetry.distribution(TELEMETRY_CODE_COVERAGE_NUM_FILES, {}, relativeFiles.length)
         }
+        this.tracer._exporter.deferTestSuiteSpan?.(testSuiteSpan)
         testSuiteSpan.finish()
         finishAllTraceSpans(testSuiteSpan)
       }
@@ -566,6 +567,7 @@ class VitestPlugin extends CiPlugin {
     this.addSub('ci:vitest:session:finish', ({
       status,
       error,
+      isTestSessionFinalizationError,
       testCodeCoverageLinesTotal,
       isEarlyFlakeDetectionEnabled,
       isEarlyFlakeDetectionFaulty,
@@ -588,6 +590,9 @@ class VitestPlugin extends CiPlugin {
       this.testSessionSpan.setTag(TEST_STATUS, status)
       this.testModuleSpan.setTag(TEST_STATUS, status)
       if (error) {
+        if (isTestSessionFinalizationError) {
+          this.tracer._exporter.setDeferredTestSuiteError?.(error)
+        }
         this.testModuleSpan.setTag('error', error)
         this.testSessionSpan.setTag('error', error)
       }
@@ -617,6 +622,7 @@ class VitestPlugin extends CiPlugin {
       if (vitestPool) {
         this.testSessionSpan.setTag(VITEST_POOL, vitestPool)
       }
+      this.tracer._exporter.exportDeferredTestSuiteSpans?.()
       this.testModuleSpan.finish()
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
       this.testSessionSpan.finish()

package/packages/datadog-webpack/index.js

@@ -6,7 +6,6 @@ const fs = require('node:fs')
 const instrumentations = require('../datadog-instrumentations/src/helpers/instrumentations')
 const extractPackageAndModulePath = require('../datadog-instrumentations/src/helpers/extract-package-and-module-path')
 const hooks = require('../datadog-instrumentations/src/helpers/hooks')
-const { matchesOptionalPeerFile } = require('../datadog-instrumentations/src/helpers/optional-peer-bundler')
 const { isESMFile } = require('../datadog-esbuild/src/utils')
 const log = require('./src/log')
 
@@ -137,16 +136,6 @@ class DatadogWebpackPlugin {
 
         const normalizedResource = resource.replaceAll('\\', '/')
 
-        // Rewrite optional-peer loads so installed peers get bundled and survive relocation
-        // (#8980); absent peers stay opaque, so a build that does not opt into the feature does
-        // not follow their dependency chain (#8635).
-        if (matchesOptionalPeerFile(normalizedResource)) {
-          createData.loaders ||= []
-          createData.loaders.push({ loader: require.resolve('./src/optional-peer-loader') })
-          log.debug('INLINE: optional-peer loader applied to %s', normalizedResource)
-          return
-        }
-
         if (!resource.includes('node_modules')) {
           return
         }

package/packages/dd-trace/index.js

@@ -1,4 +1,3 @@
 'use strict'
 
-require('./src/openfeature/register')
 module.exports = require('./src/bootstrap')

package/packages/dd-trace/src/agent/info.js

@@ -17,8 +17,10 @@ module.exports = {
  * Fetches agent information from the /info endpoint
  * @param {URL} url - The agent URL
  * @param {Function} callback - Callback function with signature (err, agentInfo)
+ * @param {{ deadline?: number, signal?: AbortSignal }} [options] - Request finalization options
+ * @param {Function} [makeRequest] - Request implementation
  */
-function fetchAgentInfo (url, callback) {
+function fetchAgentInfo (url, callback, options = {}, makeRequest = request) {
   const urlKey = url.href
 
   if (cachedUrl !== null && cachedUrl !== urlKey) {
@@ -29,10 +31,9 @@ function fetchAgentInfo (url, callback) {
     return process.nextTick(callback, null, cachedData)
   }
 
-  request('', {
-    path: '/info',
-    url,
-  }, (err, res) => {
+  options.path = '/info'
+  options.url = url
+  makeRequest('', options, (err, res) => {
     if (err) {
       return callback(err)
     }

package/packages/dd-trace/src/aiguard/client.js

@@ -1,5 +1,27 @@
 'use strict'
 
+const tracerVersion = require('../../../../package.json').version
+const { AIGuardClientError } = require('./errors')
+const { parseEvaluationResponse } = require('./evaluation')
+const TAGS = require('./tags')
+
+/**
+ * Resolves the AI Guard host for a Datadog site.
+ *
+ * @param {string} site
+ * @returns {string}
+ */
+function aiGuardHost (site) {
+  return site.split('.').length === 2 ? `app.${site}` : site
+}
+
+/**
+ * Sends a request to the AI Guard service.
+ *
+ * @param {object} body
+ * @param {{ url: string, headers: Record<string, string>, timeout: number }} opts
+ * @returns {Promise<{ status: number, body: unknown }>}
+ */
 async function executeRequest (body, opts) {
   const postData = JSON.stringify(body)
   const headers = {
@@ -22,4 +44,81 @@ async function executeRequest (body, opts) {
   }
 }
 
-module.exports = executeRequest
+class AIGuardClient {
+  #headers
+  #evaluateUrl
+  #timeout
+
+  /**
+   * @param {import('../config/config-base')} config
+   */
+  constructor (config) {
+    this.#headers = {
+      'DD-API-KEY': config.DD_API_KEY,
+      'DD-APPLICATION-KEY': config.DD_APP_KEY,
+      'DD-AI-GUARD-VERSION': tracerVersion,
+      'DD-AI-GUARD-SOURCE': 'SDK',
+      'DD-AI-GUARD-LANGUAGE': 'nodejs',
+    }
+    const endpoint = config.experimental.aiguard.endpoint || `https://${aiGuardHost(config.site)}/api/v2/ai-guard`
+    this.#evaluateUrl = `${endpoint}/evaluate`
+    this.#timeout = config.experimental.aiguard.timeout
+  }
+
+  /**
+   * Evaluates messages and converts the service response to the internal evaluation contract.
+   *
+   * @param {import('../../../../index').aiguard.Message[]} messages
+   * @param {{ service: string, env: string }} meta
+   * @returns {Promise<NonNullable<ReturnType<typeof parseEvaluationResponse>>>}
+   */
+  evaluate (messages, meta) {
+    const payload = {
+      data: {
+        attributes: {
+          messages,
+          meta,
+        },
+      },
+    }
+    return executeRequest(
+      payload,
+      { url: this.#evaluateUrl, headers: this.#headers, timeout: this.#timeout }
+    )
+      .then(response => this.#parseResponse(response))
+      .catch(cause => {
+        if (cause instanceof AIGuardClientError) throw cause
+
+        throw new AIGuardClientError(`Unexpected error calling AI Guard service: ${cause.message}`, {
+          cause,
+          telemetryType: TAGS.ERROR_TYPE_CLIENT,
+        })
+      })
+  }
+
+  /**
+   * Validates an AI Guard HTTP response.
+   *
+   * @param {{ status: number, body: unknown }} response
+   * @returns {NonNullable<ReturnType<typeof parseEvaluationResponse>>}
+   */
+  #parseResponse (response) {
+    if (response.status !== 200) {
+      throw new AIGuardClientError(`AI Guard service call failed, status ${response.status}`, {
+        errors: response.body?.errors,
+        telemetryType: TAGS.ERROR_TYPE_STATUS,
+      })
+    }
+
+    const evaluation = parseEvaluationResponse(response.body)
+    if (!evaluation) {
+      throw new AIGuardClientError(`AI Guard service returned unexpected response : ${response.body}`, {
+        telemetryType: TAGS.ERROR_TYPE_RESPONSE,
+      })
+    }
+
+    return evaluation
+  }
+}
+
+module.exports = AIGuardClient

package/packages/dd-trace/src/aiguard/errors.js

@@ -0,0 +1,41 @@
+'use strict'
+
+class AIGuardAbortError extends Error {
+  /**
+   * @param {string|undefined} reason
+   * @param {Array<unknown>} tags
+   * @param {Record<string, unknown>} tagProbabilities
+   * @param {Array<unknown>} sds
+   */
+  constructor (reason, tags, tagProbabilities, sds) {
+    super(reason)
+    this.name = 'AIGuardAbortError'
+    this.reason = reason
+    this.tags = tags
+    this.tagProbabilities = tagProbabilities
+    this.sds = sds || []
+  }
+}
+
+class AIGuardClientError extends Error {
+  /**
+   * @param {string} message
+   * @param {{ telemetryType: string, errors?: Array<unknown>, cause?: Error }} opts
+   */
+  constructor (message, opts) {
+    super(message)
+    this.name = 'AIGuardClientError'
+    this.telemetryType = opts.telemetryType
+    if (opts.errors) {
+      this.errors = opts.errors
+    }
+    if (opts.cause) {
+      this.cause = opts.cause
+    }
+  }
+}
+
+module.exports = {
+  AIGuardAbortError,
+  AIGuardClientError,
+}