dd-trace 6.12.0 → 6.14.0

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

@@ -12,12 +12,15 @@ const patched = new WeakSet()
 const configureCh = channel('ci:log-submission:winston:configure')
 const addTransport = channel('ci:log-submission:winston:add-transport')
 
-addHook({ name: 'winston', file: 'lib/winston/transports/index.js', versions: ['>=3'] }, transportsPackage => {
+addHook({ name: 'winston', versions: ['>=3'] }, winston => {
   if (configureCh.hasSubscribers) {
-    configureCh.publish(transportsPackage.Http)
+    configureCh.publish({
+      createJsonFormat: winston.format.json,
+      StreamTransport: winston.transports.Stream,
+    })
   }
 
-  return transportsPackage
+  return winston
 })
 
 addHook({ name: 'winston', file: 'lib/winston/logger.js', versions: ['>=3'] }, Logger => {

package/packages/datadog-plugin-amqp10/src/consumer.js

@@ -12,9 +12,11 @@ class Amqp10ConsumerPlugin extends ConsumerPlugin {
 
     const source = getShortName(link)
     const address = getAddress(link)
+    let resource = 'receive'
+    if (source) resource += ` ${source}`
 
     this.startSpan({
-      resource: ['receive', source].filter(Boolean).join(' '),
+      resource,
       type: 'worker',
       meta: {
         'amqp.link.source.address': source,

package/packages/datadog-plugin-amqp10/src/producer.js

@@ -14,9 +14,11 @@ class Amqp10ProducerPlugin extends ProducerPlugin {
 
     const address = getAddress(link)
     const target = getShortName(link)
+    let resource = 'send'
+    if (target) resource += ` ${target}`
 
     this.startSpan({
-      resource: ['send', target].filter(Boolean).join(' '),
+      resource,
       meta: {
         'amqp.link.target.address': target,
         'amqp.link.role': 'sender',

package/packages/datadog-plugin-amqp10/src/util.js

@@ -9,7 +9,8 @@ function getAddress (link) {
 function getShortName (link) {
   if (!link || !link.name) return null
 
-  return link.name.split('_').slice(0, -1).join('_')
+  const lastUnderscorePosition = link.name.lastIndexOf('_')
+  return lastUnderscorePosition === -1 ? link.name : link.name.slice(0, lastUnderscorePosition)
 }
 
 module.exports = { getAddress, getShortName }

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

@@ -50,7 +50,12 @@ class SchemaExtractor {
 
     if (Array.isArray(fieldType)) {
       // Union Type
-      type = 'union[' + fieldType.map(t => SchemaExtractor.getType(t.type || t)).join(',') + ']'
+      type = 'union['
+      for (const typeDefinition of fieldType) {
+        if (type !== 'union[') type += ','
+        type += SchemaExtractor.getType(typeDefinition.type || typeDefinition)
+      }
+      type += ']'
     } else if (fieldType === 'array') {
       // Array Type
       array = true

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

@@ -265,8 +265,11 @@ function extractRequestParams (params, provider) {
         for (const message of requestBody.messages) {
           const textBlocks = message.content?.filter(block => block.text) || []
           if (textBlocks.length > 0) {
+            let content = ''
+            for (const block of textBlocks) content += block.text
+
             messages.push({
-              content: textBlocks.map(block => block.text).join(''),
+              content,
               role: message.role,
             })
           }
@@ -288,9 +291,14 @@ function extractRequestParams (params, provider) {
         for (let idx = requestBody.messages.length - 1; idx >= 0; idx--) {
           const message = requestBody.messages[idx]
           if (message.role === 'user') {
-            prompt = message.content?.filter(block => block.type === 'text')
-              .map(block => block.text)
-              .join('')
+            const content = message.content
+            prompt = undefined
+            if (content) {
+              prompt = ''
+              for (const block of content) {
+                if (block.type === 'text') prompt += block.text
+              }
+            }
             break
           }
         }
@@ -546,7 +554,10 @@ function parseToolInput (inputStr) {
 }
 
 function buildToolResult ({ toolUseId, content }) {
-  const result = (content || []).map(resolveToolResultItem).join('')
+  let result = ''
+  if (content) {
+    for (const item of content) result += resolveToolResultItem(item)
+  }
   return { name: '', result, toolId: toolUseId ?? '', type: 'tool_result' }
 }
 

package/packages/datadog-plugin-cassandra-driver/src/index.js

@@ -33,9 +33,14 @@ class CassandraDriverPlugin extends DatabasePlugin {
 }
 
 function combine (queries) {
-  return queries
-    .map(query => (query.query || query).replace(/;?$/, ';'))
-    .join(' ')
+  let combined = ''
+  let isFirstQuery = true
+  for (const query of queries) {
+    if (!isFirstQuery) combined += ' '
+    combined += (query.query || query).replace(/;?$/, ';')
+    isFirstQuery = false
+  }
+  return combined
 }
 
 function trim (str, size) {

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

@@ -124,7 +124,6 @@ class CucumberPlugin extends CiPlugin {
         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()
@@ -202,7 +201,6 @@ 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/cypress-plugin.js

@@ -97,6 +97,12 @@ const {
   getScreenshotUploadResult,
   setScreenshotUploadTags,
 } = require('../../dd-trace/src/ci-visibility/test-screenshot')
+const {
+  VIDEO_UPLOAD_RESULT_ERROR,
+  VIDEO_UPLOAD_RESULT_UPLOADED,
+  VIDEO_UPLOAD_SCOPE_TEST_SUITE,
+  setVideoUploadTags,
+} = require('../../dd-trace/src/ci-visibility/test-video')
 const { appClosing: appClosingTelemetry } = require('../../dd-trace/src/telemetry')
 const log = require('../../dd-trace/src/log')
 
@@ -491,6 +497,8 @@ class CypressPlugin {
   attemptToFixExecutions = new Map()
   loggedAttemptToFixTests = new Set()
   uploadedScreenshotPaths = new Set()
+  uploadedVideoPaths = new Set()
+  pendingVideoUploads = []
   screenshotUploadPromisesByTraceId = new Map()
   screenshotUploadAbortControllers = new Set()
   afterScreenshotHandler = undefined
@@ -581,13 +589,14 @@ class CypressPlugin {
     this.attemptToFixExecutions = new Map()
     this.loggedAttemptToFixTests = new Set()
     this.uploadedScreenshotPaths = new Set()
+    this.uploadedVideoPaths = new Set()
+    this.pendingVideoUploads = []
     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
@@ -801,6 +810,35 @@ class CypressPlugin {
     }
   }
 
+  /**
+   * Warns when video upload is enabled but Cypress cannot produce or send videos.
+   *
+   * @param {object} cypressConfig - Cypress resolved config
+   * @param {object} tracer - dd-trace proxy tracer
+   * @param {object} testOptimizationConfig - Test Optimization config
+   * @returns {void}
+   */
+  warnIfMisconfiguredTestFailureVideos (cypressConfig, tracer, testOptimizationConfig) {
+    if (!testOptimizationConfig.DD_TEST_FAILURE_VIDEOS_ENABLED) return
+
+    if (cypressConfig.video === false) {
+      log.warn(
+        '%s %s',
+        'DD_TEST_FAILURE_VIDEOS_ENABLED is true, but Cypress video capture is disabled.',
+        'Datadog cannot upload failure videos unless Cypress is configured to record videos.'
+      )
+      return
+    }
+
+    if (!tracer?._tracer?._exporter?.canUploadTestVideos?.()) {
+      log.warn(
+        '%s %s',
+        'DD_TEST_FAILURE_VIDEOS_ENABLED is true, but Cypress failure video upload is not supported',
+        'by the active Test Optimization transport.'
+      )
+    }
+  }
+
   // Init function returns a promise that resolves with the Cypress configuration
   // Depending on the received configuration, the Cypress configuration can be modified:
   // for example, to enable retries for failed tests.
@@ -827,6 +865,7 @@ class CypressPlugin {
     const testOptimizationConfig = getConfig().testOptimization
     this.rumFlushWaitMillis = testOptimizationConfig.DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS
     this.warnIfMisconfiguredTestFailureScreenshots(cypressConfig, tracer, testOptimizationConfig)
+    this.warnIfMisconfiguredTestFailureVideos(cypressConfig, tracer, testOptimizationConfig)
 
     if (!this.isTestIsolationEnabled) {
       log.warn('Test isolation is disabled, retries will not be enabled')
@@ -1272,11 +1311,34 @@ class CypressPlugin {
     return details
   }
 
-  afterRun (suiteStats, error, shouldFailFinishedSuites = true) {
+  afterRun (suiteStats, error) {
+    const hasPendingVideoSpans = this.pendingVideoUploads.length > 0
+    const videoUploadsPromise = this.uploadPendingTestSuiteVideos()
     if (!this._isInit) {
       log.warn('Attemping to call afterRun without initializating the plugin first')
+      if (videoUploadsPromise) {
+        return Promise.all([videoUploadsPromise, this.#flushExporter(false)])
+          .then(() => this.#flushExporter(false))
+      }
       return
     }
+    const finalizationPromise = this.#finalizeRun(suiteStats, error, hasPendingVideoSpans)
+    if (videoUploadsPromise) {
+      return Promise.all([videoUploadsPromise, finalizationPromise])
+        .then(() => this.#flushExporter(false))
+    }
+    return finalizationPromise
+  }
+
+  /**
+   * Finalizes Cypress run state without starting queued video uploads.
+   *
+   * @param {object|undefined} suiteStats - Cypress run statistics
+   * @param {Error|undefined} error - Run finalization error
+   * @param {boolean} [hasPendingVideoSpans] - Whether video-owned spans will finish during finalization
+   * @returns {Promise<null>}
+   */
+  #finalizeRun (suiteStats, error, hasPendingVideoSpans = false) {
     if (this.testSessionSpan && this.testModuleSpan) {
       const testStatus = error ? 'fail' : getSessionStatus(suiteStats)
       const hasBackfilledCoverage = this.applySkippedCoverageToTestSessionCoverage()
@@ -1284,13 +1346,6 @@ class CypressPlugin {
 
       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)
@@ -1331,14 +1386,28 @@ class CypressPlugin {
         autoInjected: !!getConfig().testOptimization.DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER,
       })
 
-      finishAllTraceSpans(this.testSessionSpan)
-      this.tracer._tracer._exporter?.exportDeferredTestSuiteSpans?.()
+      // Cypress finishes suite videos in after:run, so their spans must remain open until the upload result is known.
+      if (!hasPendingVideoSpans) {
+        finishAllTraceSpans(this.testSessionSpan)
+      }
     }
 
+    return this.#flushExporter(true)
+  }
+
+  /**
+   * Flushes Test Optimization data after Cypress finalization work.
+   *
+   * @param {boolean} closeRun - Whether to close the Cypress run and telemetry lifecycle
+   * @returns {Promise<null>}
+   */
+  #flushExporter (closeRun) {
     return new Promise(resolve => {
       const finishAfterRun = () => {
-        this._isInit = false
-        appClosingTelemetry()
+        if (closeRun) {
+          this._isInit = false
+          appClosingTelemetry()
+        }
         resolve(null)
       }
 
@@ -1391,12 +1460,12 @@ class CypressPlugin {
   }
 
   afterSpec (spec, results, error) {
-    const { tests, stats, screenshots } = results || {}
+    const { tests, stats, screenshots, video } = results || {}
     const cypressTests = tests || []
     const specScreenshots = screenshots || []
     const finishedTests = this.finishedTestsByFile[spec.relative] || []
     const screenshotUploadPromises = []
-    const testSpanFinishPromises = []
+    const testSpanFinishes = []
 
     if (!this.testSuiteSpan) {
       // dd:testSuiteStart hasn't been triggered for whatever reason
@@ -1463,7 +1532,7 @@ class CypressPlugin {
         })
       }
 
-      skippedTestSpan.finish()
+      testSpanFinishes.push({ testSpan: skippedTestSpan, finishTime: this._now() })
     }
 
     // Make sure that reported test statuses are the same as Cypress reports.
@@ -1604,36 +1673,46 @@ class CypressPlugin {
         const screenshotUploadResultPromise = failedTestTraceId
           ? this.getScreenshotUploadResultPromise(failedTestTraceId)
           : undefined
-        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)
-        }
+        testSpanFinishes.push({
+          testSpan: finishedTest.testSpan,
+          finishTime: finishedTest.finishTime,
+          screenshotUploadResultPromise: error ? undefined : screenshotUploadResultPromise,
+          failedTestTraceId,
+        })
       }
     }
 
-    const finishSuite = () => {
-      if (this.testSuiteSpan) {
-        const status = error ? 'fail' : getSuiteStatus(stats)
-        this.testSuiteSpan.setTag(TEST_STATUS, status)
-
-        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
+    const testSuiteFinishTime = this._now()
+    const suiteFailed = error || latestError || getSuiteStatus(stats) === 'fail'
+    const testSuiteSpan = this.testSuiteSpan
+    const uploadOptions = {
+      filePath: video,
+      testSessionId: typeof this.testSessionSpan?.context === 'function'
+        ? this.testSessionSpan.context().toTraceId()
+        : undefined,
+      testSuiteId: typeof testSuiteSpan?.context === 'function'
+        ? testSuiteSpan.context().toSpanId()
+        : undefined,
+    }
+    const shouldUploadVideo = suiteFailed && this.#canUploadTestSuiteVideo(uploadOptions)
+    if (testSuiteSpan) {
+      testSuiteSpan.setTag(TEST_STATUS, error ? 'fail' : getSuiteStatus(stats))
+      if (error || latestError) testSuiteSpan.setTag('error', error || latestError)
+      this.testSuiteSpan = null
+    }
+
+    let testSpansPromise
+    if (shouldUploadVideo) {
+      this.pendingVideoUploads.push({
+        ...uploadOptions,
+        testSpanFinishes,
+        testSuiteSpan,
+        testSuiteFinishTime,
+      })
+    } else {
+      testSpansPromise = this.finishTestSpans(testSpanFinishes)
+      if (testSuiteSpan) {
+        testSuiteSpan.finish(testSuiteFinishTime)
         this.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
       }
     }
@@ -1646,17 +1725,19 @@ class CypressPlugin {
       }
     }
 
-    finishSuite()
-
     if (error) {
       this.abortPendingScreenshotUploads(error)
-      return this.afterRun(undefined, error, false)
+      const videoSpansPromise = this.#finishPendingTestSuiteVideos(VIDEO_UPLOAD_RESULT_ERROR)
+      const finalizationPromise = this.#finalizeRun(undefined, error)
+      if (videoSpansPromise) {
+        return Promise.all([videoSpansPromise, finalizationPromise]).then(() => null)
+      }
+      return finalizationPromise
     }
 
     const screenshotUploadsPromise = waitForScreenshotUploads()
     let afterSpecPromise = screenshotUploadsPromise
-    if (testSpanFinishPromises.length > 0) {
-      const testSpansPromise = Promise.all(testSpanFinishPromises).then(() => null)
+    if (testSpansPromise) {
       if (screenshotUploadsPromise) {
         afterSpecPromise = Promise.all([testSpansPromise, screenshotUploadsPromise]).then(() => null)
       } else {
@@ -1667,6 +1748,36 @@ class CypressPlugin {
     return afterSpecPromise
   }
 
+  /**
+   * Applies media outcome tags and finishes test spans from one Cypress suite.
+   *
+   * @param {Array<object>} testSpanFinishes - Test spans and deferred screenshot outcomes
+   * @param {string|undefined} videoUploadResult - Test suite video upload outcome
+   * @returns {Promise<null>|undefined}
+   */
+  finishTestSpans (testSpanFinishes, videoUploadResult) {
+    const finishPromises = []
+    for (const {
+      testSpan,
+      finishTime,
+      screenshotUploadResultPromise,
+      failedTestTraceId,
+    } of testSpanFinishes) {
+      const finishTestSpan = (screenshotUploadResult) => {
+        setScreenshotUploadTags(testSpan, screenshotUploadResult)
+        setVideoUploadTags(testSpan, videoUploadResult, VIDEO_UPLOAD_SCOPE_TEST_SUITE)
+        if (failedTestTraceId) this.screenshotUploadPromisesByTraceId.delete(failedTestTraceId)
+        testSpan.finish(finishTime)
+      }
+      if (screenshotUploadResultPromise) {
+        finishPromises.push(screenshotUploadResultPromise.then(finishTestSpan))
+      } else {
+        finishTestSpan()
+      }
+    }
+    if (finishPromises.length > 0) return Promise.all(finishPromises).then(() => null)
+  }
+
   /**
    * Uploads failure screenshots for a Cypress test attempt.
    *
@@ -1720,6 +1831,109 @@ class CypressPlugin {
     }
   }
 
+  /**
+   * Returns whether a Cypress test suite video can be uploaded.
+   *
+   * @param {object} options - Upload options
+   * @param {string|undefined} options.filePath - Cypress video path
+   * @param {string|undefined} options.testSessionId - Test session id
+   * @param {string|undefined} options.testSuiteId - Test suite id
+   * @returns {boolean}
+   */
+  #canUploadTestSuiteVideo ({ filePath, testSessionId, testSuiteId }) {
+    const exporter = this.tracer?._tracer?._exporter
+    return Boolean(filePath && testSessionId && testSuiteId && !this.uploadedVideoPaths.has(filePath) &&
+      exporter?.canUploadTestVideos?.() && exporter.uploadTestSuiteVideo)
+  }
+
+  /**
+   * Uploads the Cypress spec video for a failed test suite.
+   *
+   * @param {object} options - Upload options
+   * @param {string|undefined} options.filePath - Cypress video path
+   * @param {string|undefined} options.testSessionId - Test session id
+   * @param {string|undefined} options.testSuiteId - Test suite id
+   * @returns {Promise<string>|undefined} Promise resolving to the upload outcome
+   */
+  uploadTestSuiteVideo ({ filePath, testSessionId, testSuiteId }) {
+    const exporter = this.tracer?._tracer?._exporter
+    if (!this.#canUploadTestSuiteVideo({ filePath, testSessionId, testSuiteId })) return
+
+    this.uploadedVideoPaths.add(filePath)
+
+    return new Promise(resolve => {
+      exporter.uploadTestSuiteVideo({
+        filePath,
+        testSessionId,
+        testSuiteId,
+        idempotencyKey: `${testSessionId}:${testSuiteId}:${basename(filePath)}`,
+        capturedAtMs: Date.now(),
+      }, (error) => {
+        resolve(error ? VIDEO_UPLOAD_RESULT_ERROR : VIDEO_UPLOAD_RESULT_UPLOADED)
+      })
+    })
+  }
+
+  /**
+   * Tags and finishes every event that references one Cypress test suite video.
+   *
+   * @param {object} pendingVideoUpload - Pending video upload and owning spans
+   * @param {Array<object>} pendingVideoUpload.testSpanFinishes - Deferred test span finishes
+   * @param {object|undefined} pendingVideoUpload.testSuiteSpan - Owning test suite span
+   * @param {number} pendingVideoUpload.testSuiteFinishTime - Suite completion time captured by after:spec
+   * @param {string|undefined} uploadResult - Video upload outcome
+   * @returns {Promise<null>|undefined}
+   */
+  #finishPendingTestSuiteVideo ({ testSpanFinishes, testSuiteSpan, testSuiteFinishTime }, uploadResult) {
+    const testSpansPromise = this.finishTestSpans(testSpanFinishes, uploadResult)
+    if (testSuiteSpan) {
+      setVideoUploadTags(testSuiteSpan, uploadResult, VIDEO_UPLOAD_SCOPE_TEST_SUITE)
+      testSuiteSpan.finish(testSuiteFinishTime)
+      this.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
+    }
+    return testSpansPromise
+  }
+
+  /**
+   * Finishes queued video-owned spans when Cypress will not reach after:run.
+   *
+   * @param {string} uploadResult - Video upload outcome applied to every queued span
+   * @returns {Promise<null>|undefined}
+   */
+  #finishPendingTestSuiteVideos (uploadResult) {
+    const pendingVideoUploads = this.pendingVideoUploads
+    this.pendingVideoUploads = []
+    const finishPromises = []
+    for (const pendingVideoUpload of pendingVideoUploads) {
+      const finishPromise = this.#finishPendingTestSuiteVideo(pendingVideoUpload, uploadResult)
+      if (finishPromise) finishPromises.push(finishPromise)
+    }
+    if (finishPromises.length > 0) return Promise.all(finishPromises).then(() => null)
+  }
+
+  /**
+   * Starts queued Cypress video uploads after Cypress has compressed the source files.
+   *
+   * @returns {Promise<null>|undefined}
+   */
+  uploadPendingTestSuiteVideos () {
+    const pendingVideoUploads = this.pendingVideoUploads
+    this.pendingVideoUploads = []
+    const finishPromises = []
+    for (const pendingVideoUpload of pendingVideoUploads) {
+      const { filePath, testSessionId, testSuiteId } = pendingVideoUpload
+      const uploadPromise = this.uploadTestSuiteVideo({ filePath, testSessionId, testSuiteId })
+      if (uploadPromise) {
+        finishPromises.push(uploadPromise.then(uploadResult =>
+          this.#finishPendingTestSuiteVideo(pendingVideoUpload, uploadResult)))
+      } else {
+        const finishPromise = this.#finishPendingTestSuiteVideo(pendingVideoUpload)
+        if (finishPromise) finishPromises.push(finishPromise)
+      }
+    }
+    if (finishPromises.length > 0) return Promise.all(finishPromises).then(() => null)
+  }
+
   getTasks () {
     return {
       'dd:testSuiteStart': ({ testSuite, testSuiteAbsolutePath }) => {

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

@@ -409,6 +409,7 @@ beforeEach(function () {
       rumCookiePromise = setRumCorrelationCookie(traceId)
     }
     if (shouldSkip) {
+      // Test Optimization requested this runtime skip through the Cypress support hook.
       this.skip()
     }
     if (rumCookiePromise) {

package/packages/datadog-plugin-google-cloud-pubsub/src/client.js

@@ -12,9 +12,12 @@ class GoogleCloudPubsubClientPlugin extends ClientPlugin {
 
     if (api === 'publish') return
 
+    let resource = api
+    if (request.name) resource += ` ${request.name}`
+
     const spanOptions = {
       service: this.config.service || this.serviceName(),
-      resource: [api, request.name].filter(Boolean).join(' '),
+      resource,
       kind: this.constructor.kind,
       meta: {
         'pubsub.method': api,