dd-trace 6.13.0 → 6.14.0

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

@@ -1,9 +1,18 @@
 'use strict'
 
 const { storage } = require('../../datadog-core')
-const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
+const { CLIENT_PORT_KEY, SVC_SRC_KEY } = require('../../dd-trace/src/constants')
 const DatabasePlugin = require('../../dd-trace/src/plugins/database')
 
+/**
+ * @typedef {{
+ *   database?: string,
+ *   host?: string,
+ *   port?: number,
+ *   user?: string
+ * }} ConnectionConfig
+ */
+
 class MySQLPlugin extends DatabasePlugin {
   static id = 'mysql'
   static system = 'mysql'
@@ -33,13 +42,7 @@ class MySQLPlugin extends DatabasePlugin {
         startTime: ctx.startTime,
         type: 'sql',
         kind: 'client',
-        meta: {
-          'db.type': this.system,
-          'db.user': ctx.conf.user,
-          'db.name': ctx.conf.database,
-          'out.host': ctx.conf.host,
-          [CLIENT_PORT_KEY]: ctx.conf.port,
-        },
+        meta: connectionMeta(this.system, ctx.conf),
       }, ctx)
     })
 
@@ -51,6 +54,20 @@ class MySQLPlugin extends DatabasePlugin {
         this.addError(ctx.error, span)
       }
       span.setTag(`${this.component}.pool.wait_time`, ctx.poolWaitTime)
+      if (ctx.connectionConfig !== undefined) {
+        span.addTags(connectionMeta(this.system, ctx.connectionConfig))
+        if (typeof this.config.service === 'function') {
+          const service = this.serviceName({
+            pluginConfig: this.config,
+            dbConfig: ctx.connectionConfig,
+            system: this.system,
+          })
+          if (service.name) {
+            this.setServiceName(span, service.name)
+            span.setTag(SVC_SRC_KEY, service.source)
+          }
+        }
+      }
       this.finish(ctx)
     })
   }
@@ -62,13 +79,7 @@ class MySQLPlugin extends DatabasePlugin {
       resource: ctx.sql,
       type: 'sql',
       kind: 'client',
-      meta: {
-        'db.type': this.system,
-        'db.user': ctx.conf.user,
-        'db.name': ctx.conf.database,
-        'out.host': ctx.conf.host,
-        [CLIENT_PORT_KEY]: ctx.conf.port,
-      },
+      meta: connectionMeta(this.system, ctx.conf),
     }, ctx)
 
     if (ctx.poolWaitTime !== undefined) {
@@ -81,4 +92,19 @@ class MySQLPlugin extends DatabasePlugin {
   }
 }
 
+/**
+ * @param {string} system
+ * @param {ConnectionConfig} config
+ * @returns {Record<string, string|number|undefined>}
+ */
+function connectionMeta (system, config) {
+  return {
+    'db.type': system,
+    'db.user': config.user,
+    'db.name': config.database,
+    'out.host': config.host,
+    [CLIENT_PORT_KEY]: config.port,
+  }
+}
+
 module.exports = MySQLPlugin

package/packages/datadog-plugin-net/src/tcp.js

@@ -28,10 +28,12 @@ class NetTCPPlugin extends ClientPlugin {
     const host = ctx.options.host || 'localhost'
     const port = ctx.options.port || 0
     const family = ctx.options.family || 4
+    let resource = host
+    if (port) resource += `:${port}`
 
     this.startSpan('tcp.connect', {
       service: this.config.service,
-      resource: [host, port].filter(Boolean).join(':'),
+      resource,
       kind: 'client',
       meta: {
         'tcp.remote.host': host,

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

@@ -11,20 +11,53 @@ const errorPages = new Set(['/404', '/500', '/_error', '/_not-found', '/_not-fou
 const reusedNextRequestStores = new WeakSet()
 const nextParentRoutes = new WeakMap()
 
+/**
+ * @typedef {Record<string, unknown> & {
+ *   span: import('../../dd-trace/src/opentracing/span'),
+ *   req: import('node:http').IncomingMessage,
+ *   backgroundRevalidationRequest?: import('node:http').IncomingMessage
+ * }} NextRequestStore
+ *
+ * @typedef {object} NextRequest
+ * @property {unknown} [error]
+ *
+ * @typedef {object} NextRequestContext
+ * @property {import('node:http').IncomingMessage} req
+ * @property {import('node:http').ServerResponse} res
+ * @property {NextRequest} [nextRequest]
+ * @property {boolean} [finishOnResponse]
+ * @property {NextRequestStore} [currentStore]
+ * @property {unknown} [error]
+ *
+ * @typedef {object} NextErrorContext
+ * @property {import('../../dd-trace/src/opentracing/span')} [span]
+ * @property {NextRequestStore} [currentStore]
+ * @property {import('node:http').IncomingMessage} [req]
+ * @property {unknown} error
+ */
+
 class NextPlugin extends ServerPlugin {
   static id = 'next'
 
   constructor (...args) {
     super(...args)
+    this.addBind('apm:next:request:background-revalidation', req => ({
+      ...storage('legacy').getStore(),
+      span: undefined,
+      backgroundRevalidationRequest: req,
+    }))
     this.addSub('apm:next:page:load', message => this.pageLoad(message))
   }
 
-  bindStart ({ req, res }) {
+  /** @param {NextRequestContext} ctx */
+  bindStart (ctx) {
+    const { req } = ctx
     const store = storage('legacy').getStore()
     const parentSpan = store?.span
     if (parentSpan?._integrationName === this.constructor.id) {
       const reusedStore = { ...store, span: parentSpan, req }
       reusedNextRequestStores.add(reusedStore)
+      if (ctx.finishOnResponse) ctx.currentStore = reusedStore
       return reusedStore
     }
 
@@ -34,17 +67,19 @@ class NextPlugin extends ServerPlugin {
     let serviceSource = this.config.service ? 'opt.plugin' : schemaServiceSource
     if (!serviceName || serviceName === this.tracer._service) serviceSource = undefined
 
+    const tags = {
+      [COMPONENT]: this.constructor.id,
+      'service.name': serviceName,
+      'resource.name': req.method,
+      'span.type': 'web',
+      'span.kind': 'server',
+      'http.method': req.method,
+    }
+    if (serviceSource !== undefined) tags[SVC_SRC_KEY] = serviceSource
+
     const span = this.tracer.startSpan(this.operationName(), {
       childOf,
-      tags: {
-        [COMPONENT]: this.constructor.id,
-        'service.name': serviceName,
-        'resource.name': req.method,
-        'span.type': 'web',
-        'span.kind': 'server',
-        'http.method': req.method,
-        ...(serviceSource === undefined ? undefined : { [SVC_SRC_KEY]: serviceSource }),
-      },
+      tags,
       integrationName: this.constructor.id,
     })
 
@@ -52,31 +87,31 @@ class NextPlugin extends ServerPlugin {
 
     analyticsSampler.sample(span, this.config.measured, true)
 
-    const isHttpParent = parentSpan?._integrationName === 'http'
-    const httpParentSpan = isHttpParent ? parentSpan : undefined
-    const httpParentReq = isHttpParent ? web.getRequest(parentSpan) : undefined
-    return { ...store, span, req, httpParentSpan, httpParentReq }
+    const httpParentSpan = parentSpan?._integrationName === 'http' ? parentSpan : undefined
+    const currentStore = { ...store, span, req, httpParentSpan }
+    if (ctx.finishOnResponse) ctx.currentStore = currentStore
+    return currentStore
   }
 
-  error ({ span, error }) {
-    if (!span) {
-      const store = storage('legacy').getStore()
-      if (!store) return
+  /** @param {NextErrorContext} ctx */
+  error ({ currentStore, span, req, error }) {
+    const store = currentStore ?? storage('legacy').getStore()
+    if (req && store?.backgroundRevalidationRequest === req) return
 
-      span = store.span
-    }
-
-    this.addError(error, span)
+    span ||= store?.span
+    if (span) this.addError(error, span)
   }
 
-  finish ({ req, res, nextRequest = {} }) {
-    const store = storage('legacy').getStore()
+  /** @param {NextRequestContext} ctx */
+  finish (ctx) {
+    const { req, res, nextRequest = {} } = ctx
+    const store = ctx.currentStore ?? storage('legacy').getStore()
 
     if (!store) return
     if (reusedNextRequestStores.has(store)) return
 
     const span = store.span
-    const error = span.context().getTag('error')
+    const error = ctx.error ?? span.context().getTag('error')
     const requestError = req.error || nextRequest.error
 
     if (requestError) {
@@ -107,7 +142,7 @@ class NextPlugin extends ServerPlugin {
 
     if (!store) return
 
-    const { span, req, httpParentReq, httpParentSpan } = store
+    const { span, req, httpParentSpan } = store
 
     // safeguard against missing req in complicated timeout scenarios
     if (!req) return
@@ -138,10 +173,9 @@ class NextPlugin extends ServerPlugin {
       'resource.name': `${req.method} ${page}`.trim(),
       'next.page': page,
     })
-    const routeRequest = httpParentReq || req
-    web.setRouteOrEndpointTag(routeRequest)
+    web.setRouteOrEndpointTag(req)
     setHttpParentRoute(httpParentSpan, req.method, page, isStatic)
-    web.setRoute(routeRequest, page)
+    web.setRoute(req, page)
   }
 
   configure (config) {

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

@@ -13,6 +13,12 @@ const {
   getScreenshotUploadResult,
   getScreenshotUploadTag,
 } = require('../../dd-trace/src/ci-visibility/test-screenshot')
+const {
+  VIDEO_UPLOAD_RESULT_ERROR,
+  VIDEO_UPLOAD_RESULT_UPLOADED,
+  getVideoUploadResult,
+  getVideoUploadTag,
+} = require('../../dd-trace/src/ci-visibility/test-video')
 
 const {
   finishAllTraceSpans,
@@ -62,6 +68,8 @@ const { appClosing: appClosingTelemetry } = require('../../dd-trace/src/telemetr
 const log = require('../../dd-trace/src/log')
 
 const PLAYWRIGHT_FAILURE_SCREENSHOT_RE = /^test-failed-\d+\.png$/
+const PLAYWRIGHT_VIDEO_CONTENT_TYPES = new Set(['video/mp4', 'video/webm'])
+const noop = () => {}
 
 /**
  * Returns whether an attachment is an automatic Playwright failure screenshot.
@@ -76,10 +84,23 @@ function isPlaywrightFailureScreenshot (attachment) {
     PLAYWRIGHT_FAILURE_SCREENSHOT_RE.test(basename(attachment.path))
 }
 
+/**
+ * Returns whether an attachment is a Playwright test video.
+ *
+ * @param {object} attachment - Playwright test attachment
+ * @returns {boolean}
+ */
+function isPlaywrightFailureVideo (attachment) {
+  return attachment?.name === 'video' &&
+    PLAYWRIGHT_VIDEO_CONTENT_TYPES.has(attachment.contentType) &&
+    typeof attachment.path === 'string'
+}
+
 class PlaywrightPlugin extends CiPlugin {
   static id = 'playwright'
 
   #isFinalizingAfterError = false
+  #finishPendingTestFinishes
   #pendingTestFinishCallbacks = new Map()
 
   constructor (...args) {
@@ -89,7 +110,6 @@ class PlaywrightPlugin extends CiPlugin {
     this.numFailedTests = 0
     this.numFailedSuites = 0
     this.pendingTestFinishes = 0
-    this.finishSession = undefined
 
     this.addSub('ci:playwright:test:is-modified', ({
       filePath,
@@ -101,29 +121,60 @@ class PlaywrightPlugin extends CiPlugin {
       onDone(isModified)
     })
 
-    this.addSub('ci:playwright:session:start', ({ isFailureScreenshotEnabled }) => {
+    this.addSub('ci:playwright:session:start', ({
+      isFailureScreenshotEnabled,
+      isFailureVideoEnabled,
+      isFailureVideoUploadSupported,
+    }) => {
       this.#isFinalizingAfterError = false
-      if (!getConfig().testOptimization.DD_TEST_FAILURE_SCREENSHOTS_ENABLED) return
+      const testOptimizationConfig = getConfig().testOptimization
 
-      if (!isFailureScreenshotEnabled) {
+      if (testOptimizationConfig.DD_TEST_FAILURE_SCREENSHOTS_ENABLED && !isFailureScreenshotEnabled) {
         log.warn(
           '%s %s',
           'DD_TEST_FAILURE_SCREENSHOTS_ENABLED is true, but Playwright screenshot capture is disabled.',
           'Set Playwright use.screenshot to "only-on-failure", "on-first-failure", or "on".'
         )
       }
+      if (testOptimizationConfig.DD_TEST_FAILURE_VIDEOS_ENABLED && !isFailureVideoUploadSupported) {
+        log.warn(
+          '%s %s',
+          'DD_TEST_FAILURE_VIDEOS_ENABLED is true, but Playwright video upload requires Playwright 1.38.0 or later.',
+          'Upgrade Playwright to enable failure video uploads.'
+        )
+      } else if (testOptimizationConfig.DD_TEST_FAILURE_VIDEOS_ENABLED && !isFailureVideoEnabled) {
+        log.warn(
+          '%s %s',
+          'DD_TEST_FAILURE_VIDEOS_ENABLED is true, but Playwright video capture is disabled.',
+          'Set Playwright use.video to "retain-on-failure" or "on".'
+        )
+      }
     })
 
-    this.addSub('ci:playwright:session:configuration', ({ isFailureScreenshotEnabled }) => {
-      if (!getConfig().testOptimization.DD_TEST_FAILURE_SCREENSHOTS_ENABLED || !isFailureScreenshotEnabled) return
+    this.addSub('ci:playwright:session:configuration', ({
+      isFailureScreenshotEnabled,
+      isFailureVideoEnabled,
+      isFailureVideoUploadSupported,
+    }) => {
+      const testOptimizationConfig = getConfig().testOptimization
 
-      if (!this.tracer._exporter?.canUploadTestScreenshots?.()) {
+      if (testOptimizationConfig.DD_TEST_FAILURE_SCREENSHOTS_ENABLED && isFailureScreenshotEnabled &&
+        !this.tracer._exporter?.canUploadTestScreenshots?.()) {
         log.warn(
           '%s %s',
           'DD_TEST_FAILURE_SCREENSHOTS_ENABLED is true, but Playwright screenshot upload is not supported',
           'by the active Test Optimization transport.'
         )
       }
+      if (testOptimizationConfig.DD_TEST_FAILURE_VIDEOS_ENABLED && isFailureVideoEnabled &&
+        isFailureVideoUploadSupported &&
+        !this.tracer._exporter?.canUploadTestVideos?.()) {
+        log.warn(
+          '%s %s',
+          'DD_TEST_FAILURE_VIDEOS_ENABLED is true, but Playwright video upload is not supported',
+          'by the active Test Optimization transport.'
+        )
+      }
     })
 
     this.addSub('ci:playwright:session:finish', ({
@@ -140,13 +191,16 @@ class PlaywrightPlugin extends CiPlugin {
           testSuiteSpan.setTag(TEST_STATUS, 'fail')
           testSuiteSpan.setTag('error', error)
         }
-        for (const [finishTest, abortController] of this.#pendingTestFinishCallbacks) {
-          finishTest(SCREENSHOT_UPLOAD_RESULT_ERROR)
-          abortController.abort()
+        for (const [finishTest, pendingTestFinish] of this.#pendingTestFinishCallbacks) {
+          finishTest(
+            pendingTestFinish.hasScreenshot ? SCREENSHOT_UPLOAD_RESULT_ERROR : undefined,
+            pendingTestFinish.hasVideo ? VIDEO_UPLOAD_RESULT_ERROR : undefined
+          )
+          pendingTestFinish.abortController.abort()
         }
       }
 
-      const finishSession = () => {
+      const finishSession = (flushDone) => {
         this.testModuleSpan.setTag(TEST_STATUS, status)
         this.testSessionSpan.setTag(TEST_STATUS, status)
 
@@ -173,7 +227,6 @@ class PlaywrightPlugin extends CiPlugin {
           this.testSessionSpan.setTag(TEST_MANAGEMENT_ENABLED, 'true')
         }
 
-        this.tracer._exporter.exportDeferredTestSuiteSpans?.()
         this.testModuleSpan.finish()
         this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
         this.testSessionSpan.finish()
@@ -184,16 +237,16 @@ class PlaywrightPlugin extends CiPlugin {
           autoInjected: !!this._tracerConfig.testOptimization.DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER,
         })
         appClosingTelemetry()
-        this.tracer._exporter.flush(onDone)
+        this.tracer._exporter.flush(flushDone)
         this.numFailedTests = 0
         this.numFailedSuites = 0
-        this.finishSession = undefined
       }
 
       if (this.pendingTestFinishes > 0) {
-        this.finishSession = finishSession
+        this.#finishPendingTestFinishes = () => this.tracer._exporter.flush(onDone)
+        finishSession(noop)
       } else {
-        finishSession()
+        finishSession(onDone)
       }
     })
 
@@ -255,7 +308,6 @@ class PlaywrightPlugin extends CiPlugin {
         this.numFailedSuites++
       }
 
-      this.tracer._exporter.deferTestSuiteSpan?.(testSuiteSpan)
       testSuiteSpan.finish()
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
     })
@@ -267,7 +319,7 @@ class PlaywrightPlugin extends CiPlugin {
       }
     })
 
-    this.addSub('ci:playwright:worker:report', ({ serializedTraces, screenshots }) => {
+    this.addSub('ci:playwright:worker:report', ({ serializedTraces, screenshots, videos }) => {
       const traces = JSON.parse(serializedTraces)
       const formattedTraces = []
       let formattedTestSpan
@@ -326,33 +378,70 @@ class PlaywrightPlugin extends CiPlugin {
         }
       }
 
-      if (!formattedTestSpan || !screenshots || this.#isFinalizingAfterError) {
+      if (!formattedTestSpan || (!screenshots && !videos) || this.#isFinalizingAfterError) {
         exportTraces()
         return
       }
 
       this.pendingTestFinishes++
       const abortController = new AbortController()
-      const finishTest = (screenshotUploadResult) => {
+      const finishTest = (screenshotUploadResult, videoUploadResult) => {
         if (!this.#pendingTestFinishCallbacks.delete(finishTest)) return
 
         const screenshotUploadTag = getScreenshotUploadTag(screenshotUploadResult)
         if (screenshotUploadTag) {
           formattedTestSpan.meta[screenshotUploadTag] = 'true'
         }
+        const videoUploadTag = getVideoUploadTag(videoUploadResult)
+        if (videoUploadTag) {
+          formattedTestSpan.meta[videoUploadTag] = 'true'
+        }
         exportTraces()
         this.pendingTestFinishes--
-        if (this.pendingTestFinishes === 0 && this.finishSession) {
-          this.finishSession()
+        if (this.pendingTestFinishes === 0 && this.#finishPendingTestFinishes) {
+          const finishPendingTestFinishes = this.#finishPendingTestFinishes
+          this.#finishPendingTestFinishes = undefined
+          finishPendingTestFinishes()
         }
       }
-      this.#pendingTestFinishCallbacks.set(finishTest, abortController)
-      const uploadStarted = this.uploadTestScreenshots({
+      const pendingTestFinish = {
+        abortController,
+        hasScreenshot: false,
+        hasVideo: false,
+      }
+      this.#pendingTestFinishCallbacks.set(finishTest, pendingTestFinish)
+      let pendingMedia = 0
+      let screenshotUploadResult
+      let videoUploadResult
+      const finishMedia = () => {
+        pendingMedia--
+        if (pendingMedia === 0) finishTest(screenshotUploadResult, videoUploadResult)
+      }
+      const screenshotUploadStarted = this.uploadTestScreenshots({
         screenshots,
         traceId: formattedTestSpan.trace_id.toString(10),
         signal: abortController.signal,
-      }, finishTest)
-      if (uploadStarted) return
+      }, (uploadResult) => {
+        screenshotUploadResult = uploadResult
+        finishMedia()
+      })
+      if (screenshotUploadStarted) {
+        pendingMedia++
+        pendingTestFinish.hasScreenshot = true
+      }
+      const videoUploadStarted = this.uploadTestVideos({
+        videos,
+        traceId: formattedTestSpan.trace_id.toString(10),
+        signal: abortController.signal,
+      }, (uploadResult) => {
+        videoUploadResult = uploadResult
+        finishMedia()
+      })
+      if (videoUploadStarted) {
+        pendingMedia++
+        pendingTestFinish.hasVideo = true
+      }
+      if (pendingMedia > 0) return
 
       finishTest()
     })
@@ -630,7 +719,58 @@ class PlaywrightPlugin extends CiPlugin {
         }
         pendingUploads--
         if (pendingUploads === 0) {
-          onDone(getScreenshotUploadResult(uploadResults))
+          const uploadResult = getScreenshotUploadResult(uploadResults)
+          queueMicrotask(() => onDone(uploadResult))
+        }
+      })
+    }
+    return true
+  }
+
+  /**
+   * Uploads failure videos for a Playwright test attempt.
+   *
+   * @param {object} options - Upload options
+   * @param {Array<object>} options.videos - Playwright test attachments
+   * @param {string} options.traceId - Test trace id used as the video key
+   * @param {AbortSignal} options.signal - Signal used to cancel uploads during error finalization
+   * @param {(result: string|undefined) => void} onDone - Completion callback
+   * @returns {boolean} Whether at least one upload was started
+   */
+  uploadTestVideos ({ videos, traceId, signal }, onDone) {
+    const exporter = this.tracer?._exporter
+    if (!Array.isArray(videos) || !videos.length ||
+      !exporter?.canUploadTestVideos?.() || !exporter.uploadTestVideo) {
+      return false
+    }
+
+    const videoPaths = new Set()
+    for (const video of videos) {
+      if (isPlaywrightFailureVideo(video)) videoPaths.add(video.path)
+    }
+    if (!videoPaths.size) return false
+
+    const uploadResults = new Array(videoPaths.size)
+    let pendingUploads = videoPaths.size
+    let index = 0
+    for (const filePath of videoPaths) {
+      const resultIndex = index++
+      exporter.uploadTestVideo({
+        filePath,
+        traceId,
+        idempotencyKey: `${traceId}:${basename(filePath)}`,
+        capturedAtMs: Date.now(),
+        signal,
+      }, (error, uploaded = true) => {
+        if (uploaded) {
+          uploadResults[resultIndex] = error
+            ? VIDEO_UPLOAD_RESULT_ERROR
+            : VIDEO_UPLOAD_RESULT_UPLOADED
+        }
+        pendingUploads--
+        if (pendingUploads === 0) {
+          const uploadResult = getVideoUploadResult(uploadResults)
+          queueMicrotask(() => onDone(uploadResult))
         }
       })
     }