dd-trace 5.121.0 → 5.122.0

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

@@ -1,35 +1,90 @@
 'use strict'
+
+const { DsmPathwayCodec, PATHWAY_FIELD_BYTES } = require('../../../dd-trace/src/datastreams')
 const log = require('../../../dd-trace/src/log')
 const BaseAwsSdkPlugin = require('../base')
 
+const DEFAULT_EVENT_BUS = 'default'
+const DEFAULT_DETAIL_TYPE = 'unknown'
 // 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.
+// every entry), not over a single entry.
 const MAX_PUT_EVENTS_BYTES = 1024 * 1024
+// Sizing runs before any checkpoint exists, so entries that carry nothing but a pathway are
+// measured against this stand-in.
+const PATHWAY_SIZE_PROBE = { hash: Buffer.alloc(8), pathwayStartNs: 0, edgeStartNs: 0 }
+
+/**
+ * @typedef {object} PutEventsRequestEntry
+ * @property {string} [Detail]
+ * @property {string} [DetailType]
+ * @property {string} [EventBusName]
+ * @property {string[]} [Resources]
+ * @property {string} [Source]
+ * @property {Date} [Time]
+ * @property {string} [TraceHeader]
+ */
+
+/**
+ * Size a single entry the way DSM reports payloads across tracers: the UTF-8 byte length of every
+ * string field the caller supplied. `Time` is excluded because it is not part of the message the
+ * consumer receives, which is also why this differs from `putEventEntrySize`.
+ *
+ * @param {PutEventsRequestEntry} entry whose `Detail` the caller has already checked is a string.
+ * @returns {number}
+ */
+function dsmPayloadSize (entry) {
+  let size = Buffer.byteLength(entry.Detail)
+  if (typeof entry.DetailType === 'string') size += Buffer.byteLength(entry.DetailType)
+  if (typeof entry.EventBusName === 'string') size += Buffer.byteLength(entry.EventBusName)
+  if (typeof entry.Source === 'string') size += Buffer.byteLength(entry.Source)
+  if (typeof entry.TraceHeader === 'string') size += Buffer.byteLength(entry.TraceHeader)
+  if (Array.isArray(entry.Resources)) {
+    for (const resource of entry.Resources) {
+      if (typeof resource === 'string') size += Buffer.byteLength(resource)
+    }
+  }
+  return size
+}
 
 /**
  * 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 {PutEventsRequestEntry} 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) {
+function putEventEntrySize (entry, detail) {
+  if (entry == null) return 0
+
+  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) {
+  if (typeof entry.Source === 'string') size += Buffer.byteLength(entry.Source)
+  if (typeof entry.DetailType === 'string') size += Buffer.byteLength(entry.DetailType)
+  if (typeof detail === 'string') size += Buffer.byteLength(detail)
+  if (Array.isArray(entry.Resources)) {
     for (const resource of entry.Resources) {
-      if (resource != null) size += Buffer.byteLength(resource)
+      if (typeof resource === 'string') size += Buffer.byteLength(resource)
     }
   }
   return size
 }
 
+/**
+ * @param {string} detail
+ * @param {Record<string, string>} carrier
+ * @returns {string|undefined} `undefined` when `detail` is not a JSON object
+ */
+function injectDetail (detail, carrier) {
+  try {
+    return BaseAwsSdkPlugin.injectFieldIntoJsonObject(detail, '_datadog', carrier)
+  } catch (error) {
+    log.error('EventBridge error injecting request', error)
+  }
+}
+
 class EventBridge extends BaseAwsSdkPlugin {
   static id = 'eventbridge'
   static isPayloadReporter = true
@@ -46,44 +101,31 @@ class EventBridge extends BaseAwsSdkPlugin {
   }
 
   /**
-   * requestInject
-   * @param {import('../../../..').Span} span
-   * @param {object} request
+   * The context goes into `Detail` because EventBridge reserves an entry's `TraceHeader` for X-Ray.
    *
-   * 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 PutEvents request size is 1mb, summed over all entries
-   * (https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-putevent-size.html)
+   * @param {import('../../../..').Span} span
+   * @param {{ operation: string, params?: { Entries?: PutEventsRequestEntry[] } }} request
+   * @see https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEventsRequestEntry.html
+   * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-putevent-size.html
    */
   requestInject (span, request) {
-    const operation = request.operation
-    if (operation === 'putEvents' &&
-      request.params &&
-      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)
-
-      // Only `injectFieldIntoJsonObject` can throw (the slow path
-      // `JSON.parse` for non-`{...}` payloads). Tighten the catch around
-      // it so the rest of the body stays in V8's optimisable surface.
-      let finalData
-      try {
-        finalData = BaseAwsSdkPlugin.injectFieldIntoJsonObject(entries[0].Detail, '_datadog', injected)
-      } catch (error) {
-        log.error('EventBridge error injecting request', error)
-        return
-      }
+    const { operation, params } = request
+    if (operation !== 'putEvents' || !params?.Entries?.length) return
+
+    const entries = params.Entries
+    const dsmEnabled = this.config.dsmEnabled
+    const batchPropagationEnabled = this.config.batchPropagationEnabled
+    const traceCarrier = this.tracer.inject(span, 'text_map')
+    if (traceCarrier === undefined && !dsmEnabled) return
 
-      // 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)
+    // The default configuration injects the first entry alone and records no checkpoint, so it
+    // needs none of the deferred-write bookkeeping the paths below depend on.
+    if (!dsmEnabled && !batchPropagationEnabled) {
+      const entry = entries[0]
+      if (typeof entry?.Detail !== 'string') return
+      const detail = injectDetail(entry.Detail, traceCarrier)
+      if (detail === undefined) return
+      let requestSize = putEventEntrySize(entry, detail)
       for (let i = 1; requestSize < MAX_PUT_EVENTS_BYTES && i < entries.length; i++) {
         requestSize += putEventEntrySize(entries[i])
       }
@@ -91,8 +133,85 @@ class EventBridge extends BaseAwsSdkPlugin {
         log.info('Payload size too large to pass context')
         return
       }
-      entries[0].Detail = finalData
+      entry.Detail = detail
+      return
     }
+
+    // Both carriers are reused across entries; the write pass overwrites the pathway on each one
+    // immediately before serializing it, so nothing may come between the two.
+    let pathwayOnlyCarrier
+    const injectable = []
+    let requestSize = 0
+
+    for (let i = 0; i < entries.length && requestSize < MAX_PUT_EVENTS_BYTES; i++) {
+      const entry = entries[i]
+      const tracePropagated = traceCarrier !== undefined && (i === 0 || batchPropagationEnabled)
+      let carrier = traceCarrier
+      if (!tracePropagated) {
+        if (dsmEnabled) pathwayOnlyCarrier ??= DsmPathwayCodec.encode(PATHWAY_SIZE_PROBE)
+        carrier = pathwayOnlyCarrier
+      }
+      if (carrier !== undefined && typeof entry?.Detail === 'string') {
+        // A malformed Detail is skipped rather than fatal: EventBridge partial-fails that entry,
+        // so the rest of the batch still propagates.
+        const traceOnlyDetail = injectDetail(entry.Detail, carrier)
+        if (traceOnlyDetail !== undefined) {
+          // The pathway field is a fixed width, so reserving it is exact and saves building the
+          // detail a second time just to measure it.
+          const reserved = dsmEnabled && tracePropagated ? PATHWAY_FIELD_BYTES : 0
+          requestSize += putEventEntrySize(entry, traceOnlyDetail) + reserved
+          injectable.push({
+            entry,
+            carrier,
+            payloadSize: dsmEnabled ? dsmPayloadSize(entry) : 0,
+            traceOnlyDetail: tracePropagated ? traceOnlyDetail : undefined,
+          })
+          continue
+        }
+      }
+      requestSize += putEventEntrySize(entry)
+    }
+
+    if (injectable.length === 0) return
+    if (requestSize >= MAX_PUT_EVENTS_BYTES) {
+      log.info('Payload size too large to pass context')
+      return
+    }
+
+    for (const { entry, carrier, payloadSize, traceOnlyDetail } of injectable) {
+      let detail = traceOnlyDetail
+      if (dsmEnabled) {
+        const dataStreamsContext = this.setDSMCheckpoint(span, entry, payloadSize)
+        // Anything short of a real pathway leaves the carrier on the sizing stand-in, which must
+        // never ship; a pathway-only entry then has no fallback and keeps the caller's detail.
+        if (DsmPathwayCodec.encode(dataStreamsContext, carrier) !== undefined) {
+          detail = injectDetail(entry.Detail, carrier)
+        }
+      }
+      if (detail !== undefined) entry.Detail = detail
+    }
+  }
+
+  /**
+   * Edge tags feed the pathway hash, so they are a cross-tracer contract: renaming or merging one
+   * splits the DSM pathway instead of extending it.
+   *
+   * @param {import('../../../..').Span} span
+   * @param {PutEventsRequestEntry} entry
+   * @param {number} payloadSize `dsmPayloadSize(entry)`, taken before the `_datadog` context is
+   *   injected. The trailing `0` opts out of the pathway estimate the processor adds by default,
+   *   because that context is propagation overhead rather than the caller's payload.
+   * @returns {object|undefined}
+   */
+  setDSMCheckpoint (span, entry, payloadSize) {
+    const eventBus = entry.EventBusName || DEFAULT_EVENT_BUS
+    const detailType = entry.DetailType ?? DEFAULT_DETAIL_TYPE
+    return this.tracer.setCheckpoint(
+      ['direction:out', `exchange:${eventBus}`, `topic:${detailType}`, 'type:eventbridge'],
+      span,
+      payloadSize,
+      0,
+    )
   }
 }
 module.exports = EventBridge

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

@@ -1,5 +1,5 @@
 'use strict'
-const { DsmPathwayCodec, getSizeOrZero } = require('../../../dd-trace/src/datastreams')
+const { DsmPathwayCodec, getSizeOrZero, PATHWAY_FIELD_BYTES } = require('../../../dd-trace/src/datastreams')
 const log = require('../../../dd-trace/src/log')
 const BaseAwsSdkPlugin = require('../base')
 
@@ -16,12 +16,6 @@ const MAX_TRACKED_SHARD_ITERATORS = 1000
 // conservatively skip propagation above this point because the request does not expose that limit.
 const KINESIS_DEFAULT_MAX_RECORD_BYTES = 1_048_576
 
-// The DSM pathway field (`dd-pathway-ctx-base64`) always serializes to a fixed 55 bytes: a
-// 21-char key, a 28-char base64 value, and 6 bytes of JSON framing. Mirrors PATHWAY_HEADER_BYTES
-// in dd-trace/src/datastreams/processor.js. Reserved in the size gate so setDSMCheckpoint never
-// runs for a record that would ship over the cap once the pathway context is attached.
-const DSM_PATHWAY_FIELD_BYTES = 55
-
 class Kinesis extends BaseAwsSdkPlugin {
   static id = 'kinesis'
   static peerServicePrecursors = ['streamname']
@@ -276,7 +270,7 @@ class Kinesis extends BaseAwsSdkPlugin {
     // Gate before setDSMCheckpoint: a record we can't ship must not record a checkpoint.
     // Reserve the pathway field that DSM appends after the gate.
     let serialized = JSON.stringify(parsedData)
-    const reservedBytes = dsmEnabled ? DSM_PATHWAY_FIELD_BYTES : 0
+    const reservedBytes = dsmEnabled ? PATHWAY_FIELD_BYTES : 0
     const partitionKeyBytes = Buffer.byteLength(params.PartitionKey ?? '', 'utf8')
     if (
       Buffer.byteLength(serialized, 'utf8') + partitionKeyBytes + reservedBytes >

package/packages/datadog-plugin-azure-functions/src/index.js

@@ -156,7 +156,7 @@ function setSpanLinks (triggerType, tracer, span, ctx) {
     : triggerMetadata.propertiesArray
 
   const addLinkFromProperties = (props) => {
-    if (!props || Object.keys(props).length === 0) return
+    if (!props) return
     const spanContext = tracer.extract('text_map', props)
     if (spanContext) {
       span.addLink({ context: spanContext })

package/packages/datadog-plugin-browser-bunyan/src/index.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const BunyanPlugin = require('../../datadog-plugin-bunyan/src')
+
+class BrowserBunyanPlugin extends BunyanPlugin {
+  static id = 'browser-bunyan'
+}
+
+module.exports = BrowserBunyanPlugin

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

@@ -8,17 +8,14 @@ class BunyanPlugin extends LogPlugin {
 
   constructor (...args) {
     super(...args)
-    this.addSub('apm:bunyan:log', (arg) => this.handleLog(arg))
+    this.addSub(`apm:${this.constructor.id}:log`, (arg) => this.handleLog(arg))
   }
 
   /**
-   * Inject `dd` directly on the record bunyan hands us. bunyan builds the
-   * record inside `mkRecord` via `objCopy(log.fields)` and then copies the
-   * caller's fields onto the result, so the `rec` object that flows
-   * through `_emit` is always bunyan-owned, has `Object.prototype` for its
-   * prototype, and is never the caller's input directly. Mutating it adds
-   * `dd` for every consumer (JSON streams via `JSON.stringify(rec)`, raw
-   * streams via the record reference) without paying for a Proxy view.
+   * Inject `dd` directly on the record Bunyan implementations hand us. They build the record
+   * inside `mkRecord` from a copy of the logger and caller fields, so the `rec` object that flows
+   * through `_emit` is always logger-owned. Mutating it adds `dd` for every consumer without
+   * paying for a Proxy view.
    *
    * @param {{ message: object }} arg
    */

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

@@ -72,6 +72,7 @@ class CucumberPlugin extends CiPlugin {
       isEarlyFlakeDetectionFaulty,
       isTestManagementTestsEnabled,
       isParallel,
+      error,
       onDone,
     }) => {
       this._exportPendingWorkerTraces()
@@ -115,6 +116,15 @@ class CucumberPlugin extends CiPlugin {
 
       this.testSessionSpan.setTag(TEST_STATUS, status)
       this.testModuleSpan.setTag(TEST_STATUS, status)
+      if (error) {
+        for (const testSuiteSpan of this._testSuiteSpansByTestSuite.values()) {
+          testSuiteSpan.setTag(TEST_STATUS, 'fail')
+          testSuiteSpan.setTag('error', error)
+        }
+        this.testSessionSpan.setTag('error', error)
+        this.testModuleSpan.setTag('error', error)
+      }
+      this.tracer._exporter.exportDeferredTestSuiteSpans?.()
       this.testModuleSpan.finish()
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
       this.testSessionSpan.finish()
@@ -192,6 +202,7 @@ class CucumberPlugin extends CiPlugin {
     this.addSub('ci:cucumber:test-suite:finish', ({ status, testSuitePath }) => {
       const testSuiteSpan = this._testSuiteSpansByTestSuite.get(testSuitePath)
       testSuiteSpan.setTag(TEST_STATUS, status)
+      this.tracer._exporter.deferTestSuiteSpan?.(testSuiteSpan)
       testSuiteSpan.finish()
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
     })

package/packages/datadog-plugin-cypress/src/after-run.js

@@ -1,5 +1,9 @@
 'use strict'
 
 const cypressPlugin = require('./cypress-plugin')
+const { shouldDeferLegacyFinalization } = require('./finalization')
 
-module.exports = cypressPlugin.afterRun.bind(cypressPlugin)
+module.exports = function afterRun () {
+  if (shouldDeferLegacyFinalization()) return
+  return cypressPlugin.afterRun.apply(cypressPlugin, arguments)
+}

package/packages/datadog-plugin-cypress/src/after-spec.js

@@ -1,5 +1,9 @@
 'use strict'
 
 const cypressPlugin = require('./cypress-plugin')
+const { shouldDeferLegacyFinalization } = require('./finalization')
 
-module.exports = cypressPlugin.afterSpec.bind(cypressPlugin)
+module.exports = function afterSpec () {
+  if (shouldDeferLegacyFinalization()) return
+  return cypressPlugin.afterSpec.apply(cypressPlugin, arguments)
+}

package/packages/datadog-plugin-cypress/src/cypress-plugin.js

@@ -477,7 +477,7 @@ class CypressPlugin {
   testsToSkip = []
   skippedTests = []
   skippedTestIds = new Set()
-  skippableTestsCoverage = {}
+  skippableTestsCoverage
   testSessionCoverageMap = createCoverageMap()
   hasForcedToRunSuites = false
   hasUnskippableSuites = false
@@ -492,6 +492,7 @@ class CypressPlugin {
   loggedAttemptToFixTests = new Set()
   uploadedScreenshotPaths = new Set()
   screenshotUploadPromisesByTraceId = new Map()
+  screenshotUploadAbortControllers = new Set()
   afterScreenshotHandler = undefined
   lastFinishedTest = null
   pendingScreenshotUploads = []
@@ -565,7 +566,7 @@ class CypressPlugin {
     this.testsToSkip = []
     this.skippedTests = []
     this.skippedTestIds = new Set()
-    this.skippableTestsCoverage = {}
+    this.skippableTestsCoverage = undefined
     this.testSessionCoverageMap = createCoverageMap()
     this.hasForcedToRunSuites = false
     this.hasUnskippableSuites = false
@@ -581,10 +582,12 @@ class CypressPlugin {
     this.loggedAttemptToFixTests = new Set()
     this.uploadedScreenshotPaths = new Set()
     this.screenshotUploadPromisesByTraceId = new Map()
+    this.screenshotUploadAbortControllers = new Set()
     this.lastFinishedTest = null
     this.pendingScreenshotUploads = []
     this.activeTestSpan = null
     this.testSuiteSpan = null
+    this.finishedTestSuiteSpans = []
     this.testModuleSpan = null
     this.testSessionSpan = null
     this.command = undefined
@@ -643,6 +646,19 @@ class CypressPlugin {
     return Promise.all(uploadPromises).then(getScreenshotUploadResult)
   }
 
+  /**
+   * Cancels screenshot work that must not outlive an errored after:spec finalization boundary.
+   *
+   * @param {Error} error - Error that triggered finalization
+   * @returns {void}
+   */
+  abortPendingScreenshotUploads (error) {
+    for (const controller of this.screenshotUploadAbortControllers) controller.abort(error)
+    this.screenshotUploadAbortControllers.clear()
+    this.screenshotUploadPromisesByTraceId.clear()
+    this.pendingScreenshotUploads = []
+  }
+
   /**
    * Returns the current time in the same coordinate system used by span
    * start/finish. Captured at session span creation so it shares the same
@@ -663,17 +679,6 @@ class CypressPlugin {
     return this.repositoryRoot || this.rootDir || process.cwd()
   }
 
-  /**
-   * Returns whether the backend supplied skipped-test coverage data.
-   *
-   * @returns {boolean}
-   */
-  hasSkippableTestsCoverage () {
-    return !!(this.skippableTestsCoverage &&
-      typeof this.skippableTestsCoverage === 'object' &&
-      Object.keys(this.skippableTestsCoverage).length > 0)
-  }
-
   /**
    * Returns whether skipped test coverage should be backfilled into the session coverage map.
    *
@@ -683,7 +688,7 @@ class CypressPlugin {
     return this.isItrEnabled &&
       this.isCoverageReportUploadEnabled &&
       this.isTestsSkipped &&
-      this.hasSkippableTestsCoverage()
+      this.skippableTestsCoverage !== undefined
   }
 
   /**
@@ -800,6 +805,17 @@ class CypressPlugin {
   // Depending on the received configuration, the Cypress configuration can be modified:
   // for example, to enable retries for failed tests.
   init (tracer, cypressConfig) {
+    if (this.cypressConfig === cypressConfig && this.hasOriginalCypressRetries) {
+      cypressConfig.retries = this.originalCypressRetries !== null &&
+        typeof this.originalCypressRetries === 'object'
+        ? { ...this.originalCypressRetries }
+        : this.originalCypressRetries
+    } else {
+      this.originalCypressRetries = cypressConfig.retries !== null && typeof cypressConfig.retries === 'object'
+        ? { ...cypressConfig.retries }
+        : cypressConfig.retries
+      this.hasOriginalCypressRetries = true
+    }
     this.resetRunState()
     this._isInit = true
     this.tracer = tracer
@@ -1063,9 +1079,13 @@ class CypressPlugin {
   }
 
   async beforeRun (details) {
-    // We need to make sure that the plugin is initialized before running the tests
-    // This is for the case where the user has not returned the promise from the init function
-    await this.libraryConfigurationPromise
+    if (this._isInit) {
+      // The user may not have returned the promise from the init function.
+      await this.libraryConfigurationPromise
+    } else {
+      // Cypress open reuses the same plugin process for every interactive run.
+      await this.init(this.tracer, this.cypressConfig)
+    }
 
     this.command = getCypressCommand(details)
     this.frameworkVersion = getCypressVersion(details)
@@ -1131,7 +1151,7 @@ class CypressPlugin {
       } else {
         const { skippableTests, correlationId, skippableTestsCoverage } = skippableTestsResponse
         this.testsToSkip = skippableTests || []
-        this.skippableTestsCoverage = skippableTestsCoverage || {}
+        this.skippableTestsCoverage = skippableTestsCoverage
         this.itrCorrelationId = correlationId
         incrementCountMetric(TELEMETRY_ITR_SKIPPED, { testLevel: 'test' }, this.testsToSkip.length)
       }
@@ -1252,18 +1272,29 @@ class CypressPlugin {
     return details
   }
 
-  afterRun (suiteStats) {
+  afterRun (suiteStats, error, shouldFailFinishedSuites = true) {
     if (!this._isInit) {
       log.warn('Attemping to call afterRun without initializating the plugin first')
       return
     }
     if (this.testSessionSpan && this.testModuleSpan) {
-      const testStatus = getSessionStatus(suiteStats)
+      const testStatus = error ? 'fail' : getSessionStatus(suiteStats)
       const hasBackfilledCoverage = this.applySkippedCoverageToTestSessionCoverage()
       const testCodeCoverageLinesTotal = this.getTestCodeCoverageLinesTotal(hasBackfilledCoverage)
 
       this.testModuleSpan.setTag(TEST_STATUS, testStatus)
       this.testSessionSpan.setTag(TEST_STATUS, testStatus)
+      for (const span of this.finishedTestSuiteSpans) {
+        if (error && shouldFailFinishedSuites) {
+          span.setTag(TEST_STATUS, 'fail')
+          span.setTag('error', error)
+        }
+      }
+      this.finishedTestSuiteSpans = []
+      if (error) {
+        this.testModuleSpan.setTag('error', error)
+        this.testSessionSpan.setTag('error', error)
+      }
 
       addIntelligentTestRunnerSpanTags(
         this.testSessionSpan,
@@ -1301,6 +1332,7 @@ class CypressPlugin {
       })
 
       finishAllTraceSpans(this.testSessionSpan)
+      this.tracer._tracer._exporter?.exportDeferredTestSuiteSpans?.()
     }
 
     return new Promise(resolve => {
@@ -1358,7 +1390,7 @@ class CypressPlugin {
     }
   }
 
-  afterSpec (spec, results) {
+  afterSpec (spec, results, error) {
     const { tests, stats, screenshots } = results || {}
     const cypressTests = tests || []
     const specScreenshots = screenshots || []
@@ -1572,13 +1604,16 @@ class CypressPlugin {
         const screenshotUploadResultPromise = failedTestTraceId
           ? this.getScreenshotUploadResultPromise(failedTestTraceId)
           : undefined
-        if (screenshotUploadResultPromise) {
+        if (screenshotUploadResultPromise && !error) {
           testSpanFinishPromises.push(screenshotUploadResultPromise.then((uploadResult) => {
             setScreenshotUploadTags(finishedTest.testSpan, uploadResult)
             this.screenshotUploadPromisesByTraceId.delete(failedTestTraceId)
             finishedTest.testSpan.finish(finishedTest.finishTime)
           }))
         } else {
+          if (screenshotUploadResultPromise) {
+            this.screenshotUploadPromisesByTraceId.delete(failedTestTraceId)
+          }
           finishedTest.testSpan.finish(finishedTest.finishTime)
         }
       }
@@ -1586,13 +1621,18 @@ class CypressPlugin {
 
     const finishSuite = () => {
       if (this.testSuiteSpan) {
-        const status = getSuiteStatus(stats)
+        const status = error ? 'fail' : getSuiteStatus(stats)
         this.testSuiteSpan.setTag(TEST_STATUS, status)
 
-        if (latestError) {
-          this.testSuiteSpan.setTag('error', latestError)
+        if (error || latestError) {
+          this.testSuiteSpan.setTag('error', error || latestError)
         }
+        const canRunAfterRun = this.cypressConfig.isTextTerminal ||
+          this.cypressConfig.experimentalInteractiveRunEvents
+        const exporter = this.tracer._tracer._exporter
+        if (canRunAfterRun && exporter?.deferTestSuiteSpan) exporter.deferTestSuiteSpan(this.testSuiteSpan)
         this.testSuiteSpan.finish()
+        if (canRunAfterRun) this.finishedTestSuiteSpans.push(this.testSuiteSpan)
         this.testSuiteSpan = null
         this.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
       }
@@ -1608,16 +1648,23 @@ class CypressPlugin {
 
     finishSuite()
 
+    if (error) {
+      this.abortPendingScreenshotUploads(error)
+      return this.afterRun(undefined, error, false)
+    }
+
     const screenshotUploadsPromise = waitForScreenshotUploads()
+    let afterSpecPromise = screenshotUploadsPromise
     if (testSpanFinishPromises.length > 0) {
       const testSpansPromise = Promise.all(testSpanFinishPromises).then(() => null)
       if (screenshotUploadsPromise) {
-        return Promise.all([testSpansPromise, screenshotUploadsPromise]).then(() => null)
+        afterSpecPromise = Promise.all([testSpansPromise, screenshotUploadsPromise]).then(() => null)
+      } else {
+        afterSpecPromise = testSpansPromise
       }
-      return testSpansPromise
     }
 
-    return screenshotUploadsPromise
+    return afterSpecPromise
   }
 
   /**
@@ -1637,6 +1684,7 @@ class CypressPlugin {
     }
 
     const uploadPromises = []
+    const abortController = new AbortController()
 
     for (const screenshot of screenshots) {
       const filePath = getScreenshotFilePath(screenshot)
@@ -1655,6 +1703,7 @@ class CypressPlugin {
           traceId,
           idempotencyKey,
           capturedAtMs,
+          signal: abortController.signal,
         }, (err) => {
           resolve(err ? SCREENSHOT_UPLOAD_RESULT_ERROR : SCREENSHOT_UPLOAD_RESULT_UPLOADED)
         })
@@ -1662,7 +1711,10 @@ class CypressPlugin {
     }
 
     if (uploadPromises.length > 0) {
-      const uploadPromise = Promise.all(uploadPromises).then(getScreenshotUploadResult)
+      this.screenshotUploadAbortControllers.add(abortController)
+      const uploadPromise = Promise.all(uploadPromises).then(getScreenshotUploadResult).finally(() => {
+        this.screenshotUploadAbortControllers.delete(abortController)
+      })
       this.addScreenshotUploadPromise(traceId, uploadPromise)
       return uploadPromise
     }