dd-trace 6.8.0 → 6.9.0

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,
@@ -51,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'
 
@@ -60,10 +157,98 @@ class MochaPlugin extends CiPlugin {
     this._testTitleToParams = {}
     this.sourceRoot = process.cwd()
 
-    this.addSub('ci:mocha:worker:configuration', ({ libraryConfig, repositoryRoot, testFramework }) => {
+    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 }) => {
@@ -484,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,

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

@@ -5,8 +5,11 @@ const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 const { COMPONENT, SVC_SRC_KEY } = require('../../dd-trace/src/constants')
 const web = require('../../dd-trace/src/plugins/util/web')
+const { HTTP_ROUTE, RESOURCE_NAME } = require('../../../ext/tags')
 
 const errorPages = new Set(['/404', '/500', '/_error', '/_not-found', '/_not-found/page'])
+const reusedNextRequestStores = new WeakSet()
+const nextParentRoutes = new WeakMap()
 
 class NextPlugin extends ServerPlugin {
   static id = 'next'
@@ -18,7 +21,14 @@ class NextPlugin extends ServerPlugin {
 
   bindStart ({ req, res }) {
     const store = storage('legacy').getStore()
-    const childOf = store ? store.span : store
+    const parentSpan = store?.span
+    if (parentSpan?._integrationName === this.constructor.id) {
+      const reusedStore = { ...store, span: parentSpan, req }
+      reusedNextRequestStores.add(reusedStore)
+      return reusedStore
+    }
+
+    const childOf = parentSpan || web.extractIncomingServerContext(this.tracer, req.headers)
     const { name: schemaServiceName, source: schemaServiceSource } = this.serviceName()
     const serviceName = this.config.service || schemaServiceName
     let serviceSource = this.config.service ? 'opt.plugin' : schemaServiceSource
@@ -42,7 +52,10 @@ class NextPlugin extends ServerPlugin {
 
     analyticsSampler.sample(span, this.config.measured, true)
 
-    return { ...store, span, req }
+    const isHttpParent = parentSpan?._integrationName === 'http'
+    const httpParentSpan = isHttpParent ? parentSpan : undefined
+    const httpParentReq = isHttpParent ? web.getRequest(parentSpan) : undefined
+    return { ...store, span, req, httpParentSpan, httpParentReq }
   }
 
   error ({ span, error }) {
@@ -60,6 +73,7 @@ class NextPlugin extends ServerPlugin {
     const store = storage('legacy').getStore()
 
     if (!store) return
+    if (reusedNextRequestStores.has(store)) return
 
     const span = store.span
     const error = span.context().getTag('error')
@@ -88,12 +102,12 @@ class NextPlugin extends ServerPlugin {
     span.finish()
   }
 
-  pageLoad ({ page, isAppPath = false, isStatic = false }) {
+  pageLoad ({ page, isAppPath = false, isStatic = false, isFilesystemPath = isAppPath }) {
     const store = storage('legacy').getStore()
 
     if (!store) return
 
-    const { span, req } = store
+    const { span, req, httpParentReq, httpParentSpan } = store
 
     // safeguard against missing req in complicated timeout scenarios
     if (!req) return
@@ -106,10 +120,11 @@ class NextPlugin extends ServerPlugin {
       return
     }
 
-    // remove ending /route or /page for appDir projects
-    // need to check if not an error page too, as those are marked as app directory
-    // in newer versions
-    if (isAppPath && !isErrorPage) page = page.slice(0, Math.max(0, page.lastIndexOf('/')))
+    // Compiled runtimes may publish a normalized pathname rather than a filesystem path.
+    if (isFilesystemPath && !isErrorPage) {
+      if (isAppPath) page = normalizeAppPath(page)
+      page = normalizeIndexPage(page)
+    }
 
     // handle static resource
     if (isStatic) {
@@ -123,7 +138,10 @@ class NextPlugin extends ServerPlugin {
       'resource.name': `${req.method} ${page}`.trim(),
       'next.page': page,
     })
-    web.setRoute(req, page)
+    const routeRequest = httpParentReq || req
+    web.setRouteOrEndpointTag(routeRequest)
+    setHttpParentRoute(httpParentSpan, req.method, page, isStatic)
+    web.setRoute(routeRequest, page)
   }
 
   configure (config) {
@@ -131,6 +149,36 @@ class NextPlugin extends ServerPlugin {
   }
 }
 
+function normalizeIndexPage (page) {
+  if (typeof page !== 'string') return page
+  if (page === '/index') return '/'
+  if (page.endsWith('/index')) return page.slice(0, -'/index'.length) || '/'
+  return page
+}
+
+function normalizeAppPath (page) {
+  if (typeof page !== 'string') return page
+
+  for (const suffix of ['/page', '/route']) {
+    if (page === suffix) return '/'
+    if (page.endsWith(suffix)) return page.slice(0, -suffix.length) || '/'
+  }
+
+  return page
+}
+
+function setHttpParentRoute (span, method, page, isStatic) {
+  if (!span) return
+  const currentRoute = span.context().getTag(HTTP_ROUTE)
+
+  // Only refine a route that Next itself set; static resources are fallbacks.
+  if (currentRoute && (nextParentRoutes.get(span) !== currentRoute || isStatic)) return
+
+  span.setTag(HTTP_ROUTE, page)
+  span.setTag(RESOURCE_NAME, `${method} ${page}`.trim())
+  nextParentRoutes.set(span, page)
+}
+
 function normalizeConfig (config) {
   const hooks = getHooks(config)
   const validateStatus = typeof config.validateStatus === 'function'

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

@@ -627,6 +627,10 @@ function lookupOperationEndpoint (operationId, methodName, url) {
  * This function essentially normalizes the OpenAI method interface. Many methods accept
  * a single object argument. The remaining ones take individual arguments. This function
  * turns the individual arguments into an object to make extracting properties consistent.
+ *
+ * @param {string} methodName SDK method name, e.g. `createChatCompletion` or `chat.completions.create`
+ * @param {unknown[]} args arguments the SDK method was called with
+ * @returns {Record<string, unknown>}
  */
 function normalizeRequestPayload (methodName, args) {
   switch (methodName) {

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

@@ -1,7 +1,7 @@
 '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')
 
 class PGPlugin extends DatabasePlugin {
@@ -16,6 +16,52 @@ class PGPlugin extends DatabasePlugin {
       ctx.parentStore = storage('legacy').getStore()
     })
     this.addBind('apm:pg:pool:connect:finish', ctx => ctx.parentStore)
+
+    this.addSub('apm:pg:pool:acquire:start', ctx => {
+      const params = ctx.poolOptions
+      const operationName = this.operationName({ operation: 'pool.acquire' })
+      const deferServiceResolution = typeof this.config.service === 'function'
+      const service = deferServiceResolution
+        ? undefined
+        : this.serviceName({ pluginConfig: this.config, params })
+      ctx.deferServiceResolution = deferServiceResolution
+
+      this.startSpan(operationName, {
+        service,
+        resource: operationName,
+        type: 'sql',
+        kind: 'client',
+        meta: {
+          'db.type': 'postgres',
+          ...connectionMeta(params),
+        },
+      }, ctx)
+    })
+    this.addSub('apm:pg:pool:acquire:finish', ctx => {
+      const span = ctx.currentStore?.span
+      if (span === undefined) return
+
+      if (ctx.error) {
+        this.addError(ctx.error, span)
+      }
+      span.setTag('db.pool.wait_time_ms', ctx.poolWaitTime)
+      // `Pool` options carry only what the caller passed, so anything pg resolves later - a
+      // connection string, the default port, `PG*` environment variables - is known once the
+      // client exists.
+      if (ctx.params !== undefined) {
+        span.addTags(connectionMeta(ctx.params))
+        if (ctx.deferServiceResolution) {
+          const service = this.serviceName({ pluginConfig: this.config, params: ctx.params })
+          // A `service` callback may return no name, and the start-time fallback already carries
+          // the schema default every other pg span falls back to.
+          if (service.name) {
+            this.setServiceName(span, service.name)
+            span.setTag(SVC_SRC_KEY, service.source)
+          }
+        }
+      }
+      this.finish(ctx)
+    })
   }
 
   bindStart (ctx) {
@@ -42,10 +88,28 @@ class PGPlugin extends DatabasePlugin {
       span.setTag('db.stream', 1)
     }
 
+    if (ctx.poolWaitTime !== undefined) {
+      span.setTag('db.pool.wait_time_ms', ctx.poolWaitTime)
+    }
+
     ctx.injected = this.injectDbmQuery(span, originalText, service.name, !!query.name)
 
     return ctx.currentStore
   }
 }
 
+/**
+ * `Pool.options` and `Client.connectionParameters` are pg internals, so either can be missing.
+ *
+ * @param {{ database?: string, user?: string, host?: string, port?: number } | undefined} params
+ */
+function connectionMeta (params) {
+  return {
+    'db.name': params?.database,
+    'db.user': params?.user,
+    'out.host': params?.host,
+    [CLIENT_PORT_KEY]: params?.port,
+  }
+}
+
 module.exports = PGPlugin

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

@@ -485,7 +485,7 @@ class PlaywrightPlugin extends CiPlugin {
         {
           hasCodeOwners: !!span.context().getTag(TEST_CODE_OWNERS),
           isNew,
-          isRum: isRUMActive,
+          isRum: isRUMActive === 'true' || undefined,
           browserDriver: 'playwright',
           isQuarantined,
           isDisabled,