dd-trace 6.2.0 → 6.4.0

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

@@ -8,7 +8,8 @@ const { getCompileToRegexp } = require('./path-to-regexp')
 const {
   getRouterMountPaths,
   joinPath,
-  setLayerMatchers,
+  setLayerMeta,
+  getLayerMeta,
   isAppMounted,
   setRouterMountPath,
   extractMountPaths,
@@ -25,137 +26,209 @@ function isFastSlash (layer, matchers) {
   return layer.regexp?.fast_slash ?? matchers.hasSlashPath
 }
 
-// TODO: Move this function to a shared file between Express and Router
 /**
+ * Cache the per-layer dispatch metadata in a side table instead of replacing
+ * `layer.handle`. Phase-sorting hosts (loopback's `_findLayerByHandler`) map a
+ * layer back to the user handler by scanning the handle, so the handle has to
+ * stay the user's function.
+ *
+ * @param {{ handle: Function, name?: string, path?: string,
+ *   regexp?: { fast_star?: boolean, fast_slash?: boolean } }} layer
+ * @param {Array<{ path?: string, regex?: RegExp }> & { hasStarPath?: boolean, hasSlashPath?: boolean }} matchers
+ */
+function annotateLayer (layer, matchers) {
+  const handle = layer.handle
+  const name = handle._name || layer.name || handle.name
+
+  let captureRoute
+  let needMultiMatch = false
+  if (matchers.length !== 0 && !isFastStar(layer, matchers) && !isFastSlash(layer, matchers)) {
+    if (matchers.length === 1) {
+      captureRoute = matchers[0].path
+    } else {
+      needMultiMatch = true
+    }
+  }
+
+  setLayerMeta(layer, { name, captureRoute, needMultiMatch, matchers })
+}
+
+/**
+ * Resolve the route for a dispatched layer. Single-pattern layers carry a
+ * constant route; only multi-pattern stacks need the per-request `layer.path`
+ * match the host already computed.
+ *
+ * @param {{ captureRoute?: string, needMultiMatch: boolean,
+ *   matchers: Array<{ path?: string, regex?: RegExp }> }} meta
+ * @param {{ path?: string }} layer
+ * @returns {string | undefined}
+ */
+function resolveLayerRoute (meta, layer) {
+  if (!meta.needMultiMatch) return meta.captureRoute
+
+  for (const matcher of meta.matchers) {
+    if (matcher.regex?.test(layer.path)) return matcher.path
+  }
+}
+
+/**
+ * Build the request/error dispatch wrappers for one host (`express` / `router`).
+ * They wrap the layer's prototype dispatch and read the side-table metadata, so
+ * `layer.handle` is never replaced. The arity guard mirrors the host's own
+ * (`handle_request` skips 4-arg handlers, `handle_error` skips the rest), so a
+ * span is published only for the layer the host actually runs.
+ *
  * @param {string} name Channel namespace (`apm:<name>:middleware:*`).
- * @param {((pattern: string | RegExp) => RegExp | undefined) | undefined} compile
- *   Host-resolved path-to-regexp compile adapter, or undefined when the host
- *   instance ships no path-to-regexp. Captured here so each express/router
- *   instance keeps the dialect it actually loaded.
  */
-function createWrapRouterMethod (name, compile) {
+function createLayerDispatchWrappers (name) {
   const enterChannel = channel(`apm:${name}:middleware:enter`)
   const exitChannel = channel(`apm:${name}:middleware:exit`)
   const finishChannel = channel(`apm:${name}:middleware:finish`)
   const errorChannel = channel(`apm:${name}:middleware:error`)
   const nextChannel = channel(`apm:${name}:middleware:next`)
-  const routeAddedChannel = channel(`apm:${name}:route:added`)
   // Bound per name so express and a bare router keep independent guards.
   const publishError = createErrorPublisher(errorChannel)
 
-  function wrapLayerHandle (layer, original, matchers) {
-    // Resolve `name` once at wrap time: cached on the original for any code
-    // that reads `_name`, captured in the closure so the per-call body avoids
-    // the property-lookup / `||` fallback.
-    const name = original._name || layer.name || original.name
-    original._name = name
-
-    // Wrap-time matcher analysis. The single-pattern case yields a constant
-    // route; only multi-pattern stacks need a per-request layer.path match.
-    let captureRoute
-    let needMultiMatch = false
-    if (matchers.length !== 0 && !isFastStar(layer, matchers) && !isFastSlash(layer, matchers)) {
-      if (matchers.length === 1) {
-        captureRoute = matchers[0].path
-      } else {
-        needMultiMatch = true
-      }
-    }
+  function wrapNext (req, originalNext) {
+    // Per layer dispatch, N per request. Named `next`/arity-1 mirrors the
+    // router continuation so wrapCallback skips its name/length rewrite.
+    let published = false
+    return shimmer.wrapCallback(originalNext, original => function next (error) {
+      // A handler that calls `next()` and then rejects (`next(); await bg()`)
+      // makes the host call this continuation twice. Publish once so the second
+      // pass cannot tag the already-finished span's parent with a late error.
+      if (!published) {
+        published = true
+
+        if (error && error !== 'route' && error !== 'router') {
+          publishError({ req, error })
+        }
 
-    // Split by arity: router only ever dispatches 3-arg request handlers
-    // through `Layer.handleRequest` and 4-arg error handlers through
-    // `Layer.handleError`. Specialising lets the per-call body use named
-    // parameters and `.call`, avoiding the rest-spread Array allocation that
-    // the unified shape forced on every middleware invocation.
-    const wrapped = original.length === 4
-      ? shimmer.wrapFunction(original, errorHandlerLayerWrap(layer, name, captureRoute, needMultiMatch, matchers))
-      : shimmer.wrapFunction(original, requestHandlerLayerWrap(layer, name, captureRoute, needMultiMatch, matchers))
-
-    // Workaround for loopback's phase-based middleware sorting. Its
-    // `_findLayerByHandler` maps a layer back to the user handler by scanning
-    // the layer handle's enumerable properties for the original function.
-    // Replacing `layer.handle` with this wrapper hides that handler, so without
-    // the back-reference loopback cannot tag the layer with its phase and
-    // `app.middleware(phase, ...)` handlers run in insertion order instead of
-    // phase order. The property name is part of that contract; keep it stable.
-    wrapped._datadog_orig = original
+        nextChannel.publish({ req })
+        finishChannel.publish({ req })
+      }
 
-    return wrapped
+      original.apply(this, arguments)
+    })
   }
 
-  function requestHandlerLayerWrap (layer, name, captureRoute, needMultiMatch, matchers) {
-    return original => function (req, res, next) {
-      if (!enterChannel.hasSubscribers) return original.call(this, req, res, next)
+  // Every host dispatch turns a synchronous throw into `next(error)`, and the
+  // hosts that await the handler (router >=2, express 5, express 4 +
+  // express-async-errors) do the same for a rejected promise. Passing
+  // `wrappedNext` through captures both without a tracer-side try/catch; only
+  // `exit` needs the `finally`. express 4's native dispatch converts only the
+  // synchronous throw — exactly what the pre-refactor handle wrap caught.
+  function wrapLayerRequest (originalRequest) {
+    return function (req, res, next) {
+      if (!enterChannel.hasSubscribers) return originalRequest.call(this, req, res, next)
 
-      const wrappedNext = typeof next === 'function' ? wrapNext(req, next) : next
+      const meta = getLayerMeta(this)
+      if (meta === undefined || this.handle.length > 3) return originalRequest.call(this, req, res, next)
 
-      let route = captureRoute
-      if (needMultiMatch) {
-        for (const matcher of matchers) {
-          if (matcher.regex?.test(layer.path)) {
-            route = matcher.path
-            break
-          }
-        }
-      }
-
-      enterChannel.publish({ name, req, route, layer })
+      const wrappedNext = typeof next === 'function' ? wrapNext(req, next) : next
+      enterChannel.publish({ name: meta.name, req, route: resolveLayerRoute(meta, this), layer: this })
 
       try {
-        return original.call(this, req, res, wrappedNext)
-      } catch (error) {
-        publishError({ req, error })
-        nextChannel.publish({ req })
-        finishChannel.publish({ req })
-
-        throw error
+        return originalRequest.call(this, req, res, wrappedNext)
       } finally {
         exitChannel.publish({ req })
       }
     }
   }
 
-  function errorHandlerLayerWrap (layer, name, captureRoute, needMultiMatch, matchers) {
-    return original => function (error, req, res, next) {
-      if (!enterChannel.hasSubscribers) return original.call(this, error, req, res, next)
+  function wrapLayerError (originalError) {
+    return function (error, req, res, next) {
+      if (!enterChannel.hasSubscribers) return originalError.call(this, error, req, res, next)
+
+      const meta = getLayerMeta(this)
+      if (meta === undefined || this.handle.length !== 4) return originalError.call(this, error, req, res, next)
 
       const wrappedNext = typeof next === 'function' ? wrapNext(req, next) : next
+      enterChannel.publish({ name: meta.name, req, route: resolveLayerRoute(meta, this), layer: this })
 
-      let route = captureRoute
-      if (needMultiMatch) {
-        for (const matcher of matchers) {
-          if (matcher.regex?.test(layer.path)) {
-            route = matcher.path
-            break
-          }
-        }
+      try {
+        return originalError.call(this, error, req, res, wrappedNext)
+      } finally {
+        exitChannel.publish({ req })
       }
+    }
+  }
 
-      enterChannel.publish({ name, req, route, layer })
+  // express <4.6.0 has no `Layer` prototype dispatch: the router invokes
+  // `layer.handle` directly and routes errors by its arity. There the handle is
+  // replaced in place, with the arity preserved so the host still routes
+  // correctly. Newer express, express 5, and the router package keep `handle`
+  // pristine and are traced through the prototype wraps above.
+  function wrapLegacyHandle (layer, original) {
+    // `annotateLayer` always runs first in `wrapStack`, so the captured meta is
+    // never undefined here (unlike the prototype wraps, where `this` can be any
+    // layer the host dispatches).
+    const meta = getLayerMeta(layer)
+    const wrapped = shimmer.wrapFunction(original, inner => function (...args) {
+      if (!enterChannel.hasSubscribers) return inner.apply(this, args)
+
+      const isErrorHandler = original.length === 4
+      const req = args[isErrorHandler ? 1 : 0]
+      const nextIndex = isErrorHandler ? 3 : 2
+      if (typeof args[nextIndex] === 'function') args[nextIndex] = wrapNext(req, args[nextIndex])
+
+      enterChannel.publish({ name: meta.name, req, route: resolveLayerRoute(meta, layer), layer })
 
       try {
-        return original.call(this, error, req, res, wrappedNext)
-      } catch (caught) {
-        publishError({ req, error: caught })
+        return inner.apply(this, args)
+      } catch (error) {
+        // Unlike the prototype hosts, this router catches a synchronous throw
+        // outside the layer and calls its own `next(error)`, never `wrappedNext`.
+        // Mirror `wrapNext` here so the throwing layer still tags its error and
+        // finishes, rather than lingering on the stack until request finish.
+        publishError({ req, error })
         nextChannel.publish({ req })
         finishChannel.publish({ req })
 
-        throw caught
+        throw error
       } finally {
         exitChannel.publish({ req })
       }
-    }
+    })
+    Object.defineProperty(wrapped, 'length', { value: original.length, configurable: true })
+    return wrapped
   }
 
+  return { wrapLayerRequest, wrapLayerError, wrapLegacyHandle }
+}
+
+/**
+ * @param {{ handle_request?: unknown, handleRequest?: unknown }} layer
+ */
+function hasLayerDispatch (layer) {
+  return typeof layer.handle_request === 'function' || typeof layer.handleRequest === 'function'
+}
+
+// TODO: Move this function to a shared file between Express and Router
+/**
+ * @param {string} name Channel namespace (`apm:<name>:middleware:*`).
+ * @param {((pattern: string | RegExp) => RegExp | undefined) | undefined} compile
+ *   Host-resolved path-to-regexp compile adapter, or undefined when the host
+ *   instance ships no path-to-regexp. Captured here so each express/router
+ *   instance keeps the dialect it actually loaded.
+ * @param {((layer: object, original: Function) => Function) | undefined} [wrapLegacyHandle]
+ *   Fallback that replaces `layer.handle` for hosts without a `Layer` prototype
+ *   dispatch (express <4.6.0). Omitted for hosts that always ship one.
+ */
+function createWrapRouterMethod (name, compile, wrapLegacyHandle) {
+  const routeAddedChannel = channel(`apm:${name}:route:added`)
+
   function wrapStack (layers, matchers) {
     for (const layer of layers) {
-      if (layer.__handle) { // express-async-errors
-        layer.__handle = wrapLayerHandle(layer, layer.__handle, matchers)
-      } else {
-        layer.handle = wrapLayerHandle(layer, layer.handle, matchers)
-      }
+      annotateLayer(layer, matchers)
 
-      setLayerMatchers(layer, matchers)
+      if (wrapLegacyHandle !== undefined && !hasLayerDispatch(layer)) {
+        if (layer.__handle) { // express-async-errors
+          layer.__handle = wrapLegacyHandle(layer, layer.__handle)
+        } else {
+          layer.handle = wrapLegacyHandle(layer, layer.handle)
+        }
+      }
 
       if (layer.route) {
         for (const method of METHODS) {
@@ -169,21 +242,6 @@ function createWrapRouterMethod (name, compile) {
     }
   }
 
-  function wrapNext (req, originalNext) {
-    // Per layer dispatch, N per request. Named `next`/arity-1 mirrors the
-    // router continuation so wrapCallback skips its name/length rewrite.
-    return shimmer.wrapCallback(originalNext, original => function next (error) {
-      if (error && error !== 'route' && error !== 'router') {
-        publishError({ req, error })
-      }
-
-      nextChannel.publish({ req })
-      finishChannel.publish({ req })
-
-      original.apply(this, arguments)
-    })
-  }
-
   function extractMatchers (fn) {
     const arg = Array.isArray(fn) ? fn.flat(Infinity) : [fn]
 
@@ -304,6 +362,15 @@ addHook({ name: 'router', versions: ['>=1 <2'] }, Router => {
   return Router
 })
 
+addHook({ name: 'router', file: 'lib/layer.js', versions: ['>=1 <2'] }, Layer => {
+  const { wrapLayerRequest, wrapLayerError } = createLayerDispatchWrappers('router')
+
+  shimmer.wrap(Layer.prototype, 'handle_request', wrapLayerRequest)
+  shimmer.wrap(Layer.prototype, 'handle_error', wrapLayerError)
+
+  return Layer
+})
+
 const queryParserReadCh = channel('datadog:query:read:finish')
 
 addHook({ name: 'router', versions: ['>=2'] }, Router => {
@@ -365,6 +432,14 @@ function wrapHandleRequest (original) {
 addHook({
   name: 'router', file: 'lib/layer.js', versions: ['>=2'],
 }, Layer => {
+  const { wrapLayerRequest, wrapLayerError } = createLayerDispatchWrappers('router')
+
+  // `handleRequest` carries two concerns: the middleware dispatch span and the
+  // param-start publish (`wrapHandleRequest`). Wrap the dispatch first so it
+  // sits inner and param-start still fires before `middleware:enter`, matching
+  // the order from when the handle itself was wrapped.
+  shimmer.wrap(Layer.prototype, 'handleRequest', wrapLayerRequest)
+  shimmer.wrap(Layer.prototype, 'handleError', wrapLayerError)
   shimmer.wrap(Layer.prototype, 'handleRequest', wrapHandleRequest)
   return Layer
 })
@@ -404,4 +479,4 @@ addHook({
   return router
 })
 
-module.exports = { createWrapRouterMethod }
+module.exports = { createWrapRouterMethod, createLayerDispatchWrappers }

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

@@ -2,7 +2,6 @@
 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')
@@ -13,6 +12,16 @@ function recordDataAsString (data) {
 // delete on consume, so their working set is ~the active shard count.
 const MAX_TRACKED_SHARD_ITERATORS = 1000
 
+// The default Kinesis record limit is 1 MiB. Streams configured for larger records
+// conservatively skip propagation above this point because the request does not expose that limit.
+const KINESIS_DEFAULT_MAX_RECORD_BYTES = 1_048_576
+
+// The DSM pathway field (`dd-pathway-ctx-base64`) always serializes to a fixed 55 bytes: a
+// 21-char key, a 28-char base64 value, and 6 bytes of JSON framing. Mirrors PATHWAY_HEADER_BYTES
+// in dd-trace/src/datastreams/processor.js. Reserved in the size gate so setDSMCheckpoint never
+// runs for a record that would ship over the cap once the pathway context is attached.
+const DSM_PATHWAY_FIELD_BYTES = 55
+
 class Kinesis extends BaseAwsSdkPlugin {
   static id = 'kinesis'
   static peerServicePrecursors = ['streamname']
@@ -237,6 +246,12 @@ class Kinesis extends BaseAwsSdkPlugin {
     }
   }
 
+  /**
+   * @param {import('../../../dd-trace/src/opentracing/span') | null} span
+   * @param {{ Data: Buffer|string|Uint8Array, PartitionKey?: string } | undefined} params
+   * @param {string} stream
+   * @param {boolean} injectTraceContext
+   */
   injectToMessage (span, params, stream, injectTraceContext) {
     if (!params) {
       return
@@ -251,30 +266,40 @@ class Kinesis extends BaseAwsSdkPlugin {
       }
     }
 
-    const ddInfo = {}
+    let ddInfo
     // For now we only inject to the first message; batches may change later.
     if (injectTraceContext) {
-      this.tracer.inject(span, 'text_map', ddInfo)
+      ddInfo = this.tracer.inject(span, 'text_map')
     }
 
-    if (this.config.dsmEnabled) {
-      parsedData._datadog = ddInfo
+    const dsmEnabled = this.config.dsmEnabled
+    if (!ddInfo && !dsmEnabled) return
+
+    parsedData._datadog = ddInfo ?? {}
+    // Gate before setDSMCheckpoint: a record we can't ship must not record a checkpoint.
+    // Reserve the pathway field that DSM appends after the gate.
+    let serialized = JSON.stringify(parsedData)
+    const reservedBytes = dsmEnabled ? DSM_PATHWAY_FIELD_BYTES : 0
+    const partitionKeyBytes = Buffer.byteLength(params.PartitionKey ?? '', 'utf8')
+    if (
+      Buffer.byteLength(serialized, 'utf8') + partitionKeyBytes + reservedBytes >
+      KINESIS_DEFAULT_MAX_RECORD_BYTES
+    ) {
+      log.info('Payload size too large to pass context')
+      return
+    }
+
+    if (dsmEnabled) {
       const dataStreamsContext = this.setDSMCheckpoint(span, params, stream)
-      if (dataStreamsContext) {
-        DsmPathwayCodec.encode(dataStreamsContext, ddInfo)
+      ddInfo = DsmPathwayCodec.encode(dataStreamsContext, ddInfo) ?? ddInfo
+      if (ddInfo) {
+        parsedData._datadog = ddInfo
+        serialized = JSON.stringify(parsedData)
       }
     }
 
-    if (isEmpty(ddInfo)) return
+    if (!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')
   }
 

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

@@ -2,7 +2,6 @@
 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'
@@ -71,6 +70,12 @@ class Sns extends BaseAwsSdkPlugin {
     }
   }
 
+  /**
+   * @param {import('../../../dd-trace/src/opentracing/span') | null} span
+   * @param {{ Message?: string, MessageAttributes?: Record<string, object> }} params
+   * @param {string | undefined} topicArn
+   * @param {boolean} injectTraceContext
+   */
   injectToMessage (span, params, topicArn, injectTraceContext) {
     if (!params.MessageAttributes) {
       params.MessageAttributes = {}
@@ -79,37 +84,32 @@ class Sns extends BaseAwsSdkPlugin {
       return
     }
 
-    const ddInfo = {}
+    let 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)
-      // add ddInfo before checking DSM so we can include DD attributes in payload size
-      params.MessageAttributes._datadog = {
-        DataType: 'Binary',
-        BinaryValue: ddInfo,
-      }
+      ddInfo = this.tracer.inject(span, 'text_map')
     }
 
     if (this.config.dsmEnabled) {
-      if (!params.MessageAttributes._datadog) {
-        params.MessageAttributes._datadog = {
-          DataType: 'Binary',
-          BinaryValue: ddInfo,
-        }
+      // Add the placeholder before the checkpoint so its payload size includes DD attributes.
+      params.MessageAttributes._datadog = {
+        DataType: 'Binary',
+        BinaryValue: ddInfo ?? {},
       }
 
       const dataStreamsContext = this.setDSMCheckpoint(span, params, topicArn)
-      DsmPathwayCodec.encode(dataStreamsContext, ddInfo)
+      ddInfo = DsmPathwayCodec.encode(dataStreamsContext, ddInfo) ?? ddInfo
     }
 
-    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 {
+    if (ddInfo) {
       // BINARY types are automatically base64 encoded
-      params.MessageAttributes._datadog.BinaryValue = Buffer.from(JSON.stringify(ddInfo))
+      params.MessageAttributes._datadog = {
+        DataType: 'Binary',
+        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
     }
   }
 

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, isEmpty } = require('../util')
+const { extractQueueMetadata } = require('../util')
 
 /**
  * @typedef {{
@@ -322,6 +322,12 @@ class Sqs extends BaseAwsSdkPlugin {
     }
   }
 
+  /**
+   * @param {import('../../../dd-trace/src/opentracing/span') | null} span
+   * @param {{ MessageBody?: string, MessageAttributes?: Record<string, object> } | undefined} params
+   * @param {string} queueUrl
+   * @param {boolean} injectTraceContext
+   */
   injectToMessage (span, params, queueUrl, injectTraceContext) {
     if (!params) {
       params = {}
@@ -333,10 +339,10 @@ class Sqs extends BaseAwsSdkPlugin {
       return
     }
 
-    const ddInfo = {}
+    let ddInfo
     // For now we only inject to the first message; batches may change later.
     if (injectTraceContext) {
-      this.tracer.inject(span, 'text_map', ddInfo)
+      ddInfo = this.tracer.inject(span, 'text_map')
     }
 
     if (this.config.dsmEnabled) {
@@ -344,19 +350,19 @@ class Sqs extends BaseAwsSdkPlugin {
       // matches the on-wire payload, then update with the encoded context.
       params.MessageAttributes._datadog = {
         DataType: 'String',
-        StringValue: JSON.stringify(ddInfo),
+        StringValue: JSON.stringify(ddInfo ?? {}),
       }
       const dataStreamsContext = this.setDSMCheckpoint(span, params, queueUrl)
-      if (dataStreamsContext) {
-        DsmPathwayCodec.encode(dataStreamsContext, ddInfo)
+      ddInfo = DsmPathwayCodec.encode(dataStreamsContext, ddInfo) ?? ddInfo
+      if (ddInfo) {
         params.MessageAttributes._datadog.StringValue = JSON.stringify(ddInfo)
-      } else if (isEmpty(ddInfo)) {
+      } else {
         delete params.MessageAttributes._datadog
       }
       return
     }
 
-    if (isEmpty(ddInfo)) return
+    if (!ddInfo) return
 
     params.MessageAttributes._datadog = {
       DataType: 'String',

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

@@ -143,31 +143,9 @@ 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-azure-functions/src/index.js

@@ -65,6 +65,7 @@ class AzureFunctionsPlugin extends TracingPlugin {
         service: this.serviceName(),
         type: 'serverless',
         meta,
+        childOf: null,
       }, ctx)
 
       if (isMessagingService) {
@@ -142,7 +143,7 @@ function mapTriggerTag (methodName) {
 // message & messages & batch with cardinality of 1 == applicationProperties
 // messages with cardinality of many == applicationPropertiesArray
 function setSpanLinks (triggerType, tracer, span, ctx) {
-  const cardinality = ctx.invocationContext.options.trigger.cardinality
+  const cardinality = ctx.invocationContext.options.trigger.cardinality ?? 'one'
   const triggerMetadata = ctx.invocationContext.triggerMetadata
   const isServiceBus = triggerType === 'ServiceBus'
 

package/packages/datadog-plugin-cypress/src/cypress-plugin.js

@@ -1835,13 +1835,13 @@ class CypressPlugin {
         }
         this.activeTestSpan.setTag(TEST_STATUS, testStatus)
 
-        // Save the test status to know if it has passed all retries
-        if (this.testStatuses[testName]) {
-          this.testStatuses[testName].push(testStatus)
+        const testIdentifier = `${testSuite}\0${testName}`
+        let testStatuses = this.testStatuses[testIdentifier]
+        if (testStatuses) {
+          testStatuses.push(testStatus)
         } else {
-          this.testStatuses[testName] = [testStatus]
+          testStatuses = this.testStatuses[testIdentifier] = [testStatus]
         }
-        const testStatuses = this.testStatuses[testName]
         const activeSpanTags = this.activeTestSpan.context().getTags()
 
         if (error) {