dd-trace 5.100.0 → 5.102.0

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
     }
   }
 }

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

@@ -2,6 +2,11 @@
 const { DsmPathwayCodec, getSizeOrZero } = require('../../../dd-trace/src/datastreams')
 const log = require('../../../dd-trace/src/log')
 const BaseAwsSdkPlugin = require('../base')
+const { isEmpty } = require('../util')
+
+function recordDataAsString (data) {
+  return Buffer.isBuffer(data) ? data.toString('utf8') : Buffer.from(data).toString('utf8')
+}
 
 class Kinesis extends BaseAwsSdkPlugin {
   static id = 'kinesis'
@@ -90,14 +95,14 @@ class Kinesis extends BaseAwsSdkPlugin {
     const record = response.Records[0]
 
     try {
-      const decodedData = JSON.parse(Buffer.from(record.Data).toString())
+      const decodedData = JSON.parse(recordDataAsString(record.Data))
 
       return {
         maybeChildOf: this.tracer.extract('text_map', decodedData._datadog),
         parsedAttributes: decodedData._datadog,
       }
-    } catch (e) {
-      log.error('Kinesis error extracting response', e)
+    } catch (error) {
+      log.error('Kinesis error extracting response', error)
     }
   }
 
@@ -107,27 +112,32 @@ class Kinesis extends BaseAwsSdkPlugin {
     if (operation !== 'getRecords') return
     if (!response || !response.Records || !response.Records[0]) return
 
-    // we only want to set the payloadSize on the span if we have one message, not repeatedly
+    // Only attribute payloadSize to the span when there is a single record.
     span = response.Records.length > 1 ? null : span
 
+    const tags = streamName
+      ? ['direction:in', `topic:${streamName}`, 'type:kinesis']
+      : ['direction:in', 'type:kinesis']
+
     for (const record of response.Records) {
-      const parsedAttributes = JSON.parse(Buffer.from(record.Data).toString())
+      let parsedAttributes
+      try {
+        parsedAttributes = JSON.parse(recordDataAsString(record.Data))
+      } catch {
+        // Non-JSON record. Skip DSM context for this entry; the
+        // checkpoint payload size below is still reported.
+      }
 
       const payloadSize = getSizeOrZero(record.Data)
       if (parsedAttributes?._datadog) {
         this.tracer.decodeDataStreamsContext(parsedAttributes._datadog)
       }
-      const tags = streamName
-        ? ['direction:in', `topic:${streamName}`, 'type:kinesis']
-        : ['direction:in', 'type:kinesis']
-      this.tracer
-        .setCheckpoint(tags, span, payloadSize)
+      this.tracer.setCheckpoint(tags, span, payloadSize)
     }
   }
 
-  // AWS-SDK will b64 kinesis payloads
-  // or will accept an already b64 encoded payload
-  // This method handles both
+  // AWS-SDK base64-encodes kinesis payloads but also accepts an already
+  // base64-encoded payload; both shapes land here.
   _tryParse (body) {
     try {
       return JSON.parse(body)
@@ -135,7 +145,7 @@ class Kinesis extends BaseAwsSdkPlugin {
       log.info('Not JSON string. Trying Base64 encoded JSON string')
     }
     try {
-      return JSON.parse(Buffer.from(body, 'base64').toString('ascii'), true)
+      return JSON.parse(Buffer.from(body, 'base64').toString('ascii'))
     } catch {
       return null
     }
@@ -179,36 +189,36 @@ class Kinesis extends BaseAwsSdkPlugin {
     }
 
     const ddInfo = {}
-    // for now, we only want to inject to the first message, this may change for batches in the future
-    if (injectTraceContext) { this.tracer.inject(span, 'text_map', ddInfo) }
+    // For now we only inject to the first message; batches may change later.
+    if (injectTraceContext) {
+      this.tracer.inject(span, 'text_map', ddInfo)
+    }
 
-    // set DSM hash if enabled
     if (this.config.dsmEnabled) {
       parsedData._datadog = ddInfo
-      const dataStreamsContext = this.setDSMCheckpoint(span, parsedData, stream)
-      DsmPathwayCodec.encode(dataStreamsContext, ddInfo)
+      const dataStreamsContext = this.setDSMCheckpoint(span, params, stream)
+      if (dataStreamsContext) {
+        DsmPathwayCodec.encode(dataStreamsContext, ddInfo)
+      }
     }
 
-    if (Object.keys(ddInfo).length !== 0) {
-      parsedData._datadog = ddInfo
-      const finalData = Buffer.from(JSON.stringify(parsedData))
-      const byteSize = finalData.length
-      // Kinesis max payload size is 1MB
-      // So we must ensure adding DD context won't go over that (512b is an estimate)
-      if (byteSize >= 1_048_576) {
-        log.info('Payload size too large to pass context')
-        return
-      }
-      params.Data = finalData
+    if (isEmpty(ddInfo)) return
+
+    parsedData._datadog = ddInfo
+    const serialized = JSON.stringify(parsedData)
+    const byteSize = Buffer.byteLength(serialized, 'utf8')
+    // Kinesis max payload size is 1 MiB; bail if our context push tipped us over.
+    if (byteSize >= 1_048_576) {
+      log.info('Payload size too large to pass context')
+      return
     }
+    params.Data = Buffer.from(serialized, 'utf8')
   }
 
-  setDSMCheckpoint (span, parsedData, stream) {
-    // get payload size of request data
-    const payloadSize = Buffer.byteLength(JSON.stringify(parsedData))
-    const dataStreamsContext = this.tracer
+  setDSMCheckpoint (span, params, stream) {
+    const payloadSize = getSizeOrZero(params.Data)
+    return this.tracer
       .setCheckpoint(['direction:out', `topic:${stream}`, 'type:kinesis'], span, payloadSize)
-    return dataStreamsContext
   }
 }
 

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

@@ -18,33 +18,44 @@ class Lambda extends BaseAwsSdkPlugin {
 
   requestInject (span, request) {
     const operation = request.operation
-    if (operation === 'invoke') {
-      if (!request.params) {
-        request.params = {}
-      }
+    if (operation !== 'invoke') return
+
+    if (!request.params) {
+      request.params = {}
+    }
+
+    const isSyncInvocation = !request.params.InvocationType ||
+      request.params.InvocationType === 'RequestResponse'
+    if (!isSyncInvocation) return
+
+    const injected = {}
+    this.tracer.inject(span, 'text_map', injected)
 
-      const isSyncInvocation = !request.params.InvocationType ||
-        request.params.InvocationType === 'RequestResponse'
+    let newContextJson
+    if (request.params.ClientContext) {
+      const clientContextJson = Buffer.from(request.params.ClientContext, 'base64').toString('utf8')
 
-      if (isSyncInvocation) {
-        try {
-          // Check to see if there's already a config on the request
-          let clientContext = {}
-          if (request.params.ClientContext) {
-            const clientContextJson = Buffer.from(request.params.ClientContext, 'base64').toString('utf8')
-            clientContext = JSON.parse(clientContextJson)
-          }
-          if (!clientContext.custom) {
-            clientContext.custom = {}
-          }
-          this.tracer.inject(span, 'text_map', clientContext.custom)
-          const newContextBase64 = Buffer.from(JSON.stringify(clientContext)).toString('base64')
-          request.params.ClientContext = newContextBase64
-        } catch (err) {
-          log.error('Lambda error injecting request', err)
+      // The two throwing surfaces here are the inline `JSON.parse` and the
+      // slow path inside `injectFieldIntoJsonObject`. Tighten the catch
+      // around the JSON ops so the rest of the inject stays optimisable.
+      try {
+        if (clientContextJson.includes('"custom"')) {
+          // Existing customer keys under `custom` survive the round-trip.
+          const clientContext = JSON.parse(clientContextJson)
+          if (!clientContext.custom) clientContext.custom = {}
+          Object.assign(clientContext.custom, injected)
+          newContextJson = JSON.stringify(clientContext)
+        } else {
+          newContextJson = BaseAwsSdkPlugin.injectFieldIntoJsonObject(clientContextJson, 'custom', injected)
         }
+      } catch (error) {
+        log.error('Lambda error injecting request', error)
+        return
       }
+    } else {
+      newContextJson = `{"custom":${JSON.stringify(injected)}}`
     }
+    request.params.ClientContext = Buffer.from(newContextJson).toString('base64')
   }
 
   operationFromRequest (request) {

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

@@ -2,6 +2,7 @@
 const { DsmPathwayCodec, getHeadersSize } = require('../../../dd-trace/src/datastreams')
 const log = require('../../../dd-trace/src/log')
 const BaseAwsSdkPlugin = require('../base')
+const { isEmpty } = require('../util')
 
 class Sns extends BaseAwsSdkPlugin {
   static id = 'sns'
@@ -14,12 +15,10 @@ class Sns extends BaseAwsSdkPlugin {
     if (!params.TopicArn && !(response.data && response.data.TopicArn)) return {}
     const TopicArn = params.TopicArn || response.data.TopicArn
 
-    // Split the ARN into its parts
-    // ex.'arn:aws:sns:us-east-1:123456789012:my-topic'
-    const arnParts = TopicArn.split(':')
-
-    // Get the topic name from the last part of the ARN
-    const topicName = arnParts.at(-1)
+    // Get the topic name from the last `:`-delimited segment of the ARN
+    // (e.g. 'my-topic' in 'arn:aws:sns:us-east-1:123456789012:my-topic')
+    // without allocating an intermediate parts array.
+    const topicName = TopicArn.slice(TopicArn.lastIndexOf(':') + 1)
 
     return {
       'resource.name': `${operation} ${params.TopicArn || response.data.TopicArn}`,
@@ -103,12 +102,14 @@ class Sns extends BaseAwsSdkPlugin {
       DsmPathwayCodec.encode(dataStreamsContext, ddInfo)
     }
 
-    if (Object.keys(ddInfo).length !== 0) {
+    if (isEmpty(ddInfo)) {
+      if (params.MessageAttributes._datadog) {
+        // let's avoid adding any additional information to payload if we failed to inject
+        delete params.MessageAttributes._datadog
+      }
+    } else {
       // BINARY types are automatically base64 encoded
       params.MessageAttributes._datadog.BinaryValue = Buffer.from(JSON.stringify(ddInfo))
-    } else if (params.MessageAttributes._datadog) {
-      // let's avoid adding any additional information to payload if we failed to inject
-      delete params.MessageAttributes._datadog
     }
   }
 
@@ -116,9 +117,7 @@ class Sns extends BaseAwsSdkPlugin {
     // only set a checkpoint if publishing to a topic
     if (topicArn) {
       const payloadSize = getHeadersSize(params)
-      const dataStreamsContext = this.tracer
-        .setCheckpoint(['direction:out', `topic:${topicArn}`, 'type:sns'], span, payloadSize)
-      return dataStreamsContext
+      return this.tracer.setCheckpoint(['direction:out', `topic:${topicArn}`, 'type:sns'], span, payloadSize)
     }
   }
 }

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

@@ -3,7 +3,7 @@
 const log = require('../../../dd-trace/src/log')
 const BaseAwsSdkPlugin = require('../base')
 const { DsmPathwayCodec, getHeadersSize } = require('../../../dd-trace/src/datastreams')
-const { extractQueueMetadata } = require('../util')
+const { extractQueueMetadata, isEmpty } = require('../util')
 
 class Sqs extends BaseAwsSdkPlugin {
   static id = 'sqs'
@@ -23,25 +23,32 @@ class Sqs extends BaseAwsSdkPlugin {
 
       let store = this._parentMap.get(request)
       let span
-      let parsedMessageAttributes = null
-      if (contextExtraction && contextExtraction.datadogContext) {
-        ctx.needsFinish = true
-        const options = {
-          childOf: contextExtraction.datadogContext,
-          meta: {
-            ...this.requestTags.get(request),
-            'span.kind': 'server',
-          },
-          integrationName: 'aws-sdk',
+      let parsedMessageAttributes
+      let parsedFirstBody
+      let firstBodyChecked = false
+      if (contextExtraction !== undefined) {
+        parsedFirstBody = contextExtraction.parsedBody
+        firstBodyChecked = contextExtraction.bodyChecked === true
+        if (contextExtraction.datadogContext !== undefined) {
+          ctx.needsFinish = true
+          const options = {
+            childOf: contextExtraction.datadogContext,
+            meta: {
+              ...this.requestTags.get(request),
+              'span.kind': 'server',
+            },
+            integrationName: 'aws-sdk',
+          }
+          parsedMessageAttributes = contextExtraction.parsedAttributes
+          span = this.startSpan('aws.response', options, ctx)
+          store = ctx.currentStore
         }
-        parsedMessageAttributes = contextExtraction.parsedAttributes
-        span = this.startSpan('aws.response', options, ctx)
-        store = ctx.currentStore
       }
 
-      // extract DSM context after as we might not have a parent-child but may have a DSM context
+      // Extract DSM context after, as we might not have a parent-child but may have a DSM context.
       this.responseExtractDSMContext(
-        request.operation, request.params, response, span || null, { parsedAttributes: parsedMessageAttributes }
+        request.operation, request.params, response, span ?? null,
+        { parsedAttributes: parsedMessageAttributes, parsedFirstBody, firstBodyChecked }
       )
 
       return store
@@ -128,21 +135,23 @@ class Sqs extends BaseAwsSdkPlugin {
     if (!response || !response.Messages || !response.Messages[0]) return
 
     let message = response.Messages[0]
+    let parsedBody
 
     if (message.Body) {
       try {
-        const body = JSON.parse(message.Body)
-
-        // SNS to SQS
-        if (body.Type === 'Notification') {
-          message = body
-        }
+        parsedBody = JSON.parse(message.Body)
       } catch {
         // SQS to SQS
       }
+      // SNS to SQS
+      if (parsedBody?.Type === 'Notification') {
+        message = parsedBody
+      }
     }
 
-    if (!message.MessageAttributes || !message.MessageAttributes._datadog) return
+    if (!message.MessageAttributes || !message.MessageAttributes._datadog) {
+      return { parsedBody, bodyChecked: true }
+    }
 
     const datadogAttribute = message.MessageAttributes._datadog
 
@@ -151,8 +160,12 @@ class Sqs extends BaseAwsSdkPlugin {
       return {
         datadogContext: this.tracer.extract('text_map', parsedAttributes),
         parsedAttributes,
+        parsedBody,
+        bodyChecked: true,
       }
     }
+
+    return { parsedBody, bodyChecked: true }
   }
 
   parseDatadogAttributes (attributes) {
@@ -164,36 +177,43 @@ class Sqs extends BaseAwsSdkPlugin {
         const buffer = Buffer.from(attributes.Value ?? attributes.BinaryValue, 'base64')
         return JSON.parse(buffer)
       }
-    } catch (e) {
-      log.error('Sqs error parsing DD attributes', e)
+    } catch (error) {
+      log.error('Sqs error parsing DD attributes', error)
     }
   }
 
   responseExtractDSMContext (operation, params, response, span, kwargs = {}) {
     let { parsedAttributes } = kwargs
+    const { parsedFirstBody, firstBodyChecked } = kwargs
     if (!this.config.dsmEnabled) return
     if (operation !== 'receiveMessage') return
     if (!response || !response.Messages || !response.Messages[0]) return
 
-    // we only want to set the payloadSize on the span if we have one message
+    // Only attribute payloadSize to the span when there is a single message.
     span = response.Messages.length > 1 ? null : span
 
-    for (let message of response.Messages) {
-      // we may have already parsed the message attributes when extracting trace context
+    // QueueUrl is the same for the whole receive batch.
+    const queue = params.QueueUrl.slice(params.QueueUrl.lastIndexOf('/') + 1)
+
+    for (let i = 0; i < response.Messages.length; i++) {
+      let message = response.Messages[i]
       if (!parsedAttributes) {
-        if (message.Body) {
+        let body
+        // responseExtract already parsed message[0]; reuse that result instead of re-parsing.
+        if (i === 0 && firstBodyChecked) {
+          body = parsedFirstBody
+        } else if (message.Body) {
           try {
-            const body = JSON.parse(message.Body)
-
-            // SNS to SQS
-            if (body.Type === 'Notification') {
-              message = body
-            }
+            body = JSON.parse(message.Body)
           } catch {
             // SQS to SQS
           }
         }
-        if (!parsedAttributes && message.MessageAttributes && message.MessageAttributes._datadog) {
+        // SNS to SQS
+        if (body?.Type === 'Notification') {
+          message = body
+        }
+        if (message.MessageAttributes && message.MessageAttributes._datadog) {
           parsedAttributes = this.parseDatadogAttributes(message.MessageAttributes._datadog)
         }
       }
@@ -201,7 +221,6 @@ class Sqs extends BaseAwsSdkPlugin {
         Body: message.Body,
         MessageAttributes: message.MessageAttributes,
       })
-      const queue = params.QueueUrl.split('/').pop()
       if (parsedAttributes) {
         this.tracer.decodeDataStreamsContext(parsedAttributes)
       }
@@ -253,34 +272,35 @@ class Sqs extends BaseAwsSdkPlugin {
       // TODO: add test when the test suite is fixed
       return
     }
+
     const ddInfo = {}
-    // for now, we only want to inject to the first message, this may change for batches in the future
+    // For now we only inject to the first message; batches may change later.
     if (injectTraceContext) {
       this.tracer.inject(span, 'text_map', ddInfo)
-      params.MessageAttributes._datadog = {
-        DataType: 'String',
-        StringValue: JSON.stringify(ddInfo),
-      }
     }
 
     if (this.config.dsmEnabled) {
-      if (!params.MessageAttributes._datadog) {
-        params.MessageAttributes._datadog = {
-          DataType: 'String',
-          StringValue: JSON.stringify(ddInfo),
-        }
+      // Attach `_datadog` before measuring so the DSM payload size metric
+      // matches the on-wire payload, then update with the encoded context.
+      params.MessageAttributes._datadog = {
+        DataType: 'String',
+        StringValue: JSON.stringify(ddInfo),
       }
-
       const dataStreamsContext = this.setDSMCheckpoint(span, params, queueUrl)
       if (dataStreamsContext) {
         DsmPathwayCodec.encode(dataStreamsContext, ddInfo)
         params.MessageAttributes._datadog.StringValue = JSON.stringify(ddInfo)
+      } else if (isEmpty(ddInfo)) {
+        delete params.MessageAttributes._datadog
       }
+      return
     }
 
-    if (params.MessageAttributes._datadog && Object.keys(ddInfo).length === 0) {
-      // let's avoid adding any additional information to payload if we failed to inject
-      delete params.MessageAttributes._datadog
+    if (isEmpty(ddInfo)) return
+
+    params.MessageAttributes._datadog = {
+      DataType: 'String',
+      StringValue: JSON.stringify(ddInfo),
     }
   }
 
@@ -289,10 +309,9 @@ class Sqs extends BaseAwsSdkPlugin {
       Body: params.MessageBody,
       MessageAttributes: params.MessageAttributes,
     })
-    const queue = queueUrl.split('/').pop()
-    const dataStreamsContext = this.tracer
+    const queue = queueUrl.slice(queueUrl.lastIndexOf('/') + 1)
+    return this.tracer
       .setCheckpoint(['direction:out', `topic:${queue}`, 'type:sqs'], span, payloadSize)
-    return dataStreamsContext
   }
 }
 

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

@@ -38,25 +38,27 @@ class Stepfunctions extends BaseAwsSdkPlugin {
 
   requestInject (span, request) {
     const operation = request.operation
-    if (operation === 'startExecution' || operation === 'startSyncExecution') {
-      if (!request.params || !request.params.input) {
-        return
-      }
+    if ((operation !== 'startExecution' && operation !== 'startSyncExecution') || !request.params?.input) return
+
+    const input = request.params.input
+    if (typeof input !== 'string' || input.length < 2) return
+
+    // Skip non-object payloads up front to avoid a `JSON.parse` round-trip.
+    // `trimEnd` is the identity on payloads with no trailing whitespace;
+    // for the rare whitespace-suffixed object the slow path inside
+    // `injectFieldIntoJsonObject` handles the parse + restringify.
+    const trimmed = input.trimEnd()
+    if (trimmed.length < 2 || trimmed.charCodeAt(trimmed.length - 1) !== 0x7D) return
 
-      const input = request.params.input
+    const injected = {}
+    this.tracer.inject(span, 'text_map', injected)
 
-      try {
-        const inputObj = JSON.parse(input)
-        if (inputObj !== null && typeof inputObj === 'object') {
-          // We've parsed the input JSON string
-          inputObj._datadog = {}
-          this.tracer.inject(span, 'text_map', inputObj._datadog)
-          const newInput = JSON.stringify(inputObj)
-          request.params.input = newInput
-        }
-      } catch {
-        log.info('Unable to treat input as JSON')
-      }
+    // `injectFieldIntoJsonObject` is the only throwing call path
+    // (`JSON.parse` slow path for non-trivial JSON shapes).
+    try {
+      request.params.input = BaseAwsSdkPlugin.injectFieldIntoJsonObject(input, '_datadog', injected)
+    } catch {
+      log.info('Unable to treat input as JSON')
     }
   }
 }