dd-trace 6.7.0 → 6.9.0

package/packages/datadog-plugin-fastify/src/tracing.js

@@ -27,7 +27,7 @@ class FastifyTracingPlugin extends RouterPlugin {
 }
 
 function getParentStore (ctx) {
-  ctx.parentStore = ctx.parentStore ?? storage('legacy').getStore()
+  ctx.parentStore ??= storage('legacy').getStore()
   return ctx.parentStore
 }
 

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

@@ -7,10 +7,6 @@ class FsPlugin extends TracingPlugin {
   static operation = 'operation'
   static experimental = true
 
-  configure (...args) {
-    return super.configure(...args)
-  }
-
   bindStart (ctx) {
     if (!this.activeSpan) return { noop: true }
 

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

@@ -96,6 +96,20 @@ class GoogleCloudPubsubConsumerPlugin extends ConsumerPlugin {
     })
   }
 
+  start (ctx) {
+    if (!this.config.dsmEnabled) return
+    const { message } = ctx
+    if (!message?.attributes) return
+
+    const { span } = ctx.currentStore
+    const subscription = message._subscriber._subscription
+    const topic = subscription?.metadata?.topic || message.attributes?.['pubsub.topic']
+    const payloadSize = getMessageSize(message)
+    this.tracer.decodeDataStreamsContext(message.attributes)
+    this.tracer
+      .setCheckpoint(['direction:in', `topic:${topic}`, 'type:google-pubsub'], span, payloadSize)
+  }
+
   bindStart (ctx) {
     const { message } = ctx
     const subscription = message._subscriber._subscription
@@ -181,13 +195,6 @@ class GoogleCloudPubsubConsumerPlugin extends ConsumerPlugin {
       }
     }
 
-    if (this.config.dsmEnabled && message?.attributes) {
-      const payloadSize = getMessageSize(message)
-      this.tracer.decodeDataStreamsContext(message.attributes)
-      this.tracer
-        .setCheckpoint(['direction:in', `topic:${topic}`, 'type:google-pubsub'], span, payloadSize)
-    }
-
     return ctx.currentStore
   }
 

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

@@ -36,6 +36,25 @@ class GoogleCloudPubsubProducerPlugin extends ProducerPlugin {
     if (topicName) attributes['pubsub.topic'] = topicName
   }
 
+  start (ctx) {
+    if (!this.config.dsmEnabled) return
+    if (ctx.api !== 'publish' || !ctx.currentStore) return
+    const { request } = ctx
+    const messages = request.messages || []
+    const topic = request.topic
+    const { span } = ctx.currentStore
+
+    for (const msg of messages) {
+      const attributes = msg.attributes ??= {}
+      const dataStreamsContext = this.tracer.setCheckpoint(
+        ['direction:out', `topic:${topic}`, 'type:google-pubsub'],
+        span,
+        getHeadersSize(msg)
+      )
+      DsmPathwayCodec.encode(dataStreamsContext, attributes)
+    }
+  }
+
   bindStart (ctx) {
     const { request, api, projectId } = ctx
     if (api !== 'publish') return
@@ -113,7 +132,6 @@ class GoogleCloudPubsubProducerPlugin extends ProducerPlugin {
 
     const messageCountStr = String(messageCount)
     const startTimeStr = String(Math.floor(batchSpan._startTime))
-    const dsmEnabled = this.config.dsmEnabled
 
     for (let i = 0; i < messageCount; i++) {
       const msg = messages[i]
@@ -137,15 +155,6 @@ class GoogleCloudPubsubProducerPlugin extends ProducerPlugin {
       if (batchTraceIdUpper) {
         attributes['_dd.pubsub_request.p.tid'] = batchTraceIdUpper
       }
-
-      if (dsmEnabled) {
-        const dataStreamsContext = this.tracer.setCheckpoint(
-          ['direction:out', `topic:${topic}`, 'type:google-pubsub'],
-          batchSpan,
-          getHeadersSize(msg)
-        )
-        DsmPathwayCodec.encode(dataStreamsContext, attributes)
-      }
     }
 
     ctx.batchSpan = batchSpan

package/packages/datadog-plugin-graphql/src/execute.js

@@ -495,6 +495,7 @@ function wrapResolve (resolve) {
     // run in the parent store, not field.currentStore: the first sibling's
     // synchronous resolver already finished the shared graphql.resolve span, so
     // re-entering its store would parent user spans to a closed span.
+    // eslint-disable-next-line unicorn/prefer-else-if -- Keep sibling early return outside first-field setup.
     if (!isFirst) {
       return callInAsyncScope(resolve, this, arguments, rootCtx.abortController, field.parentStore, (err) => {
         if (updateFieldCh.hasSubscribers) {

package/packages/datadog-plugin-graphql/src/tools/signature.js

@@ -11,7 +11,7 @@ const transforms = require('./transforms')
 const cache = new WeakMap()
 
 function defaultEngineReportingSignature (ast, operationName) {
-  const key = operationName == null ? '' : operationName
+  const key = operationName ?? ''
   let inner = cache.get(ast)
   if (inner !== undefined) {
     const cached = inner.get(key)

package/packages/datadog-plugin-http/src/client.js

@@ -10,6 +10,7 @@ const HTTP_HEADERS = formats.HTTP_HEADERS
 const urlFilter = require('../../dd-trace/src/plugins/util/urlfilter')
 const { buildClientHttpUrl } = require('../../dd-trace/src/plugins/util/url')
 const log = require('../../dd-trace/src/log')
+const { stripQueryAndFragment } = require('../../dd-trace/src/util')
 const { CLIENT_PORT_KEY, COMPONENT, ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK } = require('../../dd-trace/src/constants')
 
 const HTTP_STATUS_CODE = tags.HTTP_STATUS_CODE
@@ -32,7 +33,7 @@ class HttpClientPlugin extends ClientPlugin {
     // A URL object (e.g. from the fetch integration) carries the query in
     // `options.search`, not `options.path`; keep it so url.full retains the query.
     const pathname = options.path || `${options.pathname || ''}${options.search || ''}`
-    const path = pathname ? pathname.split(/[?#]/)[0] : '/'
+    const path = pathname ? stripQueryAndFragment(pathname) : '/'
     const uri = `${base}${path}`
 
     const allowed = this.config.filter(uri)
@@ -55,7 +56,7 @@ class HttpClientPlugin extends ClientPlugin {
         'out.host': hostname,
       },
       metrics: {
-        [CLIENT_PORT_KEY]: Number.parseInt(options.port),
+        [CLIENT_PORT_KEY]: Number.parseInt(options.port, 10),
       },
     }, false)
 

package/packages/datadog-plugin-http2/src/client.js

@@ -55,7 +55,7 @@ class Http2ClientPlugin extends ClientPlugin {
         'out.host': sessionDetails.host,
       },
       metrics: {
-        [CLIENT_PORT_KEY]: Number.parseInt(sessionDetails.port),
+        [CLIENT_PORT_KEY]: Number.parseInt(sessionDetails.port, 10),
       },
     }, false)
 

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

@@ -197,7 +197,7 @@ class JestPlugin extends CiPlugin {
         config._ddRequestErrorTags = this.getSessionRequestErrorTags()
         config._ddItrCorrelationId = this.itrCorrelationId
         config._ddIsEarlyFlakeDetectionEnabled = !!this.libraryConfig?.isEarlyFlakeDetectionEnabled
-        config._ddEarlyFlakeDetectionSlowTestRetries = this.libraryConfig?.earlyFlakeDetectionSlowTestRetries ?? {}
+        config._ddEarlyFlakeDetectionRetryPolicy = this.libraryConfig?.earlyFlakeDetectionRetryPolicy
         config._ddRepositoryRoot = this.repositoryRoot
         config._ddIsFlakyTestRetriesEnabled = this.libraryConfig?.isFlakyTestRetriesEnabled ?? false
         config._ddIsTestManagementTestsEnabled = this.libraryConfig?.isTestManagementEnabled ?? false
@@ -237,9 +237,8 @@ class JestPlugin extends CiPlugin {
 
       const testSuiteMetadata = {
         ...getTestSuiteCommonTags(testCommand, frameworkVersion, testSuite, 'jest'),
-        // requestErrorTags from test env options may be undefined
-        ...(requestErrorTags !== undefined && requestErrorTags !== null ? requestErrorTags : {}),
-        ...(itrSkippingEnabledTags !== undefined && itrSkippingEnabledTags !== null ? itrSkippingEnabledTags : {}),
+        ...requestErrorTags,
+        ...itrSkippingEnabledTags,
       }
 
       if (_ddUnskippable) {
@@ -300,23 +299,6 @@ class JestPlugin extends CiPlugin {
       }
     })
 
-    this.addSub('ci:jest:worker-report:telemetry', data => {
-      const telemetryEvents = JSON.parse(data)
-      for (const event of telemetryEvents) {
-        if (event.type === 'ciVisEvent') {
-          this.telemetry.ciVisEvent(event.name, event.testLevel, {
-            ...event.tags,
-            testFramework: event.testFramework,
-            isUnsupportedCIProvider: event.isUnsupportedCIProvider,
-          })
-        } else if (event.type === 'count') {
-          this.telemetry.count(event.name, event.tags, event.value)
-        } else if (event.type === 'distribution') {
-          this.telemetry.distribution(event.name, event.tags, event.measure)
-        }
-      }
-    })
-
     this.addSub('ci:jest:test-suite:finish', ({
       status,
       errorMessage,

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

@@ -15,6 +15,8 @@ const log = require('../../dd-trace/src/log')
  * [[1, 2, 3], [2, 3, 5]]
  * 2. An array of objects, e.g.
  * [{ a: 1, b: 2, expected: 3 }, { a: 2, b: 3, expected: 5}]
+ *
+ * @param {unknown[]} testParameters `test.each` arguments
  */
 function getFormattedJestTestParameters (testParameters) {
   if (!testParameters || !testParameters.length) {
@@ -43,7 +45,8 @@ function getFormattedJestTestParameters (testParameters) {
 
 // @fast-check/jest appends a random seed to the reported test name. A test name that keeps changing
 // breaks some Test Optimization features, so normalize this narrow suffix regardless of import style.
-const SEED_SUFFIX_RE = /\s*\(with seed=-?\d+\)\s*$/i
+// fast-check emits exactly one space before the suffix.
+const SEED_SUFFIX_RE = / ?\(with seed=-?\d+\) ?$/i
 
 function removeSeedSuffixFromTestName (testName) {
   return testName.replace(SEED_SUFFIX_RE, '')

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

@@ -29,12 +29,13 @@ class KafkajsProducerPlugin extends ProducerPlugin {
   /**
    *
    * @typedef {object} ProducerResponseItem
-   * @property {string} topic
+   * @property {string} topicName
    * @property {number} partition
    * @property {import('kafkajs/utils/long').Long} [offset]
    * @property {import('kafkajs/utils/long').Long} [baseOffset]
    *
    * @param {ProducerResponseItem} response
+   * @param {string} [clusterId]
    * @returns {ProducerBacklog}
    */
   transformProduceResponse (response, clusterId) {

package/packages/datadog-plugin-langchain/src/tokens.js

@@ -9,7 +9,7 @@ function getTokensFromLlmOutput (result) {
   const { llmOutput } = result
   if (!llmOutput) return tokens
 
-  const tokenUsage = llmOutput.tokenUsage || llmOutput.usage_metadata || llmOutput.usage_metadata
+  const tokenUsage = llmOutput.tokenUsage || llmOutput.usage_metadata
   if (!tokenUsage) return tokens
 
   for (const tokenNames of [['input', 'prompt'], ['output', 'completion'], ['total']]) {
@@ -25,7 +25,7 @@ function getTokensFromLlmOutput (result) {
   }
 
   // assign total_tokens again in case it was improperly set the first time, or was not on tokenUsage
-  tokens.total = tokens.total || tokens.input + tokens.output
+  tokens.total ||= tokens.input + tokens.output
 
   return tokens
 }

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

@@ -1,7 +1,16 @@
 'use strict'
 
+const { fileURLToPath } = require('node:url')
+
+const { channel } = require('dc-polyfill')
+
 const CiPlugin = require('../../dd-trace/src/plugins/ci_plugin')
 const { storage } = require('../../datadog-core')
+const log = require('../../dd-trace/src/log')
+const {
+  sendWebdriverioWorkerMessage,
+  SUITE_FINISH,
+} = require('../../datadog-instrumentations/src/mocha/webdriverio-protocol')
 
 const {
   TEST_STATUS,
@@ -34,6 +43,8 @@ const {
   TEST_IS_MODIFIED,
   TEST_FINAL_STATUS,
   TEST_HAS_DYNAMIC_NAME,
+  TEST_FRAMEWORK_ADAPTER,
+  getTestSuiteExecutionKey,
   isModifiedTest,
 } = require('../../dd-trace/src/plugins/util/test')
 const { COMPONENT } = require('../../dd-trace/src/constants')
@@ -49,6 +60,94 @@ const {
   TELEMETRY_TEST_SESSION,
 } = require('../../dd-trace/src/ci-visibility/telemetry')
 
+const jasmineAdapterRunAsyncEndCh = 'tracing:orchestrion:@wdio/jasmine-framework:JasmineAdapter_run:asyncEnd'
+const jasmineDoneCh = 'ci:webdriverio:jasmine:done'
+const jasmineReporterSpecDoneEndCh = 'tracing:orchestrion:@wdio/jasmine-framework:JasmineReporter_specDone:end'
+const jasmineReporterSpecStartedEndCh = 'tracing:orchestrion:@wdio/jasmine-framework:JasmineReporter_specStarted:end'
+const jasmineReporterSuiteDoneEndCh = 'tracing:orchestrion:@wdio/jasmine-framework:JasmineReporter_suiteDone:end'
+const jasmineReporterSuiteStartedEndCh = 'tracing:orchestrion:@wdio/jasmine-framework:JasmineReporter_suiteStarted:end'
+const jasmineTestFunctionStartCh = 'tracing:orchestrion:@wdio/utils:testFrameworkFnWrapper:start'
+const testFinishCh = channel('ci:mocha:test:finish')
+const WEBDRIVERIO_JASMINE_ADAPTER = 'jasmine'
+const workerFinishCh = channel('ci:mocha:worker:finish')
+
+/**
+ * @typedef {object} WebdriverioJasmineResult
+ * @property {string|undefined} id
+ * @property {string|undefined} description
+ * @property {Array<{message?: string, stack?: string}>|undefined} failedExpectations
+ * @property {string|undefined} file
+ * @property {string|undefined} filename
+ * @property {string|undefined} fullName
+ * @property {string|undefined} parentSuiteId
+ * @property {string|undefined} status
+ */
+
+/**
+ * Normalizes a WebdriverIO Jasmine spec identifier to a filesystem path.
+ *
+ * @param {string|undefined} file
+ * @returns {string|undefined}
+ */
+function normalizeJasmineFile (file) {
+  return file?.startsWith('file://') ? fileURLToPath(file) : file
+}
+
+/**
+ * Maps a Jasmine result status to the Test Optimization status vocabulary.
+ *
+ * @param {string|undefined} status
+ * @returns {'pass'|'fail'|'skip'}
+ */
+function getJasmineStatus (status) {
+  if (status === 'passed') return 'pass'
+  if (status === 'failed') return 'fail'
+  return 'skip'
+}
+
+/**
+ * Converts Jasmine's failed-expectation shape to an Error.
+ *
+ * @param {WebdriverioJasmineResult} result
+ * @returns {Error|undefined}
+ */
+function getJasmineError (result) {
+  const failedExpectation = result.failedExpectations?.[0]
+  if (!failedExpectation) return
+
+  const error = new Error(failedExpectation.message)
+  if (failedExpectation.stack) {
+    error.stack = failedExpectation.stack
+  }
+  return error
+}
+
+/**
+ * Resolves the spec file responsible for a run-level Jasmine failure.
+ *
+ * @param {WebdriverioJasmineResult|undefined} result
+ * @param {string[]} specs
+ * @returns {string|undefined}
+ */
+function getJasmineFailureFile (result, specs) {
+  const resultFile = normalizeJasmineFile(result?.file || result?.filename)
+  if (resultFile) {
+    return resultFile
+  }
+
+  const stack = result?.failedExpectations?.[0]?.stack
+  if (stack) {
+    for (const spec of specs) {
+      const file = normalizeJasmineFile(spec)
+      if (file && stack.includes(file)) {
+        return file
+      }
+    }
+  }
+
+  return specs.length === 1 ? normalizeJasmineFile(specs[0]) : undefined
+}
+
 class MochaPlugin extends CiPlugin {
   static id = 'mocha'
 
@@ -58,6 +157,100 @@ class MochaPlugin extends CiPlugin {
     this._testTitleToParams = {}
     this.sourceRoot = process.cwd()
 
+    this.addSub('ci:mocha:worker:configuration', ({
+      libraryConfig,
+      repositoryRoot,
+      specs,
+      testFramework,
+      testFrameworkAdapter,
+    }) => {
+      this.libraryConfig = libraryConfig
+      this.testFramework = testFramework
+      this.testFrameworkAdapter = testFrameworkAdapter
+      this._setRepositoryRoot(repositoryRoot)
+      if (testFrameworkAdapter === WEBDRIVERIO_JASMINE_ADAPTER) {
+        this._webdriverioJasmineState = {
+          currentResult: undefined,
+          specs: specs || [],
+          suiteErrors: new Map(),
+          suiteFiles: new Map(),
+          suiteStatuses: new Map(),
+          tests: new Map(),
+        }
+      }
+    })
+
+    this.addBind(jasmineTestFunctionStartCh, (ctx) => {
+      if (this.testFrameworkAdapter !== WEBDRIVERIO_JASMINE_ADAPTER) {
+        return storage('legacy').getStore()
+      }
+
+      const result = this._webdriverioJasmineState?.currentResult
+      const type = ctx.arguments?.[1]
+      if (type === 'Test' || (type === 'Hook' && result)) {
+        return this.#startWebdriverioJasmineTest(result)
+      }
+      return storage('legacy').getStore()
+    })
+
+    this.addSub(jasmineReporterSuiteStartedEndCh, (ctx) => {
+      if (this.testFrameworkAdapter === WEBDRIVERIO_JASMINE_ADAPTER) {
+        const suite = ctx.arguments?.[0]
+        const file = normalizeJasmineFile(suite?.filename)
+        if (suite?.id && file) {
+          this._webdriverioJasmineState.suiteFiles.set(suite.id, file)
+        }
+      }
+    })
+
+    this.addSub(jasmineReporterSuiteDoneEndCh, (ctx) => {
+      if (this.testFrameworkAdapter === WEBDRIVERIO_JASMINE_ADAPTER) {
+        const state = this._webdriverioJasmineState
+        const suite = ctx.arguments?.[0]
+        const error = suite && getJasmineError(suite)
+        const file = normalizeJasmineFile(
+          suite?.filename ||
+          state.suiteFiles.get(suite?.id) ||
+          (state.specs.length === 1 ? state.specs[0] : undefined)
+        )
+        if (error && file) {
+          state.suiteErrors.set(file, error)
+          state.suiteStatuses.set(file, 'fail')
+        }
+      }
+    })
+
+    this.addSub(jasmineDoneCh, ({ result } = {}) => {
+      if (this.testFrameworkAdapter === WEBDRIVERIO_JASMINE_ADAPTER) {
+        const state = this._webdriverioJasmineState
+        const error = result && getJasmineError(result)
+        const file = getJasmineFailureFile(result, state.specs)
+        if (error && file) {
+          state.suiteErrors.set(file, error)
+          state.suiteStatuses.set(file, 'fail')
+        }
+      }
+    })
+
+    this.addSub(jasmineReporterSpecStartedEndCh, (ctx) => {
+      if (this.testFrameworkAdapter === WEBDRIVERIO_JASMINE_ADAPTER) {
+        this._webdriverioJasmineState.currentResult = ctx.arguments?.[0]
+        this.#startWebdriverioJasmineTest(ctx.arguments?.[0], ctx.self?._specs, ctx.self?.startedSuite)
+      }
+    })
+
+    this.addSub(jasmineReporterSpecDoneEndCh, (ctx) => {
+      if (this.testFrameworkAdapter === WEBDRIVERIO_JASMINE_ADAPTER) {
+        this.#finishWebdriverioJasmineTest(ctx.arguments?.[0], ctx.self?._specs)
+      }
+    })
+
+    this.addSub(jasmineAdapterRunAsyncEndCh, (ctx) => {
+      if (this.testFrameworkAdapter === WEBDRIVERIO_JASMINE_ADAPTER) {
+        this.#finishWebdriverioJasmineWorker(ctx)
+      }
+    })
+
     this.addSub('ci:mocha:test-suite:code-coverage', ({ coverageFiles, suiteFile }) => {
       if (!this.libraryConfig?.isCodeCoverageEnabled) {
         return
@@ -88,23 +281,33 @@ class MochaPlugin extends CiPlugin {
     })
 
     this.addBind('ci:mocha:test-suite:start', (ctx) => {
-      const { testSuiteAbsolutePath, isUnskippable, isForcedToRun, itrCorrelationId } = ctx
+      const {
+        testSuiteAbsolutePath,
+        testSuiteExecutionId,
+        isUnskippable,
+        isForcedToRun,
+        itrCorrelationId,
+      } = ctx
 
       // If the test module span is undefined, the plugin has not been initialized correctly and we bail out
       if (!this.testModuleSpan) {
         return
       }
       const testSuite = getTestSuitePath(testSuiteAbsolutePath, this.sourceRoot)
+      const testFramework = this.testFramework || this.constructor.id
       const testSuiteMetadata = {
         ...getTestSuiteCommonTags(
           this.command,
           this.frameworkVersion,
           testSuite,
-          'mocha'
+          testFramework
         ),
         ...this.getSessionRequestErrorTags(),
         ...this.getSessionItrSkippingEnabledTags(),
       }
+      if (this.testFrameworkAdapter) {
+        testSuiteMetadata[TEST_FRAMEWORK_ADAPTER] = this.testFrameworkAdapter
+      }
       if (isUnskippable) {
         testSuiteMetadata[TEST_ITR_UNSKIPPABLE] = 'true'
         this.telemetry.count(TELEMETRY_ITR_UNSKIPPABLE, { testLevel: 'suite' })
@@ -144,8 +347,9 @@ class MochaPlugin extends CiPlugin {
       const store = storage('legacy').getStore()
       ctx.parentStore = store
       ctx.currentStore = { ...store, testSuiteSpan }
-      this._testSuiteSpansByTestSuite.set(testSuite, testSuiteSpan)
-      this._exportPendingWorkerTracesForTestSuite(testSuite)
+      const testSuiteKey = getTestSuiteExecutionKey(testSuite, testSuiteExecutionId)
+      this._testSuiteSpansByTestSuite.set(testSuiteKey, testSuiteSpan)
+      this._exportPendingWorkerTracesForTestSuite(testSuiteKey)
     })
 
     this.addSub('ci:mocha:test-suite:finish', ({ testSuiteSpan, status }) => {
@@ -203,8 +407,8 @@ class MochaPlugin extends CiPlugin {
       return ctx.currentStore
     })
 
-    this.addSub('ci:mocha:worker:finish', () => {
-      this.tracer._exporter.flush()
+    this.addSub('ci:mocha:worker:finish', ({ onDone } = {}) => {
+      this.tracer._exporter.flush(onDone)
     })
 
     this.addSub('ci:mocha:test:finish', ({
@@ -465,6 +669,138 @@ class MochaPlugin extends CiPlugin {
     })
   }
 
+  /**
+   * Starts a Jasmine test span around WebdriverIO's test-function wrapper.
+   *
+   * @param {WebdriverioJasmineResult|undefined} result
+   * @param {string[]} [specs]
+   * @param {{filename?: string}|undefined} currentSuite
+   * @returns {object|undefined}
+   */
+  #startWebdriverioJasmineTest (result, specs, currentSuite) {
+    const state = this._webdriverioJasmineState
+    const currentStore = storage('legacy').getStore()
+    if (!state || !result?.id) {
+      return currentStore
+    }
+
+    const existingTest = state.tests.get(result.id)
+    if (existingTest) {
+      return existingTest.currentStore
+    }
+
+    const candidateSpecs = specs || state.specs
+    const testSuiteAbsolutePath = normalizeJasmineFile(
+      state.suiteFiles.get(result.parentSuiteId) ||
+      currentSuite?.filename ||
+      (candidateSpecs.length === 1 ? candidateSpecs[0] : undefined) ||
+      result.file ||
+      result.filename ||
+      candidateSpecs[0]
+    )
+    if (!testSuiteAbsolutePath) {
+      return currentStore
+    }
+
+    const span = this.startTestSpan({
+      testName: result.fullName || result.description,
+      testSuiteAbsolutePath,
+      title: result.description,
+    })
+    const testStore = { ...currentStore, span }
+    state.tests.set(result.id, {
+      currentStore: testStore,
+      span,
+      testSuiteAbsolutePath,
+    })
+    this.activeTestSpan = span
+
+    return testStore
+  }
+
+  /**
+   * Finishes a Jasmine test after its reporter receives the final result.
+   *
+   * @param {WebdriverioJasmineResult|undefined} result
+   * @param {string[]} [specs]
+   * @returns {void}
+   */
+  #finishWebdriverioJasmineTest (result, specs) {
+    const state = this._webdriverioJasmineState
+    if (!state || !result?.id) {
+      return
+    }
+
+    this.#startWebdriverioJasmineTest(result, specs)
+    const test = state.tests.get(result.id)
+    if (!test) {
+      return
+    }
+
+    const status = getJasmineStatus(result.status)
+    const error = getJasmineError(result)
+    if (error) {
+      test.span.setTag('error', error)
+    }
+    testFinishCh.publish({ span: test.span, status })
+    state.tests.delete(result.id)
+    if (state.currentResult?.id === result.id) {
+      state.currentResult = undefined
+    }
+
+    const previousStatus = state.suiteStatuses.get(test.testSuiteAbsolutePath)
+    if (status === 'fail' || !previousStatus || previousStatus === 'skip') {
+      state.suiteStatuses.set(test.testSuiteAbsolutePath, status)
+    }
+  }
+
+  /**
+   * Reports Jasmine suite statuses and flushes worker traces before its run settles.
+   *
+   * @param {{
+   *   resolveCallback?: (onDone: () => void) => void,
+   *   rejectCallback?: (onDone: () => void) => void
+   * }} context
+   * @returns {void}
+   */
+  #finishWebdriverioJasmineWorker (context) {
+    const state = this._webdriverioJasmineState
+    const results = []
+    const reportedFiles = new Set()
+    for (const [file, status] of state.suiteStatuses) {
+      const error = state.suiteErrors.get(file)
+      const result = { file, status }
+      if (error) {
+        result.error = {
+          message: error.message,
+          stack: error.stack,
+        }
+      }
+      results.push(result)
+      reportedFiles.add(file)
+    }
+    for (const spec of state.specs) {
+      const file = normalizeJasmineFile(spec)
+      if (!reportedFiles.has(file)) {
+        results.push({ file, status: 'skip' })
+      }
+    }
+
+    const waitForWorker = onDone => {
+      sendWebdriverioWorkerMessage({
+        origin: 'datadog',
+        name: SUITE_FINISH,
+        content: { results },
+      }, error => {
+        if (error) {
+          log.error('WebdriverIO Test Optimization IPC error', error)
+        }
+      }, () => workerFinishCh.publish({ onDone }))
+    }
+    context.resolveCallback = waitForWorker
+    context.rejectCallback = waitForWorker
+  }
+
   startTestSpan (testInfo) {
     const {
       testName,