dd-trace 6.18.0 → 6.20.0

package/packages/datadog-instrumentations/src/aws-sdk.js

@@ -198,11 +198,11 @@ function wrapSmithySend (send) {
     }
 
     return channels.start.runStores(ctx, () => {
-      // When the region is not set this never resolves so we can't await.
+      // Resolve region tags independently; send reports provider failures through its promise or callback.
       this.config.region().then(region => {
         ctx.region = region
         channels.region.publish(ctx)
-      })
+      }, () => {})
 
       if (cbExists) {
         args[args.length - 1] = shimmer.wrapCallback(cb, cb => function (err, result) {

package/packages/datadog-instrumentations/src/claude-agent-sdk.js

@@ -44,6 +44,7 @@ const chunkEmitTimes = new WeakMap()
  *   tools: Map<string, ToolState>,
  *   subagents: Map<string, Record<string, unknown>>,
  *   prompt?: string,
+ *   systemPrompt?: string | string[] | { type: string, prompt?: string | string[], append?: string },
  *   model?: string,
  *   resume?: string,
  *   maxTurns?: number,
@@ -235,6 +236,7 @@ function onQueryStart (ctx) {
   const prompt = queryArg.prompt
   const sessionCtx = {
     prompt: typeof prompt === 'string' ? prompt : undefined,
+    systemPrompt: options.systemPrompt,
     model: options.model,
     resume: options.resume,
     maxTurns: options.maxTurns,
@@ -451,6 +453,7 @@ function processStep (
     llmCh.traceSync(() => {}, {
       model,
       usage,
+      systemPrompt: parentToolUseId ? undefined : sessionCtx?.systemPrompt,
       startTime: stepStartTime,
       finishTime: chunkEmitTimes.get(chunks[messageEndIdx - 1]),
       chunks,
@@ -529,7 +532,8 @@ function processChunks (chunks, agentCtx) {
   const sessionCtx = agentCtx.sessionCtx
   const getLifecycle = createStreamLookup(chunks)
 
-  const { type, subtype, ...rest } = chunks[0]
+  const initChunk = chunks.find(chunk => chunk.type === 'system' && chunk.subtype === 'init') || chunks[0]
+  const { type, subtype, ...rest } = initChunk
   Object.assign(agentCtx, rest)
   if (sessionCtx) {
     if (sessionCtx.sessionId) agentCtx.session_id = sessionCtx.sessionId

package/packages/datadog-instrumentations/src/cucumber.js

@@ -1418,13 +1418,49 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
 
     if (isImpactedTestsEnabled) {
       const setIsModified = (receivedIsModified) => { isModified = receivedIsModified }
-      const scenarios = gherkinDocument.feature?.children?.filter(
-        children => pickle.astNodeIds.includes(children.scenario.id)
-      ).map(scenario => scenario.scenario)
+      const gherkinNodes = []
+      // Prefix ranges catch removed Backgrounds, which have no AST node in the target document.
+      const gherkinScopeRanges = []
+      const feature = gherkinDocument.feature
+      const featureChildren = feature?.children
+      if (featureChildren?.length) {
+        const firstFeatureChild = featureChildren[0]
+        const firstFeatureNode = firstFeatureChild.background ?? firstFeatureChild.rule ?? firstFeatureChild.scenario
+        const firstFeatureLine = firstFeatureNode.tags?.[0]?.location.line ?? firstFeatureNode.location.line
+        const featurePrefix = [feature.location.line, firstFeatureLine - 1]
+        let featureBackground
+        for (const child of featureChildren) {
+          if (child.background) {
+            featureBackground = child.background
+            continue
+          }
+          const rule = child.rule
+          const children = rule?.children ?? [child]
+          let ruleBackground
+          for (const { background } of children) {
+            if (background) ruleBackground = background
+          }
+          for (const { scenario } of children) {
+            if (scenario && pickle.astNodeIds.includes(scenario.id)) {
+              if (!featureBackground) gherkinScopeRanges.push(featurePrefix)
+              if (rule?.children?.length && !ruleBackground) {
+                const firstRuleChild = rule.children.at(0)
+                const firstRuleNode = firstRuleChild.background ?? firstRuleChild.scenario
+                const firstRuleLine = firstRuleNode.tags?.[0]?.location.line ?? firstRuleNode.location.line
+                gherkinScopeRanges.push([rule.location.line, firstRuleLine - 1])
+              }
+              if (featureBackground) gherkinNodes.push(featureBackground)
+              if (ruleBackground) gherkinNodes.push(ruleBackground)
+              gherkinNodes.push(scenario)
+            }
+          }
+        }
+      }
       const stepIds = testCase?.testSteps?.flatMap(testStep => testStep.stepDefinitionIds)
 
       isModifiedCh.publish({
-        scenarios,
+        gherkinNodes,
+        gherkinScopeRanges,
         testFileAbsolutePath: gherkinDocument.uri,
         modifiedFiles,
         stepIds,

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -2,12 +2,6 @@
 
 module.exports = {
   // Only list unprefixed node modules. They will automatically be instrumented as prefixed and unprefixed.
-  '@supabase/auth-js': { esmFirst: true, fn: () => require('../supabase') },
-  '@supabase/functions-js': { esmFirst: true, fn: () => require('../supabase') },
-  '@supabase/postgrest-js': { esmFirst: true, fn: () => require('../supabase') },
-  '@supabase/realtime-js': { esmFirst: true, fn: () => require('../supabase') },
-  '@supabase/storage-js': { esmFirst: true, fn: () => require('../supabase') },
-  '@supabase/supabase-js': { esmFirst: true, fn: () => require('../supabase') },
   child_process: () => require('../child_process'),
   crypto: () => require('../crypto'),
   dns: () => require('../dns'),
@@ -142,7 +136,6 @@ module.exports = {
   'pino-pretty': () => require('../pino'),
   playwright: () => require('../playwright'),
   'playwright-core': () => require('../playwright'),
-  postgres: { esmFirst: true, fn: () => require('../postgres') },
   'promise-js': () => require('../promise-js'),
   promise: () => require('../promise'),
   protobufjs: () => require('../protobufjs'),

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentation-registry.js

@@ -17,10 +17,10 @@ const registry = [
   { instrumentations: require('./instrumentations/modelcontextprotocol-sdk') },
   { instrumentations: require('./instrumentations/openai-agents') },
   { instrumentations: require('./instrumentations/playwright') },
-  { instrumentations: require('./instrumentations/postgres') },
+  { activate: true, instrumentations: require('./instrumentations/postgres') },
   { instrumentations: require('./instrumentations/webdriverio') },
   { instrumentations: require('./instrumentations/aws-durable-execution-sdk-js') },
-  { instrumentations: require('./instrumentations/supabase') },
+  { activate: true, instrumentations: require('./instrumentations/supabase') },
 ]
 
 const activatedModules = new Set()

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/ai.js

@@ -88,6 +88,31 @@ module.exports = [
     },
     channelName: 'resolveLanguageModel',
   },
+  // AI SDK v7 filters runtime context from tracing channel events unless each key is included.
+  {
+    module: {
+      name: 'ai',
+      versionRange: '>=7.0.0',
+      filePath: 'dist/index.js',
+    },
+    functionQuery: {
+      functionName: 'generateText',
+      kind: 'Async',
+    },
+    channelName: 'includeRuntimeContext',
+  },
+  {
+    module: {
+      name: 'ai',
+      versionRange: '>=7.0.0',
+      filePath: 'dist/index.js',
+    },
+    functionQuery: {
+      functionName: 'streamText',
+      kind: 'Sync',
+    },
+    channelName: 'includeRuntimeContext',
+  },
   {
     module: {
       name: 'ai',

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/playwright.js

@@ -3,6 +3,14 @@
 // Playwright keeps several hook targets in private local classes/functions.
 // Keep these rewrites limited to bundled internals that addHook cannot wrap.
 module.exports = [
+  ...[
+    ['>=1.38.0 <1.60.0', 'lib/common/config.js'],
+    ['>=1.60.0', 'lib/common/index.js'],
+  ].map(([versionRange, filePath]) => ({
+    module: { name: 'playwright', versionRange, filePath },
+    functionQuery: { className: 'FullProjectInternal', methodName: 'constructor', kind: 'Sync' },
+    channelName: 'FullProjectInternal',
+  })),
   {
     module: {
       name: '@playwright/test',

package/packages/datadog-instrumentations/src/helpers/rewriter/targets.json

@@ -77,6 +77,8 @@
   "jasmine-core/lib/jasmine-core/jasmine.js": "jasmine-core",
   "mercurius/index.js": "mercurius",
   "playwright-core/lib/coreBundle.js": "playwright-core",
+  "playwright/lib/common/config.js": "playwright",
+  "playwright/lib/common/index.js": "playwright",
   "playwright/lib/index.js": "playwright",
   "playwright/lib/runner/index.js": "playwright",
   "playwright/lib/runner/lastRun.js": "playwright",

package/packages/datadog-instrumentations/src/jest/session-error.js

@@ -0,0 +1,102 @@
+'use strict'
+
+const { stripVTControlCharacters } = require('node:util')
+
+const { MAX_META_VALUE_LENGTH_TEST_OPTIMIZATION: MAX_LENGTH } =
+  require('../../../dd-trace/src/encode/tags-processors')
+const log = require('../../../dd-trace/src/log')
+
+/**
+ * @typedef {{ name?: unknown, type?: unknown, message?: unknown, stack?: unknown }} SuiteError
+ * @typedef {object} JestResults
+ * @property {number} [numFailedTestSuites]
+ * @property {number} [numFailedTests]
+ * @property {{ testExecError?: SuiteError, failureMessage?: unknown, numFailingTests?: number }[]} [testResults]
+ */
+
+/**
+ * Includes complete, deduplicated suite errors only when all details fit.
+ *
+ * @param {JestResults} results
+ * @returns {Error}
+ */
+function getSessionError (results = {}) {
+  const { numFailedTestSuites = 0, numFailedTests = 0 } = results
+  const summary = `Failed test suites: ${numFailedTestSuites}. Failed tests: ${numFailedTests}`
+  const error = new Error(summary)
+  const groups = new Map()
+  let size = 0
+  try {
+    const { testResults } = results
+    if (!testResults) return error
+    for (const result of testResults) {
+      let name, message, stack
+      try {
+        const { testExecError } = result
+        if (testExecError && !result.numFailingTests) {
+          name = readField(testExecError.name)
+          if (name === '') name = readField(testExecError.type)
+          message = readField(testExecError.message)
+          stack = readField(testExecError.stack)
+        } else {
+          // Jest's report includes assertion failures, hook errors and any suite execution error.
+          name = 'Error'
+          message = readField(result.failureMessage)
+          stack = message
+        }
+      } catch {
+        log.debug('Skipping unreadable Jest suite error in the test session summary')
+        continue
+      }
+      if (name === undefined || message === undefined || stack === undefined) return omitDetails(error)
+      if (!message && !stack) continue
+      name ||= 'Error'
+      const key = JSON.stringify([name, message, stack])
+      const group = groups.get(key)
+      if (group) {
+        group.count++
+      } else {
+        // Retained text must fit across error.message and error.stack; also bound grouping memory.
+        size += name.length + message.length + stack.length
+        if (size > 2 * MAX_LENGTH) return omitDetails(error)
+        groups.set(key, { name, message, stack, count: 1 })
+      }
+    }
+  } catch {
+    log.debug('Unable to read Jest results for the test session summary')
+    return error
+  }
+  if (!groups.size) return error
+
+  const errors = [...groups.keys()].sort().map(key => groups.get(key))
+  let message = summary
+  let stack = ''
+  for (const { name, message: detail, stack: originalStack, count } of errors) {
+    message += `\n\n${name}: ${detail} (${count} suite${count === 1 ? '' : 's'})`
+    const prefix = errors.length === 1 ? '' : `Affected suites: ${count}\n`
+    stack += (stack ? '\n\n' : '') + prefix + (originalStack || `${name}: ${detail}`)
+    if (message.length > MAX_LENGTH || stack.length > MAX_LENGTH) return omitDetails(error)
+  }
+  error.name = errors.length === 1 ? errors[0].name : 'Error'
+  error.message = message
+  error.stack = stack
+  return error
+}
+
+/**
+ * Returns undefined for oversized input before scanning or copying it.
+ * @param {unknown} value
+ */
+function readField (value) {
+  if (typeof value !== 'string') return ''
+  if (value.length > MAX_LENGTH) return
+  return stripVTControlCharacters(value)
+}
+
+/** @param {Error} error */
+function omitDetails (error) {
+  error.message += '\n\nError details exceed the size limit. See test and suite events for full details.'
+  return error
+}
+
+module.exports = { getSessionError }

package/packages/datadog-instrumentations/src/jest.js

@@ -58,6 +58,7 @@ const {
   addCoverageBackfillUntestedFiles,
   getCoverageBackfillFiles,
 } = require('./jest/coverage-backfill')
+const { getSessionError } = require('./jest/session-error')
 const {
   getChannelPromise,
   publishWithCompletion,
@@ -2739,13 +2740,6 @@ function applySkippedCoverageToJestCoverageMap (coverageMap, rootDir) {
   )
 }
 
-function getSessionFinishError (results) {
-  const numFailedTestSuites = results?.numFailedTestSuites || 0
-  const numFailedTests = results?.numFailedTests || 0
-
-  return new Error(`Failed test suites: ${numFailedTestSuites}. Failed tests: ${numFailedTests}`)
-}
-
 function getTestSessionCoveragePayload (results, fallbackRootDir) {
   const payload = {}
   if (!shouldReportCodeCoverageLinesPct()) return payload
@@ -2847,7 +2841,7 @@ function getTestSessionFinishPayload (status, error, extra = {}) {
 async function finishBailTestSession (results, fallbackRootDir) {
   await waitForTestSessionFinish(getTestSessionFinishPayload(
     'fail',
-    getSessionFinishError(results),
+    getSessionError(results),
     getTestSessionCoveragePayload(results, fallbackRootDir)
   ))
 }
@@ -3170,7 +3164,6 @@ function getCliWrapper (isNewJestVersion) {
 
       const {
         results: {
-          numFailedTestSuites,
           numFailedTests,
           numPassedTests,
           numRuntimeErrorTestSuites = 0,
@@ -3351,7 +3344,7 @@ function getCliWrapper (isNewJestVersion) {
         status = testSessionEmptyReason ? 'skip' : 'pass'
       } else {
         status = 'fail'
-        error = new Error(`Failed test suites: ${numFailedTestSuites}. Failed tests: ${numFailedTests}`)
+        error = getSessionError(result.results)
       }
 
       await waitForTestSessionFinish(getTestSessionFinishPayload(status, error, {

package/packages/datadog-instrumentations/src/playwright.js

@@ -75,6 +75,7 @@ const artifactsRecorderScreenshotPathCh =
 const snapshotRecorderScreenshotPathCh = tracingChannel('orchestrion:playwright:SnapshotRecorder_createAttachmentPath')
 const saveAutomaticVideoCh = tracingChannel('orchestrion:playwright:saveAutomaticVideo')
 const pageGotoCh = tracingChannel('orchestrion:playwright-core:Page_goto')
+const fullProjectInternalCh = tracingChannel('orchestrion:playwright:FullProjectInternal')
 
 const testToCtx = new WeakMap()
 const originalTestIdsByRetry = new WeakMap()
@@ -91,6 +92,8 @@ const isFailureScreenshotUploadEnabled =
   getValueFromEnvSources('DD_TEST_FAILURE_SCREENSHOTS_ENABLED') === true
 const isFailureVideoUploadEnabled =
   getValueFromEnvSources('DD_TEST_FAILURE_VIDEOS_ENABLED') === true
+const shouldEnableFailureScreenshots = getValueFromEnvSources('DD_TEST_FAILURE_SCREENSHOTS_ENABLED', true) === true
+const shouldEnableFailureVideos = getValueFromEnvSources('DD_TEST_FAILURE_VIDEOS_ENABLED', true) === true
 
 let applyRepeatEachIndex = null
 let reporterError
@@ -1057,6 +1060,8 @@ function testEndHandler ({
   if (isFlakyTestRetriesEnabled && !testProperties.attemptToFix && !test._ddIsEfdRetry &&
     !(test._ddIsNew || test._ddIsModified) &&
     atrRetryCount != null && atrRetryCount > 0 &&
+    // Serial suites can add skipped results before a test's first execution.
+    results.some((result, index) => index < results.length - 1 && result.status !== 'skipped') &&
     !willRetry && testResultStatus !== expectedStatus &&
     testStatuses.every(status => status === 'fail')) {
     test._ddHasFailedAllRetries = true
@@ -1882,6 +1887,27 @@ dispatcherRunCh.subscribe({
   },
 })
 
+fullProjectInternalCh.subscribe({
+  end ({ self, error }) {
+    if (error || !libraryConfigurationCh.hasSubscribers) return
+
+    // Workers reload the config, so apply capture settings as each project is resolved in either process.
+    const { project } = self
+    if (shouldEnableFailureScreenshots && !isFailureScreenshotCaptureEnabled([project])) {
+      const screenshot = project.use.screenshot
+      project.use.screenshot = typeof screenshot === 'object' && screenshot !== null
+        ? { ...screenshot, mode: 'only-on-failure' }
+        : 'only-on-failure'
+    }
+    if (shouldEnableFailureVideos && !isFailureVideoCaptureEnabled([project])) {
+      const video = project.use.video
+      project.use.video = typeof video === 'object' && video !== null
+        ? { ...video, mode: 'retain-on-failure' }
+        : 'retain-on-failure'
+    }
+  },
+})
+
 dispatcherCreateWorkerCh.subscribe({
   end (ctx) {
     onDispatcherCreateWorker(ctx.self, ctx.result)

package/packages/datadog-instrumentations/src/vitest-main.js

@@ -1981,6 +1981,9 @@ function getWrappedOn (on) {
     if (event !== 'message') {
       return on.apply(this, arguments)
     }
+    // Reply through Vitest's pool worker, which owns its version-specific serialization.
+    // The listener's `this` is the underlying ChildProcess or Worker instead.
+    const worker = this
     // `arguments[1]` is the callback function, which
     // we modify to intercept our messages to not interfere
     // with vitest's own messages
@@ -1988,7 +1991,7 @@ function getWrappedOn (on) {
       if (message.type !== 'Buffer' && Array.isArray(message)) {
         const [interprocessCode, data] = message
         if (
-          handleEfdAdmissionMessage(this, interprocessCode, data) ||
+          handleEfdAdmissionMessage(worker, interprocessCode, data) ||
           handleWorkerReport(interprocessCode, data)
         ) {
           // If we execute the callback vitest crashes, as the message is not supported

package/packages/datadog-instrumentations/src/vitest-worker.js

@@ -4,6 +4,7 @@ const fs = require('node:fs')
 const path = require('node:path')
 const { performance } = require('node:perf_hooks')
 const { fileURLToPath } = require('node:url')
+const { deserialize } = require('node:v8')
 const { isMainThread, parentPort } = require('node:worker_threads')
 
 const { channel } = require('dc-polyfill')
@@ -47,6 +48,7 @@ const {
 
 const EFD_SUITE_ADMISSION_TIMEOUT_MS = 5000
 const logSubmissionFlushCh = channel('ci:log-submission:flush')
+const wrappedTestRunners = new WeakSet()
 const taskToCtx = new WeakMap()
 const taskToTestProperties = new WeakMap()
 const taskToStatuses = new WeakMap()
@@ -412,6 +414,14 @@ function finishEfdSuiteAdmissionRequest (requestId, allowed) {
  * @param {unknown} message
  */
 function handleEfdSuiteAdmissionResponse (message) {
+  // Older Vitest 4 forks serialize parent messages explicitly; newer forks and threads send plain values.
+  if (Buffer.isBuffer(message) || (message?.type === 'Buffer' && Array.isArray(message.data))) {
+    try {
+      message = deserialize(Buffer.from(message))
+    } catch {
+      return
+    }
+  }
   if (!Array.isArray(message) || message[0] !== VITEST_WORKER_EFD_SUITE_ADMISSION_RESPONSE_CODE) return
 
   const { allowed, requestId } = message[1] || {}
@@ -520,6 +530,11 @@ function wrapSuiteHookFn (hookType, fn, fallbackTask) {
 }
 
 function wrapVitestTestRunner (VitestTestRunner) {
+  // ESM hooks can expose the same runner through multiple module identities.
+  // Wrapping its lifecycle methods twice would report each retry twice.
+  if (wrappedTestRunners.has(VitestTestRunner)) return
+  wrappedTestRunners.add(VitestTestRunner)
+
   // `onBeforeRunTask` is run before any repetition or attempt is run
   // `onBeforeRunTask` is an async function
   shimmer.wrap(VitestTestRunner.prototype, 'onBeforeRunTask', onBeforeRunTask => async function (task) {
@@ -623,6 +638,13 @@ function wrapVitestTestRunner (VitestTestRunner) {
   shimmer.wrap(VitestTestRunner.prototype, 'onAfterRunTask', onAfterRunTask => function (task) {
     const { isTestManagementTestsEnabled } = getProvidedContext()
 
+    // Vitest 5 aggregates failed repetitions into the final state. Preserve the last attempt's actual result.
+    if ((attemptToFixTasks.has(task) || efdRetryTasks.has(task)) &&
+        task.result.state === 'fail' && taskToCtx.get(task)?.status === 'pass' &&
+        (task.result.errors?.length ?? 0) === (taskToReportedErrorCount.get(task) ?? 0)) {
+      task.result.state = 'pass'
+    }
+
     if (isTestManagementTestsEnabled) {
       const isAttemptingToFix = attemptToFixTasks.has(task)
       const isQuarantined = quarantinedTasks.has(task)
@@ -745,7 +767,12 @@ function wrapVitestTestRunner (VitestTestRunner) {
       }
     }
 
-    const lastExecutionStatus = task.result.state
+    let lastExecutionStatus = task.result.state
+    if (lastExecutionStatus === 'run' && numRepetition > 0) {
+      // Vitest 5 resets the state before each repetition but retains errors from earlier attempts.
+      const reportedErrorCount = taskToReportedErrorCount.get(task) ?? 0
+      lastExecutionStatus = (task.result.errors?.length ?? 0) > reportedErrorCount ? 'fail' : 'pass'
+    }
     const isAtf = attemptToFixTasks.has(task)
     const isEfd = efdRetryTasks.has(task)
     const shouldTrackStatuses = isEfd || isAtf
@@ -1101,14 +1128,18 @@ function getStartTestsWrapper (frameworkVersion) {
             isDisabled: disabledTasks.has(task),
             isQuarantined: quarantinedTasks.has(task),
           })
-        } else if (state === 'pass' && !isSwitchedStatus) {
+        } else if ((state === 'pass' && !isSwitchedStatus) || switchedStatus === 'pass') {
+          // Attempt-to-fix can pass its last attempt while an earlier failure still fails the suite.
+          if (switchedStatus === 'pass' && errors?.length) {
+            testSuiteError = testError
+          }
           if (testCtx) {
             const isSkippedByTestManagement =
               !attemptToFixTasks.has(task) && (disabledTasks.has(task) || quarantinedTasks.has(task))
             const promises = {}
             testPassCh.publish({
               task,
-              finalStatus: isSkippedByTestManagement ? 'skip' : 'pass',
+              finalStatus: isSkippedByTestManagement ? 'skip' : state,
               earlyFlakeAbortReason: efdSlowAbortedTasks.has(task) ? 'slow' : undefined,
               promises,
               ...testCtx.currentStore,