dd-trace 5.101.0 → 5.103.0

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
@@ -92,7 +99,7 @@ class Sqs extends BaseAwsSdkPlugin {
   }
 
   generateTags (params, operation, response) {
-    if (!params || (!params.QueueName && !params.QueueUrl)) return {}
+    if (!params || (!params.QueueName && !params.QueueUrl)) return
 
     const queueMetadata = extractQueueMetadata(params.QueueUrl)
     const queueName = queueMetadata?.queueName || params.QueueName
@@ -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

@@ -28,7 +28,7 @@ class Stepfunctions extends BaseAwsSdkPlugin {
   //   }
 
   generateTags (params, operation, response) {
-    if (!params) return {}
+    if (!params) return
     const tags = { 'resource.name': params.name ? `${operation} ${params.name}` : `${operation}` }
     if (operation === 'startExecution' || operation === 'startSyncExecution') {
       tags.statemachinearn = `${params.stateMachineArn}`
@@ -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')
     }
   }
 }

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

@@ -143,9 +143,31 @@ const extractQueueMetadata = queueURL => {
   return { queueName, arn }
 }
 
+/**
+ * Returns true when `obj` has no own enumerable properties. The
+ * `for-in` loop with an early return is the only allocation-free shape
+ * for this check; benchmarks pin it as 1.3-1.4x faster than
+ * `Object.keys(obj).length === 0` across small / medium / large
+ * objects, and this is the hot path on every AWS messaging send.
+ *
+ * Callers in this package only pass plain objects they construct
+ * locally, so prototype-enumerable keys are not a concern here. Do not
+ * reuse this helper on caller-supplied objects without revisiting that
+ * assumption.
+ *
+ * @param {object} obj
+ * @returns {boolean}
+ */
+const isEmpty = obj => {
+  // eslint-disable-next-line no-unreachable-loop
+  for (const _ in obj) return false
+  return true
+}
+
 module.exports = {
   generatePointerHash,
   encodeValue,
   extractPrimaryKeys,
   extractQueueMetadata,
+  isEmpty,
 }

package/packages/datadog-plugin-child_process/src/scrub-cmd-params.js

@@ -5,7 +5,7 @@ const shellParser = require('../../../vendor/dist/shell-quote').parse
 const ALLOWED_ENV_VARIABLES = new Set(['LD_PRELOAD', 'LD_LIBRARY_PATH', 'PATH'])
 const PROCESS_DENYLIST = new Set(['md5'])
 
-const VARNAMES_REGEX = /\$([\w\d_]*)(?:[^\w\d_]|$)/gmi
+const VARNAMES_REGEX = /\$(\w*)(?:[^\w]|$)/gmi
 // eslint-disable-next-line @stylistic/max-len
 const PARAM_PATTERN = '^-{0,2}(?:p(?:ass(?:w(?:or)?d)?)?|address|api[-_]?key|e?mail|secret(?:[-_]?key)?|a(?:ccess|uth)[-_]?token|mysql_pwd|credentials|(?:stripe)?token)$'
 const regexParam = new RegExp(PARAM_PATTERN, 'i')
@@ -104,13 +104,13 @@ function scrubChildProcessCmd (expression) {
           result.push(token)
 
           if (PROCESS_DENYLIST.has(token)) {
-            for (index++; index < expressionTokens.length; index++) {
-              const token = expressionTokens[index]
+            for (let i = index + 1; i < expressionTokens.length; i++) {
+              const innerToken = expressionTokens[i]
 
-              if (token.op) {
-                result.push(token.op)
+              if (innerToken.op) {
+                result.push(innerToken.op)
               } else {
-                expressionTokens[index] = REDACTED
+                expressionTokens[i] = REDACTED
                 result.push(REDACTED)
               }
             }

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

@@ -1,18 +1,49 @@
 'use strict'
 
 const StoragePlugin = require('../../dd-trace/src/plugins/storage')
-const { storage } = require('../../datadog-core')
 
 class CouchBasePlugin extends StoragePlugin {
   static id = 'couchbase'
   static peerServicePrecursors = ['db.couchbase.seed.nodes']
 
-  addBinds (func, start) {
-    this.addBind(`apm:couchbase:${func}:start`, start)
-    this.addSub(`apm:couchbase:${func}:error`, ({ error }) => this.addError(error))
-    this.addSub(`apm:couchbase:${func}:finish`, ctx => this.finish(ctx))
-    this.addBind(`apm:couchbase:${func}:callback:start`, callbackStart)
-    this.addBind(`apm:couchbase:${func}:callback:finish`, callbackFinish)
+  constructor (...args) {
+    super(...args)
+
+    this.#addOpSubs('query', (ctx) => {
+      const { resource, bucket, seedNodes } = ctx
+      this.startSpan(
+        'query',
+        {
+          'span.type': 'sql',
+          'resource.name': resource,
+          'span.kind': this.constructor.kind,
+        },
+        { bucket, seedNodes },
+        ctx
+      )
+      return ctx.currentStore
+    })
+
+    for (const op of ['upsert', 'insert', 'replace']) {
+      this.#addOpSubs(op, (ctx) => {
+        const { bucket, collection, seedNodes } = ctx
+        this.startSpan(op, {}, { bucket, collection, seedNodes }, ctx)
+        return ctx.currentStore
+      })
+    }
+  }
+
+  /**
+   * @param {string} op Operation name (`query`, `upsert`, ...).
+   * @param {(ctx: object) => object} bindStart Operation-specific span starter.
+   */
+  #addOpSubs (op, bindStart) {
+    const prefix = `tracing:apm:couchbase:${op}`
+    this.addBind(`${prefix}:start`, bindStart)
+    this.addBind(`${prefix}:asyncStart`, bindAsyncStart)
+    this.addSub(`${prefix}:asyncEnd`, finishSpan)
+    this.addSub(`${prefix}:end`, finishSpanIfSync)
+    this.addSub(`${prefix}:error`, setSpanError)
   }
 
   startSpan (operation, customTags, { bucket, collection, seedNodes }, ctx) {
@@ -27,8 +58,8 @@ class CouchBasePlugin extends StoragePlugin {
     if (bucket) tags['couchbase.bucket.name'] = bucket.name
     if (collection) tags['couchbase.collection.name'] = collection.name
 
-    for (const tag in customTags) {
-      tags[tag] = customTags[tag]
+    for (const key of Object.keys(customTags)) {
+      tags[key] = customTags[key]
     }
 
     return super.startSpan(
@@ -40,55 +71,30 @@ class CouchBasePlugin extends StoragePlugin {
       ctx
     )
   }
+}
 
-  constructor (...args) {
-    super(...args)
-
-    this.addBinds('query', (ctx) => {
-      const { resource, bucket, seedNodes } = ctx
-
-      this.startSpan(
-        'query',
-        {
-          'span.type': 'sql',
-          'resource.name': resource,
-          'span.kind': this.constructor.kind,
-        },
-        { bucket, seedNodes },
-        ctx
-      )
-
-      return ctx.currentStore
-    })
-    this.addBind('apm:couchbase:bucket:maybeInvoke:callback:start', callbackStart)
-    this.addBind('apm:couchbase:bucket:maybeInvoke:callback:finish', callbackFinish)
-    this.addBind('apm:couchbase:cluster:maybeInvoke:callback:start', callbackStart)
-    this.addBind('apm:couchbase:cluster:maybeInvoke:callback:finish', callbackFinish)
-
-    this._addCommandSubs('upsert')
-    this._addCommandSubs('insert')
-    this._addCommandSubs('replace')
-    this._addCommandSubs('append')
-    this._addCommandSubs('prepend')
-  }
-
-  _addCommandSubs (name) {
-    this.addBinds(name, (ctx) => {
-      const { bucket, collection, seedNodes } = ctx
+function bindAsyncStart (ctx) {
+  return ctx.parentStore
+}
 
-      this.startSpan(name, {}, { bucket, collection, seedNodes }, ctx)
-      return ctx.currentStore
-    })
-  }
+function finishSpan (ctx) {
+  ctx.currentStore?.span?.finish()
 }
 
-function callbackStart (ctx) {
-  ctx.parentStore = storage('legacy').getStore()
-  return ctx.parentStore
+// `end` fires synchronously after the wrapped function returns. For async
+// resolutions ctx.result and ctx.error are still unset at that point and the
+// span is closed later via asyncEnd. For a sync throw or sync-resolved
+// callback, this is the only finalization signal.
+function finishSpanIfSync (ctx) {
+  if ((ctx.error !== undefined || ctx.result !== undefined) && ctx.currentStore?.span) {
+    ctx.currentStore.span.finish()
+  }
 }
 
-function callbackFinish (ctx) {
-  return ctx.parentStore
+function setSpanError (ctx) {
+  if (ctx.error && ctx.currentStore?.span) {
+    ctx.currentStore.span.setTag('error', ctx.error)
+  }
 }
 
 module.exports = CouchBasePlugin

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

@@ -141,6 +141,7 @@ class CucumberPlugin extends CiPlugin {
           'cucumber'
         ),
         ...this.getSessionRequestErrorTags(),
+        ...this.getSessionItrSkippingEnabledTags(),
       }
       if (isUnskippable) {
         this.telemetry.count(TELEMETRY_ITR_UNSKIPPABLE, { testLevel: 'suite' })
@@ -308,6 +309,7 @@ class CucumberPlugin extends CiPlugin {
       isDisabled,
       isQuarantined,
       isModified,
+      earlyFlakeAbortReason,
       finalStatus,
     }) => {
       const statusTag = isStep ? 'step.status' : TEST_STATUS
@@ -317,6 +319,9 @@ class CucumberPlugin extends CiPlugin {
       if (finalStatus) {
         span.setTag(TEST_FINAL_STATUS, finalStatus)
       }
+      if (earlyFlakeAbortReason) {
+        span.setTag(TEST_EARLY_FLAKE_ABORT_REASON, earlyFlakeAbortReason)
+      }
 
       if (isNew) {
         span.setTag(TEST_IS_NEW, 'true')