dd-trace 5.75.0 → 5.77.0

package/LICENSE-3rdparty.csv

@@ -11,7 +11,7 @@ require,@opentelemetry/api,Apache license 2.0,Copyright OpenTelemetry Authors
 require,@opentelemetry/api-logs,Apache license 2.0,Copyright OpenTelemetry Authors
 require,@opentelemetry/core,Apache license 2.0,Copyright OpenTelemetry Authors
 require,@opentelemetry/resources,Apache license 2.0,Copyright OpenTelemetry Authors
-require,@isaacs/ttlcache,ISC,Copyright (c) 2022-2023 - Isaac Z. Schlueter and Contributors
+require,@isaacs/ttlcache,Blue Oak,Copyright Isaac Z. Schlueter and Contributors
 require,crypto-randomuuid,MIT,Copyright 2021 Node.js Foundation and contributors
 require,dc-polyfill,MIT,Copyright 2023 Datadog Inc.
 require,escape-string-regexp,MIT,Copyright Sindre Sorhus

package/ci/init.js

@@ -29,6 +29,7 @@ function detectTestWorkerType () {
   if (getEnvironmentVariable('MOCHA_WORKER_ID')) return 'mocha'
   if (getEnvironmentVariable('DD_PLAYWRIGHT_WORKER')) return 'playwright'
   if (getEnvironmentVariable('TINYPOOL_WORKER_ID')) return 'vitest'
+  if (getEnvironmentVariable('DD_VITEST_WORKER')) return 'vitest'
   return null
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.75.0",
+  "version": "5.77.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -125,15 +125,15 @@
     "@datadog/native-appsec": "10.3.0",
     "@datadog/native-iast-taint-tracking": "4.0.0",
     "@datadog/native-metrics": "3.1.1",
-    "@datadog/openfeature-node-server": "0.1.0-preview.12",
-    "@datadog/pprof": "5.11.1",
+    "@datadog/openfeature-node-server": "0.1.0-preview.15",
+    "@datadog/pprof": "5.12.0",
     "@datadog/sketches-js": "2.1.1",
-    "@datadog/wasm-js-rewriter": "4.0.1",
-    "@isaacs/ttlcache": "^1.4.1",
+    "@datadog/wasm-js-rewriter": "5.0.1",
+    "@isaacs/ttlcache": "^2.0.1",
     "@opentelemetry/api": ">=1.0.0 <1.10.0",
     "@opentelemetry/api-logs": "<1.0.0",
     "@opentelemetry/core": ">=1.14.0 <1.31.0",
-    "@opentelemetry/resources": ">=1.0.0 <1.10.0",
+    "@opentelemetry/resources": ">=1.0.0 <1.31.0",
     "crypto-randomuuid": "^1.0.0",
     "dc-polyfill": "^0.1.10",
     "escape-string-regexp": "^5.0.0",
@@ -160,13 +160,13 @@
     "ttl-set": "^1.0.0"
   },
   "devDependencies": {
-    "@babel/helpers": "^7.27.6",
+    "@babel/helpers": "^7.28.4",
     "@eslint/eslintrc": "^3.3.1",
-    "@eslint/js": "^9.29.0",
+    "@eslint/js": "^9.39.0",
     "@msgpack/msgpack": "^3.1.2",
     "@openfeature/core": "^1.9.0",
     "@openfeature/server-sdk": "^1.20.0",
-    "@stylistic/eslint-plugin": "^5.0.0",
+    "@stylistic/eslint-plugin": "^5.5.0",
     "@types/chai": "^4.3.16",
     "@types/mocha": "^10.0.10",
     "@types/node": "^18.19.106",
@@ -175,15 +175,15 @@
     "axios": "^1.12.2",
     "benchmark": "^2.1.4",
     "body-parser": "^2.2.0",
-    "bun": "1.3.1",
+    "bun": "1.3.2",
     "chai": "^4.5.0",
-    "eslint": "^9.29.0",
-    "eslint-plugin-cypress": "^5.1.0",
+    "eslint": "^9.39.0",
+    "eslint-plugin-cypress": "^5.2.0",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-mocha": "^11.1.0",
-    "eslint-plugin-n": "^17.20.0",
+    "eslint-plugin-mocha": "^11.2.0",
+    "eslint-plugin-n": "^17.23.1",
     "eslint-plugin-promise": "^7.2.1",
-    "eslint-plugin-unicorn": "^61.0.2",
+    "eslint-plugin-unicorn": "^62.0.0",
     "express": "^5.1.0",
     "glob": "^10.4.5",
     "globals": "^16.3.0",

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

@@ -53,12 +53,21 @@ function wrapResponseRender (render) {
       return render.apply(this, arguments)
     }
 
+    const abortController = new AbortController()
     return responseRenderChannel.traceSync(
-      render,
+      function () {
+        if (abortController.signal.aborted) {
+          const error = abortController.signal.reason || new Error('Aborted')
+          throw error
+        }
+
+        return render.apply(this, arguments)
+      },
       {
         req: this.req,
         view,
-        options
+        options,
+        abortController
       },
       this,
       ...arguments
@@ -67,26 +76,28 @@ function wrapResponseRender (render) {
 }
 
 function wrapAppAll (all) {
-  return function wrappedAll (path, ...otherArgs) {
-    if (!routeAddedChannel.hasSubscribers) return all.call(this, path, ...otherArgs)
+  return function wrappedAll (...args) {
+    if (!routeAddedChannel.hasSubscribers) return all.apply(this, args)
 
+    const path = args[0]
     const paths = normalizeRoutePaths(path)
 
     for (const p of paths) {
       routeAddedChannel.publish({ method: '*', path: p })
     }
 
-    return all.call(this, path, ...otherArgs)
+    return all.apply(this, args)
   }
 }
 
 // Wrap app.route() to instrument Route object
 function wrapAppRoute (route) {
-  return function wrappedRoute (path, ...otherArgs) {
-    const routeObj = route.call(this, path, ...otherArgs)
+  return function wrappedRoute (...args) {
+    const routeObj = route.apply(this, args)
 
     if (!routeAddedChannel.hasSubscribers) return routeObj
 
+    const path = args[0]
     const paths = normalizeRoutePaths(path)
 
     if (!paths.length) return routeObj

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

@@ -140,7 +140,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       this.hasSnapshotTests = undefined
       this.testSuiteAbsolutePath = context.testPath
 
-      this.displayName = config.projectConfig?.displayName?.name
+      this.displayName = config.projectConfig?.displayName?.name || config.displayName
       this.testEnvironmentOptions = getTestEnvironmentOptions(config)
 
       const repositoryRoot = this.testEnvironmentOptions._ddRepositoryRoot
@@ -411,23 +411,19 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             } else {
               originalHookFns.set(hook, hookFn)
             }
-            // The rule has a bug, see https://github.com/sindresorhus/eslint-plugin-unicorn/issues/2164
-            // eslint-disable-next-line unicorn/consistent-function-scoping
-            const wrapperHook = function () {
+            const newHookFn = shimmer.wrapFunction(hookFn, hookFn => function () {
               return testFnCh.runStores(ctx, () => hookFn.apply(this, arguments))
-            }
-            // If we don't do this, the timeout will not be triggered
-            Object.defineProperty(wrapperHook, 'length', { value: hookFn.length })
-            hook.fn = wrapperHook
+            })
+            hook.fn = newHookFn
           }
           const originalFn = event.test.fn
           originalTestFns.set(event.test, originalFn)
-          const wrapper = function () {
-            return testFnCh.runStores(ctx, () => originalFn.apply(this, arguments))
-          }
-          // If we don't do this, the timeout will be not be triggered
-          Object.defineProperty(wrapper, 'length', { value: originalFn.length })
-          event.test.fn = wrapper
+
+          const newFn = shimmer.wrapFunction(event.test.fn, testFn => function () {
+            return testFnCh.runStores(ctx, () => testFn.apply(this, arguments))
+          })
+
+          event.test.fn = newFn
         })
       }
 
@@ -1293,7 +1289,7 @@ addHook({
 
   shimmer.wrap(Runtime.prototype, '_createJestObjectFor', _createJestObjectFor => function (from) {
     const result = _createJestObjectFor.apply(this, arguments)
-    const suiteFilePath = this._testPath
+    const suiteFilePath = this._testPath || from
 
     shimmer.wrap(result, 'mock', mock => function (moduleName) {
       // If the library is mocked with `jest.mock`, we don't want to bypass jest's own require engine
@@ -1450,7 +1446,11 @@ addHook({
 }, (childProcessWorker) => {
   const ChildProcessWorker = childProcessWorker.default
   shimmer.wrap(ChildProcessWorker.prototype, 'send', sendWrapper)
-  shimmer.wrap(ChildProcessWorker.prototype, '_onMessage', onMessageWrapper)
+  if (ChildProcessWorker.prototype._onMessage) {
+    shimmer.wrap(ChildProcessWorker.prototype, '_onMessage', onMessageWrapper)
+  } else if (ChildProcessWorker.prototype.onMessage) {
+    shimmer.wrap(ChildProcessWorker.prototype, 'onMessage', onMessageWrapper)
+  }
   return childProcessWorker
 })
 

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

@@ -22,6 +22,14 @@ const V4_PACKAGE_SHIMS = [
     methods: ['create'],
     streamedResponse: true
   },
+  {
+    file: 'resources/responses/responses',
+    targetClass: 'Responses',
+    baseResource: 'responses',
+    methods: ['create'],
+    streamedResponse: true,
+    versions: ['>=4.87.0']
+  },
   {
     file: 'resources/embeddings',
     targetClass: 'Embeddings',

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

@@ -68,6 +68,8 @@ let modifiedFiles = {}
 const quarantinedOrDisabledTestsAttemptToFix = []
 let quarantinedButNotAttemptToFixFqns = new Set()
 let rootDir = ''
+let sessionProjects = []
+
 const MINIMUM_SUPPORTED_VERSION_RANGE_EFD = '>=1.38.0' // TODO: remove this once we drop support for v5
 
 function isValidKnownTests (receivedKnownTests) {
@@ -495,6 +497,7 @@ function dispatcherHook (dispatcherExport) {
     const dispatcher = this
     const worker = createWorker.apply(this, arguments)
     const projects = getProjectsFromDispatcher(dispatcher)
+    sessionProjects = projects
 
     // for older versions of playwright, `shouldCreateTestSpan` should always be true,
     // since the `_runTest` function wrapper is not available for older versions
@@ -535,6 +538,7 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
     const dispatcher = this
     const worker = createWorker.apply(this, arguments)
     const projects = getProjectsFromDispatcher(dispatcher)
+    sessionProjects = projects
 
     worker.on('testBegin', ({ testId }) => {
       const test = getTestByTestId(dispatcher, testId)
@@ -1255,3 +1259,46 @@ addHook({
 
   return workerPackage
 })
+
+function generateSummaryWrapper (generateSummary) {
+  return function () {
+    for (const test of this.suite.allTests()) {
+      // https://github.com/microsoft/playwright/blob/bf92ffecff6f30a292b53430dbaee0207e0c61ad/packages/playwright/src/reporters/base.ts#L279
+      const didNotRun = test.outcome() === 'skipped' &&
+        (!test.results.length || test.expectedStatus !== 'skipped')
+      if (didNotRun) {
+        const {
+          _requireFile: testSuiteAbsolutePath,
+          location: { line: testSourceLine },
+        } = test
+        const browserName = getBrowserNameFromProjects(sessionProjects, test)
+
+        testSkipCh.publish({
+          testName: getTestFullname(test),
+          testSuiteAbsolutePath,
+          testSourceLine,
+          browserName,
+        })
+      }
+    }
+    return generateSummary.apply(this, arguments)
+  }
+}
+
+// If a playwright project B has a dependency on project A,
+// and project A fails, the tests in project B will not run.
+// This hook is used to report tests that did not run as skipped.
+// Note: this is different from tests skipped via test.skip() or test.fixme()
+addHook({
+  name: 'playwright',
+  file: 'lib/reporters/base.js',
+  versions: ['>=1.38.0']
+}, (reportersPackage) => {
+  // v1.50.0 changed the name of the base reporter from BaseReporter to TerminalReporter
+  if (reportersPackage.TerminalReporter) {
+    shimmer.wrap(reportersPackage.TerminalReporter.prototype, 'generateSummary', generateSummaryWrapper)
+  } else if (reportersPackage.BaseReporter) {
+    shimmer.wrap(reportersPackage.BaseReporter.prototype, 'generateSummary', generateSummaryWrapper)
+  }
+  return reportersPackage
+})

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

@@ -146,33 +146,34 @@ function createWrapRouterMethod (name) {
   }
 
   function wrapMethod (original) {
-    return shimmer.wrapFunction(original, original => function methodWithTrace (fn, ...otherArgs) {
+    return shimmer.wrapFunction(original, original => function methodWithTrace (...args) {
       let offset = 0
       if (this.stack) {
         offset = Array.isArray(this.stack) ? this.stack.length : 1
       }
-      const router = original.call(this, fn, ...otherArgs)
+      const router = original.apply(this, args)
 
       if (typeof this.stack === 'function') {
         this.stack = [{ handle: this.stack }]
       }
 
       if (routeAddedChannel.hasSubscribers) {
-        routeAddedChannel.publish({ topOfStackFunc: methodWithTrace, layer: this.stack.at(-1) })
+        routeAddedChannel.publish({ topOfStackFunc: methodWithTrace, layer: this.stack?.at(-1) })
       }
 
+      const fn = args[0]
+
       // Publish only if this router was mounted by app.use() (prevents early '/sub/...')
       if (routeAddedChannel.hasSubscribers && isAppMounted(this) && this.stack?.length > offset) {
         // Handle nested router mounting for 'use' method
-        if (original.name === 'use' && otherArgs.length >= 1) {
+        if (original.name === 'use' && args.length >= 2) {
           const { mountPaths, startIdx } = extractMountPaths(fn)
 
           if (mountPaths.length) {
             const parentPaths = getRouterMountPaths(this)
-            const callArgs = [fn, ...otherArgs]
 
-            for (let i = startIdx; i < callArgs.length; i++) {
-              const nestedRouter = callArgs[i]
+            for (let i = startIdx; i < args.length; i++) {
+              const nestedRouter = args[i]
 
               if (!nestedRouter || typeof nestedRouter !== 'function') continue
 
@@ -206,7 +207,7 @@ function createWrapRouterMethod (name) {
         }
       }
 
-      if (this.stack.length > offset) {
+      if (this.stack?.length > offset) {
         wrapStack(this.stack.slice(offset), extractMatchers(fn))
       }
 

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

@@ -60,6 +60,7 @@ let testManagementAttemptToFixRetries = 0
 let isDiEnabled = false
 let testCodeCoverageLinesTotal
 let isSessionStarted = false
+let vitestPool = null
 
 const BREAKPOINT_HIT_GRACE_PERIOD_MS = 400
 
@@ -157,6 +158,14 @@ function isTestPackage (testPackage) {
   return testPackage.V?.name === 'VitestTestRunner'
 }
 
+function hasForksPoolWorker (vitestPackage) {
+  return vitestPackage.f?.name === 'ForksPoolWorker'
+}
+
+function hasThreadsPoolWorker (vitestPackage) {
+  return vitestPackage.T?.name === 'ThreadsPoolWorker'
+}
+
 function getSessionStatus (state) {
   if (state.getCountOfFailedTests() > 0) {
     return 'fail'
@@ -389,6 +398,7 @@ function getFinishWrapper (exitOrClose) {
       isEarlyFlakeDetectionEnabled,
       isEarlyFlakeDetectionFaulty,
       isTestManagementTestsEnabled,
+      vitestPool,
       onFinish
     })
 
@@ -418,11 +428,27 @@ function getCreateCliWrapper (vitestPackage, frameworkVersion) {
 }
 
 function threadHandler (thread) {
-  if (workerProcesses.has(thread.process)) {
+  const { runtime } = thread
+  let workerProcess
+  if (runtime === 'child_process') {
+    vitestPool = 'child_process'
+    workerProcess = thread.process
+  } else if (runtime === 'worker_threads') {
+    vitestPool = 'worker_threads'
+    workerProcess = thread.thread
+  } else {
+    vitestPool = 'unknown'
+  }
+  if (!workerProcess) {
+    log.error('Vitest error: could not get process or thread from TinyPool#run')
     return
   }
-  workerProcesses.add(thread.process)
-  thread.process.on('message', (message) => {
+
+  if (workerProcesses.has(workerProcess)) {
+    return
+  }
+  workerProcesses.add(workerProcess)
+  workerProcess.on('message', (message) => {
     if (message.__tinypool_worker_message__ && message.data) {
       if (message.interprocessCode === VITEST_WORKER_TRACE_PAYLOAD_CODE) {
         workerReportTraceCh.publish(message.data)
@@ -433,11 +459,7 @@ function threadHandler (thread) {
   })
 }
 
-addHook({
-  name: 'tinypool',
-  versions: ['>=1.0.0'],
-  file: 'dist/index.js'
-}, (TinyPool) => {
+function wrapTinyPoolRun (TinyPool) {
   shimmer.wrap(TinyPool.prototype, 'run', run => async function () {
     // We have to do this before and after because the threads list gets recycled, that is, the processes are re-created
     this.threads.forEach(threadHandler)
@@ -445,15 +467,79 @@ addHook({
     this.threads.forEach(threadHandler)
     return runResult
   })
+}
+
+addHook({
+  name: 'tinypool',
+  // version from tinypool@0.8 was used in vitest@1.6.0
+  versions: ['>=0.8.0 <1.0.0'],
+  file: 'dist/esm/index.js'
+}, (TinyPool) => {
+  wrapTinyPoolRun(TinyPool)
+  return TinyPool
+})
+
+addHook({
+  name: 'tinypool',
+  versions: ['>=1.0.0'],
+  file: 'dist/index.js'
+}, (TinyPool) => {
+  wrapTinyPoolRun(TinyPool)
 
   return TinyPool
 })
 
+function getWrappedOn (on) {
+  return function (event, callback) {
+    if (event !== 'message') {
+      return on.apply(this, arguments)
+    }
+    // `arguments[1]` is the callback function, which
+    // we modify to intercept our messages to not interfere
+    // with vitest's own messages
+    arguments[1] = shimmer.wrapFunction(callback, callback => function (message) {
+      if (message.type !== 'Buffer' && Array.isArray(message)) {
+        const [interprocessCode, data] = message
+        if (interprocessCode === VITEST_WORKER_TRACE_PAYLOAD_CODE) {
+          workerReportTraceCh.publish(data)
+        } else if (interprocessCode === VITEST_WORKER_LOGS_PAYLOAD_CODE) {
+          workerReportLogsCh.publish(data)
+        }
+        // If we execute the callback vitest crashes, as the message is not supported
+        return
+      }
+      return callback.apply(this, arguments)
+    })
+    return on.apply(this, arguments)
+  }
+}
+
 function getStartVitestWrapper (cliApiPackage, frameworkVersion) {
   if (!isCliApiPackage(cliApiPackage)) {
     return cliApiPackage
   }
   shimmer.wrap(cliApiPackage, 's', getCliOrStartVitestWrapper(frameworkVersion))
+
+  if (hasForksPoolWorker(cliApiPackage)) {
+    // function is async
+    shimmer.wrap(cliApiPackage.f.prototype, 'start', start => function () {
+      vitestPool = 'child_process'
+      this.env.DD_VITEST_WORKER = '1'
+
+      return start.apply(this, arguments)
+    })
+    shimmer.wrap(cliApiPackage.f.prototype, 'on', getWrappedOn)
+  }
+
+  if (hasThreadsPoolWorker(cliApiPackage)) {
+    // function is async
+    shimmer.wrap(cliApiPackage.T.prototype, 'start', start => function () {
+      vitestPool = 'worker_threads'
+      this.env.DD_VITEST_WORKER = '1'
+      return start.apply(this, arguments)
+    })
+    shimmer.wrap(cliApiPackage.T.prototype, 'on', getWrappedOn)
+  }
   return cliApiPackage
 }
 

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

@@ -51,7 +51,8 @@ const {
 } = require('../../dd-trace/src/ci-visibility/telemetry')
 
 const BREAKPOINT_HIT_GRACE_PERIOD_MS = 200
-const BREAKPOINT_SET_GRACE_PERIOD_MS = 200
+const BREAKPOINT_SET_GRACE_PERIOD_MS = 400
+
 const isCucumberWorker = !!getEnvironmentVariable('CUCUMBER_WORKER_ID')
 
 class CucumberPlugin extends CiPlugin {

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

@@ -3,6 +3,10 @@
 const pick = require('../../datadog-core/src/utils/src/pick')
 const log = require('../../dd-trace/src/log')
 
+function getEmptyObject () {
+  return {}
+}
+
 module.exports = {
   getMethodMetadata (path, kind) {
     const tags = {
@@ -57,6 +61,6 @@ module.exports = {
       log.error('Expected \'%s\' to be an array or function.', filter)
     }
 
-    return () => ({})
+    return getEmptyObject
   }
 }

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

@@ -183,13 +183,17 @@ function normalizeClientConfig (config) {
   }
 }
 
+function is400ErrorCode (code) {
+  return code < 400 || code >= 500
+}
+
 function getStatusValidator (config) {
   if (typeof config.validateStatus === 'function') {
     return config.validateStatus
   } else if (config.hasOwnProperty('validateStatus')) {
     log.error('Expected `validateStatus` to be a function.')
   }
-  return code => code < 400 || code >= 500
+  return is400ErrorCode
 }
 
 function getFilter (config) {

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

@@ -162,13 +162,17 @@ function hasAmazonSignature (headers, path) {
   return false
 }
 
+function is400ErrorCode (code) {
+  return code < 400 || code >= 500
+}
+
 function getStatusValidator (config) {
   if (typeof config.validateStatus === 'function') {
     return config.validateStatus
   } else if (config.hasOwnProperty('validateStatus')) {
     log.error('Expected `validateStatus` to be a function.')
   }
-  return code => code < 400 || code >= 500
+  return is400ErrorCode
 }
 
 function normalizeConfig (config) {

package/packages/datadog-plugin-openai/src/stream-helpers.js

@@ -107,8 +107,33 @@ function constructChatCompletionResponseFromStreamedChunks (chunks, n) {
   })
 }
 
+/**
+ * Constructs the entire response from a stream of OpenAI responses chunks.
+ * The responses API uses event-based streaming with delta chunks.
+ * @param {Array<Record<string, any>>} chunks
+ * @returns {Record<string, any>}
+ */
+function constructResponseResponseFromStreamedChunks (chunks) {
+  // The responses API streams events with different types:
+  // - response.output_text.delta: incremental text deltas
+  // - response.output_text.done: complete text for a content part
+  // - response.output_item.done: complete output item with role
+  // - response.done/response.incomplete/response.completed: final response with output array and usage
+
+  // Find the last chunk with a complete response object (status: done, incomplete, or completed)
+  const responseStatusSet = new Set(['done', 'incomplete', 'completed'])
+
+  for (let i = chunks.length - 1; i >= 0; i--) {
+    const chunk = chunks[i]
+    if (chunk.response && responseStatusSet.has(chunk.response.status)) {
+      return chunk.response
+    }
+  }
+}
+
 module.exports = {
   convertBuffersToObjects,
   constructCompletionResponseFromStreamedChunks,
-  constructChatCompletionResponseFromStreamedChunks
+  constructChatCompletionResponseFromStreamedChunks,
+  constructResponseResponseFromStreamedChunks
 }