dd-trace 6.9.0 → 6.11.0

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

@@ -8,6 +8,17 @@ const {
   channel,
   addHook,
 } = require('./helpers/instrument')
+const {
+  clearPoolWaitTime,
+  dispatchesAcquireSynchronously,
+  isPoolQueryAcquire,
+  runOutsidePoolQueryAcquire,
+  runPoolAcquireError,
+  runWithPoolWait,
+  takePoolWaitTime,
+  wrapPoolAcquireCarrier,
+  wrapPoolQueryMethod,
+} = require('./helpers/pool-acquire')
 
 const startCh = channel('apm:pg:query:start')
 const finishCh = channel('apm:pg:query:finish')
@@ -21,20 +32,16 @@ const poolConnectFinishCh = channel('apm:pg:pool:connect:finish')
 
 const poolAcquireStartCh = channel('apm:pg:pool:acquire:start')
 const poolAcquireFinishCh = channel('apm:pg:pool:acquire:finish')
+const poolAcquireChannels = {
+  connectionFinishCh: poolConnectFinishCh,
+  acquireStartCh: poolAcquireStartCh,
+  acquireFinishCh: poolAcquireFinishCh,
+}
 
 // Drivers like pg-promise reuse the same prepared-statement query object across executions; cache
 // the un-injected `text` so the wrap doesn't capture a previous DBM injection as the new original.
 const originalTextCache = new WeakMap()
 
-// Pool.query dispatches its client query synchronously from the connect callback, including nested
-// `_release` queue pulses, so the wait can cross that callback without retaining the client.
-const poolWaitClients = []
-const poolWaitTimes = []
-
-// Pool.query reports its internal acquire on the query span; explicit connects get an acquire span.
-// Pool.query calls connect synchronously, so a module flag reliably distinguishes the two.
-let acquiringForPoolQuery = false
-
 addHook({ name: 'pg', versions: ['>=8.0.3'], file: 'lib/native/client.js' }, Client => {
   shimmer.wrap(Client.prototype, 'query', query => wrapQuery(query))
   return Client
@@ -46,79 +53,118 @@ addHook({ name: 'pg', versions: ['>=8.0.3'], file: 'lib/client.js' }, Client =>
 })
 
 addHook({ name: 'pg', versions: ['>=8.0.3'] }, pg => {
+  const poolWaitTransfer = { deferred: false }
+  const deferredPoolAcquire = !dispatchesAcquireSynchronously(
+    pg.Pool.prototype.query,
+    Object.assign(Object.create(pg.Pool.prototype), { Promise }),
+    'connect',
+    ['SELECT 1', () => {}]
+  )
+
   // pg defers a busy pool's connect callback and runs it in the releasing query's async context;
   // capture the caller's context and restore it around the callback so spans attach to the caller.
-  shimmer.wrap(pg.Pool.prototype, 'connect', connect => function (cb) {
-    // Pool.query always supplies a callback, so a missing callback is an explicit acquire.
-    if (typeof cb !== 'function') {
-      if (!poolAcquireStartCh.hasSubscribers) {
+  shimmer.wrap(pg.Pool.prototype, 'connect', connect => {
+    /**
+     * @param {Function|undefined} callback
+     * @returns {unknown}
+     */
+    const wrappedConnect = function (callback) {
+      // Pool.query always supplies a callback, so a missing callback is an explicit acquire.
+      if (typeof callback !== 'function') {
+        if (!poolAcquireStartCh.hasSubscribers) {
+          return connect.apply(this, arguments)
+        }
+
+        const start = acquireStart(this)
+        const acquireCtx = { poolOptions: this.options }
+        poolAcquireStartCh.publish(acquireCtx)
+
+        return connectForAcquire(connect, this, arguments, acquireCtx, start).then(client => {
+          clearPoolWaitTime(client)
+          acquireCtx.params = client.connectionParameters
+          finishAcquire(acquireCtx, start)
+          return client
+        }, error => {
+          acquireCtx.error = error
+          finishAcquire(acquireCtx, start)
+          throw error
+        })
+      }
+
+      if (!poolConnectStartCh.hasSubscribers) {
         return connect.apply(this, arguments)
       }
 
+      const ctx = {}
+      const poolOptions = this.options
       const start = acquireStart(this)
-      const acquireCtx = { poolOptions: this.options }
-      poolAcquireStartCh.publish(acquireCtx)
-
-      return connectForAcquire(connect, this, arguments, acquireCtx, start).then(client => {
-        acquireCtx.params = client.connectionParameters
-        finishAcquire(acquireCtx, start)
-        return client
-      }, error => {
-        acquireCtx.error = error
-        finishAcquire(acquireCtx, start)
-        throw error
-      })
-    }
+      const poolQueryAcquire = isPoolQueryAcquire()
+      let acquireCtx
 
-    if (!poolConnectStartCh.hasSubscribers) {
-      return connect.apply(this, arguments)
-    }
-
-    const ctx = {}
-    const start = acquireStart(this)
-    let acquireCtx
-
-    if (acquiringForPoolQuery) {
-      arguments[0] = function (...args) {
-        const client = args[1]
-        if (client !== undefined) {
-          poolWaitClients.push(client)
-          poolWaitTimes.push(acquireWait(start))
-        }
-        try {
-          return poolConnectFinishCh.runStores(ctx, cb, this, ...args)
-        } finally {
+      if (poolQueryAcquire) {
+        arguments[0] = function (...args) {
+          const client = args[1]
           if (client !== undefined) {
-            poolWaitClients.pop()
-            poolWaitTimes.pop()
+            const waitTime = acquireWait(start)
+            return runWithPoolWait(
+              poolWaitTransfer,
+              client,
+              waitTime,
+              poolConnectFinishCh,
+              ctx,
+              callback,
+              this,
+              args
+            )
+          }
+          if (args[0] && poolAcquireStartCh.hasSubscribers) {
+            return runPoolAcquireError(
+              start,
+              args[0],
+              { poolOptions },
+              poolAcquireChannels,
+              ctx,
+              callback,
+              this,
+              args
+            )
           }
+          return poolConnectFinishCh.runStores(ctx, callback, this, ...args)
         }
-      }
-    } else {
-      acquireCtx = { poolOptions: this.options }
-      poolAcquireStartCh.publish(acquireCtx)
-
-      arguments[0] = function (...args) {
-        const client = args[1]
-        acquireCtx.error = args[0]
-        // A failed acquire has no client, so keep the parameters `connectForAcquire` snapshotted.
-        if (client !== undefined) {
-          acquireCtx.params = client.connectionParameters
+      } else {
+        acquireCtx = { poolOptions: this.options }
+        poolAcquireStartCh.publish(acquireCtx)
+
+        arguments[0] = function (...args) {
+          const client = args[1]
+          acquireCtx.error = args[0]
+          // A failed acquire has no client, so keep the parameters `connectForAcquire` snapshotted.
+          if (client !== undefined) {
+            clearPoolWaitTime(client)
+            acquireCtx.params = client.connectionParameters
+          }
+          finishAcquire(acquireCtx, start)
+          return poolConnectFinishCh.runStores(ctx, callback, this, ...args)
         }
-        finishAcquire(acquireCtx, start)
-        return poolConnectFinishCh.runStores(ctx, cb, this, ...args)
       }
-    }
 
-    poolConnectStartCh.publish(ctx)
+      poolConnectStartCh.publish(ctx)
 
-    if (acquireCtx === undefined) {
-      return connect.apply(this, arguments)
+      if (acquireCtx === undefined) return runOutsidePoolQueryAcquire(connect, this, arguments)
+
+      return connectForAcquire(connect, this, arguments, acquireCtx, start)
     }
 
-    return connectForAcquire(connect, this, arguments, acquireCtx, start)
+    return wrapPoolAcquireCarrier(
+      wrappedConnect,
+      connect,
+      poolConnectStartCh,
+      deferredPoolAcquire
+    )
   })
-  shimmer.wrap(pg.Pool.prototype, 'query', query => wrapPoolQuery(query))
+  shimmer.wrap(pg.Pool.prototype, 'query', query => wrapPoolQuery(
+    wrapPoolQueryMethod(query, poolConnectStartCh, deferredPoolAcquire)
+  ))
   return pg
 })
 
@@ -153,14 +199,9 @@ function wrapQuery (query) {
       stream,
     }
 
-    if (poolWaitClients.length !== 0) {
-      for (let i = poolWaitClients.length - 1; i >= 0; i--) {
-        if (poolWaitClients[i] === this) {
-          ctx.poolWaitTime = poolWaitTimes[i]
-          poolWaitClients[i] = undefined
-          break
-        }
-      }
+    const waitTime = takePoolWaitTime(this)
+    if (waitTime !== undefined) {
+      ctx.poolWaitTime = waitTime
     }
 
     const finish = (error, res) => {
@@ -342,25 +383,10 @@ function finishAcquire (ctx, start) {
   poolAcquireFinishCh.publish(ctx)
 }
 
-/**
- * @param {Function} query
- * @param {InstrumentedPool} pool
- * @param {unknown[]} args
- */
-function acquireForPoolQuery (query, pool, args) {
-  acquiringForPoolQuery = true
-  try {
-    return query.apply(pool, args)
-  } finally {
-    acquiringForPoolQuery = false
-  }
-}
 function wrapPoolQuery (query) {
   return function (...args) {
     if (!startPoolQueryCh.hasSubscribers) {
-      return poolConnectStartCh.hasSubscribers
-        ? acquireForPoolQuery(query, this, args)
-        : query.apply(this, args)
+      return query.apply(this, args)
     }
 
     const pgQuery = args[0] !== null && typeof args[0] === 'object' ? args[0] : { text: args[0] }
@@ -390,9 +416,7 @@ function wrapPoolQuery (query) {
         })
       }
 
-      const retval = poolConnectStartCh.hasSubscribers
-        ? acquireForPoolQuery(query, this, args)
-        : query.apply(this, args)
+      const retval = query.apply(this, args)
 
       if (retval?.then) {
         retval.then(() => {

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

@@ -0,0 +1,99 @@
+'use strict'
+
+const { channel } = require('dc-polyfill')
+
+const reporterErrorCh = channel('ci:playwright:reporter:error')
+const PLAYWRIGHT_REPORTER_ERROR_MESSAGE = 'Error in reporter'
+const PLAYWRIGHT_REPORTER_ERROR_CALLER_RE =
+  /^\s*at wrapAsync .*?[\\/]playwright[\\/]lib[\\/]runner[\\/]index\.js:\d+:\d+\)?$/
+
+/**
+ * Identifies the private Playwright 1.60-1.61 reporter error fallback without
+ * interpreting identical user console output as a framework error.
+ *
+ * @param {unknown} message - First console.error argument
+ * @returns {boolean}
+ */
+function isPlaywrightReporterError (message) {
+  if (message !== PLAYWRIGHT_REPORTER_ERROR_MESSAGE) return false
+
+  const originalPrepareStackTrace = Error.prepareStackTrace
+  try {
+    Error.prepareStackTrace = (_, callSites) => callSites
+    const stack = new Error('Playwright reporter error provenance').stack
+    return PLAYWRIGHT_REPORTER_ERROR_CALLER_RE.test(`at ${stack?.[2]?.toString() || ''}`)
+  } finally {
+    Error.prepareStackTrace = originalPrepareStackTrace
+  }
+}
+
+class DatadogPlaywrightReporter {
+  /**
+   * Restores console error after Playwright completes the reporter lifecycle.
+   *
+   * @returns {void}
+   */
+  static restoreConsoleError () {
+    // eslint-disable-next-line no-console
+    if (console.error === DatadogPlaywrightReporter.consoleError) {
+      try {
+        // eslint-disable-next-line no-console
+        console.error = DatadogPlaywrightReporter.originalConsoleError
+      } catch {}
+    }
+    DatadogPlaywrightReporter.consoleError = undefined
+    DatadogPlaywrightReporter.originalConsoleError = undefined
+  }
+
+  /**
+   * Marks the beginning of reporter finalization so later reporter errors can be identified.
+   *
+   * @returns {void}
+   */
+  onEnd () {
+    this.isFinalizing = true
+    // Playwright 1.60 and 1.61 only expose reporter errors through this exact console call.
+    // eslint-disable-next-line no-console
+    const originalConsoleError = console.error
+    const reporter = this
+    const consoleError = function (message, error) {
+      if (isPlaywrightReporterError(message)) {
+        reporter.onError(error)
+      }
+      return originalConsoleError.apply(this, arguments)
+    }
+    try {
+      // eslint-disable-next-line no-console
+      console.error = consoleError
+    } catch {
+      return
+    }
+    // An accessor may ignore the assignment without throwing.
+    // eslint-disable-next-line no-console
+    if (console.error !== consoleError) return
+
+    DatadogPlaywrightReporter.originalConsoleError = originalConsoleError
+    DatadogPlaywrightReporter.consoleError = consoleError
+  }
+
+  /**
+   * Reports errors emitted by Playwright while later reporters are finalizing.
+   *
+   * @param {unknown} error
+   * @returns {void}
+   */
+  onError (error) {
+    if (this.isFinalizing) reporterErrorCh.publish(error)
+  }
+
+  /**
+   * Keeps the internal reporter from affecting Playwright's output reporter selection.
+   *
+   * @returns {boolean}
+   */
+  printsToStdio () {
+    return false
+  }
+}
+
+module.exports = DatadogPlaywrightReporter

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

@@ -45,6 +45,7 @@ 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 reporterErrorCh = channel('ci:playwright:reporter:error')
 
 const libraryConfigurationCh = channel('ci:playwright:library-configuration')
 const knownTestsCh = channel('ci:playwright:known-tests')
@@ -81,6 +82,8 @@ const isFailureScreenshotUploadEnabled =
   getValueFromEnvSources('DD_TEST_FAILURE_SCREENSHOTS_ENABLED') === true
 
 let applyRepeatEachIndex = null
+let reporterError
+let hasReporterError = false
 
 let startedSuites = []
 
@@ -134,8 +137,10 @@ const DD_PROPERTIES_REQUEST = 'ddPropertiesRequest'
 const DD_PROPERTIES_RESPONSE = 'ddProperties'
 const kDdPlaywrightDisabledTestIds = Symbol('ddPlaywrightDisabledTestIds')
 const kDdPlaywrightFailureScreenshots = Symbol('ddPlaywrightFailureScreenshots')
+const kDdPlaywrightReporterConfigured = Symbol('ddPlaywrightReporterConfigured')
 const kDdPlaywrightWorkerHostInstrumented = Symbol('ddPlaywrightWorkerHostInstrumented')
 const kDdPlaywrightWorkerInstrumented = Symbol('ddPlaywrightWorkerInstrumented')
+const instrumentedPlaywrightReporters = new WeakSet()
 const PLAYWRIGHT_FAILURE_SCREENSHOT_PATH_RE = /(?:^|[\\/])test-failed-\d+\.png$/
 const automaticFailureScreenshotPaths = new Set()
 
@@ -1252,6 +1257,17 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
 function runAllTestsWrapper (runAllTests, playwrightVersion) {
   // Config parameter is only available from >=1.55.0
   return async function (config) {
+    reporterError = undefined
+    hasReporterError = false
+    let restoreReporterConsoleError
+    if (satisfies(playwrightVersion, '>=1.60.0') && config?.config) {
+      const DatadogPlaywrightReporter = require('./playwright-reporter')
+      restoreReporterConsoleError = DatadogPlaywrightReporter.restoreConsoleError
+      if (!config.config[kDdPlaywrightReporterConfigured]) {
+        Object.defineProperty(config.config, kDdPlaywrightReporterConfigured, { value: true })
+        config.config.reporter.unshift([require.resolve('./playwright-reporter')])
+      }
+    }
     rootDir = getRootDir(this, config)
     const projects = getProjectsFromRunner(this, config)
     const isFailureScreenshotEnabled = isFailureScreenshotCaptureEnabled(projects)
@@ -1367,7 +1383,27 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
       }
     }
 
-    let runAllTestsReturn = await runAllTests.apply(this, arguments)
+    let runAllTestsReturn
+    try {
+      runAllTestsReturn = await runAllTests.apply(this, arguments)
+    } catch (error) {
+      try {
+        await getChannelPromise(testSessionFinishCh, {
+          status: 'fail',
+          error: hasReporterError ? reporterError : error,
+          isEarlyFlakeDetectionEnabled,
+          isEarlyFlakeDetectionFaulty,
+          isTestManagementTestsEnabled,
+        })
+      } catch (finalizationError) {
+        log.error('Playwright test session finalization error: %s', finalizationError)
+      }
+      reporterError = undefined
+      hasReporterError = false
+      throw error
+    } finally {
+      restoreReporterConsoleError?.()
+    }
 
     // Tests that have only skipped tests may reach this point
     // Skipped tests may or may not go through `testBegin` or `testEnd`
@@ -1422,12 +1458,21 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
     logTestOptimizationSummary({ attemptToFixExecutions, newTestsWithDynamicNames })
     loggedAttemptToFixTests.clear()
 
+    const finalizationError = reporterError
+    const finalStatus = hasReporterError
+      ? 'fail'
+      : (preventedToFail ? 'pass' : STATUS_TO_TEST_STATUS[sessionStatus])
     await getChannelPromise(testSessionFinishCh, {
-      status: preventedToFail ? 'pass' : STATUS_TO_TEST_STATUS[sessionStatus],
+      status: finalStatus,
+      error: finalizationError,
       isEarlyFlakeDetectionEnabled,
       isEarlyFlakeDetectionFaulty,
       isTestManagementTestsEnabled,
     })
+    if (hasReporterError) {
+      if (typeof runAllTestsReturn === 'string') runAllTestsReturn = 'failed'
+      else runAllTestsReturn.status = 'failed'
+    }
 
     startedSuites = []
     remainingTestsByFile = {}
@@ -1444,6 +1489,8 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
     ddPropertiesByTestId.clear()
     ddPropertiesRequestsByTestId.clear()
     disabledTestIds.clear()
+    reporterError = undefined
+    hasReporterError = false
 
     // TODO: we can trick playwright into thinking the session passed by returning
     // 'passed' here. We might be able to use this for both EFD and Test Management tests.
@@ -1451,6 +1498,68 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
   }
 }
 
+/**
+ * Records errors thrown or rejected by Playwright reporters before Playwright converts them into run status.
+ *
+ * @param {object} reportersPackage
+ * @returns {object}
+ */
+function reportersHook (reportersPackage) {
+  return shimmer.wrap(reportersPackage, 'createReporters', createReporters => async function () {
+    const reporters = await createReporters.apply(this, arguments)
+    for (const reporter of reporters) {
+      if (instrumentedPlaywrightReporters.has(reporter)) continue
+
+      const onEnd = reporter.onEnd
+      const onExit = reporter.onExit
+      try {
+        if (typeof onEnd === 'function') {
+          reporter.onEnd = async function () {
+            try {
+              return await onEnd.apply(this, arguments)
+            } catch (error) {
+              recordReporterError(error)
+              throw error
+            }
+          }
+        }
+        if (typeof onExit === 'function') {
+          reporter.onExit = async function () {
+            try {
+              return await onExit.apply(this, arguments)
+            } catch (error) {
+              recordReporterError(error)
+              throw error
+            }
+          }
+        }
+      } catch {
+        continue
+      }
+      if (reporter.onEnd !== onEnd || reporter.onExit !== onExit) instrumentedPlaywrightReporters.add(reporter)
+    }
+    return reporters
+  }, { replaceGetter: true })
+}
+
+/**
+ * Records errors from the reporter multiplexer used by Playwright before 1.38.
+ *
+ * @param {object} reportersPackage
+ * @returns {object}
+ */
+function reporterMultiplexerHook (reportersPackage) {
+  shimmer.wrap(reportersPackage.Multiplexer.prototype, 'onEnd', onEnd => async function () {
+    try {
+      return await onEnd.apply(this, arguments)
+    } catch (error) {
+      recordReporterError(error)
+      throw error
+    }
+  })
+  return reportersPackage
+}
+
 function runnerHook (runnerExport, playwrightVersion) {
   shimmer.wrap(
     runnerExport.Runner.prototype,
@@ -1550,6 +1659,32 @@ pageGotoCh.subscribe({
   },
 })
 
+reporterErrorCh.subscribe((error) => {
+  recordReporterError(error)
+})
+
+/**
+ * Records a reporter failure even when the reporter throws a falsy value.
+ *
+ * @param {unknown} error
+ * @returns {void}
+ */
+function recordReporterError (error) {
+  if (hasReporterError) return
+
+  let normalizedError
+  try {
+    const errorObject = error && typeof error === 'object' ? error : undefined
+    normalizedError = new Error(errorObject?.message || errorObject?.value || String(error))
+    normalizedError.name = errorObject?.name || normalizedError.name
+    normalizedError.stack = errorObject?.stack || normalizedError.stack
+  } catch {
+    normalizedError = new Error('Playwright reporter failed')
+  }
+  reporterError = normalizedError
+  hasReporterError = true
+}
+
 /**
  * Records a path created by Playwright's automatic screenshot recorder.
  *
@@ -1597,6 +1732,12 @@ if (DD_MAJOR < 6) { // <1.38.0 is only supported up to version 5
     file: 'lib/runner/runner.js',
     versions: ['>=1.31.0 <1.38.0'],
   }, runnerHook)
+
+  addHook({
+    name: '@playwright/test',
+    file: 'lib/reporters/multiplexer.js',
+    versions: ['>=1.18.0 <1.38.0'],
+  }, reporterMultiplexerHook)
 }
 
 addHook({
@@ -1617,6 +1758,12 @@ addHook({
   versions: ['>=1.38.0 <1.60.0'],
 }, runnerHook)
 
+addHook({
+  name: 'playwright',
+  file: 'lib/runner/reporters.js',
+  versions: ['>=1.38.0 <1.60.0'],
+}, reportersHook)
+
 addHook({
   name: 'playwright',
   file: 'lib/runner/testRunner.js',

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

@@ -596,6 +596,7 @@ const visitedParams = new WeakSet()
 function wrapHandleRequest (original) {
   return function wrappedHandleRequest (...args) {
     const req = args[0]
+    // eslint-disable-next-line no-restricted-syntax -- arbitrary param names; publishing {} sets a WAF address
     if (routerParamStartCh.hasSubscribers && !visitedParams.has(req.params) && Object.keys(req.params).length) {
       visitedParams.add(req.params)
 
@@ -635,6 +636,7 @@ function wrapParam (original) {
     args[1] = shimmer.wrapFunction(args[1], (originalFn) => {
       return function wrappedFn (...fnArgs) {
         const req = fnArgs[0]
+        // eslint-disable-next-line no-restricted-syntax -- arbitrary param names; publishing {} sets a WAF address
         if (routerParamStartCh.hasSubscribers && Object.keys(req.params).length && !visitedParams.has(req.params)) {
           visitedParams.add(req.params)