dd-trace 5.90.0 → 5.91.0

package/index.d.ts

@@ -262,6 +262,7 @@ interface Plugins {
   "knex": tracer.plugins.knex;
   "koa": tracer.plugins.koa;
   "langchain": tracer.plugins.langchain;
+  "langgraph": tracer.plugins.langgraph;
   "mariadb": tracer.plugins.mariadb;
   "memcached": tracer.plugins.memcached;
   "microgateway-core": tracer.plugins.microgateway_core;
@@ -2579,6 +2580,12 @@ declare namespace tracer {
 
     /**
      * This plugin automatically instruments the
+     * [langgraph](https://github.com/npmjs/package/langgraph) library.
+     */
+    interface langgraph extends Instrumentation {}
+
+      /**
+     * This plugin automatically instruments the
      * [ldapjs](https://github.com/ldapjs/node-ldapjs/) module.
      */
     interface ldapjs extends Instrumentation {}

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "dd-trace",
-  "version": "5.90.0",
+  "version": "5.91.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
   "scripts": {
     "env": "bash ./plugin-env",
+    "prepare": "cd vendor && npm ci --include=dev",
     "preinstall": "node scripts/preinstall.js",
     "bench": "node benchmark/index.js",
     "bench:e2e:test-optimization": "node benchmark/e2e-test-optimization/benchmark-run.js",
@@ -146,13 +147,13 @@
     "@datadog/wasm-js-rewriter": "5.0.1",
     "@opentelemetry/api": ">=1.0.0 <1.10.0",
     "@opentelemetry/api-logs": "<1.0.0",
-    "oxc-parser": "^0.116.0"
+    "oxc-parser": "^0.118.0"
   },
   "devDependencies": {
     "@actions/core": "^3.0.0",
     "@actions/github": "^9.0.0",
     "@babel/helpers": "^7.28.6",
-    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/eslintrc": "^3.3.5",
     "@eslint/js": "^9.39.2",
     "@msgpack/msgpack": "^3.1.3",
     "@openfeature/core": "^1.8.1",
@@ -165,11 +166,11 @@
     "benchmark": "^2.1.4",
     "body-parser": "^2.2.2",
     "bun": "1.3.10",
-    "codeowners-audit": "^2.7.1",
+    "codeowners-audit": "^2.9.0",
     "eslint": "^9.39.2",
-    "eslint-plugin-cypress": "^6.1.0",
+    "eslint-plugin-cypress": "^6.2.0",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-jsdoc": "^62.5.0",
+    "eslint-plugin-jsdoc": "^62.8.0",
     "eslint-plugin-mocha": "^11.2.0",
     "eslint-plugin-n": "^17.23.2",
     "eslint-plugin-promise": "^7.2.1",

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

@@ -166,9 +166,9 @@ function getErrorFromCucumberResult (cucumberResult) {
   return error
 }
 
-function getChannelPromise (channelToPublishTo, isParallel = false, frameworkVersion = null) {
+function getChannelPromise (channelToPublishTo, frameworkVersion = null) {
   return new Promise(resolve => {
-    channelToPublishTo.publish({ onDone: resolve, isParallel, frameworkVersion })
+    channelToPublishTo.publish({ onDone: resolve, frameworkVersion })
   })
 }
 
@@ -505,7 +505,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
     }
     let errorSkippableRequest
 
-    const configurationResponse = await getChannelPromise(libraryConfigurationCh, isParallel, frameworkVersion)
+    const configurationResponse = await getChannelPromise(libraryConfigurationCh, frameworkVersion)
 
     isEarlyFlakeDetectionEnabled = configurationResponse.libraryConfig?.isEarlyFlakeDetectionEnabled
     earlyFlakeDetectionNumRetries = configurationResponse.libraryConfig?.earlyFlakeDetectionNumRetries
@@ -681,6 +681,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     let isQuarantined = false
     let isModified = false
 
+    const originalDryRun = this.options.dryRun
     if (isTestManagementTestsEnabled) {
       const testProperties = getTestProperties(testSuitePath, pickle.name)
       isAttemptToFix = testProperties.attemptToFix
@@ -719,6 +720,9 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     // TODO: for >=11 we could use `runTestCaseResult` instead of accumulating results in `lastStatusByPickleId`
     let runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
 
+    // Restore dryRun so it doesn't affect subsequent tests in the same worker
+    this.options.dryRun = originalDryRun
+
     const testStatuses = lastStatusByPickleId.get(pickle.id)
     const lastTestStatus = testStatuses.at(-1)
 
@@ -1053,6 +1057,12 @@ addHook({
     this.options.worldParameters._ddIsFlakyTestRetriesEnabled = isFlakyTestRetriesEnabled
     this.options.worldParameters._ddNumTestRetries = numTestRetries
 
+    if (isTestManagementTestsEnabled) {
+      this.options.worldParameters._ddIsTestManagementTestsEnabled = true
+      this.options.worldParameters._ddTestManagementTests = testManagementTests
+      this.options.worldParameters._ddTestManagementAttemptToFixRetries = testManagementAttemptToFixRetries
+    }
+
     return startWorker.apply(this, arguments)
   })
   return adapterPackage
@@ -1090,6 +1100,11 @@ addHook({
       }
       isFlakyTestRetriesEnabled = !!this.options.worldParameters._ddIsFlakyTestRetriesEnabled
       numTestRetries = this.options.worldParameters._ddNumTestRetries ?? 0
+      isTestManagementTestsEnabled = !!this.options.worldParameters._ddIsTestManagementTestsEnabled
+      if (isTestManagementTestsEnabled) {
+        testManagementTests = this.options.worldParameters._ddTestManagementTests
+        testManagementAttemptToFixRetries = this.options.worldParameters._ddTestManagementAttemptToFixRetries
+      }
     }
   )
   return workerPackage

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -4,6 +4,7 @@ module.exports = {
   '@anthropic-ai/sdk': { esmFirst: true, fn: () => require('../anthropic') },
   '@apollo/server': () => require('../apollo-server'),
   '@apollo/gateway': () => require('../apollo'),
+  '@langchain/langgraph': { esmFirst: true, fn: () => require('../langgraph') },
   'apollo-server-core': () => require('../apollo-server-core'),
   '@aws-sdk/smithy-client': () => require('../aws-sdk'),
   '@azure/event-hubs': () => require('../azure-event-hubs'),

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/index.js

@@ -4,4 +4,5 @@ module.exports = [
   ...require('./ai'),
   ...require('./bullmq'),
   ...require('./langchain'),
+  ...require('./langgraph'),
 ]

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/langgraph.js

@@ -0,0 +1,30 @@
+'use strict'
+
+module.exports = [
+  {
+    module: {
+      name: '@langchain/langgraph',
+      versionRange: '>=1.1.2',
+      filePath: 'dist/pregel/index.js',
+    },
+    functionQuery: {
+      methodName: 'stream',
+      className: 'Pregel',
+      kind: 'AsyncIterator',
+    },
+    channelName: 'Pregel_stream',
+  },
+  {
+    module: {
+      name: '@langchain/langgraph',
+      versionRange: '>=1.1.2',
+      filePath: 'dist/pregel/index.cjs',
+    },
+    functionQuery: {
+      methodName: 'stream',
+      className: 'Pregel',
+      kind: 'AsyncIterator',
+    },
+    channelName: 'Pregel_stream',
+  },
+]

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

@@ -702,11 +702,15 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         const mightHitBreakpoint = this.isDiEnabled && numTestExecutions >= 2
 
         const ctx = testContexts.get(event.test)
+        if (!ctx) {
+          log.warn('"ci:jest:test_done": no context found for test "%s"', testName)
+          return
+        }
 
         const finalStatus = this.getFinalStatus(testName,
           status,
-          !!ctx?.isNew,
-          !!ctx?.isModified,
+          !!ctx.isNew,
+          !!ctx.isModified,
           isEfdRetry,
           isAttemptToFix,
           numTestExecutions)
@@ -761,6 +765,9 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         efdDeterminedRetries.clear()
         efdSlowAbortedTests.clear()
         efdNewTestCandidates.clear()
+        retriedTestsToNumAttempts.clear()
+        attemptToFixRetriedTestsStatuses.clear()
+        testsToBeRetried.clear()
       }
       if (event.name === 'test_skip' || event.name === 'test_todo') {
         const testName = getJestTestName(event.test, this.getShouldStripSeedFromTestName())

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

@@ -0,0 +1,7 @@
+'use strict'
+
+const { addHook, getHooks } = require('./helpers/instrument')
+
+for (const hook of getHooks('@langchain/langgraph')) {
+  addHook(hook, exports => exports)
+}

package/packages/datadog-instrumentations/src/mocha/main.js

@@ -101,12 +101,12 @@ function getFilteredSuites (originalSuites) {
   }, { suitesToRun: [], skippedSuites: new Set() })
 }
 
-function getOnStartHandler (isParallel, frameworkVersion) {
+function getOnStartHandler (frameworkVersion) {
   return function () {
     const processArgv = process.argv.slice(2).join(' ')
     const command = `mocha ${processArgv}`
     testSessionStartCh.publish({ command, frameworkVersion })
-    if (!isParallel && skippedSuites.length) {
+    if (skippedSuites.length) {
       itrSkippedSuitesCh.publish({ skippedSuites, frameworkVersion })
     }
   }
@@ -315,8 +315,7 @@ function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFini
     config.isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
     config.testManagementAttemptToFixRetries = libraryConfig.testManagementAttemptToFixRetries
     config.isImpactedTestsEnabled = libraryConfig.isImpactedTestsEnabled
-    // ITR is not supported in parallel mode yet
-    config.isSuitesSkippingEnabled = !isParallel && libraryConfig.isSuitesSkippingEnabled
+    config.isSuitesSkippingEnabled = libraryConfig.isSuitesSkippingEnabled
     config.isFlakyTestRetriesEnabled = libraryConfig.isFlakyTestRetriesEnabled
     config.flakyTestRetriesCount = libraryConfig.flakyTestRetriesCount
 
@@ -452,7 +451,7 @@ addHook({
 
     const { suitesByTestFile, numSuitesByTestFile } = getSuitesByTestFile(this.suite)
 
-    this.once('start', getOnStartHandler(false, frameworkVersion))
+    this.once('start', getOnStartHandler(frameworkVersion))
 
     this.once('end', getOnEndHandler(false))
 
@@ -623,9 +622,16 @@ addHook({
       return run.apply(this, arguments)
     }
 
-    this.once('start', getOnStartHandler(true, frameworkVersion))
+    this.once('start', getOnStartHandler(frameworkVersion))
     this.once('end', getOnEndHandler(true))
 
+    // Populate unskippable suites before config is fetched (matches serial mode at Mocha.prototype.run)
+    for (const filePath of files) {
+      if (isMarkedAsUnskippable({ path: filePath })) {
+        unskippableSuites.push(filePath)
+      }
+    }
+
     getExecutionConfiguration(this, true, frameworkVersion, () => {
       if (config.isKnownTestsEnabled) {
         const testSuites = files.map(file => getTestSuitePath(file, process.cwd()))
@@ -640,7 +646,25 @@ addHook({
           config.isEarlyFlakeDetectionFaulty = true
         }
       }
-      run.apply(this, arguments)
+      if (config.isSuitesSkippingEnabled && suitesToSkip.length) {
+        const filteredFiles = []
+        const skippedFiles = []
+        for (const file of files) {
+          const testPath = getTestSuitePath(file, process.cwd())
+          const shouldSkip = suitesToSkip.includes(testPath)
+          const isUnskippable = unskippableSuites.includes(file)
+          if (shouldSkip && !isUnskippable) {
+            skippedFiles.push(testPath)
+          } else {
+            filteredFiles.push(file)
+          }
+        }
+        isSuitesSkipped = skippedFiles.length > 0
+        skippedSuites = skippedFiles
+        run.apply(this, [cb, { files: filteredFiles }])
+      } else {
+        run.apply(this, arguments)
+      }
     })
 
     return this
@@ -694,8 +718,7 @@ addHook({
     if (config.isTestManagementTestsEnabled) {
       const testSuiteTestManagementTests = config.testManagementTests?.mocha?.suites?.[testPath] || {}
       newWorkerArgs._ddIsTestManagementTestsEnabled = true
-      // TODO: attempt to fix does not work in parallel mode yet
-      // newWorkerArgs._ddTestManagementAttemptToFixRetries = config.testManagementAttemptToFixRetries
+      newWorkerArgs._ddTestManagementAttemptToFixRetries = config.testManagementAttemptToFixRetries
       newWorkerArgs._ddTestManagementTests = {
         mocha: {
           suites: {

package/packages/datadog-instrumentations/src/mocha/utils.js

@@ -140,7 +140,6 @@ function runnableWrapper (RunnablePackage, libraryConfig) {
     if (!testFinishCh.hasSubscribers) {
       return run.apply(this, arguments)
     }
-    // Flaky test retries does not work in parallel mode
     if (libraryConfig?.isFlakyTestRetriesEnabled) {
       this.retries(libraryConfig?.flakyTestRetriesCount)
     }

package/packages/datadog-instrumentations/src/mocha/worker.js

@@ -43,10 +43,10 @@ addHook({
     }
     if (this.options._ddIsTestManagementTestsEnabled) {
       config.isTestManagementTestsEnabled = true
-      // TODO: attempt to fix does not work in parallel mode yet
-      // config.testManagementAttemptToFixRetries = this.options._ddTestManagementAttemptToFixRetries
+      config.testManagementAttemptToFixRetries = this.options._ddTestManagementAttemptToFixRetries
       config.testManagementTests = this.options._ddTestManagementTests
       delete this.options._ddIsTestManagementTestsEnabled
+      delete this.options._ddTestManagementAttemptToFixRetries
       delete this.options._ddTestManagementTests
     }
     if (this.options._ddIsFlakyTestRetriesEnabled) {

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

@@ -146,8 +146,23 @@ function isReporterPackageNewest (vitestPackage) {
   return vitestPackage.h?.name === 'BaseSequencer'
 }
 
-function isBaseSequencer (vitestPackage) {
-  return vitestPackage.b?.name === 'BaseSequencer'
+/**
+ * Finds an export by its `.name` property in a minified vitest chunk.
+ * Minified export keys change across versions, so we search by function/class name.
+ * @param {object} pkg - The module exports object
+ * @param {string} name - The `.name` value to look for
+ * @returns {{ key: string, value: Function } | undefined}
+ */
+function findExportByName (pkg, name) {
+  for (const [key, value] of Object.entries(pkg)) {
+    if (value?.name === name) {
+      return { key, value }
+    }
+  }
+}
+
+function getBaseSequencerExport (vitestPackage) {
+  return findExportByName(vitestPackage, 'BaseSequencer')
 }
 
 function getChannelPromise (channelToPublishTo, frameworkVersion) {
@@ -157,19 +172,19 @@ function getChannelPromise (channelToPublishTo, frameworkVersion) {
 }
 
 function isCliApiPackage (vitestPackage) {
-  return vitestPackage.s?.name === 'startVitest'
+  return !!findExportByName(vitestPackage, 'startVitest')
 }
 
-function isTestPackage (testPackage) {
-  return testPackage.V?.name === 'VitestTestRunner'
+function getTestRunnerExport (testPackage) {
+  return findExportByName(testPackage, 'VitestTestRunner') || findExportByName(testPackage, 'TestRunner')
 }
 
-function hasForksPoolWorker (vitestPackage) {
-  return vitestPackage.f?.name === 'ForksPoolWorker'
+function getForksPoolWorkerExport (vitestPackage) {
+  return findExportByName(vitestPackage, 'ForksPoolWorker')
 }
 
-function hasThreadsPoolWorker (vitestPackage) {
-  return vitestPackage.T?.name === 'ThreadsPoolWorker'
+function getThreadsPoolWorkerExport (vitestPackage) {
+  return findExportByName(vitestPackage, 'ThreadsPoolWorker')
 }
 
 function getSessionStatus (state) {
@@ -447,7 +462,11 @@ function getCliOrStartVitestWrapper (frameworkVersion) {
 }
 
 function getCreateCliWrapper (vitestPackage, frameworkVersion) {
-  shimmer.wrap(vitestPackage, 'c', getCliOrStartVitestWrapper(frameworkVersion))
+  const createCliExport = findExportByName(vitestPackage, 'createCLI')
+  if (!createCliExport) {
+    return vitestPackage
+  }
+  shimmer.wrap(vitestPackage, createCliExport.key, getCliOrStartVitestWrapper(frameworkVersion))
 
   return vitestPackage
 }
@@ -534,27 +553,30 @@ function getStartVitestWrapper (cliApiPackage, frameworkVersion) {
   if (!isCliApiPackage(cliApiPackage)) {
     return cliApiPackage
   }
-  shimmer.wrap(cliApiPackage, 's', getCliOrStartVitestWrapper(frameworkVersion))
+  const startVitestExport = findExportByName(cliApiPackage, 'startVitest')
+  shimmer.wrap(cliApiPackage, startVitestExport.key, getCliOrStartVitestWrapper(frameworkVersion))
 
-  if (hasForksPoolWorker(cliApiPackage)) {
+  const forksPoolWorker = getForksPoolWorkerExport(cliApiPackage)
+  if (forksPoolWorker) {
     // function is async
-    shimmer.wrap(cliApiPackage.f.prototype, 'start', start => function () {
+    shimmer.wrap(forksPoolWorker.value.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)
+    shimmer.wrap(forksPoolWorker.value.prototype, 'on', getWrappedOn)
   }
 
-  if (hasThreadsPoolWorker(cliApiPackage)) {
+  const threadsPoolWorker = getThreadsPoolWorkerExport(cliApiPackage)
+  if (threadsPoolWorker) {
     // function is async
-    shimmer.wrap(cliApiPackage.T.prototype, 'start', start => function () {
+    shimmer.wrap(threadsPoolWorker.value.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)
+    shimmer.wrap(threadsPoolWorker.value.prototype, 'on', getWrappedOn)
   }
   return cliApiPackage
 }
@@ -747,7 +769,10 @@ function wrapVitestTestRunner (VitestTestRunner) {
     }
 
     const lastExecutionStatus = task.result.state
-    const shouldFlipStatus = isEarlyFlakeDetectionEnabled || attemptToFixTasks.has(task)
+    const isAtf = attemptToFixTasks.has(task)
+    const isQuarantinedOrDisabledAtf = isAtf && (quarantinedTasks.has(task) || disabledTasks.has(task))
+    const shouldTrackStatuses = isEarlyFlakeDetectionEnabled || isAtf
+    const shouldFlipStatus = isEarlyFlakeDetectionEnabled || isQuarantinedOrDisabledAtf
     const statuses = taskToStatuses.get(task)
 
     // These clauses handle task.repeats, whether EFD is enabled or not
@@ -765,8 +790,10 @@ function wrapVitestTestRunner (VitestTestRunner) {
         } else {
           testPassCh.publish({ task, ...ctx.currentStore })
         }
-        if (shouldFlipStatus) {
+        if (shouldTrackStatuses) {
           statuses.push(lastExecutionStatus)
+        }
+        if (shouldFlipStatus) {
           // If we don't "reset" the result.state to "pass", once a repetition fails,
           // vitest will always consider the test as failed, so we can't read the actual status
           // This means that we change vitest's behavior:
@@ -776,7 +803,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
         }
       }
     } else if (numRepetition === task.repeats) {
-      if (shouldFlipStatus) {
+      if (shouldTrackStatuses) {
         statuses.push(lastExecutionStatus)
       }
 
@@ -864,11 +891,12 @@ addHook({
   versions: ['>=4.0.0'],
   filePattern: 'dist/chunks/test.*',
 }, (testPackage) => {
-  if (!isTestPackage(testPackage)) {
+  const testRunner = getTestRunnerExport(testPackage)
+  if (!testRunner) {
     return testPackage
   }
 
-  wrapVitestTestRunner(testPackage.V)
+  wrapVitestTestRunner(testRunner.value)
 
   return testPackage
 })
@@ -937,8 +965,9 @@ addHook({
   versions: ['>=3.0.9'],
   filePattern: 'dist/chunks/coverage.*',
 }, (coveragePackage) => {
-  if (isBaseSequencer(coveragePackage)) {
-    shimmer.wrap(coveragePackage.b.prototype, 'sort', getSortWrapper)
+  const baseSequencer = getBaseSequencerExport(coveragePackage)
+  if (baseSequencer) {
+    shimmer.wrap(baseSequencer.value.prototype, 'sort', getSortWrapper)
   }
   return coveragePackage
 })

package/packages/datadog-plugin-cypress/src/cypress-plugin.js

@@ -607,7 +607,7 @@ class CypressPlugin {
           [TEST_SESSION_NAME]: testSessionName,
         }
       }
-      const libraryCapabilitiesTags = getLibraryCapabilitiesTags(this.constructor.id, false, this.frameworkVersion)
+      const libraryCapabilitiesTags = getLibraryCapabilitiesTags(this.constructor.id, this.frameworkVersion)
       metadataTags.test = {
         ...metadataTags.test,
         ...libraryCapabilitiesTags,

package/packages/datadog-plugin-cypress/src/support.js

@@ -61,18 +61,16 @@ Cypress.on('fail', (err, runnable) => {
   }
 
   const testName = runnable.fullTitle()
-  const { isQuarantined, isAttemptToFix } = getTestProperties(testName)
+  const { isQuarantined, isDisabled } = getTestProperties(testName)
 
-  // For pure quarantined tests (not attemptToFix), suppress the failure
-  // This makes the test "pass" from Cypress's perspective while we still track the error
-  if (isQuarantined && !isAttemptToFix) {
-    // Store the error so we can report it to Datadog in afterEach
+  // Suppress failures for quarantined or disabled tests so they don't affect the exit code.
+  // This applies regardless of attempt-to-fix status: per spec, quarantined/disabled test
+  // results are always ignored.
+  if (isQuarantined || isDisabled) {
     quarantinedTestErrors.set(testName, err)
-    // Don't re-throw - this prevents Cypress from marking the test as failed
     return
   }
 
-  // For all other tests (including attemptToFix), let the error propagate normally
   throw err
 })
 

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

@@ -0,0 +1,24 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const langgraphLLMObsPlugins = require('../../dd-trace/src/llmobs/plugins/langgraph')
+const streamPlugin = require('./stream')
+
+const plugins = {}
+
+// CRITICAL: LLMObs plugins MUST come first
+for (const Plugin of langgraphLLMObsPlugins) {
+  plugins[Plugin.id] = Plugin
+}
+
+// Tracing plugins second
+for (const Plugin of streamPlugin) {
+  plugins[Plugin.id] = Plugin
+}
+
+class LanggraphPlugin extends CompositePlugin {
+  static id = 'langgraph'
+  static plugins = plugins
+}
+
+module.exports = LanggraphPlugin

package/packages/datadog-plugin-langgraph/src/stream.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+const { spanHasError } = require('../../dd-trace/src/llmobs/util')
+
+// We are only tracing Pregel.stream because Pregel.invoke calls stream internally resulting in
+// a graph with spans that look redundant.
+class PregelStreamPlugin extends TracingPlugin {
+  static id = 'langgraph_pregel_stream'
+  static prefix = 'tracing:orchestrion:@langchain/langgraph:Pregel_stream'
+
+  bindStart (ctx) {
+    this.startSpan('LangGraph', {
+      service: this.config.service,
+      kind: 'internal',
+      component: 'langgraph',
+    }, ctx)
+    return ctx.currentStore
+  }
+}
+class NextStreamPlugin extends TracingPlugin {
+  static id = 'langgraph_stream_next'
+  static prefix = 'tracing:orchestrion:@langchain/langgraph:Pregel_stream_next'
+
+  bindStart (ctx) {
+    return ctx.currentStore
+  }
+
+  asyncEnd (ctx) {
+    const span = ctx.currentStore?.span
+    if (!span) return
+    if (ctx.result.done === true || spanHasError(span)) {
+      span.finish()
+    }
+  }
+}
+
+module.exports = [
+  PregelStreamPlugin,
+  NextStreamPlugin,
+]

package/packages/dd-trace/src/config/defaults.js

@@ -106,6 +106,7 @@ const defaultsWithoutSupportedConfigurationEntry = {
   isGCPFunction: false,
   instrumentationSource: 'manual',
   isServiceUserProvided: false,
+  isServiceNameInferred: true,
   lookup: undefined,
   plugins: true,
 }

package/packages/dd-trace/src/config/index.js

@@ -722,8 +722,10 @@ class Config {
     // Priority:
     // DD_SERVICE > tags.service > OTEL_SERVICE_NAME > NX_TASK_TARGET_PROJECT (if DD_ENABLE_NX_SERVICE_NAME) > default
     let serviceName = DD_SERVICE || tags.service || OTEL_SERVICE_NAME
+    let isServiceNameInferred
     if (!serviceName && NX_TASK_TARGET_PROJECT) {
       if (isTrue(DD_ENABLE_NX_SERVICE_NAME)) {
+        isServiceNameInferred = true
         serviceName = NX_TASK_TARGET_PROJECT
       } else if (DD_MAJOR < 6) {
         // Warn about v6 behavior change for Nx projects
@@ -734,6 +736,7 @@ class Config {
       }
     }
     setString(target, 'service', serviceName)
+    if (serviceName) setBoolean(target, 'isServiceNameInferred', isServiceNameInferred ?? false)
     if (DD_SERVICE_MAPPING) {
       target.serviceMapping = Object.fromEntries(
         DD_SERVICE_MAPPING.split(',').map(x => x.trim().split(':'))
@@ -1004,7 +1007,11 @@ class Config {
     setUnit(opts, 'sampleRate', options.sampleRate ?? options.ingestion.sampleRate)
     opts['sampler.rateLimit'] = maybeInt(options.rateLimit ?? options.ingestion.rateLimit)
     setSamplingRule(opts, 'sampler.rules', options.samplingRules)
-    setString(opts, 'service', options.service || tags.service)
+    const optService = options.service || tags.service
+    setString(opts, 'service', optService)
+    if (optService) {
+      setBoolean(opts, 'isServiceNameInferred', false)
+    }
     opts.serviceMapping = options.serviceMapping
     setString(opts, 'site', options.site)
     if (options.spanAttributeSchema) {

package/packages/dd-trace/src/config/supported-configurations.json

@@ -2995,6 +2995,13 @@
         "default": "true"
       }
     ],
+    "DD_TRACE_LANGGRAPH_ENABLED": [
+      {
+        "implementation": "C",
+        "type": "boolean",
+        "default": "true"
+      }
+    ],
     "DD_TRACE_LDAPJS_ENABLED": [
       {
         "implementation": "A",

package/packages/dd-trace/src/constants.js

@@ -23,6 +23,7 @@ module.exports = {
   SPAN_SAMPLING_MAX_PER_SECOND: '_dd.span_sampling.max_per_second',
   DATADOG_LAMBDA_EXTENSION_PATH: '/opt/extensions/datadog-agent',
   DECISION_MAKER_KEY: '_dd.p.dm',
+  SAMPLING_KNUTH_RATE: '_dd.p.ksr',
   PROCESS_ID: 'process_id',
   ERROR_TYPE: 'error.type',
   ERROR_MESSAGE: 'error.message',

package/packages/dd-trace/src/crashtracking/crashtracker.js

@@ -74,7 +74,7 @@ class Crashtracker {
         timeout_ms: 3000,
       },
       timeout: { secs: 5, nanos: 0 },
-      demangle_names: false,
+      demangle_names: true,
       signals: [],
       resolve_frames: resolveMode,
     }

package/packages/dd-trace/src/debugger/devtools_client/config.js

@@ -2,8 +2,11 @@
 
 const { workerData: { config: parentConfig, parentThreadId, configPort } } = require('node:worker_threads')
 const { getAgentUrl } = require('../../agent/url')
+const processTags = require('../../process-tags')
 const log = require('./log')
 
+processTags.initialize()
+
 const config = module.exports = {
   ...parentConfig,
   parentThreadId,

package/packages/dd-trace/src/dogstatsd.js

@@ -26,6 +26,7 @@ class DogStatsDClient {
   constructor (options = {}) {
     if (options.metricsProxyUrl) {
       this._httpOptions = {
+        method: 'POST',
         url: options.metricsProxyUrl.toString(),
         path: '/dogstatsd/v2/proxy',
       }

package/packages/dd-trace/src/llmobs/plugins/langchain/handlers/chain.js

@@ -15,6 +15,17 @@ class LangChainLLMObsChainHandler extends LangChainLLMObsHandler {
     // chain spans will always be workflows
     this._tagger.tagTextIO(span, input, output)
   }
+
+  getName ({ span, instance }) {
+    const firstCallable = instance?.first
+
+    if (firstCallable?.constructor?.name === 'ChannelWrite') return
+
+    const firstCallableIsLangGraph = firstCallable?.lc_namespace?.includes('langgraph')
+    const firstCallableName = firstCallable?.name
+
+    return firstCallableIsLangGraph ? firstCallableName : super.getName({ span })
+  }
 }
 
 module.exports = LangChainLLMObsChainHandler

package/packages/dd-trace/src/llmobs/plugins/langchain/index.js

@@ -54,6 +54,8 @@ class BaseLangChainLLMObsPlugin extends LLMObsPlugin {
     const handler = this._handlers[ctx.type]
     const name = handler?.getName({ span, instance })
 
+    if (name == null) return
+
     return {
       modelProvider,
       modelName,

package/packages/dd-trace/src/llmobs/plugins/langgraph/index.js

@@ -0,0 +1,114 @@
+'use strict'
+
+const LLMObsPlugin = require('../base')
+const { spanHasError } = require('../../util')
+
+const streamDataMap = new WeakMap()
+
+function formatIO (data) {
+  if (data == null) return ''
+
+  if (typeof data === 'string' || typeof data === 'number' || typeof data === 'boolean') {
+    return data
+  }
+
+  if (data.constructor?.name === 'Object') {
+    const formatted = {}
+    for (const [key, value] of Object.entries(data)) {
+      formatted[key] = formatIO(value)
+    }
+    return formatted
+  }
+
+  if (Array.isArray(data)) {
+    return data.map(item => formatIO(item))
+  }
+
+  try {
+    return JSON.stringify(data)
+  } catch {
+    return String(data)
+  }
+}
+
+class PregelStreamLLMObsPlugin extends LLMObsPlugin {
+  static id = 'llmobs_langgraph_pregel_stream'
+  static integration = 'langgraph'
+  static prefix = 'tracing:orchestrion:@langchain/langgraph:Pregel_stream'
+
+  getLLMObsSpanRegisterOptions (ctx) {
+    const name = ctx.self.name || 'LangGraph'
+
+    const enabled = this._tracerConfig.llmobs.enabled
+    if (!enabled) return
+
+    const span = ctx.currentStore?.span
+    if (!span) return
+    streamDataMap.set(span, {
+      streamInputs: ctx.arguments?.[0],
+      chunks: [],
+    })
+
+    return {
+      kind: 'workflow',
+      name,
+    }
+  }
+
+  asyncEnd () {}
+}
+
+class NextStreamLLMObsPlugin extends LLMObsPlugin {
+  static id = 'llmobs_langgraph_next_stream'
+  static prefix = 'tracing:orchestrion:@langchain/langgraph:Pregel_stream_next'
+
+  start () {} // no-op: span was already registered by PregelStreamLLMObsPlugin
+
+  end () {} // no-op: context restore is handled by PregelStreamLLMObsPlugin
+
+  error (ctx) {
+    const span = ctx.currentStore?.span
+    if (!span) return
+
+    this.#tagAndCleanup(span, true)
+  }
+
+  setLLMObsTags (ctx) {
+    const span = ctx.currentStore?.span
+    if (!span) return
+
+    // Accumulate chunks until done
+    if (ctx.result?.value && !ctx.result.done) {
+      const streamData = streamDataMap.get(span)
+      if (streamData) {
+        streamData.chunks.push(ctx.result.value)
+      }
+      return
+    }
+
+    // Tag on last chunk
+    if (ctx.result?.done) {
+      const hasError = ctx.error || spanHasError(span)
+      this.#tagAndCleanup(span, hasError)
+    }
+  }
+
+  #tagAndCleanup (span, hasError) {
+    const streamData = streamDataMap.get(span)
+    if (!streamData) return
+
+    const { streamInputs: inputs, chunks } = streamData
+    const input = inputs == null ? undefined : formatIO(inputs)
+    const lastChunk = chunks.length > 0 ? chunks[chunks.length - 1] : undefined
+    const output = !hasError && lastChunk != null ? formatIO(lastChunk) : undefined
+
+    this._tagger.tagTextIO(span, input, output)
+
+    streamDataMap.delete(span)
+  }
+}
+
+module.exports = [
+  PregelStreamLLMObsPlugin,
+  NextStreamLLMObsPlugin,
+]

package/packages/dd-trace/src/plugins/ci_plugin.js

@@ -125,7 +125,7 @@ module.exports = class CiPlugin extends Plugin {
     this._pendingRequestErrorTags = []
 
     this.addSub(`ci:${this.constructor.id}:library-configuration`, (ctx) => {
-      const { onDone, isParallel, frameworkVersion } = ctx
+      const { onDone, frameworkVersion } = ctx
       ctx.currentStore = storage('legacy').getStore()
 
       if (!this.tracer._exporter || !this.tracer._exporter.getLibraryConfiguration) {
@@ -143,7 +143,7 @@ module.exports = class CiPlugin extends Plugin {
           ? getSessionRequestErrorTags(this.testSessionSpan)
           : Object.fromEntries(this._pendingRequestErrorTags.map(({ tag, value }) => [tag, value]))
 
-        const libraryCapabilitiesTags = getLibraryCapabilitiesTags(this.constructor.id, isParallel, frameworkVersion)
+        const libraryCapabilitiesTags = getLibraryCapabilitiesTags(this.constructor.id, frameworkVersion)
         const metadataTags = {
           test: {
             ...libraryCapabilitiesTags,

package/packages/dd-trace/src/plugins/index.js

@@ -31,6 +31,7 @@ const plugins = {
   get '@redis/client' () { return require('../../../datadog-plugin-redis/src') },
   get '@smithy/smithy-client' () { return require('../../../datadog-plugin-aws-sdk/src') },
   get '@vitest/runner' () { return require('../../../datadog-plugin-vitest/src') },
+  get '@langchain/langgraph' () { return require('../../../datadog-plugin-langgraph/src') },
   get aerospike () { return require('../../../datadog-plugin-aerospike/src') },
   get ai () { return require('../../../datadog-plugin-ai/src') },
   get amqp10 () { return require('../../../datadog-plugin-amqp10/src') },

package/packages/dd-trace/src/plugins/util/test.js

@@ -150,7 +150,6 @@ const DD_CAPABILITIES_FAILED_TEST_REPLAY = '_dd.library_capabilities.failed_test
 const DD_CI_LIBRARY_CONFIGURATION_ERROR = '_dd.ci.library_configuration_error'
 
 const UNSUPPORTED_TIA_FRAMEWORKS = new Set(['playwright', 'vitest'])
-const UNSUPPORTED_TIA_FRAMEWORKS_PARALLEL_MODE = new Set(['cucumber', 'mocha'])
 const MINIMUM_FRAMEWORK_VERSION_FOR_EFD = {
   playwright: '>=1.38.0',
 }
@@ -170,7 +169,6 @@ const MINIMUM_FRAMEWORK_VERSION_FOR_FAILED_TEST_REPLAY = {
   playwright: '>=1.38.0',
 }
 
-const UNSUPPORTED_ATTEMPT_TO_FIX_FRAMEWORKS_PARALLEL_MODE = new Set(['mocha'])
 const NOT_SUPPORTED_GRANULARITY_IMPACTED_TESTS_FRAMEWORKS = new Set(['mocha', 'playwright', 'vitest'])
 
 const TEST_LEVEL_EVENT_TYPES = [
@@ -987,9 +985,8 @@ function getFormattedError (error, repositoryRoot) {
   return newError
 }
 
-function isTiaSupported (testFramework, isParallel) {
-  return !(UNSUPPORTED_TIA_FRAMEWORKS.has(testFramework) ||
-           (isParallel && UNSUPPORTED_TIA_FRAMEWORKS_PARALLEL_MODE.has(testFramework)))
+function isTiaSupported (testFramework) {
+  return !UNSUPPORTED_TIA_FRAMEWORKS.has(testFramework)
 }
 
 function isEarlyFlakeDetectionSupported (testFramework, frameworkVersion) {
@@ -1016,12 +1013,12 @@ function isDisableSupported (testFramework, frameworkVersion) {
     : true
 }
 
-function isAttemptToFixSupported (testFramework, isParallel, frameworkVersion) {
+function isAttemptToFixSupported (testFramework, frameworkVersion) {
   if (testFramework === 'playwright') {
     return satisfies(frameworkVersion, MINIMUM_FRAMEWORK_VERSION_FOR_ATTEMPT_TO_FIX[testFramework])
   }
 
-  return !(isParallel && UNSUPPORTED_ATTEMPT_TO_FIX_FRAMEWORKS_PARALLEL_MODE.has(testFramework))
+  return true
 }
 
 function isFailedTestReplaySupported (testFramework, frameworkVersion) {
@@ -1030,9 +1027,9 @@ function isFailedTestReplaySupported (testFramework, frameworkVersion) {
     : true
 }
 
-function getLibraryCapabilitiesTags (testFramework, isParallel, frameworkVersion) {
+function getLibraryCapabilitiesTags (testFramework, frameworkVersion) {
   return {
-    [DD_CAPABILITIES_TEST_IMPACT_ANALYSIS]: isTiaSupported(testFramework, isParallel)
+    [DD_CAPABILITIES_TEST_IMPACT_ANALYSIS]: isTiaSupported(testFramework)
       ? '1'
       : undefined,
     [DD_CAPABILITIES_EARLY_FLAKE_DETECTION]: isEarlyFlakeDetectionSupported(testFramework, frameworkVersion)
@@ -1049,7 +1046,7 @@ function getLibraryCapabilitiesTags (testFramework, isParallel, frameworkVersion
       ? '1'
       : undefined,
     [DD_CAPABILITIES_TEST_MANAGEMENT_ATTEMPT_TO_FIX]:
-      isAttemptToFixSupported(testFramework, isParallel, frameworkVersion)
+      isAttemptToFixSupported(testFramework, frameworkVersion)
         ? '5'
         : undefined,
     [DD_CAPABILITIES_FAILED_TEST_REPLAY]: isFailedTestReplaySupported(testFramework, frameworkVersion)

package/packages/dd-trace/src/priority_sampler.js

@@ -31,10 +31,21 @@ const {
   SAMPLING_LIMIT_DECISION,
   SAMPLING_AGENT_DECISION,
   DECISION_MAKER_KEY,
+  SAMPLING_KNUTH_RATE,
 } = require('./constants')
 
 const DEFAULT_KEY = 'service:,env:'
 
+/**
+ * Formats a sampling rate as a string with up to 6 significant digits and no trailing zeros.
+ *
+ * @param {number} rate
+ * @returns {string}
+ */
+function formatKnuthRate (rate) {
+  return Number(rate.toPrecision(6)).toString()
+}
+
 const defaultSampler = new Sampler(AUTO_KEEP)
 
 /**
@@ -254,6 +265,7 @@ class PrioritySampler {
    */
   #getPriorityByRule (context, rule) {
     context._trace[SAMPLING_RULE_DECISION] = rule.sampleRate
+    context._trace.tags[SAMPLING_KNUTH_RATE] = formatKnuthRate(rule.sampleRate)
     context._sampling.mechanism = SAMPLING_MECHANISM_RULE
     if (rule.provenance === 'customer') context._sampling.mechanism = SAMPLING_MECHANISM_REMOTE_USER
     if (rule.provenance === 'dynamic') context._sampling.mechanism = SAMPLING_MECHANISM_REMOTE_DYNAMIC
@@ -290,9 +302,15 @@ class PrioritySampler {
     // TODO: Change underscored properties to private ones.
     const sampler = this._samplers[key] || this._samplers[DEFAULT_KEY]
 
-    context._trace[SAMPLING_AGENT_DECISION] = sampler.rate()
+    const rate = sampler.rate()
+    context._trace[SAMPLING_AGENT_DECISION] = rate
 
-    context._sampling.mechanism = sampler === defaultSampler ? SAMPLING_MECHANISM_DEFAULT : SAMPLING_MECHANISM_AGENT
+    if (sampler === defaultSampler) {
+      context._sampling.mechanism = SAMPLING_MECHANISM_DEFAULT
+    } else {
+      context._trace.tags[SAMPLING_KNUTH_RATE] = formatKnuthRate(rate)
+      context._sampling.mechanism = SAMPLING_MECHANISM_AGENT
+    }
 
     return sampler.isSampled(context) ? AUTO_KEEP : AUTO_REJECT
   }

package/packages/dd-trace/src/process-tags/index.js

@@ -12,8 +12,19 @@ const ENTRYPOINT_PATH = require.main?.filename || ''
 // entrypoint.basedir = baz
 // package.json.name = <from package.json>
 
-// process tags are constant throughout the lifetime of a process
-function getProcessTags () {
+/**
+ * Sanitize a process tag value
+ *
+ * @param {string} value
+ * @returns {string}
+ */
+function sanitize (value) {
+  return String(value)
+    .toLowerCase()
+    .replaceAll(/[^a-zA-Z0-9/_.-]+/g, '_')
+}
+
+function buildProcessTags (config) {
   // Lazy load pkg to avoid issues with require.main during test initialization
   const pkg = require('../pkg')
 
@@ -35,6 +46,13 @@ function getProcessTags () {
     ['package.json.name', pkg.name || undefined],
   ]
 
+  // If config dependent tags keep growing, we should consider moving this into a function
+  if (config?.isServiceNameInferred) {
+    tags.push(['svc.auto', config.service])
+  } else if (config) {
+    tags.push(['svc.user', true])
+  }
+
   const tagsArray = []
   const tagsObject = {}
 
@@ -46,38 +64,27 @@ function getProcessTags () {
     }
   }
 
-  const serialized = tagsArray.join(',')
-
-  return {
-    tags,
-    serialized,
-    tagsObject,
-    tagsArray,
-  }
+  processTags.tags = tags
+  processTags.serialized = tagsArray.join(',')
+  processTags.tagsObject = tagsObject
+  processTags.tagsArray = tagsArray
 }
 
-// Export the singleton
-module.exports = getProcessTags()
-
-module.exports.TRACING_FIELD_NAME = '_dd.tags.process'
-module.exports.DSM_FIELD_NAME = 'ProcessTags'
-module.exports.PROFILING_FIELD_NAME = 'process_tags'
-module.exports.DYNAMIC_INSTRUMENTATION_FIELD_NAME = 'process_tags'
-module.exports.TELEMETRY_FIELD_NAME = 'process_tags'
-module.exports.REMOTE_CONFIG_FIELD_NAME = 'process_tags'
-module.exports.CRASH_TRACKING_FIELD_NAME = 'process_tags'
-module.exports.CLIENT_TRACE_STATISTICS_FIELD_NAME = 'ProcessTags'
-
-/**
- * Sanitize a process tag value
- *
- * @param {string} value
- * @returns {string}
- */
-function sanitize (value) {
-  return String(value)
-    .toLowerCase()
-    .replaceAll(/[^a-zA-Z0-9/_.-]+/g, '_')
+// Singleton with constant defaults so pre-init reads don't blow up
+const processTags = module.exports = {
+  initialize (config) {
+    // check if one of the properties added during build exist and if so return
+    if (processTags.tags) return
+    buildProcessTags(config)
+  },
+
+  TRACING_FIELD_NAME: '_dd.tags.process',
+  DSM_FIELD_NAME: 'ProcessTags',
+  PROFILING_FIELD_NAME: 'process_tags',
+  DYNAMIC_INSTRUMENTATION_FIELD_NAME: 'process_tags',
+  TELEMETRY_FIELD_NAME: 'process_tags',
+  REMOTE_CONFIG_FIELD_NAME: 'process_tags',
+  CRASH_TRACKING_FIELD_NAME: 'process_tags',
+  CLIENT_TRACE_STATISTICS_FIELD_NAME: 'ProcessTags',
+  sanitize,
 }
-
-module.exports.sanitize = sanitize

package/packages/dd-trace/src/profiling/profilers/wall.js

@@ -290,7 +290,15 @@ class NativeWallProfiler {
       }
 
       profilingContext = { spanId, rootSpanId, webTags }
-      span[ProfilingContext] = profilingContext
+      // Don't cache if endpoint collection is enabled and webTags is undefined but
+      // the span's type hasn't been set yet. TracingPlugin.startSpan() calls
+      // enterWith() before the plugin sets span.type='web' via addRequestTags(),
+      // so the first enterCh event fires before the type is known. Without this
+      // guard we'd cache webTags=undefined and then serve that stale value on the
+      // subsequent activation (when span.type='web' is already set).
+      if (!this.#endpointCollectionEnabled || webTags !== undefined || context._tags['span.type']) {
+        span[ProfilingContext] = profilingContext
+      }
     }
     return profilingContext
   }

package/packages/dd-trace/src/proxy.js

@@ -13,6 +13,7 @@ const nomenclature = require('./service-naming')
 const PluginManager = require('./plugin_manager')
 const NoopDogStatsDClient = require('./noop/dogstatsd')
 const { IS_SERVERLESS } = require('./serverless')
+const processTags = require('./process-tags')
 const {
   setBaggageItem,
   getBaggageItem,
@@ -102,6 +103,9 @@ class Tracer extends NoopProxy {
     try {
       const config = getConfig(options) // TODO: support dynamic code config
 
+      // Add config dependent process tags
+      processTags.initialize(config)
+
       // Configure propagation hash manager for process tags + container tags
       const propagationHash = require('./propagation-hash')
       propagationHash.configure(config)