dd-trace 5.69.0 → 5.71.0

package/index.d.ts

@@ -168,6 +168,7 @@ interface Plugins {
   "aerospike": tracer.plugins.aerospike;
   "amqp10": tracer.plugins.amqp10;
   "amqplib": tracer.plugins.amqplib;
+  "anthropic": tracer.plugins.anthropic;
   "apollo": tracer.plugins.apollo;
   "avsc": tracer.plugins.avsc;
   "aws-sdk": tracer.plugins.aws_sdk;
@@ -785,6 +786,8 @@ declare namespace tracer {
 
         /** Whether to enable request body collection on RASP event
          * @default false
+         *
+         * @deprecated Use UI and Remote Configuration to enable extended data collection
          */
         bodyCollection?: boolean
       },
@@ -809,20 +812,28 @@ declare namespace tracer {
       },
       /**
        * Configuration for extended headers collection tied to security events
+       *
+       * @deprecated Use UI and Remote Configuration to enable extended data collection
        */
       extendedHeadersCollection?: {
         /** Whether to enable extended headers collection
          * @default false
+         *
+         * @deprecated Use UI and Remote Configuration to enable extended data collection
          */
         enabled: boolean,
 
         /** Whether to redact collected headers
          * @default true
+         *
+         * @deprecated Use UI and Remote Configuration to enable extended data collection
          */
         redaction: boolean,
 
         /** Specifies the maximum number of headers collected.
          * @default 50
+         *
+         * @deprecated Use UI and Remote Configuration to enable extended data collection
          */
         maxHeaders: number,
       }
@@ -1530,6 +1541,12 @@ declare namespace tracer {
      */
     interface amqplib extends Instrumentation {}
 
+    /**
+     * This plugin automatically instruments the
+     * [anthropic](https://www.npmjs.com/package/@anthropic-ai/sdk) module.
+     */
+    interface anthropic extends Instrumentation {}
+
     /**
      * Currently this plugin automatically instruments
      * [@apollo/gateway](https://github.com/apollographql/federation) for module versions >= v2.3.0.

package/initialize.mjs

@@ -36,7 +36,13 @@ ${result.source}`
 const [NODE_MAJOR, NODE_MINOR] = process.versions.node.split('.').map(Number)
 
 const brokenLoaders = NODE_MAJOR === 18 && NODE_MINOR === 0
-const iitmExclusions = [/langsmith/, /openai\/_shims/, /openai\/resources\/chat\/completions\/messages/, /openai\/agents-core\/dist\/shims/]
+const iitmExclusions = [
+  /langsmith/,
+  /openai\/_shims/,
+  /openai\/resources\/chat\/completions\/messages/,
+  /openai\/agents-core\/dist\/shims/,
+  /@anthropic-ai\/sdk\/_shims/
+]
 
 export async function load (url, context, nextLoad) {
   const iitmExclusionsMatch = iitmExclusions.some((exclusion) => exclusion.test(url))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.69.0",
+  "version": "5.71.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -61,7 +61,7 @@
     "test:integration:playwright": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/playwright/*.spec.js\"",
     "test:integration:selenium": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/selenium/*.spec.js\"",
     "test:integration:vitest": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/vitest/*.spec.js\"",
-    "test:integration:testopt": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/ci-visibility/*.spec.js\"",
+    "test:integration:testopt": "mocha --timeout 90000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/ci-visibility/*.spec.js\"",
     "test:integration:profiler": "mocha --timeout 180000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/profiler/*.spec.js\"",
     "test:integration:plugins": "mocha -r \"packages/dd-trace/test/setup/mocha.js\" \"packages/datadog-plugin-@($(echo $PLUGINS))/test/integration-test/**/*.spec.js\"",
     "test:unit:plugins": "mocha -r \"packages/dd-trace/test/setup/mocha.js\" \"packages/datadog-instrumentations/test/@($(echo $PLUGINS)).spec.js\" \"packages/datadog-plugin-@($(echo $PLUGINS))/test/**/*.spec.js\" --exclude \"packages/datadog-plugin-@($(echo $PLUGINS))/test/integration-test/**/*.spec.js\"",

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

@@ -0,0 +1,115 @@
+'use strict'
+
+const { addHook } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+const { channel, tracingChannel } = require('dc-polyfill')
+
+const anthropicTracingChannel = tracingChannel('apm:anthropic:request')
+const onStreamedChunkCh = channel('apm:anthropic:request:chunk')
+
+function wrapStreamIterator (iterator, ctx) {
+  return function () {
+    const itr = iterator.apply(this, arguments)
+    shimmer.wrap(itr, 'next', next => function () {
+      return next.apply(this, arguments)
+        .then(res => {
+          const { done, value: chunk } = res
+          onStreamedChunkCh.publish({ ctx, chunk, done })
+
+          if (done) {
+            finish(ctx)
+          }
+
+          return res
+        })
+        .catch(error => {
+          finish(ctx, null, error)
+          throw error
+        })
+    })
+
+    return itr
+  }
+}
+
+function wrapCreate (create) {
+  return function () {
+    if (!anthropicTracingChannel.start.hasSubscribers) {
+      return create.apply(this, arguments)
+    }
+
+    const options = arguments[0]
+    const stream = options.stream
+
+    const ctx = { options, resource: 'create' }
+
+    return anthropicTracingChannel.start.runStores(ctx, () => {
+      let apiPromise
+      try {
+        apiPromise = create.apply(this, arguments)
+      } catch (error) {
+        finish(ctx, null, error)
+        throw error
+      }
+
+      shimmer.wrap(apiPromise, 'parse', parse => function () {
+        return parse.apply(this, arguments)
+          .then(response => {
+            if (stream) {
+              shimmer.wrap(response, Symbol.asyncIterator, iterator => wrapStreamIterator(iterator, ctx))
+            } else {
+              finish(ctx, response, null)
+            }
+
+            return response
+          }).catch(error => {
+            finish(ctx, null, error)
+            throw error
+          })
+      })
+
+      anthropicTracingChannel.end.publish(ctx)
+
+      return apiPromise
+    })
+  }
+}
+
+function finish (ctx, result, error) {
+  if (error) {
+    ctx.error = error
+    anthropicTracingChannel.error.publish(ctx)
+  }
+
+  // streamed responses are handled and set separately
+  ctx.result ??= result
+
+  anthropicTracingChannel.asyncEnd.publish(ctx)
+}
+
+const extensions = ['js', 'mjs']
+for (const extension of extensions) {
+  addHook({
+    name: '@anthropic-ai/sdk',
+    file: `resources/messages.${extension}`,
+    versions: ['>=0.14.0 <0.33.0']
+  }, exports => {
+    const Messages = exports.Messages
+
+    shimmer.wrap(Messages.prototype, 'create', wrapCreate)
+
+    return exports
+  })
+
+  addHook({
+    name: '@anthropic-ai/sdk',
+    file: `resources/messages/messages.${extension}`,
+    versions: ['>=0.33.0']
+  }, exports => {
+    const Messages = exports.Messages
+
+    shimmer.wrap(Messages.prototype, 'create', wrapCreate)
+
+    return exports
+  })
+}

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

@@ -1,6 +1,7 @@
 'use strict'
 
 module.exports = {
+  '@anthropic-ai/sdk': { esmFirst: true, fn: () => require('../anthropic') },
   '@apollo/server': () => require('../apollo-server'),
   '@apollo/gateway': () => require('../apollo'),
   'apollo-server-core': () => require('../apollo-server-core'),

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

@@ -11,12 +11,8 @@ const {
   getTestLineStart,
   getTestSuitePath,
   getTestParametersString,
-  addEfdStringToTestName,
-  removeEfdStringFromTestName,
   getIsFaultyEarlyFlakeDetection,
   JEST_WORKER_LOGS_PAYLOAD_CODE,
-  addAttemptToFixStringToTestName,
-  removeAttemptToFixStringFromTestName,
   getTestEndLine,
   isModifiedTest
 } = require('../../dd-trace/src/plugins/util/test')
@@ -92,6 +88,7 @@ const newTestsTestStatuses = new Map()
 const attemptToFixRetriedTestsStatuses = new Map()
 const wrappedWorkers = new WeakSet()
 const testSuiteMockedFiles = new Map()
+const testsToBeRetried = new Set()
 
 const BREAKPOINT_HIT_GRACE_PERIOD_MS = 200
 
@@ -146,6 +143,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
 
       const repositoryRoot = this.testEnvironmentOptions._ddRepositoryRoot
 
+      // TODO: could we grab testPath from `this.getVmContext().expect.getState()` instead?
+      // so we don't rely on context being passed (some custom test environment do not pass it)
       if (repositoryRoot) {
         this.testSourceFile = getTestSuitePath(context.testPath, repositoryRoot)
         this.repositoryRoot = repositoryRoot
@@ -209,19 +208,31 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       }
     }
 
-    getHasSnapshotTests () {
-      if (this.hasSnapshotTests !== undefined) {
-        return this.hasSnapshotTests
-      }
-      let hasSnapshotTests = true
+    /**
+     * Jest snapshot counter issue during test retries
+     *
+     * Problem:
+     * - Jest tracks snapshot calls using an internal counter per test name
+     * - Each `toMatchSnapshot()` call increments this counter
+     * - When a test is retried, it keeps the same name but the counter continues from where it left off
+     *
+     * Example Issue:
+     * Original test run creates: `exports["test can do multiple snapshots 1"] = "hello"`
+     * Retried test expects:      `exports["test can do multiple snapshots 2"] = "hello"`
+     *
+     * This mismatch causes snapshot tests to fail on retry because Jest is looking
+     * for the wrong snapshot number. The solution is to reset the snapshot state.
+     */
+    resetSnapshotState () {
       try {
-        const { _snapshotData } = this.getVmContext().expect.getState().snapshotState
-        hasSnapshotTests = Object.keys(_snapshotData).length > 0
-      } catch {
-        // if we can't be sure, we'll err on the side of caution and assume it has snapshots
+        const expectGlobal = this.getVmContext().expect
+        const { snapshotState: { _counters: counters } } = expectGlobal.getState()
+        if (counters) {
+          counters.clear()
+        }
+      } catch (e) {
+        log.warn('Error resetting snapshot state', e)
       }
-      this.hasSnapshotTests = hasSnapshotTests
-      return hasSnapshotTests
     }
 
     // This function returns an array if the known tests are valid and null otherwise.
@@ -293,18 +304,15 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
     }
 
     // Generic function to handle test retries
-    retryTest (testName, retryCount, addRetryStringToTestName, retryType, event) {
-      // Retrying snapshots has proven to be problematic, so we'll skip them for now
-      // We'll still detect new tests, but we won't retry them.
-      // TODO: do not bail out of retrying tests for the whole test suite
-      if (this.getHasSnapshotTests()) {
-        log.warn('%s is disabled for suites with snapshots', retryType)
-        return
-      }
-
+    retryTest ({
+      jestEvent,
+      retryCount,
+      retryType
+    }) {
+      const { testName, fn, timeout } = jestEvent
       for (let retryIndex = 0; retryIndex < retryCount; retryIndex++) {
         if (this.global.test) {
-          this.global.test(addRetryStringToTestName(testName, retryIndex), event.fn, event.timeout)
+          this.global.test(testName, fn, timeout)
         } else {
           log.error('%s could not retry test because global.test is undefined', retryType)
         }
@@ -314,8 +322,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
     // At the `add_test` event we don't have the test object yet, so we can't use it
     getTestNameFromAddTestEvent (event, state) {
       const describeSuffix = getJestTestName(state.currentDescribeBlock)
-      const fullTestName = describeSuffix ? `${describeSuffix} ${event.testName}` : event.testName
-      return removeAttemptToFixStringFromTestName(removeEfdStringFromTestName(fullTestName))
+      return describeSuffix ? `${describeSuffix} ${event.testName}` : event.testName
     }
 
     async handleTestEvent (event, state) {
@@ -337,25 +344,27 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         })
       }
       if (event.name === 'test_start') {
+        const testName = getJestTestName(event.test)
+        if (testsToBeRetried.has(testName)) {
+          // This is needed because we're trying tests with the same name
+          this.resetSnapshotState()
+        }
+
         let isNewTest = false
         let numEfdRetry = null
         let numOfAttemptsToFixRetries = null
         const testParameters = getTestParametersString(this.nameToParams, event.test.name)
-        // Async resource for this test is created here
-        // It is used later on by the test_done handler
-        const testName = getJestTestName(event.test)
-        const originalTestName = removeEfdStringFromTestName(removeAttemptToFixStringFromTestName(testName))
 
         let isAttemptToFix = false
         let isDisabled = false
         let isQuarantined = false
         if (this.isTestManagementTestsEnabled) {
-          isAttemptToFix = this.testManagementTestsForThisSuite?.attemptToFix?.includes(originalTestName)
-          isDisabled = this.testManagementTestsForThisSuite?.disabled?.includes(originalTestName)
-          isQuarantined = this.testManagementTestsForThisSuite?.quarantined?.includes(originalTestName)
+          isAttemptToFix = this.testManagementTestsForThisSuite?.attemptToFix?.includes(testName)
+          isDisabled = this.testManagementTestsForThisSuite?.disabled?.includes(testName)
+          isQuarantined = this.testManagementTestsForThisSuite?.quarantined?.includes(testName)
           if (isAttemptToFix) {
-            numOfAttemptsToFixRetries = retriedTestsToNumAttempts.get(originalTestName)
-            retriedTestsToNumAttempts.set(originalTestName, numOfAttemptsToFixRetries + 1)
+            numOfAttemptsToFixRetries = retriedTestsToNumAttempts.get(testName)
+            retriedTestsToNumAttempts.set(testName, numOfAttemptsToFixRetries + 1)
           } else if (isDisabled) {
             event.test.mode = 'skip'
           }
@@ -375,17 +384,17 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         }
 
         if (this.isKnownTestsEnabled) {
-          isNewTest = retriedTestsToNumAttempts.has(originalTestName)
+          isNewTest = retriedTestsToNumAttempts.has(testName)
         }
 
         if (this.isEarlyFlakeDetectionEnabled && (isNewTest || isModified)) {
-          numEfdRetry = retriedTestsToNumAttempts.get(originalTestName)
-          retriedTestsToNumAttempts.set(originalTestName, numEfdRetry + 1)
+          numEfdRetry = retriedTestsToNumAttempts.get(testName)
+          retriedTestsToNumAttempts.set(testName, numEfdRetry + 1)
         }
 
         const isJestRetry = event.test?.invocations > 1
         const ctx = {
-          name: originalTestName,
+          name: testName,
           suite: this.testSuite,
           testSourceFile: this.testSourceFile,
           displayName: this.displayName,
@@ -431,24 +440,22 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       }
 
       if (event.name === 'add_test') {
-        const originalTestName = this.getTestNameFromAddTestEvent(event, state)
-
         if (event.failing) {
           return
         }
 
+        const testFullName = this.getTestNameFromAddTestEvent(event, state)
         const isSkipped = event.mode === 'todo' || event.mode === 'skip'
         if (this.isTestManagementTestsEnabled) {
-          const isAttemptToFix = this.testManagementTestsForThisSuite?.attemptToFix?.includes(originalTestName)
-          if (isAttemptToFix && !isSkipped && !retriedTestsToNumAttempts.has(originalTestName)) {
-            retriedTestsToNumAttempts.set(originalTestName, 0)
-            this.retryTest(
-              event.testName,
-              testManagementAttemptToFixRetries,
-              addAttemptToFixStringToTestName,
-              'Test Management (Attempt to Fix)',
-              event
-            )
+          const isAttemptToFix = this.testManagementTestsForThisSuite?.attemptToFix?.includes(testFullName)
+          if (isAttemptToFix && !isSkipped && !retriedTestsToNumAttempts.has(testFullName)) {
+            retriedTestsToNumAttempts.set(testFullName, 0)
+            testsToBeRetried.add(testFullName)
+            this.retryTest({
+              jestEvent: event,
+              retryCount: testManagementAttemptToFixRetries,
+              retryType: 'Test Management (Attempt to Fix)'
+            })
           }
         }
         if (this.isImpactedTestsEnabled) {
@@ -461,29 +468,27 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             this.modifiedTestsForThisSuite,
             'jest'
           )
-          if (isModified && !retriedTestsToNumAttempts.has(originalTestName) && this.isEarlyFlakeDetectionEnabled) {
-            retriedTestsToNumAttempts.set(originalTestName, 0)
-            this.retryTest(
-              event.testName,
-              earlyFlakeDetectionNumRetries,
-              addEfdStringToTestName,
-              'Early flake detection',
-              event
-            )
+          if (isModified && !retriedTestsToNumAttempts.has(testFullName) && this.isEarlyFlakeDetectionEnabled) {
+            retriedTestsToNumAttempts.set(testFullName, 0)
+            testsToBeRetried.add(testFullName)
+            this.retryTest({
+              jestEvent: event,
+              retryCount: earlyFlakeDetectionNumRetries,
+              retryType: 'Impacted tests'
+            })
           }
         }
         if (this.isKnownTestsEnabled) {
-          const isNew = !this.knownTestsForThisSuite.includes(originalTestName)
-          if (isNew && !isSkipped && !retriedTestsToNumAttempts.has(originalTestName)) {
-            retriedTestsToNumAttempts.set(originalTestName, 0)
+          const isNew = !this.knownTestsForThisSuite.includes(testFullName)
+          if (isNew && !isSkipped && !retriedTestsToNumAttempts.has(testFullName)) {
+            retriedTestsToNumAttempts.set(testFullName, 0)
             if (this.isEarlyFlakeDetectionEnabled) {
-              this.retryTest(
-                event.testName,
-                earlyFlakeDetectionNumRetries,
-                addEfdStringToTestName,
-                'Early flake detection',
-                event
-              )
+              testsToBeRetried.add(testFullName)
+              this.retryTest({
+                jestEvent: event,
+                retryCount: earlyFlakeDetectionNumRetries,
+                retryType: 'Early flake detection'
+              })
             }
           }
         }
@@ -502,15 +507,14 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         let isAttemptToFix = false
         if (this.isTestManagementTestsEnabled) {
           const testName = getJestTestName(event.test)
-          const originalTestName = removeAttemptToFixStringFromTestName(testName)
-          isAttemptToFix = this.testManagementTestsForThisSuite?.attemptToFix?.includes(originalTestName)
+          isAttemptToFix = this.testManagementTestsForThisSuite?.attemptToFix?.includes(testName)
           if (isAttemptToFix) {
-            if (attemptToFixRetriedTestsStatuses.has(originalTestName)) {
-              attemptToFixRetriedTestsStatuses.get(originalTestName).push(status)
+            if (attemptToFixRetriedTestsStatuses.has(testName)) {
+              attemptToFixRetriedTestsStatuses.get(testName).push(status)
             } else {
-              attemptToFixRetriedTestsStatuses.set(originalTestName, [status])
+              attemptToFixRetriedTestsStatuses.set(testName, [status])
             }
-            const testStatuses = attemptToFixRetriedTestsStatuses.get(originalTestName)
+            const testStatuses = attemptToFixRetriedTestsStatuses.get(testName)
             // Check if this is the last attempt to fix.
             // If it is, we'll set the failedAllTests flag to true if all the tests failed
             // If all tests passed, we'll set the attemptToFixPassed flag to true
@@ -531,14 +535,13 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         // We'll store the test statuses of the retries
         if (this.isKnownTestsEnabled) {
           const testName = getJestTestName(event.test)
-          const originalTestName = removeEfdStringFromTestName(testName)
-          const isNewTest = retriedTestsToNumAttempts.has(originalTestName)
+          const isNewTest = retriedTestsToNumAttempts.has(testName)
           if (isNewTest) {
-            if (newTestsTestStatuses.has(originalTestName)) {
-              newTestsTestStatuses.get(originalTestName).push(status)
+            if (newTestsTestStatuses.has(testName)) {
+              newTestsTestStatuses.get(testName).push(status)
               isEfdRetry = true
             } else {
-              newTestsTestStatuses.set(originalTestName, [status])
+              newTestsTestStatuses.set(testName, [status])
             }
           }
         }
@@ -951,13 +954,12 @@ function getCliWrapper (isNewJestVersion) {
 
         for (const { testName, testSuiteAbsolutePath } of failedTests) {
           const testSuite = getTestSuitePath(testSuiteAbsolutePath, result.globalConfig.rootDir)
-          const originalName = removeAttemptToFixStringFromTestName(testName)
           const testManagementTest = testManagementTests
             ?.jest
             ?.suites
             ?.[testSuite]
             ?.tests
-            ?.[originalName]
+            ?.[testName]
             ?.properties
           // This uses `attempt_to_fix` because this is always the main process and it's not formatted in camelCase
           if (testManagementTest?.attempt_to_fix && (testManagementTest?.quarantined || testManagementTest?.disabled)) {

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

@@ -1,12 +1,6 @@
 'use strict'
 
-const {
-  getTestSuitePath,
-  removeEfdStringFromTestName,
-  addEfdStringToTestName,
-  addAttemptToFixStringToTestName,
-  removeAttemptToFixStringFromTestName
-} = require('../../../dd-trace/src/plugins/util/test')
+const { getTestSuitePath } = require('../../../dd-trace/src/plugins/util/test')
 const { channel } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 
@@ -60,17 +54,15 @@ function isNewTest (test, knownTests) {
     return false
   }
   const testSuite = getTestSuitePath(test.file, process.cwd())
-  const testName = removeEfdStringFromTestName(test.fullTitle())
+  const testName = test.fullTitle()
   const testsForSuite = knownTests.mocha?.[testSuite] || []
   return !testsForSuite.includes(testName)
 }
 
-function retryTest (test, numRetries, modifyTestName, tags) {
-  const originalTestName = test.title
+function retryTest (test, numRetries, tags) {
   const suite = test.parent
   for (let retryIndex = 0; retryIndex < numRetries; retryIndex++) {
     const clonedTest = test.clone()
-    clonedTest.title = modifyTestName(originalTestName, retryIndex + 1)
     suite.addTest(clonedTest)
     tags.forEach(tag => {
       if (tag) {
@@ -113,10 +105,7 @@ function getIsLastRetry (test) {
 }
 
 function getTestFullName (test) {
-  const testName = removeEfdStringFromTestName(
-    removeAttemptToFixStringFromTestName(test.fullTitle())
-  )
-  return `mocha.${getTestSuitePath(test.file, process.cwd())}.${testName}`
+  return `mocha.${getTestSuitePath(test.file, process.cwd())}.${test.fullTitle()}`
 }
 
 function getTestStatus (test) {
@@ -216,10 +205,8 @@ function getOnTestHandler (isMain) {
       _ddIsModified: isModified
     } = test
 
-    const testName = removeEfdStringFromTestName(removeAttemptToFixStringFromTestName(test.fullTitle()))
-
     const testInfo = {
-      testName,
+      testName: test.fullTitle(),
       testSuiteAbsolutePath,
       title,
       testStartLine
@@ -445,7 +432,6 @@ function getRunTestsWrapper (runTests, config) {
           retryTest(
             test,
             config.testManagementAttemptToFixRetries,
-            addAttemptToFixStringToTestName,
             ['_ddIsAttemptToFix', isDisabled && '_ddIsDisabled', isQuarantined && '_ddIsQuarantined']
           )
         } else if (isDisabled) {
@@ -469,7 +455,6 @@ function getRunTestsWrapper (runTests, config) {
                 retryTest(
                   test,
                   config.earlyFlakeDetectionNumRetries,
-                  addEfdStringToTestName,
                   ['_ddIsModified', '_ddIsEfdRetry']
                 )
               }
@@ -488,7 +473,6 @@ function getRunTestsWrapper (runTests, config) {
             retryTest(
               test,
               config.earlyFlakeDetectionNumRetries,
-              addEfdStringToTestName,
               ['_ddIsNew', '_ddIsEfdRetry']
             )
           }

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

@@ -772,7 +772,10 @@ addHook({
     if (!isKnownTestsEnabled && !isTestManagementTestsEnabled && !isImpactedTestsEnabled) {
       return oldCreateRootSuite.apply(this, arguments)
     }
-    const rootSuite = await oldCreateRootSuite.apply(this, arguments)
+
+    const createRootSuiteReturnValue = await oldCreateRootSuite.apply(this, arguments)
+    // From v1.56.0 on, createRootSuite returns `{ rootSuite, topLevelProjects }`
+    const rootSuite = createRootSuiteReturnValue.rootSuite || createRootSuiteReturnValue
 
     const allTests = rootSuite.allTests()
 
@@ -861,7 +864,7 @@ addHook({
       }
     }
 
-    return rootSuite
+    return createRootSuiteReturnValue
   }
 
   // We need to proxy the createRootSuite function because the function is not configurable

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

@@ -0,0 +1,17 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const AnthropicTracingPlugin = require('./tracing')
+const AnthropicLLMObsPlugin = require('../../dd-trace/src/llmobs/plugins/anthropic')
+
+class AnthropicPlugin extends CompositePlugin {
+  static id = 'anthropic'
+  static get plugins () {
+    return {
+      llmobs: AnthropicLLMObsPlugin,
+      tracing: AnthropicTracingPlugin
+    }
+  }
+}
+
+module.exports = AnthropicPlugin

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

@@ -0,0 +1,30 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+
+class AnthropicTracingPlugin extends TracingPlugin {
+  static id = 'anthropic'
+  static operation = 'request'
+  static system = 'anthropic'
+  static prefix = 'tracing:apm:anthropic:request'
+
+  bindStart (ctx) {
+    const { resource, options } = ctx
+
+    this.startSpan('anthropic.request', {
+      meta: {
+        'resource.name': `Messages.${resource}`,
+        'anthropic.request.model': options.model
+      }
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  asyncEnd (ctx) {
+    const span = ctx.currentStore?.span
+    span?.finish()
+  }
+}
+
+module.exports = AnthropicTracingPlugin