dd-trace 5.101.0 → 5.103.0

package/packages/datadog-plugin-apollo/src/gateway/request.js

@@ -2,8 +2,7 @@
 
 const { storage } = require('../../../datadog-core')
 const ApolloBasePlugin = require('../../../dd-trace/src/plugins/apollo')
-
-let tools
+const { getSignature } = require('../../../datadog-plugin-graphql/src/utils')
 
 const OPERATION_DEFINITION = 'OperationDefinition'
 const FRAGMENT_DEFINITION = 'FragmentDefinition'
@@ -100,23 +99,4 @@ function buildOperationContext (schema, operationDocument, operationName) {
   }
 }
 
-function getSignature (document, operationName, operationType, calculate) {
-  if (calculate !== false && tools !== false) {
-    try {
-      try {
-        tools = tools || require('../../../datadog-plugin-graphql/src/tools')
-      } catch (e) {
-        tools = false
-        throw e
-      }
-
-      return tools.defaultEngineReportingSignature(document, operationName)
-    } catch {
-      // safety net
-    }
-  }
-
-  return [operationType, operationName].filter(Boolean).join(' ')
-}
-
 module.exports = ApolloGatewayRequestPlugin

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

@@ -3,15 +3,55 @@
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 const ClientPlugin = require('../../dd-trace/src/plugins/client')
 const { storage } = require('../../datadog-core')
-const { isTrue } = require('../../dd-trace/src/util')
 const { tagsFromRequest, tagsFromResponse } = require('../../dd-trace/src/payload-tagging')
-const { getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
+const getConfig = require('../../dd-trace/src/config')
 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', {
@@ -204,16 +244,15 @@ class BaseAwsSdkPlugin extends ClientPlugin {
     if (!span || !response.request) return
     const params = response.request.params
     const operation = response.request.operation
-    const extraTags = this.generateTags(params, operation, response) || {}
 
-    const tags = {
-      'aws.response.request_id': response.requestId,
-      'resource.name': operation,
-      'span.kind': 'client',
-      ...extraTags,
-    }
+    // `'span.kind': 'client'` is already set by the start-meta; SQS overrides via `generateTags`.
+    span.setTag('aws.response.request_id', response.requestId)
+    span.setTag('resource.name', operation)
 
-    span.addTags(tags)
+    const extraTags = this.generateTags(params, operation, response)
+    if (extraTags) {
+      span.addTags(extraTags)
+    }
 
     if (this.constructor.isPayloadReporter && this.cloudTaggingConfig.response) {
       const maxDepth = this.cloudTaggingConfig.maxDepth
@@ -224,12 +263,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 () {
@@ -266,29 +312,25 @@ function normalizeConfig (config, serviceIdentifier) {
   const hooks = getHooks(config)
 
   let specificConfig = config[serviceIdentifier]
-  switch (typeof specificConfig) {
-    case 'undefined':
-      specificConfig = {}
-      break
-    case 'boolean':
-      specificConfig = { enabled: specificConfig }
-      break
+  if (typeof specificConfig === 'boolean') {
+    specificConfig = { enabled: specificConfig }
   }
 
-  // check if AWS batch propagation or AWS_[SERVICE] batch propagation is enabled via env variable
+  // Check if AWS batch propagation or AWS_[SERVICE] batch propagation is enabled via env variable
+  const tracerConfig = getConfig()
   const serviceId = serviceIdentifier.toUpperCase()
-  const batchPropagationEnabled = isTrue(
-    specificConfig.batchPropagationEnabled ??
-    getValueFromEnvSources(`DD_TRACE_AWS_SDK_${serviceId}_BATCH_PROPAGATION_ENABLED`) ??
-    config.batchPropagationEnabled ??
-    getValueFromEnvSources('DD_TRACE_AWS_SDK_BATCH_PROPAGATION_ENABLED')
+  const serviceBatchKey = /** @type {import('../../dd-trace/src/config/config-types').ConfigPath} */(
+    `DD_TRACE_AWS_SDK_${serviceId}_BATCH_PROPAGATION_ENABLED`
   )
+  const batchPropagationEnabled = tracerConfig.getOrigin(serviceBatchKey) === 'default'
+    ? tracerConfig.DD_TRACE_AWS_SDK_BATCH_PROPAGATION_ENABLED
+    : tracerConfig[serviceBatchKey]
 
   // Merge the specific config back into the main config
   return {
+    batchPropagationEnabled,
     ...config,
     ...specificConfig,
-    batchPropagationEnabled,
     hooks,
   }
 }

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

@@ -6,7 +6,7 @@ class CloudwatchLogs extends BaseAwsSdkPlugin {
   static id = 'cloudwatchlogs'
 
   generateTags (params, operation) {
-    if (!params?.logGroupName) return {}
+    if (!params?.logGroupName) return
 
     return {
       'resource.name': `${operation} ${params.logGroupName}`,

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

@@ -7,7 +7,7 @@ class EventBridge extends BaseAwsSdkPlugin {
   static isPayloadReporter = true
 
   generateTags (params, operation, response) {
-    if (!params?.source) return {}
+    if (!params?.source) return
     const rulename = params.Name ?? ''
     return {
       'resource.name': operation ? `${operation} ${params.source}` : params.source,
@@ -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'
@@ -63,7 +68,7 @@ class Kinesis extends BaseAwsSdkPlugin {
   }
 
   generateTags (params, operation, response) {
-    if (!params || !params.StreamName) return {}
+    if (!params || !params.StreamName) return
 
     return {
       'resource.name': `${operation} ${params.StreamName}`,
@@ -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

@@ -7,7 +7,7 @@ class Lambda extends BaseAwsSdkPlugin {
   static id = 'lambda'
 
   generateTags (params, operation, response) {
-    if (!params?.FunctionName) return {}
+    if (!params?.FunctionName) return
 
     return {
       'resource.name': `${operation} ${params.FunctionName}`,
@@ -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/redshift.js

@@ -6,7 +6,7 @@ class Redshift extends BaseAwsSdkPlugin {
   static id = 'redshift'
 
   generateTags (params, operation, response) {
-    if (!params?.ClusterIdentifier) return {}
+    if (!params?.ClusterIdentifier) return
 
     return {
       'resource.name': `${operation} ${params.ClusterIdentifier}`,

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

@@ -11,7 +11,7 @@ class S3 extends BaseAwsSdkPlugin {
   static isPayloadReporter = true
 
   generateTags (params, operation, response) {
-    if (!params?.Bucket) return {}
+    if (!params?.Bucket) return
 
     return {
       'resource.name': `${operation} ${params.Bucket}`,

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'
@@ -9,17 +10,15 @@ class Sns extends BaseAwsSdkPlugin {
   static isPayloadReporter = true
 
   generateTags (params, operation, response) {
-    if (!params) return {}
+    if (!params) return
 
-    if (!params.TopicArn && !(response.data && response.data.TopicArn)) return {}
+    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)
     }
   }
 }