dd-trace 5.101.0 → 5.102.0

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

@@ -35,7 +35,7 @@ function wrapAddCommand (addCommand) {
 }
 
 function wrapCommandQueueClass (cls) {
-  const ret = class RedisCommandQueue extends cls {
+  return class RedisCommandQueue extends cls {
     constructor (...args) {
       super(...args)
       let url = { host: 'localhost', port: 6379 }
@@ -50,7 +50,6 @@ function wrapCommandQueueClass (cls) {
       instanceInfo.set(this, { connectionName: createClientName, url })
     }
   }
-  return ret
 }
 
 function wrapCreateClient (request) {

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

@@ -72,11 +72,11 @@ function wrapFn (fn) {
 }
 
 function wrapNext (req, next) {
-  return shimmer.wrapFunction(next, next => function () {
+  return shimmer.wrapFunction(next, next => function (...args) {
     nextChannel.publish({ req })
     finishChannel.publish({ req })
 
-    next.apply(this, arguments)
+    next.apply(this, args)
   })
 }
 

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

@@ -45,17 +45,17 @@ function createWrapRouterMethod (name, compile) {
   function wrapLayerHandle (layer, original) {
     original._name = original._name || layer.name
 
-    return shimmer.wrapFunction(original, original => function () {
-      if (!enterChannel.hasSubscribers) return original.apply(this, arguments)
+    return shimmer.wrapFunction(original, original => function (...args) {
+      if (!enterChannel.hasSubscribers) return original.apply(this, args)
 
       const matchers = getLayerMatchers(layer)
-      const lastIndex = arguments.length - 1
+      const lastIndex = args.length - 1
       const name = original._name || original.name
-      const req = arguments[arguments.length > 3 ? 1 : 0]
-      const next = arguments[lastIndex]
+      const req = args[args.length > 3 ? 1 : 0]
+      const next = args[lastIndex]
 
       if (typeof next === 'function') {
-        arguments[lastIndex] = wrapNext(req, next)
+        args[lastIndex] = wrapNext(req, next)
       }
 
       let route
@@ -77,7 +77,7 @@ function createWrapRouterMethod (name, compile) {
       enterChannel.publish({ name, req, route, layer })
 
       try {
-        return original.apply(this, arguments)
+        return original.apply(this, args)
       } catch (error) {
         errorChannel.publish({ req, error })
         nextChannel.publish({ req })
@@ -251,8 +251,8 @@ addHook({ name: 'router', versions: ['>=2'] }, Router => {
   const wrapRouterMethod = createWrapRouterMethod('router', getCompileToRegexp())
 
   const WrappedRouter = shimmer.wrapFunction(Router, function (originalRouter) {
-    return function wrappedMethod () {
-      const router = originalRouter.apply(this, arguments)
+    return function wrappedMethod (...args) {
+      const router = originalRouter.apply(this, args)
 
       shimmer.wrap(router, 'handle', function wrapHandle (originalHandle) {
         return function wrappedHandle (req, res, next) {
@@ -310,8 +310,8 @@ addHook({
 })
 
 function wrapParam (original) {
-  return function wrappedProcessParams () {
-    arguments[1] = shimmer.wrapFunction(arguments[1], (originalFn) => {
+  return function wrappedProcessParams (...args) {
+    args[1] = shimmer.wrapFunction(args[1], (originalFn) => {
       return function wrappedFn (req, res) {
         if (routerParamStartCh.hasSubscribers && Object.keys(req.params).length && !visitedParams.has(req.params)) {
           visitedParams.add(req.params)
@@ -332,7 +332,7 @@ function wrapParam (original) {
       }
     })
 
-    return original.apply(this, arguments)
+    return original.apply(this, args)
   }
 }
 

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

@@ -8,8 +8,8 @@ const paymentIntentCreateFinishCh = channel('datadog:stripe:paymentIntent:create
 const constructEventFinishCh = channel('datadog:stripe:constructEvent:finish')
 
 function wrapSessionCreate (create) {
-  return function wrappedSessionCreate () {
-    const promise = create.apply(this, arguments)
+  return function wrappedSessionCreate (...args) {
+    const promise = create.apply(this, args)
 
     if (!checkoutSessionCreateFinishCh.hasSubscribers) return promise
 
@@ -21,8 +21,8 @@ function wrapSessionCreate (create) {
 }
 
 function wrapPaymentIntentCreate (create) {
-  return function wrappedPaymentIntentCreate () {
-    const promise = create.apply(this, arguments)
+  return function wrappedPaymentIntentCreate (...args) {
+    const promise = create.apply(this, args)
 
     if (!paymentIntentCreateFinishCh.hasSubscribers) return promise
 
@@ -34,8 +34,8 @@ function wrapPaymentIntentCreate (create) {
 }
 
 function wrapConstructEvent (constructEvent) {
-  return function wrappedConstructEvent () {
-    const result = constructEvent.apply(this, arguments)
+  return function wrappedConstructEvent (...args) {
+    const result = constructEvent.apply(this, args)
 
     // no need to check for hasSubscribers,
     // if it's false, the publish function will be noop
@@ -46,8 +46,8 @@ function wrapConstructEvent (constructEvent) {
 }
 
 function wrapConstructEventAsync (constructEventAsync) {
-  return function wrappedConstructEventAsync () {
-    const promise = constructEventAsync.apply(this, arguments)
+  return function wrappedConstructEventAsync (...args) {
+    const promise = constructEventAsync.apply(this, args)
 
     if (!constructEventFinishCh.hasSubscribers) return promise
 
@@ -77,8 +77,8 @@ function instrumentStripeInstance (stripe) {
 // returns nothing; without 'new' it delegates to 'new Stripe(...)' and returns
 // that result. We need to instrument whichever object actually got populated
 function wrapLegacyStripe (Stripe) {
-  return function wrappedStripe () {
-    const result = Stripe.apply(this, arguments)
+  return function wrappedStripe (...args) {
+    const result = Stripe.apply(this, args)
     const stripe = this instanceof Stripe ? this : result
     instrumentStripeInstance(stripe)
     return stripe
@@ -88,8 +88,8 @@ function wrapLegacyStripe (Stripe) {
 // stripe >=22: the constructor is a factory that always returns a fresh Stripe
 // instance regardless of 'new', so we just instrument and forward the result
 function wrapStripe (Stripe) {
-  return function wrappedStripe () {
-    const stripe = Stripe.apply(this, arguments)
+  return function wrappedStripe (...args) {
+    const stripe = Stripe.apply(this, args)
     instrumentStripeInstance(stripe)
     return stripe
   }

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

@@ -4,6 +4,7 @@
 const realSetTimeout = setTimeout
 
 const path = require('node:path')
+const { performance } = require('node:perf_hooks')
 
 const shimmer = require('../../datadog-shimmer')
 const log = require('../../dd-trace/src/log')
@@ -12,6 +13,8 @@ const {
   VITEST_WORKER_LOGS_PAYLOAD_CODE,
   DYNAMIC_NAME_RE,
   getTestSuitePath,
+  getEfdRetryCount,
+  getMaxEfdRetryCount,
   recordAttemptToFixExecution,
   collectTestOptimizationSummariesFromTraces,
   logAttemptToFixTestExecution,
@@ -61,6 +64,10 @@ const disabledTasks = new WeakSet()
 const quarantinedTasks = new WeakSet()
 const attemptToFixTasks = new WeakSet()
 const modifiedTasks = new WeakSet()
+const efdDeterminedRetries = new WeakMap()
+const efdSlowAbortedTasks = new WeakSet()
+const efdExecutionStartByTask = new WeakMap()
+const efdSkippedRetryResults = new WeakMap()
 const attemptToFixExecutions = new Map()
 const loggedAttemptToFixTests = new Set()
 let isRetryReasonEfd = false
@@ -71,6 +78,7 @@ let isFlakyTestRetriesEnabled = false
 let flakyTestRetriesCount = 0
 let isEarlyFlakeDetectionEnabled = false
 let earlyFlakeDetectionNumRetries = 0
+let earlyFlakeDetectionSlowTestRetries = {}
 let isEarlyFlakeDetectionFaulty = false
 let isKnownTestsEnabled = false
 let isTestManagementTestsEnabled = false
@@ -87,6 +95,13 @@ let vitestPool = null
 
 const BREAKPOINT_HIT_GRACE_PERIOD_MS = 400
 
+function getConfiguredEfdRetryCount (slowTestRetries, fallbackRetryCount) {
+  if (!slowTestRetries || !Object.keys(slowTestRetries).length) {
+    return fallbackRetryCount
+  }
+  return getMaxEfdRetryCount(slowTestRetries)
+}
+
 function getTestCommand () {
   return `vitest ${process.argv.slice(2).join(' ')}`
 }
@@ -110,6 +125,7 @@ function getProvidedContext () {
       _ddIsDiEnabled,
       _ddKnownTests: knownTests,
       _ddEarlyFlakeDetectionNumRetries: numRepeats,
+      _ddEarlyFlakeDetectionSlowTestRetries: slowTestRetries,
       _ddIsKnownTestsEnabled: isKnownTestsEnabled,
       _ddIsTestManagementTestsEnabled: isTestManagementTestsEnabled,
       _ddTestManagementAttemptToFixRetries: testManagementAttemptToFixRetries,
@@ -125,6 +141,7 @@ function getProvidedContext () {
       isEarlyFlakeDetectionEnabled: _ddIsEarlyFlakeDetectionEnabled,
       knownTests,
       numRepeats,
+      slowTestRetries: slowTestRetries ?? {},
       isKnownTestsEnabled,
       isTestManagementTestsEnabled,
       testManagementAttemptToFixRetries,
@@ -141,6 +158,7 @@ function getProvidedContext () {
       isEarlyFlakeDetectionEnabled: false,
       knownTests: {},
       numRepeats: 0,
+      slowTestRetries: {},
       isKnownTestsEnabled: false,
       isTestManagementTestsEnabled: false,
       testManagementAttemptToFixRetries: 0,
@@ -219,12 +237,8 @@ function getSessionStatus (state) {
 
 // From https://github.com/vitest-dev/vitest/blob/51c04e2f44d91322b334f8ccbcdb368facc3f8ec/packages/runner/src/run.ts#L243-L250
 function getVitestTestStatus (test, retryCount) {
-  if (test.result.state !== 'fail') {
-    if (!test.repeats) {
-      return 'pass'
-    } else if (test.repeats && (test.retry ?? 0) === retryCount) {
-      return 'pass'
-    }
+  if (test.result.state !== 'fail' && (!test.repeats || (test.retry ?? 0) === retryCount)) {
+    return 'pass'
   }
   return 'fail'
 }
@@ -291,8 +305,8 @@ function recordFinalAttemptToFixExecution (task, status, providedContext) {
  * @returns {Function}
  */
 function wrapTestScopedFn (task, fn) {
-  return shimmer.wrapFunction(fn, fn => function () {
-    return testFnCh.runStores(taskToCtx.get(task), () => fn.apply(this, arguments))
+  return shimmer.wrapFunction(fn, fn => function (...args) {
+    return testFnCh.runStores(taskToCtx.get(task), () => fn.apply(this, args))
   })
 }
 
@@ -331,6 +345,7 @@ function getSortWrapper (sort, frameworkVersion) {
         flakyTestRetriesCount = libraryConfig.flakyTestRetriesCount
         isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
         earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
+        earlyFlakeDetectionSlowTestRetries = libraryConfig.earlyFlakeDetectionSlowTestRetries ?? {}
         isDiEnabled = libraryConfig.isDiEnabled
         isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
         isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
@@ -389,7 +404,9 @@ function getSortWrapper (sort, frameworkVersion) {
               workspaceProject._provided._ddIsKnownTestsEnabled = isKnownTestsEnabled
               workspaceProject._provided._ddKnownTests = knownTests
               workspaceProject._provided._ddIsEarlyFlakeDetectionEnabled = isEarlyFlakeDetectionEnabled
-              workspaceProject._provided._ddEarlyFlakeDetectionNumRetries = earlyFlakeDetectionNumRetries
+              workspaceProject._provided._ddEarlyFlakeDetectionNumRetries =
+                getConfiguredEfdRetryCount(earlyFlakeDetectionSlowTestRetries, earlyFlakeDetectionNumRetries)
+              workspaceProject._provided._ddEarlyFlakeDetectionSlowTestRetries = earlyFlakeDetectionSlowTestRetries
             } catch {
               log.warn('Could not send known tests to workers so Early Flake Detection will not work.')
             }
@@ -527,13 +544,13 @@ function getFinishWrapper (exitOrClose) {
 
 function getCliOrStartVitestWrapper (frameworkVersion) {
   return function (oldCliOrStartVitest) {
-    return function () {
+    return function (...args) {
       if (!testSessionStartCh.hasSubscribers || isSessionStarted) {
-        return oldCliOrStartVitest.apply(this, arguments)
+        return oldCliOrStartVitest.apply(this, args)
       }
       isSessionStarted = true
       testSessionStartCh.publish({ command: getTestCommand(), frameworkVersion })
-      return oldCliOrStartVitest.apply(this, arguments)
+      return oldCliOrStartVitest.apply(this, args)
     }
   }
 }
@@ -644,11 +661,11 @@ function getStartVitestWrapper (cliApiPackage, frameworkVersion) {
   const forksPoolWorker = getForksPoolWorkerExport(cliApiPackage)
   if (forksPoolWorker) {
     // function is async
-    shimmer.wrap(forksPoolWorker.value.prototype, 'start', start => function () {
+    shimmer.wrap(forksPoolWorker.value.prototype, 'start', start => function (...args) {
       vitestPool = 'child_process'
       this.env.DD_VITEST_WORKER = '1'
 
-      return start.apply(this, arguments)
+      return start.apply(this, args)
     })
     shimmer.wrap(forksPoolWorker.value.prototype, 'on', getWrappedOn)
   }
@@ -656,10 +673,10 @@ function getStartVitestWrapper (cliApiPackage, frameworkVersion) {
   const threadsPoolWorker = getThreadsPoolWorkerExport(cliApiPackage)
   if (threadsPoolWorker) {
     // function is async
-    shimmer.wrap(threadsPoolWorker.value.prototype, 'start', start => function () {
+    shimmer.wrap(threadsPoolWorker.value.prototype, 'start', start => function (...args) {
       vitestPool = 'worker_threads'
       this.env.DD_VITEST_WORKER = '1'
-      return start.apply(this, arguments)
+      return start.apply(this, args)
     })
     shimmer.wrap(threadsPoolWorker.value.prototype, 'on', getWrappedOn)
   }
@@ -721,7 +738,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
         onDone: (isImpacted) => {
           if (isImpacted) {
             if (isEarlyFlakeDetectionEnabled) {
-              isRetryReasonEfd = task.repeats !== numRepeats
+              isRetryReasonEfd = true
               task.repeats = numRepeats
             }
             modifiedTasks.add(task)
@@ -739,7 +756,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
         onDone: (isNew) => {
           if (isNew && !attemptToFixTasks.has(task)) {
             if (isEarlyFlakeDetectionEnabled && !modifiedTasks.has(task)) {
-              isRetryReasonEfd = task.repeats !== numRepeats
+              isRetryReasonEfd = true
               task.repeats = numRepeats
             }
             newTasks.add(task)
@@ -811,6 +828,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
       isTestManagementTestsEnabled,
       testManagementTests,
       isFlakyTestRetriesEnabled,
+      slowTestRetries,
     } = getProvidedContext()
 
     if (isKnownTestsEnabled) {
@@ -832,6 +850,39 @@ function wrapVitestTestRunner (VitestTestRunner) {
     }
 
     const { retry: numAttempt, repeats: numRepetition } = retryInfo
+    const isEfdManagedTask = isEarlyFlakeDetectionEnabled && taskToStatuses.has(task) && !attemptToFixTasks.has(task)
+
+    if (isEfdManagedTask && numRepetition > 0 && !efdDeterminedRetries.has(task)) {
+      const previousExecutionStart = efdExecutionStartByTask.get(task)
+      const duration = previousExecutionStart === undefined
+        ? task.result?.duration ?? 0
+        : performance.now() - previousExecutionStart
+      const retryCount = getEfdRetryCount(duration, slowTestRetries)
+      efdDeterminedRetries.set(task, retryCount)
+      task.repeats = retryCount
+      if (retryCount === 0) {
+        efdSlowAbortedTasks.add(task)
+      }
+    }
+
+    const efdRetryCount = efdDeterminedRetries.get(task)
+    if (isEfdManagedTask && efdRetryCount !== undefined && numRepetition > efdRetryCount) {
+      if (task.result) {
+        efdSkippedRetryResults.set(task, {
+          ...task.result,
+          errors: task.result.errors?.slice(),
+        })
+      }
+      if (vitestSetFn) {
+        const noop = function () {}
+        noop.__ddTraceWrapped = true
+        vitestSetFn(task, noop)
+      }
+      return onBeforeTryTask.apply(this, arguments)
+    }
+    if (isEfdManagedTask) {
+      efdExecutionStartByTask.set(task, performance.now())
+    }
 
     // We finish the previous test here because we know it has failed already
     if (numAttempt > 0) {
@@ -963,8 +1014,8 @@ function wrapVitestTestRunner (VitestTestRunner) {
           for (let i = 0; i < hookArray.length; i++) {
             const currentFn = hookArray[i]
             const originalFn = originalHookFns.get(currentFn) || currentFn
-            const wrappedFn = shimmer.wrapFunction(originalFn, fn => function () {
-              const result = testFnCh.runStores(taskToCtx.get(task), () => fn.apply(this, arguments))
+            const wrappedFn = shimmer.wrapFunction(originalFn, fn => function (...args) {
+              const result = testFnCh.runStores(taskToCtx.get(task), () => fn.apply(this, args))
 
               if (hookType === 'beforeEach') {
                 return wrapBeforeEachCleanupResult(task, result)
@@ -985,23 +1036,50 @@ function wrapVitestTestRunner (VitestTestRunner) {
 
   // test finish (only passed tests)
   shimmer.wrap(VitestTestRunner.prototype, 'onAfterTryTask', onAfterTryTask =>
-    async function (task, { retry: retryCount }) {
+    async function (task, retryInfo) {
       if (!testPassCh.hasSubscribers && !testErrorCh.hasSubscribers && !testSkipCh.hasSubscribers) {
         return onAfterTryTask.apply(this, arguments)
       }
       const result = await onAfterTryTask.apply(this, arguments)
 
-      const { testManagementAttemptToFixRetries } = getProvidedContext()
+      const {
+        isEarlyFlakeDetectionEnabled,
+        testManagementAttemptToFixRetries,
+        slowTestRetries,
+      } = getProvidedContext()
 
-      const status = getVitestTestStatus(task, retryCount)
+      const status = getVitestTestStatus(task, retryInfo.retry)
       const ctx = taskToCtx.get(task)
 
       const { isDiEnabled } = getProvidedContext()
 
-      if (isDiEnabled && retryCount > 1) {
+      if (efdSkippedRetryResults.has(task)) {
+        task.result = efdSkippedRetryResults.get(task)
+        efdSkippedRetryResults.delete(task)
+        return result
+      }
+
+      if (isDiEnabled && retryInfo.retry > 1) {
         await waitForHitProbe()
       }
 
+      if (
+        isEarlyFlakeDetectionEnabled &&
+        (retryInfo.repeats ?? 0) === 0 &&
+        taskToStatuses.has(task) &&
+        !attemptToFixTasks.has(task) &&
+        !efdDeterminedRetries.has(task)
+      ) {
+        const executionStart = efdExecutionStartByTask.get(task)
+        const duration = executionStart === undefined ? task.result?.duration ?? 0 : performance.now() - executionStart
+        const retryCount = getEfdRetryCount(duration, slowTestRetries)
+        efdDeterminedRetries.set(task, retryCount)
+        task.repeats = retryCount
+        if (retryCount === 0) {
+          efdSlowAbortedTasks.add(task)
+        }
+      }
+
       let attemptToFixPassed = false
       let attemptToFixFailed = false
       if (attemptToFixTasks.has(task)) {
@@ -1234,6 +1312,7 @@ addHook({
             testPassCh.publish({
               task,
               finalStatus: isSkippedByTestManagement ? 'skip' : 'pass',
+              earlyFlakeAbortReason: efdSlowAbortedTasks.has(task) ? 'slow' : undefined,
               ...testCtx.currentStore,
             })
           }
@@ -1255,8 +1334,9 @@ addHook({
             providedContext.isEarlyFlakeDetectionEnabled && (newTasks.has(task) || modifiedTasks.has(task))
           if (isEfdRetry) {
             const statuses = taskToStatuses.get(task)
-            // statuses only includes repetitions (not the initial run), so we check against numRepeats (not +1)
-            if (statuses && statuses.length === providedContext.numRepeats &&
+            const efdRetryCount = efdDeterminedRetries.get(task) ?? providedContext.numRepeats
+            // statuses only includes repetitions (not the initial run), so we check against retry count (not +1)
+            if (efdRetryCount > 0 && statuses && statuses.length === efdRetryCount &&
               statuses.every(status => status === 'fail')) {
               hasFailedAllRetries = true
             }
@@ -1297,6 +1377,7 @@ addHook({
               hasFailedAllRetries,
               attemptToFixFailed,
               finalStatus,
+              earlyFlakeAbortReason: efdSlowAbortedTasks.has(task) ? 'slow' : undefined,
               ...testCtx.currentStore,
             })
           }

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

@@ -33,8 +33,8 @@ addHook({ name: 'winston', file: 'lib/winston/logger.js', versions: ['>=3'] }, L
     }
   })
 
-  shimmer.wrap(Logger.prototype, 'configure', configure => function () {
-    const configureResponse = configure.apply(this, arguments)
+  shimmer.wrap(Logger.prototype, 'configure', configure => function (...args) {
+    const configureResponse = configure.apply(this, args)
     // After the original `configure`, because it resets transports
     if (addTransport.hasSubscribers) {
       addTransport.publish(this)
@@ -55,8 +55,8 @@ addHook({ name: 'winston', file: 'lib/winston/logger.js', versions: ['1', '2'] }
 })
 
 function wrapMethod (method, logCh) {
-  return function methodWithTrace () {
-    const result = method.apply(this, arguments)
+  return function methodWithTrace (...args) {
+    const result = method.apply(this, args)
 
     if (logCh.hasSubscribers) {
       for (const name in this.transports) {

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

@@ -62,24 +62,24 @@ const setSocketCh = channel('tracing:ws:server:connect:setSocket')
 let kWebSocketSymbol
 
 function wrapHandleUpgrade (handleUpgrade) {
-  return function () {
-    const [req, socket, , cb] = arguments
+  return function (...args) {
+    const [req, socket, , cb] = args
     if (!serverCh.start.hasSubscribers || typeof cb !== 'function') {
-      return handleUpgrade.apply(this, arguments)
+      return handleUpgrade.apply(this, args)
     }
 
     const ctx = { req, socket }
 
-    arguments[3] = function () {
+    args[3] = function (...args) {
       return serverCh.asyncStart.runStores(ctx, () => {
         try {
-          return cb.apply(this, arguments)
+          return cb.apply(this, args)
         } finally {
           serverCh.asyncEnd.publish(ctx)
         }
-      }, this, ...arguments)
+      }, this, ...args)
     }
-    return serverCh.traceSync(handleUpgrade, ctx, this, ...arguments)
+    return serverCh.traceSync(handleUpgrade, ctx, this, ...args)
   }
 }
 

package/packages/datadog-plugin-aws-sdk/src/base.js

@@ -8,10 +8,51 @@ const { tagsFromRequest, tagsFromResponse } = require('../../dd-trace/src/payloa
 const { getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
 const { IS_SERVERLESS } = require('../../dd-trace/src/serverless')
 
+const RESPONSE_SKIP_KEYS = new Set(['request', 'requestId', 'error', '$metadata'])
+
 class BaseAwsSdkPlugin extends ClientPlugin {
   static id = 'aws'
   static isPayloadReporter = false
 
+  /**
+   * Append `"<key>": <JSON.stringify(value)>` to a JSON-encoded object
+   * payload without re-parsing when possible.
+   *
+   * Fast path: `payload` is `{}` (returns `{"<key>":<json>}`) or ends with
+   * `}` preceded by a non-whitespace, non-`{` byte and does not contain
+   * `"<key>"` anywhere. The new field is spliced in before the trailing
+   * brace.
+   *
+   * Slow path falls back to `JSON.parse` + assign + `JSON.stringify` so the
+   * result still matches the previous round-trip when the payload has
+   * whitespace before the trailing `}`, is not a JSON object, or already
+   * contains `key`. The slow path replaces an existing `key` rather than
+   * merging — callers that need to preserve nested fields under `key` must
+   * read and merge before calling.
+   *
+   * @param {string} payload
+   * @param {string} key   Top-level key to insert. Must be a simple
+   *   identifier that does not need JSON escaping.
+   * @param {object} value Value to inject; will be `JSON.stringify`'d.
+   * @returns {string}
+   */
+  static injectFieldIntoJsonObject (payload, key, value) {
+    const last = payload.length - 1
+    if (last >= 1 && payload[last] === '}') {
+      if (last === 1) {
+        return `{"${key}":${JSON.stringify(value)}}`
+      }
+      const before = payload.charCodeAt(last - 1)
+      const isWhitespace = before === 0x20 || before === 0x09 || before === 0x0A || before === 0x0D
+      if (!isWhitespace && before !== 0x7B && !payload.includes(`"${key}"`)) {
+        return `${payload.slice(0, last)},"${key}":${JSON.stringify(value)}}`
+      }
+    }
+    const obj = JSON.parse(payload)
+    obj[key] = value
+    return JSON.stringify(obj)
+  }
+
   get serviceIdentifier () {
     const id = this.constructor.id.toLowerCase()
     Object.defineProperty(this, 'serviceIdentifier', {
@@ -224,12 +265,19 @@ class BaseAwsSdkPlugin extends ClientPlugin {
   }
 
   extractResponseBody (response) {
-    if (response.hasOwnProperty('data')) {
+    if (Object.hasOwn(response, 'data')) {
       return response.data
     }
-    return Object.fromEntries(
-      Object.entries(response).filter(([key]) => !['request', 'requestId', 'error', '$metadata'].includes(key))
-    )
+    // `{ ...response }` followed by `delete body.X` allocates a copy and then
+    // pushes the copy into V8 dictionary mode for every SDK response. Filter
+    // on build instead -- ~2.3x faster on the typical 4-of-8-keys shape.
+    const body = {}
+    for (const key of Object.keys(response)) {
+      if (!RESPONSE_SKIP_KEYS.has(key)) {
+        body[key] = response[key]
+      }
+    }
+    return body
   }
 
   generateTags () {

package/packages/datadog-plugin-aws-sdk/src/services/eventbridge.js

@@ -34,20 +34,27 @@ class EventBridge extends BaseAwsSdkPlugin {
       request.params.Entries &&
       request.params.Entries.length > 0 &&
       request.params.Entries[0].Detail) {
+      const injected = {}
+      this.tracer.inject(span, 'text_map', injected)
+
+      // Only `injectFieldIntoJsonObject` can throw (the slow path
+      // `JSON.parse` for non-`{...}` payloads). Tighten the catch around
+      // it so the rest of the body stays in V8's optimisable surface.
+      let finalData
       try {
-        const details = JSON.parse(request.params.Entries[0].Detail)
-        details._datadog = {}
-        this.tracer.inject(span, 'text_map', details._datadog)
-        const finalData = JSON.stringify(details)
-        const byteSize = Buffer.byteLength(finalData)
-        if (byteSize >= (1024 * 256)) {
-          log.info('Payload size too large to pass context')
-          return
-        }
-        request.params.Entries[0].Detail = finalData
-      } catch (e) {
-        log.error('EventBridge error injecting request', e)
+        finalData = BaseAwsSdkPlugin.injectFieldIntoJsonObject(
+          request.params.Entries[0].Detail, '_datadog', injected
+        )
+      } catch (error) {
+        log.error('EventBridge error injecting request', error)
+        return
+      }
+
+      if (Buffer.byteLength(finalData) >= 1024 * 256) {
+        log.info('Payload size too large to pass context')
+        return
       }
+      request.params.Entries[0].Detail = finalData
     }
   }
 }