dd-trace 3.12.1 → 3.15.0

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

@@ -0,0 +1,263 @@
+const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const testStartCh = channel('ci:playwright:test:start')
+const testFinishCh = channel('ci:playwright:test:finish')
+
+const testSessionStartCh = channel('ci:playwright:session:start')
+const testSessionFinishCh = channel('ci:playwright:session:finish')
+
+const testSuiteStartCh = channel('ci:playwright:test-suite:start')
+const testSuiteFinishCh = channel('ci:playwright:test-suite:finish')
+
+const testToAr = new WeakMap()
+const testSuiteToAr = new Map()
+const testSuiteToTestStatuses = new Map()
+
+let startedSuites = []
+
+const STATUS_TO_TEST_STATUS = {
+  passed: 'pass',
+  failed: 'fail',
+  timedOut: 'fail',
+  skipped: 'skip'
+}
+
+let remainingTestsByFile = {}
+
+function getTestsBySuiteFromTestGroups (testGroups) {
+  return testGroups.reduce((acc, { requireFile, tests }) => {
+    if (acc[requireFile]) {
+      acc[requireFile] = acc[requireFile].concat(tests)
+    } else {
+      acc[requireFile] = tests
+    }
+    return acc
+  }, {})
+}
+
+function getTestsBySuiteFromTestsById (testsById) {
+  const testsByTestSuite = {}
+  for (const { test } of testsById.values()) {
+    const { _requireFile } = test
+    if (test._type === 'beforeAll' || test._type === 'afterAll') {
+      continue
+    }
+    if (testsByTestSuite[_requireFile]) {
+      testsByTestSuite[_requireFile].push(test)
+    } else {
+      testsByTestSuite[_requireFile] = [test]
+    }
+  }
+  return testsByTestSuite
+}
+
+function getPlaywrightConfig (playwrightRunner) {
+  try {
+    return playwrightRunner._configLoader.fullConfig()
+  } catch (e) {
+    try {
+      return playwrightRunner._loader.fullConfig()
+    } catch (e) {
+      return playwrightRunner._config || {}
+    }
+  }
+}
+
+function getRootDir (playwrightRunner) {
+  const config = getPlaywrightConfig(playwrightRunner)
+  if (config.rootDir) {
+    return config.rootDir
+  }
+  if (playwrightRunner._configDir) {
+    return playwrightRunner._configDir
+  }
+  return process.cwd()
+}
+
+function testBeginHandler (test) {
+  const { title: testName, location: { file: testSuiteAbsolutePath }, _type } = test
+
+  if (_type === 'beforeAll' || _type === 'afterAll') {
+    return
+  }
+
+  const isNewTestSuite = !startedSuites.includes(testSuiteAbsolutePath)
+
+  if (isNewTestSuite) {
+    startedSuites.push(testSuiteAbsolutePath)
+    const testSuiteAsyncResource = new AsyncResource('bound-anonymous-fn')
+    testSuiteToAr.set(testSuiteAbsolutePath, testSuiteAsyncResource)
+    testSuiteAsyncResource.runInAsyncScope(() => {
+      testSuiteStartCh.publish(testSuiteAbsolutePath)
+    })
+  }
+
+  const testAsyncResource = new AsyncResource('bound-anonymous-fn')
+  testToAr.set(test, testAsyncResource)
+  testAsyncResource.runInAsyncScope(() => {
+    testStartCh.publish({ testName, testSuiteAbsolutePath })
+  })
+}
+
+function testEndHandler (test, testStatus, error) {
+  const { location: { file: testSuiteAbsolutePath }, results, _type } = test
+
+  if (_type === 'beforeAll' || _type === 'afterAll') {
+    return
+  }
+
+  const testResult = results[results.length - 1]
+  const testAsyncResource = testToAr.get(test)
+  testAsyncResource.runInAsyncScope(() => {
+    testFinishCh.publish({ testStatus, steps: testResult.steps, error })
+  })
+
+  if (!testSuiteToTestStatuses.has(testSuiteAbsolutePath)) {
+    testSuiteToTestStatuses.set(testSuiteAbsolutePath, [testStatus])
+  } else {
+    testSuiteToTestStatuses.get(testSuiteAbsolutePath).push(testStatus)
+  }
+
+  remainingTestsByFile[testSuiteAbsolutePath] = remainingTestsByFile[testSuiteAbsolutePath]
+    .filter(currentTest => currentTest !== test)
+
+  if (!remainingTestsByFile[testSuiteAbsolutePath].length) {
+    const testStatuses = testSuiteToTestStatuses.get(testSuiteAbsolutePath)
+
+    let testSuiteStatus = 'pass'
+    if (testStatuses.some(status => status === 'fail')) {
+      testSuiteStatus = 'fail'
+    } else if (testStatuses.every(status => status === 'skip')) {
+      testSuiteStatus = 'skip'
+    }
+
+    const testSuiteAsyncResource = testSuiteToAr.get(testSuiteAbsolutePath)
+    testSuiteAsyncResource.runInAsyncScope(() => {
+      testSuiteFinishCh.publish(testSuiteStatus)
+    })
+  }
+}
+
+function dispatcherRunWrapper (run) {
+  return function () {
+    remainingTestsByFile = getTestsBySuiteFromTestsById(this._testById)
+    return run.apply(this, arguments)
+  }
+}
+
+function dispatcherRunWrapperNew (run) {
+  return function () {
+    remainingTestsByFile = getTestsBySuiteFromTestGroups(arguments[0])
+    return run.apply(this, arguments)
+  }
+}
+
+function dispatcherHook (dispatcherExport) {
+  shimmer.wrap(dispatcherExport.Dispatcher.prototype, 'run', dispatcherRunWrapper)
+  shimmer.wrap(dispatcherExport.Dispatcher.prototype, '_createWorker', createWorker => function () {
+    const dispatcher = this
+    const worker = createWorker.apply(this, arguments)
+
+    worker.process.on('message', ({ method, params }) => {
+      if (method === 'testBegin') {
+        const { test } = dispatcher._testById.get(params.testId)
+        testBeginHandler(test)
+      } else if (method === 'testEnd') {
+        const { test } = dispatcher._testById.get(params.testId)
+
+        const { results } = test
+        const testResult = results[results.length - 1]
+
+        testEndHandler(test, STATUS_TO_TEST_STATUS[testResult.status], testResult.error)
+      }
+    })
+
+    return worker
+  })
+  return dispatcherExport
+}
+
+function dispatcherHookNew (dispatcherExport, runWrapper) {
+  shimmer.wrap(dispatcherExport.Dispatcher.prototype, 'run', runWrapper)
+  shimmer.wrap(dispatcherExport.Dispatcher.prototype, '_createWorker', createWorker => function () {
+    const dispatcher = this
+    const worker = createWorker.apply(this, arguments)
+
+    worker.on('testBegin', ({ testId }) => {
+      const { test } = dispatcher._testById.get(testId)
+      testBeginHandler(test)
+    })
+    worker.on('testEnd', ({ testId, status, errors }) => {
+      const { test } = dispatcher._testById.get(testId)
+
+      testEndHandler(test, STATUS_TO_TEST_STATUS[status], errors && errors[0])
+    })
+
+    return worker
+  })
+  return dispatcherExport
+}
+
+function runnerHook (runnerExport, playwrightVersion) {
+  shimmer.wrap(runnerExport.Runner.prototype, 'runAllTests', runAllTests => async function () {
+    const testSessionAsyncResource = new AsyncResource('bound-anonymous-fn')
+    const rootDir = getRootDir(this)
+
+    const processArgv = process.argv.slice(2).join(' ')
+    const command = `playwright ${processArgv}`
+    testSessionAsyncResource.runInAsyncScope(() => {
+      testSessionStartCh.publish({ command, frameworkVersion: playwrightVersion, rootDir })
+    })
+
+    const runAllTestsReturn = await runAllTests.apply(this, arguments)
+    const sessionStatus = runAllTestsReturn.status || runAllTestsReturn
+
+    let onDone
+
+    const flushWait = new Promise(resolve => {
+      onDone = resolve
+    })
+    testSessionAsyncResource.runInAsyncScope(() => {
+      testSessionFinishCh.publish({ status: STATUS_TO_TEST_STATUS[sessionStatus], onDone })
+    })
+    await flushWait
+
+    startedSuites = []
+    remainingTestsByFile = {}
+
+    return runAllTestsReturn
+  })
+
+  return runnerExport
+}
+
+addHook({
+  name: '@playwright/test',
+  file: 'lib/runner.js',
+  versions: ['>=1.18.0 <1.30.0']
+}, runnerHook)
+
+addHook({
+  name: '@playwright/test',
+  file: 'lib/dispatcher.js',
+  versions: ['>=1.18.0  <1.30.0']
+}, dispatcherHook)
+
+addHook({
+  name: '@playwright/test',
+  file: 'lib/dispatcher.js',
+  versions: ['>=1.30.0 <1.31.0']
+}, (dispatcher) => dispatcherHookNew(dispatcher, dispatcherRunWrapper))
+
+addHook({
+  name: '@playwright/test',
+  file: 'lib/runner/dispatcher.js',
+  versions: ['>=1.31.0']
+}, (dispatcher) => dispatcherHookNew(dispatcher, dispatcherRunWrapperNew))
+
+addHook({
+  name: '@playwright/test',
+  file: 'lib/runner/runner.js',
+  versions: ['>=1.31.0']
+}, runnerHook)

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

@@ -23,13 +23,12 @@ class BaseAwsSdkPlugin extends Plugin {
       request,
       operation,
       awsRegion,
-      awsService,
-      serviceIdentifier
+      awsService
     }) => {
       if (!this.isEnabled(request)) {
         return
       }
-      const serviceName = this.getServiceName(serviceIdentifier)
+      const serviceName = this.getServiceName()
       const childOf = this.tracer.scope().active()
       const tags = {
         'span.kind': 'client',
@@ -52,6 +51,14 @@ class BaseAwsSdkPlugin extends Plugin {
       this.enter(span, store)
     })
 
+    this.addSub(`apm:aws:request:region:${this.serviceIdentifier}`, region => {
+      const store = storage.getStore()
+      if (!store) return
+      const { span } = store
+      if (!span) return
+      span.setTag('aws.region', region)
+    })
+
     this.addSub(`apm:aws:request:complete:${this.serviceIdentifier}`, ({ response }) => {
       const store = storage.getStore()
       if (!store) return
@@ -109,10 +116,10 @@ class BaseAwsSdkPlugin extends Plugin {
   }
 
   // TODO: test splitByAwsService when the test suite is fixed
-  getServiceName (serviceIdentifier) {
+  getServiceName () {
     return this.config.service
       ? this.config.service
-      : `${this.tracer._service}-aws-${serviceIdentifier}`
+      : `${this.tracer._service}-aws-${this.serviceIdentifier}`
   }
 }
 

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

@@ -48,8 +48,8 @@ class Kinesis extends BaseAwsSdkPlugin {
       const parsedData = this._tryParse(injectPath.Data)
       if (parsedData) {
         parsedData._datadog = traceData
-        const finalData = JSON.stringify(parsedData)
-        const byteSize = Buffer.byteLength(finalData, 'ascii')
+        const finalData = Buffer.from(JSON.stringify(parsedData))
+        const byteSize = finalData.length
         // Kinesis max payload size is 1MB
         // So we must ensure adding DD context won't go over that (512b is an estimate)
         if (byteSize >= 1048576) {

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

@@ -18,30 +18,35 @@ class Sns extends BaseAwsSdkPlugin {
   }
 
   requestInject (span, request) {
-    const operation = request.operation
-    if (operation === 'publish' || operation === 'publishBatch') {
-      if (!request.params) {
-        request.params = {}
-      }
-      let injectPath
-      if (request.params.PublishBatchRequestEntries && request.params.PublishBatchRequestEntries.length > 0) {
-        injectPath = request.params.PublishBatchRequestEntries[0]
-      } else if (request.params.Message) {
-        injectPath = request.params
-      }
-      if (!injectPath.MessageAttributes) {
-        injectPath.MessageAttributes = {}
-      }
-      if (Object.keys(injectPath.MessageAttributes).length >= 10) { // SNS quota
-        log.info('Message attributes full, skipping trace context injection')
-        return
-      }
-      const ddInfo = {}
-      this.tracer.inject(span, 'text_map', ddInfo)
-      injectPath.MessageAttributes._datadog = {
-        DataType: 'Binary',
-        BinaryValue: JSON.stringify(ddInfo) // BINARY types are automatically base64 encoded
-      }
+    const { operation, params } = request
+
+    if (!params) return
+
+    switch (operation) {
+      case 'publish':
+        this._injectMessageAttributes(span, params)
+        break
+      case 'publishBatch':
+        if (params.PublishBatchRequestEntries && params.PublishBatchRequestEntries.length > 0) {
+          this._injectMessageAttributes(span, params.PublishBatchRequestEntries[0])
+        }
+        break
+    }
+  }
+
+  _injectMessageAttributes (span, params) {
+    if (!params.MessageAttributes) {
+      params.MessageAttributes = {}
+    }
+    if (Object.keys(params.MessageAttributes).length >= 10) { // SNS quota
+      log.info('Message attributes full, skipping trace context injection')
+      return
+    }
+    const ddInfo = {}
+    this.tracer.inject(span, 'text_map', ddInfo)
+    params.MessageAttributes._datadog = {
+      DataType: 'Binary',
+      BinaryValue: Buffer.from(JSON.stringify(ddInfo)) // BINARY types are automatically base64 encoded
     }
   }
 }

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

@@ -78,24 +78,39 @@ class Sqs extends BaseAwsSdkPlugin {
   }
 
   responseExtract (params, operation, response) {
-    if (operation === 'receiveMessage') {
-      if (
-        (!params.MaxNumberOfMessages || params.MaxNumberOfMessages === 1) &&
-        response &&
-        response.Messages &&
-        response.Messages[0] &&
-        response.Messages[0].MessageAttributes &&
-        response.Messages[0].MessageAttributes._datadog &&
-        response.Messages[0].MessageAttributes._datadog.StringValue
-      ) {
-        const textMap = response.Messages[0].MessageAttributes._datadog.StringValue
-        try {
-          return this.tracer.extract('text_map', JSON.parse(textMap))
-        } catch (err) {
-          log.error(err)
-          return undefined
+    if (operation !== 'receiveMessage') return
+    if (params.MaxNumberOfMessages && params.MaxNumberOfMessages !== 1) return
+    if (!response || !response.Messages || !response.Messages[0]) return
+
+    let message = response.Messages[0]
+
+    if (message.Body) {
+      try {
+        const body = JSON.parse(message.Body)
+
+        // SNS to SQS
+        if (body.Type === 'Notification') {
+          message = body
         }
+      } catch (e) {
+        // SQS to SQS
+      }
+    }
+
+    if (!message.MessageAttributes || !message.MessageAttributes._datadog) return
+
+    const datadogAttribute = message.MessageAttributes._datadog
+
+    try {
+      if (datadogAttribute.StringValue) {
+        const textMap = datadogAttribute.StringValue
+        return this.tracer.extract('text_map', JSON.parse(textMap))
+      } else if (datadogAttribute.Type === 'Binary') {
+        const buffer = Buffer.from(datadogAttribute.Value, 'base64')
+        return this.tracer.extract('text_map', JSON.parse(buffer))
       }
+    } catch (e) {
+      log.error(e)
     }
   }
 

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

@@ -7,7 +7,8 @@ const {
   TEST_SKIP_REASON,
   TEST_STATUS,
   finishAllTraceSpans,
-  getTestSuitePath
+  getTestSuitePath,
+  getTestSuiteCommonTags
 } = require('../../dd-trace/src/plugins/util/test')
 const { RESOURCE_NAME } = require('../../../ext/tags')
 const { COMPONENT, ERROR_MESSAGE } = require('../../dd-trace/src/constants')
@@ -20,21 +21,47 @@ class CucumberPlugin extends CiPlugin {
   constructor (...args) {
     super(...args)
 
-    this.addSub('ci:cucumber:session:finish', () => {
+    this.sourceRoot = process.cwd()
+
+    this.addSub('ci:cucumber:session:finish', (status) => {
+      this.testSessionSpan.setTag(TEST_STATUS, status)
+      this.testModuleSpan.setTag(TEST_STATUS, status)
+      this.testModuleSpan.finish()
+      this.testSessionSpan.finish()
+      finishAllTraceSpans(this.testSessionSpan)
       this.tracer._exporter.flush()
     })
 
-    this.addSub('ci:cucumber:run:start', ({ testName, fullTestSuite }) => {
-      const store = storage.getStore()
-      const childOf = store ? store.span : store
-      const testSuite = getTestSuitePath(fullTestSuite, process.cwd())
+    this.addSub('ci:cucumber:test-suite:start', (testSuiteFullPath) => {
+      const testSuiteMetadata = getTestSuiteCommonTags(
+        this.command,
+        this.frameworkVersion,
+        getTestSuitePath(testSuiteFullPath, this.sourceRoot)
+      )
+      this.testSuiteSpan = this.tracer.startSpan('cucumber.test_suite', {
+        childOf: this.testModuleSpan,
+        tags: {
+          [COMPONENT]: this.constructor.name,
+          ...this.testEnvironmentMetadata,
+          ...testSuiteMetadata
+        }
+      })
+    })
 
-      const testSpan = this.startTestSpan(testName, testSuite, childOf)
+    this.addSub('ci:cucumber:test-suite:finish', status => {
+      this.testSuiteSpan.setTag(TEST_STATUS, status)
+      this.testSuiteSpan.finish()
+    })
+
+    this.addSub('ci:cucumber:test:start', ({ testName, fullTestSuite }) => {
+      const store = storage.getStore()
+      const testSuite = getTestSuitePath(fullTestSuite, this.sourceRoot)
+      const testSpan = this.startTestSpan(testName, testSuite)
 
       this.enter(testSpan, store)
     })
 
-    this.addSub('ci:cucumber:run-step:start', ({ resource }) => {
+    this.addSub('ci:cucumber:test-step:start', ({ resource }) => {
       const store = storage.getStore()
       const childOf = store ? store.span : store
       const span = this.tracer.startSpan('cucumber.step', {
@@ -48,7 +75,7 @@ class CucumberPlugin extends CiPlugin {
       this.enter(span, store)
     })
 
-    this.addSub('ci:cucumber:run:finish', ({ isStep, status, skipReason, errorMessage }) => {
+    this.addSub('ci:cucumber:test:finish', ({ isStep, status, skipReason, errorMessage }) => {
       const span = storage.getStore().span
       const statusTag = isStep ? 'step.status' : TEST_STATUS
 
@@ -76,8 +103,12 @@ class CucumberPlugin extends CiPlugin {
     })
   }
 
-  startTestSpan (testName, testSuite, childOf) {
-    return super.startTestSpan(testName, testSuite, {}, childOf)
+  startTestSpan (testName, testSuite) {
+    return super.startTestSpan(
+      testName,
+      testSuite,
+      this.testSuiteSpan
+    )
   }
 }
 

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

@@ -7,7 +7,16 @@ const {
   getTestParentSpan,
   getCodeOwnersFileEntries,
   getCodeOwnersForFilename,
-  getTestCommonTags
+  getTestCommonTags,
+  getTestSessionCommonTags,
+  getTestModuleCommonTags,
+  getTestSuiteCommonTags,
+  TEST_SUITE_ID,
+  TEST_MODULE_ID,
+  TEST_SESSION_ID,
+  TEST_COMMAND,
+  TEST_BUNDLE,
+  finishAllTraceSpans
 } = require('../../dd-trace/src/plugins/util/test')
 
 const { ORIGIN_KEY, COMPONENT } = require('../../dd-trace/src/constants')
@@ -30,6 +39,43 @@ function getTestSpanMetadata (tracer, testName, testSuite, cypressConfig) {
   }
 }
 
+function getCypressVersion (details) {
+  if (details && details.cypressVersion) {
+    return details.cypressVersion
+  }
+  if (details && details.config && details.config.version) {
+    return details.config.version
+  }
+  return ''
+}
+
+function getCypressCommand (details) {
+  if (!details) {
+    return 'cypress'
+  }
+  return `cypress ${details.specPattern || ''}`
+}
+
+function getSessionStatus (summary) {
+  if (summary.totalFailed !== undefined && summary.totalFailed > 0) {
+    return 'fail'
+  }
+  if (summary.totalSkipped !== undefined && summary.totalSkipped === summary.totalTests) {
+    return 'skip'
+  }
+  return 'pass'
+}
+
+function getSuiteStatus (suiteStats) {
+  if (suiteStats.failures !== undefined && suiteStats.failures > 0) {
+    return 'fail'
+  }
+  if (suiteStats.tests !== undefined && suiteStats.tests === suiteStats.pending) {
+    return 'skip'
+  }
+  return 'pass'
+}
+
 module.exports = (on, config) => {
   const tracer = require('../../dd-trace')
   const testEnvironmentMetadata = getTestEnvironmentMetadata('cypress')
@@ -37,14 +83,92 @@ module.exports = (on, config) => {
   const codeOwnersEntries = getCodeOwnersFileEntries()
 
   let activeSpan = null
-  on('after:run', () => {
+  let testSessionSpan = null
+  let testModuleSpan = null
+  let testSuiteSpan = null
+  let command = null
+  let frameworkVersion
+
+  on('before:run', (details) => {
+    const childOf = getTestParentSpan(tracer)
+
+    command = getCypressCommand(details)
+    frameworkVersion = getCypressVersion(details)
+
+    const testSessionSpanMetadata = getTestSessionCommonTags(command, frameworkVersion)
+    const testModuleSpanMetadata = getTestModuleCommonTags(command, frameworkVersion)
+
+    testSessionSpan = tracer.startSpan('cypress.test_session', {
+      childOf,
+      tags: {
+        [COMPONENT]: 'cypress',
+        ...testEnvironmentMetadata,
+        ...testSessionSpanMetadata
+      }
+    })
+    testModuleSpan = tracer.startSpan('cypress.test_module', {
+      childOf: testSessionSpan,
+      tags: {
+        [COMPONENT]: 'cypress',
+        ...testEnvironmentMetadata,
+        ...testModuleSpanMetadata
+      }
+    })
+  })
+
+  on('after:run', (suiteStats) => {
+    const testStatus = getSessionStatus(suiteStats)
+    testModuleSpan.setTag(TEST_STATUS, testStatus)
+    testSessionSpan.setTag(TEST_STATUS, testStatus)
+
+    testModuleSpan.finish()
+    testSessionSpan.finish()
+
+    finishAllTraceSpans(testSessionSpan)
+
     return new Promise(resolve => {
-      tracer._tracer._exporter._writer.flush(() => resolve(null))
+      tracer._tracer._exporter._writer.flush(() => {
+        resolve(null)
+      })
     })
   })
   on('task', {
+    'dd:testSuiteStart': (suite) => {
+      if (testSuiteSpan) {
+        return null
+      }
+      const testSuiteSpanMetadata = getTestSuiteCommonTags(command, frameworkVersion, suite)
+      testSuiteSpan = tracer.startSpan('cypress.test_suite', {
+        childOf: testModuleSpan,
+        tags: {
+          [COMPONENT]: 'cypress',
+          ...testEnvironmentMetadata,
+          ...testSuiteSpanMetadata
+        }
+      })
+      return null
+    },
+    'dd:testSuiteFinish': (suiteStats) => {
+      const status = getSuiteStatus(suiteStats)
+      testSuiteSpan.setTag(TEST_STATUS, status)
+      testSuiteSpan.finish()
+      testSuiteSpan = null
+      return null
+    },
     'dd:beforeEach': (test) => {
       const { testName, testSuite } = test
+      const testSuiteId = testSuiteSpan.context().toSpanId()
+      const testSessionId = testSessionSpan.context().toTraceId()
+      const testModuleId = testModuleSpan.context().toSpanId()
+
+      const testSuiteTags = {
+        [TEST_SUITE_ID]: testSuiteId,
+        [TEST_SESSION_ID]: testSessionId,
+        [TEST_COMMAND]: command,
+        [TEST_MODULE_ID]: testModuleId,
+        [TEST_COMMAND]: command,
+        [TEST_BUNDLE]: command
+      }
 
       const {
         childOf,
@@ -65,7 +189,8 @@ module.exports = (on, config) => {
             [COMPONENT]: 'cypress',
             [ORIGIN_KEY]: CI_APP_ORIGIN,
             ...testSpanMetadata,
-            ...testEnvironmentMetadata
+            ...testEnvironmentMetadata,
+            ...testSuiteTags
           }
         })
       }