dd-trace 6.9.0 → 6.11.0

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

@@ -1,35 +1,90 @@
 'use strict'
+
+const { DsmPathwayCodec, PATHWAY_FIELD_BYTES } = require('../../../dd-trace/src/datastreams')
 const log = require('../../../dd-trace/src/log')
 const BaseAwsSdkPlugin = require('../base')
 
+const DEFAULT_EVENT_BUS = 'default'
+const DEFAULT_DETAIL_TYPE = 'unknown'
 // EventBridge enforces this limit over the whole PutEvents request (the sum of
-// every entry), not over a single entry. 1 MiB == 1,048,576 bytes.
+// every entry), not over a single entry.
 const MAX_PUT_EVENTS_BYTES = 1024 * 1024
+// Sizing runs before any checkpoint exists, so entries that carry nothing but a pathway are
+// measured against this stand-in.
+const PATHWAY_SIZE_PROBE = { hash: Buffer.alloc(8), pathwayStartNs: 0, edgeStartNs: 0 }
+
+/**
+ * @typedef {object} PutEventsRequestEntry
+ * @property {string} [Detail]
+ * @property {string} [DetailType]
+ * @property {string} [EventBusName]
+ * @property {string[]} [Resources]
+ * @property {string} [Source]
+ * @property {Date} [Time]
+ * @property {string} [TraceHeader]
+ */
+
+/**
+ * Size a single entry the way DSM reports payloads across tracers: the UTF-8 byte length of every
+ * string field the caller supplied. `Time` is excluded because it is not part of the message the
+ * consumer receives, which is also why this differs from `putEventEntrySize`.
+ *
+ * @param {PutEventsRequestEntry} entry whose `Detail` the caller has already checked is a string.
+ * @returns {number}
+ */
+function dsmPayloadSize (entry) {
+  let size = Buffer.byteLength(entry.Detail)
+  if (typeof entry.DetailType === 'string') size += Buffer.byteLength(entry.DetailType)
+  if (typeof entry.EventBusName === 'string') size += Buffer.byteLength(entry.EventBusName)
+  if (typeof entry.Source === 'string') size += Buffer.byteLength(entry.Source)
+  if (typeof entry.TraceHeader === 'string') size += Buffer.byteLength(entry.TraceHeader)
+  if (Array.isArray(entry.Resources)) {
+    for (const resource of entry.Resources) {
+      if (typeof resource === 'string') size += Buffer.byteLength(resource)
+    }
+  }
+  return size
+}
 
 /**
  * Size a single `PutEventsRequestEntry` the way EventBridge does server-side:
  * the UTF-8 byte length of `Source`, `DetailType`, `Detail`, and each
  * `Resources` ARN, plus a flat 14 bytes when `Time` is set.
  *
- * @param {object} entry a single PutEvents request entry
+ * @param {PutEventsRequestEntry} entry
  * @param {string} [detail] overrides `entry.Detail`, used to size the entry as
  *   it would be sent with the injected `_datadog` context
- * @returns {number}
  * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-putevents.html
  */
-function putEventEntrySize (entry, detail = entry.Detail) {
+function putEventEntrySize (entry, detail) {
+  if (entry == null) return 0
+
+  detail ??= entry.Detail
   let size = entry.Time == null ? 0 : 14
-  if (entry.Source != null) size += Buffer.byteLength(entry.Source)
-  if (entry.DetailType != null) size += Buffer.byteLength(entry.DetailType)
-  if (detail != null) size += Buffer.byteLength(detail)
-  if (entry.Resources != null) {
+  if (typeof entry.Source === 'string') size += Buffer.byteLength(entry.Source)
+  if (typeof entry.DetailType === 'string') size += Buffer.byteLength(entry.DetailType)
+  if (typeof detail === 'string') size += Buffer.byteLength(detail)
+  if (Array.isArray(entry.Resources)) {
     for (const resource of entry.Resources) {
-      if (resource != null) size += Buffer.byteLength(resource)
+      if (typeof resource === 'string') size += Buffer.byteLength(resource)
     }
   }
   return size
 }
 
+/**
+ * @param {string} detail
+ * @param {Record<string, string>} carrier
+ * @returns {string|undefined} `undefined` when `detail` is not a JSON object
+ */
+function injectDetail (detail, carrier) {
+  try {
+    return BaseAwsSdkPlugin.injectFieldIntoJsonObject(detail, '_datadog', carrier)
+  } catch (error) {
+    log.error('EventBridge error injecting request', error)
+  }
+}
+
 class EventBridge extends BaseAwsSdkPlugin {
   static id = 'eventbridge'
   static isPayloadReporter = true
@@ -46,44 +101,31 @@ class EventBridge extends BaseAwsSdkPlugin {
   }
 
   /**
-   * requestInject
-   * @param {import('../../../..').Span} span
-   * @param {object} request
+   * The context goes into `Detail` because EventBridge reserves an entry's `TraceHeader` for X-Ray.
    *
-   * Docs: https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEventsRequestEntry.html
-   * We cannot use the traceHeader field as that's reserved for X-Ray.
-   * Detail must be a valid JSON string
-   * Max PutEvents request size is 1mb, summed over all entries
-   * (https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-putevent-size.html)
+   * @param {import('../../../..').Span} span
+   * @param {{ operation: string, params?: { Entries?: PutEventsRequestEntry[] } }} request
+   * @see https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEventsRequestEntry.html
+   * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-putevent-size.html
    */
   requestInject (span, request) {
-    const operation = request.operation
-    if (operation === 'putEvents' &&
-      request.params &&
-      request.params.Entries &&
-      request.params.Entries.length > 0 &&
-      request.params.Entries[0].Detail) {
-      const entries = request.params.Entries
-      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 {
-        finalData = BaseAwsSdkPlugin.injectFieldIntoJsonObject(entries[0].Detail, '_datadog', injected)
-      } catch (error) {
-        log.error('EventBridge error injecting request', error)
-        return
-      }
+    const { operation, params } = request
+    if (operation !== 'putEvents' || !params?.Entries?.length) return
+
+    const entries = params.Entries
+    const dsmEnabled = this.config.dsmEnabled
+    const batchPropagationEnabled = this.config.batchPropagationEnabled
+    const traceCarrier = this.tracer.inject(span, 'text_map')
+    if (traceCarrier === undefined && !dsmEnabled) return
 
-      // EventBridge applies the 1 MiB cap to the whole request, so size every
-      // entry as it would be sent (the first with `_datadog` injected) and skip
-      // rather than tip a request AWS would otherwise accept over the limit. The
-      // running total only needs to clear the cap, so stop summing the moment it
-      // does instead of byte-counting the rest of a batch we already know is over.
-      let requestSize = putEventEntrySize(entries[0], finalData)
+    // The default configuration injects the first entry alone and records no checkpoint, so it
+    // needs none of the deferred-write bookkeeping the paths below depend on.
+    if (!dsmEnabled && !batchPropagationEnabled) {
+      const entry = entries[0]
+      if (typeof entry?.Detail !== 'string') return
+      const detail = injectDetail(entry.Detail, traceCarrier)
+      if (detail === undefined) return
+      let requestSize = putEventEntrySize(entry, detail)
       for (let i = 1; requestSize < MAX_PUT_EVENTS_BYTES && i < entries.length; i++) {
         requestSize += putEventEntrySize(entries[i])
       }
@@ -91,8 +133,85 @@ class EventBridge extends BaseAwsSdkPlugin {
         log.info('Payload size too large to pass context')
         return
       }
-      entries[0].Detail = finalData
+      entry.Detail = detail
+      return
     }
+
+    // Both carriers are reused across entries; the write pass overwrites the pathway on each one
+    // immediately before serializing it, so nothing may come between the two.
+    let pathwayOnlyCarrier
+    const injectable = []
+    let requestSize = 0
+
+    for (let i = 0; i < entries.length && requestSize < MAX_PUT_EVENTS_BYTES; i++) {
+      const entry = entries[i]
+      const tracePropagated = traceCarrier !== undefined && (i === 0 || batchPropagationEnabled)
+      let carrier = traceCarrier
+      if (!tracePropagated) {
+        if (dsmEnabled) pathwayOnlyCarrier ??= DsmPathwayCodec.encode(PATHWAY_SIZE_PROBE)
+        carrier = pathwayOnlyCarrier
+      }
+      if (carrier !== undefined && typeof entry?.Detail === 'string') {
+        // A malformed Detail is skipped rather than fatal: EventBridge partial-fails that entry,
+        // so the rest of the batch still propagates.
+        const traceOnlyDetail = injectDetail(entry.Detail, carrier)
+        if (traceOnlyDetail !== undefined) {
+          // The pathway field is a fixed width, so reserving it is exact and saves building the
+          // detail a second time just to measure it.
+          const reserved = dsmEnabled && tracePropagated ? PATHWAY_FIELD_BYTES : 0
+          requestSize += putEventEntrySize(entry, traceOnlyDetail) + reserved
+          injectable.push({
+            entry,
+            carrier,
+            payloadSize: dsmEnabled ? dsmPayloadSize(entry) : 0,
+            traceOnlyDetail: tracePropagated ? traceOnlyDetail : undefined,
+          })
+          continue
+        }
+      }
+      requestSize += putEventEntrySize(entry)
+    }
+
+    if (injectable.length === 0) return
+    if (requestSize >= MAX_PUT_EVENTS_BYTES) {
+      log.info('Payload size too large to pass context')
+      return
+    }
+
+    for (const { entry, carrier, payloadSize, traceOnlyDetail } of injectable) {
+      let detail = traceOnlyDetail
+      if (dsmEnabled) {
+        const dataStreamsContext = this.setDSMCheckpoint(span, entry, payloadSize)
+        // Anything short of a real pathway leaves the carrier on the sizing stand-in, which must
+        // never ship; a pathway-only entry then has no fallback and keeps the caller's detail.
+        if (DsmPathwayCodec.encode(dataStreamsContext, carrier) !== undefined) {
+          detail = injectDetail(entry.Detail, carrier)
+        }
+      }
+      if (detail !== undefined) entry.Detail = detail
+    }
+  }
+
+  /**
+   * Edge tags feed the pathway hash, so they are a cross-tracer contract: renaming or merging one
+   * splits the DSM pathway instead of extending it.
+   *
+   * @param {import('../../../..').Span} span
+   * @param {PutEventsRequestEntry} entry
+   * @param {number} payloadSize `dsmPayloadSize(entry)`, taken before the `_datadog` context is
+   *   injected. The trailing `0` opts out of the pathway estimate the processor adds by default,
+   *   because that context is propagation overhead rather than the caller's payload.
+   * @returns {object|undefined}
+   */
+  setDSMCheckpoint (span, entry, payloadSize) {
+    const eventBus = entry.EventBusName || DEFAULT_EVENT_BUS
+    const detailType = entry.DetailType ?? DEFAULT_DETAIL_TYPE
+    return this.tracer.setCheckpoint(
+      ['direction:out', `exchange:${eventBus}`, `topic:${detailType}`, 'type:eventbridge'],
+      span,
+      payloadSize,
+      0,
+    )
   }
 }
 module.exports = EventBridge

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

@@ -1,5 +1,5 @@
 'use strict'
-const { DsmPathwayCodec, getSizeOrZero } = require('../../../dd-trace/src/datastreams')
+const { DsmPathwayCodec, getSizeOrZero, PATHWAY_FIELD_BYTES } = require('../../../dd-trace/src/datastreams')
 const log = require('../../../dd-trace/src/log')
 const BaseAwsSdkPlugin = require('../base')
 
@@ -16,12 +16,6 @@ const MAX_TRACKED_SHARD_ITERATORS = 1000
 // 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']
@@ -196,14 +190,11 @@ class Kinesis extends BaseAwsSdkPlugin {
       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.
+        // Non-JSON record: it carries no context, so the checkpoint below starts a new pathway.
       }
 
       const payloadSize = getSizeOrZero(record.Data)
-      if (parsedAttributes?._datadog) {
-        this.tracer.decodeDataStreamsContext(parsedAttributes._datadog)
-      }
+      this.tracer.decodeDataStreamsContext(parsedAttributes?._datadog)
       this.tracer.setCheckpoint(tags, span, payloadSize)
     }
   }
@@ -279,7 +270,7 @@ class Kinesis extends BaseAwsSdkPlugin {
     // 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 reservedBytes = dsmEnabled ? PATHWAY_FIELD_BYTES : 0
     const partitionKeyBytes = Buffer.byteLength(params.PartitionKey ?? '', 'utf8')
     if (
       Buffer.byteLength(serialized, 'utf8') + partitionKeyBytes + reservedBytes >

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

@@ -275,11 +275,7 @@ class Sqs extends BaseAwsSdkPlugin {
     for (let i = 0; i < messages.length; i++) {
       const message = messages[i]
       const carrier = carriers === undefined ? this.parseMessageCarrier(message) : carriers[i]
-      if (carrier) {
-        // Inert for EventBridge until its producer emits a pathway (separate
-        // change) — no `dd-pathway-ctx-base64` to decode yet; SQS/SNS decode now.
-        this.tracer.decodeDataStreamsContext(carrier)
-      }
+      this.tracer.decodeDataStreamsContext(carrier)
       const payloadSize = getHeadersSize({
         Body: message.Body,
         MessageAttributes: message.MessageAttributes,

package/packages/datadog-plugin-azure-functions/src/index.js

@@ -156,7 +156,7 @@ function setSpanLinks (triggerType, tracer, span, ctx) {
     : triggerMetadata.propertiesArray
 
   const addLinkFromProperties = (props) => {
-    if (!props || Object.keys(props).length === 0) return
+    if (!props) return
     const spanContext = tracer.extract('text_map', props)
     if (spanContext) {
       span.addLink({ context: spanContext })

package/packages/datadog-plugin-browser-bunyan/src/index.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const BunyanPlugin = require('../../datadog-plugin-bunyan/src')
+
+class BrowserBunyanPlugin extends BunyanPlugin {
+  static id = 'browser-bunyan'
+}
+
+module.exports = BrowserBunyanPlugin

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

@@ -8,17 +8,14 @@ class BunyanPlugin extends LogPlugin {
 
   constructor (...args) {
     super(...args)
-    this.addSub('apm:bunyan:log', (arg) => this.handleLog(arg))
+    this.addSub(`apm:${this.constructor.id}:log`, (arg) => this.handleLog(arg))
   }
 
   /**
-   * Inject `dd` directly on the record bunyan hands us. bunyan builds the
-   * record inside `mkRecord` via `objCopy(log.fields)` and then copies the
-   * caller's fields onto the result, so the `rec` object that flows
-   * through `_emit` is always bunyan-owned, has `Object.prototype` for its
-   * prototype, and is never the caller's input directly. Mutating it adds
-   * `dd` for every consumer (JSON streams via `JSON.stringify(rec)`, raw
-   * streams via the record reference) without paying for a Proxy view.
+   * Inject `dd` directly on the record Bunyan implementations hand us. They build the record
+   * inside `mkRecord` from a copy of the logger and caller fields, so the `rec` object that flows
+   * through `_emit` is always logger-owned. Mutating it adds `dd` for every consumer without
+   * paying for a Proxy view.
    *
    * @param {{ message: object }} arg
    */

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

@@ -72,6 +72,7 @@ class CucumberPlugin extends CiPlugin {
       isEarlyFlakeDetectionFaulty,
       isTestManagementTestsEnabled,
       isParallel,
+      error,
       onDone,
     }) => {
       this._exportPendingWorkerTraces()
@@ -115,6 +116,15 @@ class CucumberPlugin extends CiPlugin {
 
       this.testSessionSpan.setTag(TEST_STATUS, status)
       this.testModuleSpan.setTag(TEST_STATUS, status)
+      if (error) {
+        for (const testSuiteSpan of this._testSuiteSpansByTestSuite.values()) {
+          testSuiteSpan.setTag(TEST_STATUS, 'fail')
+          testSuiteSpan.setTag('error', error)
+        }
+        this.testSessionSpan.setTag('error', error)
+        this.testModuleSpan.setTag('error', error)
+      }
+      this.tracer._exporter.exportDeferredTestSuiteSpans?.()
       this.testModuleSpan.finish()
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
       this.testSessionSpan.finish()
@@ -192,6 +202,7 @@ class CucumberPlugin extends CiPlugin {
     this.addSub('ci:cucumber:test-suite:finish', ({ status, testSuitePath }) => {
       const testSuiteSpan = this._testSuiteSpansByTestSuite.get(testSuitePath)
       testSuiteSpan.setTag(TEST_STATUS, status)
+      this.tracer._exporter.deferTestSuiteSpan?.(testSuiteSpan)
       testSuiteSpan.finish()
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
     })

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

@@ -1,5 +1,9 @@
 'use strict'
 
 const cypressPlugin = require('./cypress-plugin')
+const { shouldDeferLegacyFinalization } = require('./finalization')
 
-module.exports = cypressPlugin.afterRun.bind(cypressPlugin)
+module.exports = function afterRun () {
+  if (shouldDeferLegacyFinalization()) return
+  return cypressPlugin.afterRun.apply(cypressPlugin, arguments)
+}

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

@@ -1,5 +1,9 @@
 'use strict'
 
 const cypressPlugin = require('./cypress-plugin')
+const { shouldDeferLegacyFinalization } = require('./finalization')
 
-module.exports = cypressPlugin.afterSpec.bind(cypressPlugin)
+module.exports = function afterSpec () {
+  if (shouldDeferLegacyFinalization()) return
+  return cypressPlugin.afterSpec.apply(cypressPlugin, arguments)
+}