dd-trace 6.4.0 → 6.6.0

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

@@ -1,6 +1,9 @@
 'use strict'
 
 const shimmer = require('../../datadog-shimmer')
+const nomenclature = require('../../dd-trace/src/service-naming')
+const spanEndingHook = require('../../dd-trace/src/opentelemetry/span-ending-hook')
+const { RESOURCE_NAME } = require('../../../ext/tags')
 const { channel, addHook } = require('./helpers/instrument')
 
 const startChannel = channel('apm:next:request:start')
@@ -21,6 +24,27 @@ const NEXT_REQUEST_META = Symbol.for('NextInternalRequestMeta')
 const META_IS_MIDDLEWARE = 'middlewareInvoke'
 const encounteredMiddleware = new WeakSet()
 
+// `next.span_type` value Next.js sets on its own OTel root request span; the whole detection surface.
+const NEXT_BASE_SERVER_HANDLE_REQUEST = 'BaseServer.handleRequest'
+
+// In OTel-bridge mode (`plugins: false` + `new tracer.TracerProvider().register()`) Next emits its
+// own OTel spans and renames the root request span to `${method} ${route}` at finish, which the
+// bridge routes into the DD operation name and leaves the resource as the bare method — the reverse
+// of Datadog's contract. Correct it via the bridge's pre-finish hook. See span-ending-hook.js.
+spanEndingHook.hook = (ddSpan) => {
+  const tags = ddSpan.context().getTags()
+  if (tags['next.span_type'] !== NEXT_BASE_SERVER_HANDLE_REQUEST) return
+
+  const method = tags['http.method']
+  const route = tags['next.route'] ?? tags['http.route']
+  // Next already wrote the RSC-aware `${method} ${route}` into `next.span_name`; prefer it so we
+  // mirror Next's own naming, and only construct the resource when it is absent.
+  const resource = tags['next.span_name'] ?? (route ? `${method} ${route}` : method)
+
+  ddSpan.setOperationName(nomenclature.opName('web', 'server', 'next'))
+  ddSpan.setTag(RESOURCE_NAME, resource)
+}
+
 function wrapHandleRequest (handleRequest) {
   return function (req, res, pathname, query) {
     return instrument(req, res, () => handleRequest.apply(this, arguments))

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

@@ -84,8 +84,6 @@ addHook({
             onDone: resolve,
           })
         })
-      }).catch(() => {
-        // Ignore errors - report generation failed
       })
     }
 

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

@@ -144,8 +144,8 @@ addHook({ name: 'oracledb', versions: ['>=5'], file: 'lib/oracledb.js' }, oracle
   shimmer.wrap(oracledb.Pool.prototype, 'getConnection', getConnection => {
     return function wrappedGetConnection (...args) {
       let callback
-      if (typeof args[args.length - 1] === 'function') {
-        callback = args[args.length - 1]
+      if (typeof args.at(-1) === 'function') {
+        callback = args.at(-1)
       }
       if (callback) {
         args[args.length - 1] = shimmer.wrapFunction(callback, callback => (err, connection) => {

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

@@ -97,7 +97,7 @@ function wrapQuery (query) {
 
         // Based on: https://github.com/brianc/node-postgres/blob/54eb0fa216aaccd727765641e7d1cf5da2bc483d/packages/pg/lib/client.js#L510
         const reusingQuery = typeof pgQuery.submit === 'function'
-        const callback = args[args.length - 1]
+        const callback = args.at(-1)
 
         finish(error)
 
@@ -197,7 +197,7 @@ function wrapPoolQuery (query) {
     const ctx = { query: pgQuery, abortController }
 
     return startPoolQueryCh.runStores(ctx, () => {
-      const cb = args[args.length - 1]
+      const cb = args.at(-1)
 
       if (abortController.signal.aborted) {
         const error = abortController.signal.reason || new Error('Aborted')

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

@@ -25,7 +25,11 @@ const log = require('../../dd-trace/src/log')
 const {
   getValueFromEnvSources,
 } = require('../../dd-trace/src/config/helper')
+const {
+  RUM_TEST_EXECUTION_ID_COOKIE_NAME: RUM_COOKIE_NAME,
+} = require('../../dd-trace/src/ci-visibility/rum')
 const { DD_MAJOR } = require('../../../version')
+const { getChannelPromise } = require('./helpers/channel')
 const { addHook, channel, tracingChannel } = require('./helpers/instrument')
 
 const testStartCh = channel('ci:playwright:test:start')
@@ -33,6 +37,7 @@ const testFinishCh = channel('ci:playwright:test:finish')
 const testSkipCh = channel('ci:playwright:test:skip')
 
 const testSessionStartCh = channel('ci:playwright:session:start')
+const testSessionConfigurationCh = channel('ci:playwright:session:configuration')
 const testSessionFinishCh = channel('ci:playwright:session:finish')
 
 const libraryConfigurationCh = channel('ci:playwright:library-configuration')
@@ -51,6 +56,9 @@ const dispatcherRunCh = tracingChannel('orchestrion:playwright:Dispatcher_run')
 const dispatcherCreateWorkerCh = tracingChannel('orchestrion:playwright:Dispatcher_createWorker')
 const processHostStartRunnerCh = tracingChannel('orchestrion:playwright:ProcessHost_startRunner')
 const createRootSuiteCh = tracingChannel('orchestrion:playwright:createRootSuite')
+const artifactsRecorderScreenshotPathCh =
+  tracingChannel('orchestrion:playwright:ArtifactsRecorder_createScreenshotAttachmentPath')
+const snapshotRecorderScreenshotPathCh = tracingChannel('orchestrion:playwright:SnapshotRecorder_createAttachmentPath')
 const pageGotoCh = tracingChannel('orchestrion:playwright-core:Page_goto')
 
 const testToCtx = new WeakMap()
@@ -61,6 +69,8 @@ const testsToTestStatuses = new Map()
 
 const RUM_FLUSH_WAIT_TIME = getValueFromEnvSources('DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS')
 const DD_PROPERTIES_TIMEOUT = 5000
+const isFailureScreenshotUploadEnabled =
+  getValueFromEnvSources('DD_TEST_FAILURE_SCREENSHOTS_ENABLED') === true
 
 let applyRepeatEachIndex = null
 
@@ -115,8 +125,21 @@ const EFD_RETRY_COUNT_RESPONSE = 'ddEfdRetryCountResponse'
 const DD_PROPERTIES_REQUEST = 'ddPropertiesRequest'
 const DD_PROPERTIES_RESPONSE = 'ddProperties'
 const kDdPlaywrightDisabledTestIds = Symbol('ddPlaywrightDisabledTestIds')
+const kDdPlaywrightFailureScreenshots = Symbol('ddPlaywrightFailureScreenshots')
 const kDdPlaywrightWorkerHostInstrumented = Symbol('ddPlaywrightWorkerHostInstrumented')
 const kDdPlaywrightWorkerInstrumented = Symbol('ddPlaywrightWorkerInstrumented')
+const PLAYWRIGHT_FAILURE_SCREENSHOT_PATH_RE = /(?:^|[\\/])test-failed-\d+\.png$/
+const automaticFailureScreenshotPaths = new Set()
+
+/**
+ * Returns whether Playwright's internal screenshot recorder created an attachment.
+ *
+ * @param {object} attachment - Playwright attachment payload
+ * @returns {boolean}
+ */
+function isAutomaticFailureScreenshotAttachment (attachment) {
+  return typeof attachment?.path === 'string' && automaticFailureScreenshotPaths.delete(attachment.path)
+}
 
 function isValidKnownTests (receivedKnownTests) {
   return !!receivedKnownTests.playwright
@@ -501,6 +524,23 @@ function getProjectsFromRunner (runner, configArg) {
   })
 }
 
+/**
+ * Returns whether at least one Playwright project captures automatic screenshots for failed tests.
+ *
+ * @param {Array<object>} projects - Playwright projects with resolved use options
+ * @returns {boolean} Whether failure screenshot capture is enabled
+ */
+function isFailureScreenshotCaptureEnabled (projects) {
+  for (const project of projects) {
+    const screenshot = project.use?.screenshot
+    const mode = typeof screenshot === 'object' && screenshot !== null ? screenshot.mode : screenshot
+    if (mode === 'on' || mode === 'only-on-failure' || mode === 'on-first-failure') {
+      return true
+    }
+  }
+  return false
+}
+
 function getProjectsFromDispatcher (dispatcher) {
   const bundledConfig = dispatcher._testRun?.config?.config?.projects
   if (bundledConfig) {
@@ -575,12 +615,6 @@ function getTestByTestId (dispatcher, testId) {
   }
 }
 
-function getChannelPromise (channelToPublishTo, params) {
-  return new Promise(resolve => {
-    channelToPublishTo.publish({ onDone: resolve, ...params })
-  })
-}
-
 // Inspired by https://github.com/microsoft/playwright/blob/2b77ed4d7aafa85a600caa0b0d101b72c8437eeb/packages/playwright/src/reporters/base.ts#L293
 // We can't use test.outcome() directly because it's set on follow up handlers:
 // our `testEndHandler` is called before the outcome is set.
@@ -993,6 +1027,7 @@ function onDispatcherCreateWorker (dispatcher, worker) {
 
   const projects = getProjectsFromDispatcher(dispatcher)
   sessionProjects = projects
+  const automaticFailureScreenshotPathsByTestId = new Map()
 
   if (disabledTestIds.size && !worker[kDdPlaywrightWorkerHostInstrumented] &&
       typeof worker.runTestGroup === 'function') {
@@ -1021,6 +1056,16 @@ function onDispatcherCreateWorker (dispatcher, worker) {
     const shouldCreateTestSpan = test.expectedStatus === 'skipped'
     testBeginHandler(test, browser, shouldCreateTestSpan)
   })
+  worker.on('attach', ({ testId, path, _ddIsAutomaticFailureScreenshot }) => {
+    if (!_ddIsAutomaticFailureScreenshot) return
+
+    let screenshotPaths = automaticFailureScreenshotPathsByTestId.get(testId)
+    if (!screenshotPaths) {
+      screenshotPaths = new Set()
+      automaticFailureScreenshotPathsByTestId.set(testId, screenshotPaths)
+    }
+    screenshotPaths.add(path)
+  })
   worker.on('testEnd', ({ testId, status, errors, annotations }) => {
     const test = getTestByTestId(dispatcher, testId)
     if (!test) return
@@ -1043,6 +1088,20 @@ function onDispatcherCreateWorker (dispatcher, worker) {
       }
     )
     const testResult = test.results.at(-1)
+    const automaticFailureScreenshotPaths = automaticFailureScreenshotPathsByTestId.get(testId)
+    automaticFailureScreenshotPathsByTestId.delete(testId)
+    if (testStatus === 'fail' && automaticFailureScreenshotPaths?.size && testResult?.attachments?.length) {
+      const screenshots = []
+      for (const attachment of testResult.attachments) {
+        if (automaticFailureScreenshotPaths.has(attachment.path)) {
+          screenshots.push(attachment)
+        }
+      }
+      if (screenshots.length) {
+        worker[kDdPlaywrightFailureScreenshots] ??= []
+        worker[kDdPlaywrightFailureScreenshots].push(screenshots)
+      }
+    }
     const isAtrRetry = testResult?.retry > 0 &&
       isFlakyTestRetriesEnabled &&
       !test._ddIsAttemptToFix &&
@@ -1142,12 +1201,17 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
 function runAllTestsWrapper (runAllTests, playwrightVersion) {
   // Config parameter is only available from >=1.55.0
   return async function (config) {
-    let onDone
-
     rootDir = getRootDir(this, config)
+    const projects = getProjectsFromRunner(this, config)
+    const isFailureScreenshotEnabled = isFailureScreenshotCaptureEnabled(projects)
     const processArgv = process.argv.slice(2).join(' ')
     const command = `playwright ${processArgv}`
-    testSessionStartCh.publish({ command, frameworkVersion: playwrightVersion, rootDir })
+    testSessionStartCh.publish({
+      command,
+      frameworkVersion: playwrightVersion,
+      rootDir,
+      isFailureScreenshotEnabled,
+    })
 
     try {
       const { err, libraryConfig } = await getChannelPromise(
@@ -1174,6 +1238,8 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
       log.error('Playwright session start error', e)
     }
 
+    testSessionConfigurationCh.publish({ isFailureScreenshotEnabled })
+
     const isTestOptimizationSupported = satisfies(playwrightVersion, MINIMUM_SUPPORTED_VERSION_RANGE_EFD)
     const shouldGetKnownTests = isKnownTestsEnabled && isTestOptimizationSupported
     const shouldGetTestManagementTests = isTestManagementTestsEnabled && isTestOptimizationSupported
@@ -1239,8 +1305,6 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
       }
     }
 
-    const projects = getProjectsFromRunner(this, config)
-
     // ATR and `--retries` are now compatible with Test Management.
     // Test Management tests have their retries set to 0 at the test level,
     // preventing them from being retried by ATR or `--retries`.
@@ -1288,7 +1352,7 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
 
       for (const [fqn, testStatuses] of testsToTestStatuses.entries()) {
         // Only count as failed if the final status (after retries) is 'fail'
-        const lastStatus = testStatuses[testStatuses.length - 1]
+        const lastStatus = testStatuses.at(-1)
         if (lastStatus === 'fail') {
           totalFailedTestCount += 1
           if (quarantinedButNotAttemptToFixFqns.has(fqn)) {
@@ -1308,17 +1372,12 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
     logTestOptimizationSummary({ attemptToFixExecutions, newTestsWithDynamicNames })
     loggedAttemptToFixTests.clear()
 
-    const flushWait = new Promise(resolve => {
-      onDone = resolve
-    })
-    testSessionFinishCh.publish({
+    await getChannelPromise(testSessionFinishCh, {
       status: preventedToFail ? 'pass' : STATUS_TO_TEST_STATUS[sessionStatus],
       isEarlyFlakeDetectionEnabled,
       isEarlyFlakeDetectionFaulty,
       isTestManagementTestsEnabled,
-      onDone,
     })
-    await flushWait
 
     startedSuites = []
     remainingTestsByFile = {}
@@ -1439,6 +1498,23 @@ pageGotoCh.subscribe({
   },
 })
 
+/**
+ * Records a path created by Playwright's automatic screenshot recorder.
+ *
+ * @param {object} ctx - Orchestrion context
+ * @returns {void}
+ */
+function recordAutomaticFailureScreenshotPath (ctx) {
+  if (isFailureScreenshotUploadEnabled &&
+    typeof ctx.result === 'string' &&
+    PLAYWRIGHT_FAILURE_SCREENSHOT_PATH_RE.test(ctx.result)) {
+    automaticFailureScreenshotPaths.add(ctx.result)
+  }
+}
+
+artifactsRecorderScreenshotPathCh.subscribe({ end: recordAutomaticFailureScreenshotPath })
+snapshotRecorderScreenshotPathCh.subscribe({ end: recordAutomaticFailureScreenshotPath })
+
 if (DD_MAJOR < 6) { // <1.38.0 is only supported up to version 5
   addHook({
     name: '@playwright/test',
@@ -1750,7 +1826,10 @@ function finishProcessHostStartRunner (processHost) {
     }
     // These messages are [code, payload]. The payload is test data
     if (Array.isArray(message) && message[0] === PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE) {
-      workerReportCh.publish(message[1])
+      workerReportCh.publish({
+        serializedTraces: message[1],
+        screenshots: processHost[kDdPlaywrightFailureScreenshots]?.shift(),
+      })
     }
   })
 }
@@ -1774,23 +1853,64 @@ addHook({
 })
 
 async function handlePageGoto (page) {
+  if (!testPageGotoCh.hasSubscribers || !page || typeof page.evaluate !== 'function') {
+    return
+  }
+
+  let rumState
   try {
-    if (page && typeof page.evaluate === 'function') {
-      const { isRumInstrumented, isRumActive, rumSamplingRate } = await page.evaluate(detectRum)
-      if (isRumInstrumented && rumSamplingRate < 100 && !isRumActive) {
-        log.debug("RUM was detected on the page, but it isn't active because the sampling rate is below 100%")
-      }
+    rumState = await page.evaluate(detectRum)
+  } catch (error) {
+    // Redirects and closed contexts can make page evaluation fail after a successful navigation.
+    log.error('Playwright RUM detection error', error)
+    return
+  }
 
-      if (isRumActive) {
-        testPageGotoCh.publish({
-          isRumActive,
-          page,
-        })
-      }
-    }
-  } catch (e) {
-    // ignore errors such as redirects, context destroyed, etc
-    log.error('goto hook error', e)
+  if (!rumState) {
+    return
+  }
+
+  const { isRumInstrumented, isRumActive, rumSamplingRate } = rumState
+  if (isRumInstrumented && rumSamplingRate < 100 && !isRumActive) {
+    log.debug("RUM was detected on the page, but it isn't active because the sampling rate is below 100%")
+  }
+  if (!isRumActive) {
+    return
+  }
+
+  let browserVersion
+  try {
+    browserVersion = page.context().browser()?.version()
+  } catch (error) {
+    log.error('Playwright browser metadata error', error)
+  }
+
+  const context = {
+    isRumActive,
+    browserVersion,
+    testExecutionId: undefined,
+  }
+  try {
+    testPageGotoCh.publish(context)
+  } catch (error) {
+    log.error('Playwright RUM correlation channel error', error)
+    return
+  }
+
+  if (!context.testExecutionId) {
+    return
+  }
+
+  try {
+    const domain = new URL(page.url()).hostname
+    await page.context().addCookies([{
+      name: RUM_COOKIE_NAME,
+      value: context.testExecutionId,
+      domain,
+      path: '/',
+    }])
+  } catch (error) {
+    log.error('Playwright RUM correlation cookie error', error)
   }
 }
 
@@ -1918,10 +2038,11 @@ function instrumentWorkerMainMethods (workerMain) {
                   if (url) {
                     const domain = new URL(url).hostname
                     await page.context().addCookies([{
-                      name: 'datadog-ci-visibility-test-execution-id',
+                      name: RUM_COOKIE_NAME,
                       value: '',
                       domain,
                       path: '/',
+                      expires: 0,
                     }])
                   } else {
                     log.error('RUM is active but page.url() is not available')
@@ -1979,12 +2100,6 @@ function instrumentWorkerMainMethods (workerMain) {
       annotationTags = parseAnnotations(annotations)
     }
 
-    let onDone
-
-    const flushPromise = new Promise(resolve => {
-      onDone = resolve
-    })
-
     // Wait for the properties to be received, but do not block the worker forever if IPC fails.
     const ddPropertiesTimeoutPromise = new Promise(resolve => {
       const ddPropertiesTimeout = realSetTimeout(() => {
@@ -2010,7 +2125,7 @@ function instrumentWorkerMainMethods (workerMain) {
       testStatus: STATUS_TO_TEST_STATUS[status],
     })
 
-    testFinishCh.publish({
+    await getChannelPromise(testFinishCh, {
       testStatus: STATUS_TO_TEST_STATUS[status],
       steps: steps.filter(step => step.testId === testId),
       error,
@@ -2028,21 +2143,20 @@ function instrumentWorkerMainMethods (workerMain) {
       hasFailedAttemptToFixRetries: test._ddHasFailedAttemptToFixRetries,
       isAtrRetry: test._ddIsAtrRetry,
       isModified: test._ddIsModified,
-      onDone,
       finalStatus,
       earlyFlakeAbortReason: test._ddEarlyFlakeAbortReason,
       ...testCtx.currentStore,
     })
 
-    await flushPromise
-
     return res
   })
 
   // We reproduce what happens in `Dispatcher#_onStepBegin` and `Dispatcher#_onStepEnd`,
   // since `startTime` and `duration` are not available directly in the worker process
   shimmer.wrap(workerMain, 'dispatchEvent', dispatchEvent => function (event, payload) {
-    if (event === 'stepBegin') {
+    if (event === 'testBegin' || event === 'testEnd') {
+      automaticFailureScreenshotPaths.clear()
+    } else if (event === 'stepBegin') {
       stepInfoByStepId[payload.stepId] = {
         startTime: payload.wallTime,
         title: payload.title,
@@ -2058,6 +2172,8 @@ function instrumentWorkerMainMethods (workerMain) {
         duration: payload.wallTime - stepInfo.startTime,
         error: payload.error,
       })
+    } else if (event === 'attach' && isAutomaticFailureScreenshotAttachment(payload)) {
+      payload._ddIsAutomaticFailureScreenshot = true
     }
     return dispatchEvent.apply(this, arguments)
   })

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

@@ -1,5 +1,7 @@
 'use strict'
 
+const { syncBuiltinESMExports } = require('node:module')
+
 const { channel } = require('dc-polyfill')
 const shimmer = require('../../datadog-shimmer')
 
@@ -26,4 +28,5 @@ if (process.setUncaughtExceptionCaptureCallback) {
         return result
       }
     })
+  syncBuiltinESMExports()
 }

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

@@ -86,26 +86,36 @@ function createLayerDispatchWrappers (name) {
   const finishChannel = channel(`apm:${name}:middleware:finish`)
   const errorChannel = channel(`apm:${name}:middleware:error`)
   const nextChannel = channel(`apm:${name}:middleware:next`)
+  const repeatChannel = channel(`apm:${name}:middleware:repeat`)
   // Bound per name so express and a bare router keep independent guards.
   const publishError = createErrorPublisher(errorChannel)
 
-  function wrapNext (req, originalNext) {
+  /**
+   * @param {import('node:http').IncomingMessage} req
+   * @param {string | undefined} layerName
+   * @param {(error?: unknown) => void} originalNext
+   */
+  function wrapNext (req, layerName, originalNext) {
     // Per layer dispatch, N per request. Named `next`/arity-1 mirrors the
     // router continuation so wrapCallback skips its name/length rewrite.
-    let published = false
+    let calls = 0
     return shimmer.wrapCallback(originalNext, original => function next (error) {
       // A handler that calls `next()` and then rejects (`next(); await bg()`)
       // makes the host call this continuation twice. Publish once so the second
       // pass cannot tag the already-finished span's parent with a late error.
-      if (!published) {
-        published = true
-
+      calls++
+      if (calls === 1) {
         if (error && error !== 'route' && error !== 'router') {
           publishError({ req, error })
         }
 
         nextChannel.publish({ req })
         finishChannel.publish({ req })
+      } else if (calls === 2) {
+        // Surface the repeat as a diagnostic on the still-live request span. The
+        // host cannot tell a legitimate `next(); await bg()` from a buggy double
+        // `next()`, so this only records that it happened, not that it is wrong.
+        repeatChannel.publish({ req, name: layerName, error })
       }
 
       original.apply(this, arguments)
@@ -125,7 +135,7 @@ function createLayerDispatchWrappers (name) {
       const meta = getLayerMeta(this)
       if (meta === undefined || this.handle.length > 3) return originalRequest.call(this, req, res, next)
 
-      const wrappedNext = typeof next === 'function' ? wrapNext(req, next) : next
+      const wrappedNext = typeof next === 'function' ? wrapNext(req, meta.name, next) : next
       enterChannel.publish({ name: meta.name, req, route: resolveLayerRoute(meta, this), layer: this })
 
       try {
@@ -143,7 +153,7 @@ function createLayerDispatchWrappers (name) {
       const meta = getLayerMeta(this)
       if (meta === undefined || this.handle.length !== 4) return originalError.call(this, error, req, res, next)
 
-      const wrappedNext = typeof next === 'function' ? wrapNext(req, next) : next
+      const wrappedNext = typeof next === 'function' ? wrapNext(req, meta.name, next) : next
       enterChannel.publish({ name: meta.name, req, route: resolveLayerRoute(meta, this), layer: this })
 
       try {
@@ -170,7 +180,7 @@ function createLayerDispatchWrappers (name) {
       const isErrorHandler = original.length === 4
       const req = args[isErrorHandler ? 1 : 0]
       const nextIndex = isErrorHandler ? 3 : 2
-      if (typeof args[nextIndex] === 'function') args[nextIndex] = wrapNext(req, args[nextIndex])
+      if (typeof args[nextIndex] === 'function') args[nextIndex] = wrapNext(req, meta.name, args[nextIndex])
 
       enterChannel.publish({ name: meta.name, req, route: resolveLayerRoute(meta, layer), layer })
 

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

@@ -5,6 +5,10 @@ const realSetTimeout = setTimeout
 
 const shimmer = require('../../datadog-shimmer')
 const { getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
+const {
+  RUM_TEST_EXECUTION_ID_COOKIE_NAME: DD_CIVISIBILITY_TEST_EXECUTION_ID_COOKIE_NAME,
+} = require('../../dd-trace/src/ci-visibility/rum')
+const log = require('../../dd-trace/src/log')
 const { addHook, channel } = require('./helpers/instrument')
 
 const ciSeleniumDriverGetStartCh = channel('ci:selenium:driver:get')
@@ -20,7 +24,6 @@ if (window.DD_RUM && window.DD_RUM.stopSession) {
 const IS_RUM_ACTIVE_SCRIPT = 'return !!window.DD_RUM'
 
 const DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS = getValueFromEnvSources('DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS')
-const DD_CIVISIBILITY_TEST_EXECUTION_ID_COOKIE_NAME = 'datadog-ci-visibility-test-execution-id'
 
 // TODO: can we increase the supported version range?
 addHook({
@@ -32,28 +35,47 @@ addHook({
     if (!ciSeleniumDriverGetStartCh.hasSubscribers) {
       return get.apply(this, arguments)
     }
-    let traceId
-    const setTraceId = (inputTraceId) => {
-      traceId = inputTraceId
-    }
     const getResult = await get.apply(this, arguments)
 
-    const isRumActive = await this.executeScript(IS_RUM_ACTIVE_SCRIPT)
-    const capabilities = await this.getCapabilities()
+    let isRumActive
+    try {
+      isRumActive = await this.executeScript(IS_RUM_ACTIVE_SCRIPT)
+    } catch (error) {
+      log.error('Selenium RUM detection error', error)
+    }
+
+    let browserName
+    let browserVersion
+    try {
+      const capabilities = await this.getCapabilities()
+      browserName = capabilities.getBrowserName()
+      browserVersion = capabilities.getBrowserVersion()
+    } catch (error) {
+      log.error('Selenium browser metadata error', error)
+    }
 
-    ciSeleniumDriverGetStartCh.publish({
-      setTraceId,
+    const context = {
       seleniumVersion,
-      browserName: capabilities.getBrowserName(),
-      browserVersion: capabilities.getBrowserVersion(),
+      browserName,
+      browserVersion,
       isRumActive,
-    })
+      testExecutionId: undefined,
+    }
+    try {
+      ciSeleniumDriverGetStartCh.publish(context)
+    } catch (error) {
+      log.error('Selenium RUM correlation channel error', error)
+    }
 
-    if (traceId && isRumActive) {
-      await this.manage().addCookie({
-        name: DD_CIVISIBILITY_TEST_EXECUTION_ID_COOKIE_NAME,
-        value: traceId,
-      })
+    if (context.testExecutionId && isRumActive) {
+      try {
+        await this.manage().addCookie({
+          name: DD_CIVISIBILITY_TEST_EXECUTION_ID_COOKIE_NAME,
+          value: context.testExecutionId,
+        })
+      } catch (error) {
+        log.error('Selenium RUM correlation cookie error', error)
+      }
     }
 
     return getResult
@@ -63,16 +85,20 @@ addHook({
     if (!ciSeleniumDriverGetStartCh.hasSubscribers) {
       return quit.apply(this, arguments)
     }
-    const isRumActive = await this.executeScript(RUM_STOP_SESSION_SCRIPT)
+    try {
+      const isRumActive = await this.executeScript(RUM_STOP_SESSION_SCRIPT)
 
-    if (isRumActive) {
-      // We'll have time for RUM to flush the events (there's no callback to know when it's done)
-      await new Promise(resolve => {
-        realSetTimeout(() => {
-          resolve()
-        }, DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS)
-      })
-      await this.manage().deleteCookie(DD_CIVISIBILITY_TEST_EXECUTION_ID_COOKIE_NAME)
+      if (isRumActive) {
+        // We'll have time for RUM to flush the events (there's no callback to know when it's done)
+        await new Promise(resolve => {
+          realSetTimeout(() => {
+            resolve()
+          }, DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS)
+        })
+        await this.manage().deleteCookie(DD_CIVISIBILITY_TEST_EXECUTION_ID_COOKIE_NAME)
+      }
+    } catch (error) {
+      log.error('Selenium RUM cleanup error', error)
     }
 
     return quit.apply(this, arguments)