dd-trace 5.109.0 → 5.110.0

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

@@ -138,6 +138,8 @@ function getProvidedContext () {
       _ddTestManagementTests: testManagementTests,
       _ddIsFlakyTestRetriesEnabled: isFlakyTestRetriesEnabled,
       _ddFlakyTestRetriesCount: flakyTestRetriesCount,
+      _ddFlakyTestRetriesIncludesUnnamedProject: flakyTestRetriesIncludesUnnamedProject,
+      _ddFlakyTestRetriesProjectNames: flakyTestRetriesProjectNames,
       _ddIsImpactedTestsEnabled: isImpactedTestsEnabled,
       _ddModifiedFiles: modifiedFiles,
       _ddTestSessionId: testSessionId,
@@ -159,6 +161,8 @@ function getProvidedContext () {
       testManagementTests,
       isFlakyTestRetriesEnabled,
       flakyTestRetriesCount: flakyTestRetriesCount ?? 0,
+      flakyTestRetriesIncludesUnnamedProject,
+      flakyTestRetriesProjectNames,
       isImpactedTestsEnabled,
       modifiedFiles,
       testSessionId,
@@ -181,6 +185,8 @@ function getProvidedContext () {
       testManagementTests: {},
       isFlakyTestRetriesEnabled: false,
       flakyTestRetriesCount: 0,
+      flakyTestRetriesIncludesUnnamedProject: false,
+      flakyTestRetriesProjectNames: undefined,
       isImpactedTestsEnabled: false,
       modifiedFiles: {},
       testSessionId: undefined,
@@ -501,11 +507,13 @@ async function runMainProcessSetup (ctx, frameworkVersion, testSpecifications) {
     getTestManagementTests: () => getChannelPromise(testManagementTestsCh),
   })
 
-  if (isFlakyTestRetriesEnabled && !ctx.config.retry && flakyTestRetriesCount > 0) {
-    ctx.config.retry = flakyTestRetriesCount
+  const flakyTestRetriesConfiguration = configureFlakyTestRetries(ctx, testSpecifications)
+  if (flakyTestRetriesConfiguration) {
     setProvidedContext(ctx, {
       _ddIsFlakyTestRetriesEnabled: isFlakyTestRetriesEnabled,
       _ddFlakyTestRetriesCount: flakyTestRetriesCount,
+      _ddFlakyTestRetriesIncludesUnnamedProject: flakyTestRetriesConfiguration.includesUnnamedProject,
+      _ddFlakyTestRetriesProjectNames: flakyTestRetriesConfiguration.projectNames,
     }, 'Could not send library configuration to workers.')
   }
 
@@ -591,6 +599,242 @@ function ensureMainProcessSetup (ctx, frameworkVersion, testSpecifications) {
   return setupPromise
 }
 
+/**
+ * Configure Vitest retries for the root project and resolved workspace projects.
+ *
+ * @param {object} ctx
+ * @param {unknown[]|undefined} testSpecifications
+ * @returns {{ projectNames: string[], includesUnnamedProject: boolean }|undefined}
+ */
+function configureFlakyTestRetries (ctx, testSpecifications) {
+  if (!isFlakyTestRetriesEnabled || flakyTestRetriesCount <= 0) return
+
+  let configured = false
+  let includesUnnamedProject = false
+  const projectNames = []
+  for (const { config, projectName } of getVitestProjectConfigs(ctx, testSpecifications)) {
+    if (!config.retry) {
+      config.retry = flakyTestRetriesCount
+      configured = true
+      if (projectName) {
+        projectNames.push(projectName)
+      } else {
+        includesUnnamedProject = true
+      }
+    }
+  }
+
+  if (!configured) return
+
+  return {
+    includesUnnamedProject,
+    projectNames,
+  }
+}
+
+/**
+ * Return unique Vitest configs that can be used to run tests.
+ *
+ * @param {object} ctx
+ * @param {unknown[]|undefined} testSpecifications
+ * @returns {{ config: object, projectName?: string }[]}
+ */
+function getVitestProjectConfigs (ctx, testSpecifications) {
+  const entries = []
+
+  addTestSpecificationConfigs(entries, testSpecifications)
+  if (entries.length > 0) {
+    return entries
+  }
+
+  const selectedProjectNames = getSelectedProjectNames()
+  addSelectedInlineProjectConfigs(entries, safeConfig(ctx), selectedProjectNames)
+  addSelectedRuntimeProjectConfigs(entries, ctx?.projects, selectedProjectNames)
+  if (entries.length > 0) {
+    return entries
+  }
+
+  if (Array.isArray(ctx?.projects)) {
+    for (const project of ctx.projects) {
+      addConfig(entries, safeConfig(project), getProjectName(project))
+    }
+    if (entries.length > 0) {
+      return entries
+    }
+  }
+
+  addConfig(entries, safeConfig(ctx))
+  addConfig(entries, safeConfig(safeWorkspaceProject(ctx)))
+
+  return entries
+}
+
+/**
+ * Add configs from runnable test specifications once.
+ *
+ * @param {{ config: object, projectName?: string }[]} entries
+ * @param {unknown[]|undefined} testSpecifications
+ */
+function addTestSpecificationConfigs (entries, testSpecifications) {
+  if (!Array.isArray(testSpecifications)) return
+
+  for (const testSpecification of testSpecifications) {
+    const project = getTestSpecificationProject(testSpecification)
+    addConfig(entries, safeConfig(project), getProjectName(project))
+  }
+}
+
+/**
+ * Add selected inline project configs from the root Vitest config once.
+ *
+ * @param {{ config: object, projectName?: string }[]} entries
+ * @param {object|undefined} rootConfig
+ * @param {string[]} selectedProjectNames
+ */
+function addSelectedInlineProjectConfigs (entries, rootConfig, selectedProjectNames) {
+  if (selectedProjectNames.length === 0 || !Array.isArray(rootConfig?.projects)) return
+
+  for (const project of rootConfig.projects) {
+    const config = getInlineProjectConfig(project)
+    const projectName = getProjectName(project)
+    if (selectedProjectNames.includes(projectName)) {
+      addConfig(entries, config, projectName)
+    }
+  }
+}
+
+/**
+ * Add selected resolved project configs once.
+ *
+ * @param {{ config: object, projectName?: string }[]} entries
+ * @param {unknown[]|undefined} projects
+ * @param {string[]} selectedProjectNames
+ */
+function addSelectedRuntimeProjectConfigs (entries, projects, selectedProjectNames) {
+  if (selectedProjectNames.length === 0 || !Array.isArray(projects)) return
+
+  for (const project of projects) {
+    const projectName = getProjectName(project)
+    if (selectedProjectNames.includes(projectName)) {
+      addConfig(entries, safeConfig(project), projectName)
+    }
+  }
+}
+
+/**
+ * Return selected project names from the Vitest CLI arguments.
+ *
+ * @returns {string[]}
+ */
+function getSelectedProjectNames () {
+  const names = []
+  for (let index = 0; index < process.argv.length; index++) {
+    const argument = process.argv[index]
+    if (argument === '--project' && process.argv[index + 1]) {
+      names.push(process.argv[index + 1])
+      index++
+    } else if (argument.startsWith('--project=')) {
+      names.push(argument.slice('--project='.length))
+    }
+  }
+  return names
+}
+
+/**
+ * Return the test config from an inline Vitest project entry.
+ *
+ * @param {unknown} project
+ * @returns {object|undefined}
+ */
+function getInlineProjectConfig (project) {
+  return project?.test || project
+}
+
+/**
+ * Return a Vitest project name from runtime or inline project objects.
+ *
+ * @param {unknown} project
+ * @returns {string|undefined}
+ */
+function getProjectName (project) {
+  return normalizeProjectName(project?.name || project?.config?.name || project?.test?.name)
+}
+
+/**
+ * Return a normalized Vitest project name.
+ *
+ * @param {unknown} name
+ * @returns {string|undefined}
+ */
+function normalizeProjectName (name) {
+  if (typeof name === 'string') return name
+
+  const label = name?.label
+  return typeof label === 'string' ? label : undefined
+}
+
+/**
+ * Add a config object once.
+ *
+ * @param {{ config: object, projectName?: string }[]} entries
+ * @param {object|undefined} config
+ * @param {string|undefined} projectName
+ */
+function addConfig (entries, config, projectName) {
+  if (config && !entries.some(entry => entry.config === config || (projectName && entry.projectName === projectName))) {
+    entries.push({ config, projectName })
+  }
+}
+
+/**
+ * Read a Vitest config object without assuming the project is initialized.
+ *
+ * @param {object|undefined} project
+ * @returns {object|undefined}
+ */
+function safeConfig (project) {
+  let config
+  try {
+    config = project?.config
+  } catch {}
+  return config
+}
+
+/**
+ * Read the workspace project without assuming the root server is initialized.
+ *
+ * @param {object} ctx
+ * @returns {object|undefined}
+ */
+function safeWorkspaceProject (ctx) {
+  let project
+  try {
+    project = getWorkspaceProject(ctx)
+  } catch {}
+  return project
+}
+
+/**
+ * Return whether Datadog configured ATR retries for a task.
+ *
+ * @param {object} providedContext
+ * @param {object} task
+ * @returns {boolean}
+ */
+function isFlakyTestRetriesEnabledForTask (providedContext, task) {
+  if (!providedContext.isFlakyTestRetriesEnabled) return false
+
+  const { flakyTestRetriesProjectNames } = providedContext
+  if (!Array.isArray(flakyTestRetriesProjectNames)) return true
+
+  const projectName = task.file?.projectName
+  if (!projectName) {
+    return providedContext.flakyTestRetriesIncludesUnnamedProject === true
+  }
+
+  return flakyTestRetriesProjectNames.includes(projectName)
+}
+
 function getSortWrapper (sort, frameworkVersion) {
   return async function () {
     await ensureMainProcessSetup(this.ctx, frameworkVersion, arguments[0])
@@ -669,8 +913,21 @@ function isThreadPool (pool) {
   return pool === 'threads' || pool === 'vmThreads'
 }
 
+/**
+ * Return the project object attached to a Vitest test specification.
+ *
+ * @param {unknown} testSpecification
+ * @returns {object|undefined}
+ */
+function getTestSpecificationProject (testSpecification) {
+  if (Array.isArray(testSpecification)) {
+    return testSpecification[0]
+  }
+  return testSpecification?.project
+}
+
 function getTestSpecificationPool (testSpecification) {
-  const project = Array.isArray(testSpecification) ? testSpecification[0] : testSpecification?.project
+  const project = getTestSpecificationProject(testSpecification)
   return project?.config?.pool || project?.serializedConfig?.pool || project?.pool || testSpecification?.pool
 }
 
@@ -995,15 +1252,15 @@ function wrapVitestTestRunner (VitestTestRunner) {
     let isNew = false
     let isQuarantined = false
 
+    const providedContext = getProvidedContext()
     const {
       isKnownTestsEnabled,
       isEarlyFlakeDetectionEnabled,
       isDiEnabled,
       isTestManagementTestsEnabled,
       testManagementTests,
-      isFlakyTestRetriesEnabled,
       slowTestRetries,
-    } = getProvidedContext()
+    } = providedContext
 
     if (isKnownTestsEnabled) {
       isNew = newTasks.has(task)
@@ -1133,7 +1390,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
     }
 
     const isRetryReasonAtr = numAttempt > 0 &&
-      isFlakyTestRetriesEnabled &&
+      isFlakyTestRetriesEnabledForTask(providedContext, task) &&
       !isRetryReasonAttemptToFix &&
       !isRetryReasonEfd
 
@@ -1524,7 +1781,7 @@ addHook({
           }
 
           // ATR: set hasFailedAllRetries when all auto test retries were exhausted and every attempt failed
-          const isAtrRetry = providedContext.isFlakyTestRetriesEnabled && !attemptToFixTasks.has(task) &&
+          const isAtrRetry = isFlakyTestRetriesEnabledForTask(providedContext, task) && !attemptToFixTasks.has(task) &&
             !newTasks.has(task) && !modifiedTasks.has(task)
           if (isAtrRetry) {
             const maxRetries = providedContext.flakyTestRetriesCount ?? 0

package/packages/datadog-plugin-avsc/src/schema_iterator.js

@@ -43,9 +43,9 @@ class SchemaExtractor {
     let type
     let format
     let enumValues
-    let description
     let ref
 
+    const description = field.doc
     const fieldType = field.type?.types ?? field.type?.typeName ?? field.type
 
     if (Array.isArray(fieldType)) {
@@ -129,7 +129,7 @@ class SchemaExtractor {
   }
 
   iterateOverSchema (builder) {
-    this.constructor.extractSchema(this.schema, builder, 0)
+    SchemaExtractor.extractSchema(this.schema, builder, 0)
   }
 
   static attachSchemaOnSpan (args, span, operation, tracer) {

package/packages/datadog-plugin-aws-sdk/src/base.js

@@ -108,7 +108,7 @@ class BaseAwsSdkPlugin extends ClientPlugin {
       const span = this.startSpan(this.operationFromRequest(request), {
         childOf,
         meta,
-        service: this.serviceName(),
+        service: this.serviceName(request),
         integrationName: 'aws-sdk',
       }, ctx)
 
@@ -216,14 +216,18 @@ class BaseAwsSdkPlugin extends ClientPlugin {
     })
   }
 
-  serviceName () {
-    return this.config.service ||
-      super.serviceName({
-        id: 'aws',
-        type: 'web',
-        kind: 'client',
-        awsService: this.serviceIdentifier,
-      })
+  /**
+   * @param {{ params?: object }} request
+   */
+  serviceName (request) {
+    return super.serviceName({
+      id: 'aws',
+      type: 'web',
+      kind: 'client',
+      awsService: this.serviceIdentifier,
+      pluginConfig: this.config,
+      params: request.params,
+    })
   }
 
   isEnabled (request) {

package/packages/datadog-plugin-aws-sdk/src/services/eventbridge.js

@@ -2,6 +2,34 @@
 const log = require('../../../dd-trace/src/log')
 const BaseAwsSdkPlugin = require('../base')
 
+// EventBridge enforces this limit over the whole PutEvents request (the sum of
+// every entry), not over a single entry. 1 MiB == 1,048,576 bytes.
+const MAX_PUT_EVENTS_BYTES = 1024 * 1024
+
+/**
+ * Size a single `PutEventsRequestEntry` the way EventBridge does server-side:
+ * the UTF-8 byte length of `Source`, `DetailType`, `Detail`, and each
+ * `Resources` ARN, plus a flat 14 bytes when `Time` is set.
+ *
+ * @param {object} entry a single PutEvents request entry
+ * @param {string} [detail] overrides `entry.Detail`, used to size the entry as
+ *   it would be sent with the injected `_datadog` context
+ * @returns {number}
+ * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-putevents.html
+ */
+function putEventEntrySize (entry, detail = entry.Detail) {
+  let size = entry.Time == null ? 0 : 14
+  if (entry.Source != null) size += Buffer.byteLength(entry.Source)
+  if (entry.DetailType != null) size += Buffer.byteLength(entry.DetailType)
+  if (detail != null) size += Buffer.byteLength(detail)
+  if (entry.Resources != null) {
+    for (const resource of entry.Resources) {
+      if (resource != null) size += Buffer.byteLength(resource)
+    }
+  }
+  return size
+}
+
 class EventBridge extends BaseAwsSdkPlugin {
   static id = 'eventbridge'
   static isPayloadReporter = true
@@ -25,7 +53,8 @@ class EventBridge extends BaseAwsSdkPlugin {
    * Docs: https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEventsRequestEntry.html
    * We cannot use the traceHeader field as that's reserved for X-Ray.
    * Detail must be a valid JSON string
-   * Max size per event is 256kb (https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-putevent-size.html)
+   * Max PutEvents request size is 1mb, summed over all entries
+   * (https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-putevent-size.html)
    */
   requestInject (span, request) {
     const operation = request.operation
@@ -34,6 +63,7 @@ class EventBridge extends BaseAwsSdkPlugin {
       request.params.Entries &&
       request.params.Entries.length > 0 &&
       request.params.Entries[0].Detail) {
+      const entries = request.params.Entries
       const injected = {}
       this.tracer.inject(span, 'text_map', injected)
 
@@ -42,19 +72,26 @@ class EventBridge extends BaseAwsSdkPlugin {
       // it so the rest of the body stays in V8's optimisable surface.
       let finalData
       try {
-        finalData = BaseAwsSdkPlugin.injectFieldIntoJsonObject(
-          request.params.Entries[0].Detail, '_datadog', injected
-        )
+        finalData = BaseAwsSdkPlugin.injectFieldIntoJsonObject(entries[0].Detail, '_datadog', injected)
       } catch (error) {
         log.error('EventBridge error injecting request', error)
         return
       }
 
-      if (Buffer.byteLength(finalData) >= 1024 * 256) {
+      // EventBridge applies the 1 MiB cap to the whole request, so size every
+      // entry as it would be sent (the first with `_datadog` injected) and skip
+      // rather than tip a request AWS would otherwise accept over the limit. The
+      // running total only needs to clear the cap, so stop summing the moment it
+      // does instead of byte-counting the rest of a batch we already know is over.
+      let requestSize = putEventEntrySize(entries[0], finalData)
+      for (let i = 1; requestSize < MAX_PUT_EVENTS_BYTES && i < entries.length; i++) {
+        requestSize += putEventEntrySize(entries[i])
+      }
+      if (requestSize >= MAX_PUT_EVENTS_BYTES) {
         log.info('Payload size too large to pass context')
         return
       }
-      request.params.Entries[0].Detail = finalData
+      entries[0].Detail = finalData
     }
   }
 }