dd-trace 5.111.0 → 5.112.0

package/packages/datadog-plugin-mongodb-core/src/query.js

@@ -0,0 +1,452 @@
+'use strict'
+
+const { isMap, isRegExp } = require('node:util').types
+
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+
+class MongodbCoreQueryPlugin extends DatabasePlugin {
+  static id = 'mongodb-core'
+  static component = 'mongodb'
+  // avoid using db.name for peer.service since it includes the collection name
+  // should be removed if one day this will be fixed
+  /**
+   * @override
+   */
+  static peerServicePrecursors = []
+
+  /**
+   * @override
+   */
+  configure (config) {
+    super.configure(config)
+
+    this.config.heartbeatEnabled = config.heartbeatEnabled ??
+      this._tracerConfig.DD_TRACE_MONGODB_HEARTBEAT_ENABLED
+    this.config.obfuscateQuery = normaliseObfuscateQuery(
+      config.obfuscateQuery ?? this._tracerConfig.DD_TRACE_MONGODB_OBFUSCATE_QUERY
+    )
+  }
+
+  bindStart (ctx) {
+    const { ns, ops, options = {}, name } = ctx
+    // heartbeat commands can be disabled if this.config.heartbeatEnabled is false
+    if (!this.config.heartbeatEnabled && isHeartbeat(ops, this.config)) {
+      return
+    }
+    const query = getQuery(ops, this.config.obfuscateQuery)
+    const resource = truncate(getResource(this, ns, query, name))
+    const serviceResult = this.serviceName({ pluginConfig: this.config })
+    const span = this.startSpan(this.operationName(), {
+      service: serviceResult,
+      resource,
+      type: 'mongodb',
+      kind: 'client',
+      meta: {
+        // this is not technically correct since it includes the collection but we changing will break customer stuff
+        'db.name': ns,
+        'mongodb.query': query,
+        'out.host': options.host,
+        'out.port': options.port,
+      },
+    }, ctx)
+    const comment = this.injectDbmComment(span, ops.comment, serviceResult.name)
+    if (comment) {
+      ops.comment = comment
+    }
+
+    return ctx.currentStore
+  }
+
+  /**
+   * @override
+   */
+  getPeerService (tags) {
+    let ns = tags['db.name']
+    if (ns && tags['peer.service'] === undefined) {
+      const dotIndex = ns.indexOf('.')
+      if (dotIndex !== -1) {
+        ns = ns.slice(0, dotIndex)
+      }
+      // the mongo ns is either dbName either dbName.collection. So we keep the first part
+      tags['peer.service'] = ns
+    }
+    return super.getPeerService(tags)
+  }
+
+  injectDbmComment (span, comment, serviceName) {
+    const dbmTraceComment = this.createDbmComment(span, serviceName)
+
+    if (!dbmTraceComment) {
+      return comment
+    }
+
+    if (comment) {
+      // if the command already has a comment, append the dbm trace comment
+      if (typeof comment === 'string') {
+        comment += `,${dbmTraceComment}`
+      } else if (Array.isArray(comment)) {
+        comment.push(dbmTraceComment)
+      } // do nothing if the comment is not a string or an array
+    } else {
+      comment = dbmTraceComment
+    }
+
+    return comment
+  }
+}
+
+const MAX_DEPTH = 10
+const MAX_QUERY_LENGTH = 10_000
+
+function extractQuery (statements) {
+  if (statements.length === 1 && statements[0].q) return statements[0].q
+
+  const extractedQueries = []
+  for (let i = 0; i < statements.length; i++) {
+    if (statements[i].q) {
+      extractedQueries.push(statements[i].q)
+    }
+  }
+
+  return extractedQueries
+}
+
+/**
+ * @param {Record<string, unknown> | unknown[] | undefined} cmd
+ * @param {'none' | 'types' | 'redact'} mode
+ */
+function getQuery (cmd, mode) {
+  if (!cmd || (typeof cmd !== 'object' && !Array.isArray(cmd))) return
+
+  if (Array.isArray(cmd)) return sanitiseAndStringify(extractQuery(cmd), mode)
+  if (cmd.query) return sanitiseAndStringify(cmd.query, mode)
+  if (cmd.filter) return sanitiseAndStringify(cmd.filter, mode)
+  if (cmd.pipeline) return sanitiseAndStringify(cmd.pipeline, mode)
+  if (cmd.deletes) return sanitiseAndStringify(extractQuery(cmd.deletes), mode)
+  if (cmd.updates) return sanitiseAndStringify(extractQuery(cmd.updates), mode)
+}
+
+function getResource (plugin, ns, query, operationName) {
+  let resource = `${operationName} ${ns}`
+
+  if (plugin.config.queryInResourceName && query) {
+    resource += ` ${query}`
+  }
+
+  return resource
+}
+
+function truncate (input) {
+  return input.length > MAX_QUERY_LENGTH ? input.slice(0, MAX_QUERY_LENGTH) : input
+}
+
+// Depth doubles as the cycle bound: a cycle pushes past MAX_DEPTH and bails,
+// after which the slow path catches it via its ancestor stack.
+/** @param {unknown} input */
+function canStringifyDirect (input) {
+  if (input === null ||
+      typeof input !== 'object' ||
+      ArrayBuffer.isView(input) ||
+      input._bsontype !== undefined ||
+      isRegExp(input) ||
+      isMap(input) ||
+      typeof input.toJSON === 'function') {
+    return false
+  }
+  return canStringifyDirectWalk(input, 1)
+}
+
+/**
+ * @param {Record<string, unknown> | unknown[]} value
+ * @param {number} depth
+ */
+function canStringifyDirectWalk (value, depth) {
+  if (depth > MAX_DEPTH) return false
+  const children = Array.isArray(value) ? value : Object.values(value)
+  for (const child of children) {
+    if (child === null ||
+        typeof child === 'string' ||
+        typeof child === 'number' ||
+        typeof child === 'boolean') {
+      continue
+    }
+    if (typeof child !== 'object' ||
+        ArrayBuffer.isView(child) ||
+        child._bsontype !== undefined ||
+        isRegExp(child) ||
+        isMap(child) ||
+        typeof child.toJSON === 'function') {
+      return false
+    }
+    if (!canStringifyDirectWalk(child, depth + 1)) return false
+  }
+  return true
+}
+
+/**
+ * @param {Record<string, unknown> | unknown[]} input
+ * @param {'none' | 'types' | 'redact'} mode
+ */
+function sanitiseAndStringify (input, mode) {
+  if (mode === 'none') {
+    if (canStringifyDirect(input)) return JSON.stringify(input)
+    return buildNone(input, [])
+  }
+  if (mode === 'redact') return buildRedact(input, [])
+  return buildTypes(input, [])
+}
+
+const REDACT_LEAF = '"?"'
+
+/**
+ * @param {RegExp} value
+ * @returns {string}
+ */
+function stringifyRegExp (value) {
+  return `{"$regex":${JSON.stringify(value.source)},"$options":${JSON.stringify(value.flags)}}`
+}
+
+/**
+ * @param {Record<string, unknown> | unknown[]} value
+ * @param {object[]} ancestors
+ * @returns {string | undefined}
+ */
+function buildNone (value, ancestors) {
+  // ArrayBuffer views (Buffer, every TypedArray, DataView) and Binary BSON
+  // wrappers redact at the leaf; the walker neither recurses into the bytes
+  // nor invokes any custom conversion.
+  const bsontype = value._bsontype
+  if (ArrayBuffer.isView(value) || bsontype === 'Binary' ||
+      ancestors.length >= MAX_DEPTH || ancestors.includes(value)) {
+    return REDACT_LEAF
+  }
+
+  if (isRegExp(value)) return stringifyRegExp(value)
+
+  // Mirror JSON.stringify's contract: when `toJSON` is present, walk its
+  // result (wrappers like Timestamp / Decimal128 expand to a small object,
+  // ObjectId / Date flatten to a primitive).
+  if (typeof value.toJSON === 'function') {
+    const json = value.toJSON()
+    if (json === value) return REDACT_LEAF
+    // JSON.stringify keeps a null result as null (an invalid Date's toJSON
+    // returns null); only function / symbol / undefined results drop the key.
+    if (json === null) return 'null'
+    if (typeof json !== 'object') return classifyLeafForNone(json)
+    // A wrapper that exposes binary state through toJSON (Buffer-backed
+    // class with WeakMap state, etc.) returns a TypedArray here. Re-screen
+    // before the per-key walk would expand it element by element.
+    if (ArrayBuffer.isView(json) || json._bsontype === 'Binary') return REDACT_LEAF
+    value = json
+  } else if (bsontype !== undefined) {
+    return REDACT_LEAF
+  }
+
+  // The driver serializes a Map via its entries; mirror that as a document so
+  // the tag matches the wire shape.
+  if (isMap(value)) value = Object.fromEntries(value)
+
+  ancestors.push(value)
+
+  let result
+  if (Array.isArray(value)) {
+    result = '['
+    let sep = ''
+    for (let i = 0; i < value.length; i++) {
+      // JSON.stringify renders unsupported leaves (function, symbol, undefined) as null in arrays.
+      result += sep + (classifyForNone(value[i], ancestors) ?? 'null')
+      sep = ','
+    }
+    result += ']'
+  } else {
+    result = '{'
+    let sep = ''
+    for (const key of Object.keys(value)) {
+      const childResult = classifyForNone(value[key], ancestors)
+      if (childResult === undefined) continue
+      result += sep + JSON.stringify(key) + ':' + childResult
+      sep = ','
+    }
+    result += '}'
+  }
+  ancestors.pop()
+  return result
+}
+
+/**
+ * @param {unknown} child
+ * @param {object[]} ancestors
+ * @returns {string | undefined}
+ */
+function classifyForNone (child, ancestors) {
+  if (typeof child !== 'object') return classifyLeafForNone(child)
+  if (child === null) return 'null'
+  return buildNone(child, ancestors)
+}
+
+/**
+ * @param {unknown} leaf
+ * @returns {string | undefined}
+ */
+function classifyLeafForNone (leaf) {
+  // Implicit `undefined` for function / symbol / undefined matches the
+  // contract callers rely on: JSON.stringify drops those property values
+  // inside objects and writes `null` in arrays.
+  switch (typeof leaf) {
+    case 'string': return JSON.stringify(leaf)
+    case 'number': return Number.isFinite(leaf) ? String(leaf) : 'null'
+    case 'boolean': return leaf ? 'true' : 'false'
+    case 'bigint': return `"${String(leaf)}"`
+  }
+}
+
+/**
+ * @param {Record<string, unknown> | unknown[]} value
+ * @param {object[]} ancestors
+ */
+function buildRedact (value, ancestors) {
+  const bsontype = value._bsontype
+  if (ArrayBuffer.isView(value) || bsontype === 'Binary' || isRegExp(value) ||
+      ancestors.length >= MAX_DEPTH || ancestors.includes(value)) {
+    return REDACT_LEAF
+  }
+
+  // Mirror JSON.stringify: when `toJSON` is present, walk its result (which
+  // wrappers like Timestamp / Decimal128 expand to `{$timestamp: "..."}` etc).
+  // A primitive, null, or self-reference collapses to the sentinel — master's
+  // `value === original` short-circuit.
+  if (typeof value.toJSON === 'function') {
+    const json = value.toJSON()
+    if (typeof json !== 'object' || json === null || json === value) return REDACT_LEAF
+    // Re-screen: toJSON can return a TypedArray or Binary BSON wrapper.
+    if (ArrayBuffer.isView(json) || json._bsontype === 'Binary') return REDACT_LEAF
+    value = json
+  } else if (bsontype !== undefined) {
+    return REDACT_LEAF
+  }
+
+  if (isMap(value)) value = Object.fromEntries(value)
+
+  ancestors.push(value)
+
+  let result
+  if (Array.isArray(value)) {
+    result = '['
+    let sep = ''
+    for (let i = 0; i < value.length; i++) {
+      result += sep + classifyForRedact(value[i], ancestors)
+      sep = ','
+    }
+    result += ']'
+  } else {
+    result = '{'
+    let sep = ''
+    for (const key of Object.keys(value)) {
+      result += sep + JSON.stringify(key) + ':' + classifyForRedact(value[key], ancestors)
+      sep = ','
+    }
+    result += '}'
+  }
+  ancestors.pop()
+  return result
+}
+
+/**
+ * @param {unknown} child
+ * @param {object[]} ancestors
+ */
+function classifyForRedact (child, ancestors) {
+  if (typeof child !== 'object' || child === null) return REDACT_LEAF
+  return buildRedact(child, ancestors)
+}
+
+const TYPE_OBJECT = '"object"'
+const TYPE_NULL = '"null"'
+const TYPE_BY_TYPEOF = {
+  string: '"string"',
+  number: '"number"',
+  boolean: '"boolean"',
+  bigint: '"bigint"',
+  undefined: '"undefined"',
+}
+
+/**
+ * @param {Record<string, unknown> | unknown[]} value
+ * @param {object[]} ancestors
+ */
+function buildTypes (value, ancestors) {
+  const bsontype = value._bsontype
+  if (ArrayBuffer.isView(value) || bsontype === 'Binary' || isRegExp(value) ||
+      ancestors.length >= MAX_DEPTH || ancestors.includes(value)) {
+    return TYPE_OBJECT
+  }
+
+  if (typeof value.toJSON === 'function') {
+    const json = value.toJSON()
+    if (typeof json !== 'object' ||
+        json === null ||
+        json === value ||
+        ArrayBuffer.isView(json) ||
+        json._bsontype === 'Binary') {
+      return TYPE_OBJECT
+    }
+    value = json
+  } else if (bsontype !== undefined) {
+    return TYPE_OBJECT
+  }
+
+  if (isMap(value)) value = Object.fromEntries(value)
+
+  ancestors.push(value)
+
+  let result
+  if (Array.isArray(value)) {
+    result = '['
+    let sep = ''
+    for (let i = 0; i < value.length; i++) {
+      // JSON.stringify renders unsupported leaves (function, symbol) as null in arrays.
+      result += sep + (classifyForTypes(value[i], ancestors) ?? 'null')
+      sep = ','
+    }
+    result += ']'
+  } else {
+    result = '{'
+    let sep = ''
+    for (const key of Object.keys(value)) {
+      const childResult = classifyForTypes(value[key], ancestors)
+      if (childResult === undefined) continue
+      result += sep + JSON.stringify(key) + ':' + childResult
+      sep = ','
+    }
+    result += '}'
+  }
+  ancestors.pop()
+  return result
+}
+
+/**
+ * @param {unknown} child
+ * @param {object[]} ancestors
+ */
+function classifyForTypes (child, ancestors) {
+  if (typeof child !== 'object') return TYPE_BY_TYPEOF[typeof child]
+  if (child === null) return TYPE_NULL
+  return buildTypes(child, ancestors)
+}
+
+/** @param {unknown} value */
+function normaliseObfuscateQuery (value) {
+  if (value === 'types' || value === 'redact') return value
+  return 'none'
+}
+
+function isHeartbeat (ops, config) {
+  // Check if it's a heartbeat command https://github.com/mongodb/specifications/blob/master/source/mongodb-handshake/handshake.md
+  return (
+    ops &&
+    typeof ops === 'object' &&
+    (ops.hello === 1 || ops.helloOk === true || ops.ismaster === 1 || ops.isMaster === 1)
+  )
+}
+
+module.exports = MongodbCoreQueryPlugin

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

@@ -87,7 +87,7 @@ class PlaywrightPlugin extends CiPlugin {
       if (isEarlyFlakeDetectionFaulty) {
         this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ABORT_REASON, 'faulty')
       }
-      if (this.numFailedSuites > 0) {
+      if (status === 'fail' && this.numFailedSuites > 0) {
         let errorMessage = `Test suites failed: ${this.numFailedSuites}.`
         if (this.numFailedTests > 0) {
           errorMessage += ` Tests failed: ${this.numFailedTests}`
@@ -113,6 +113,7 @@ class PlaywrightPlugin extends CiPlugin {
       appClosingTelemetry()
       this.tracer._exporter.flush(onDone)
       this.numFailedTests = 0
+      this.numFailedSuites = 0
     })
 
     this.addBind('ci:playwright:test-suite:start', (ctx) => {
@@ -408,7 +409,7 @@ class PlaywrightPlugin extends CiPlugin {
         }
         stepSpan.finish(stepStartTime + stepDuration)
       }
-      if (testStatus === 'fail') {
+      if (finalStatus === 'fail') {
         this.numFailedTests++
       }
 

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

@@ -67,6 +67,7 @@ class VitestPlugin extends CiPlugin {
         testCommand: this.command,
         repositoryRoot: this.repositoryRoot,
         codeOwnersEntries: this.codeOwnersEntries,
+        testEnvironmentMetadata: this.testEnvironmentMetadata,
       })
     })
 
@@ -192,7 +193,7 @@ class VitestPlugin extends CiPlugin {
       return ctx.currentStore
     })
 
-    this.addSub('ci:vitest:test:pass', ({ span, task, finalStatus, earlyFlakeAbortReason }) => {
+    this.addSub('ci:vitest:test:pass', ({ span, task, finalStatus, earlyFlakeAbortReason, promises }) => {
       if (span) {
         this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'test', this.getTestTelemetryTags(span))
         span.setTag(TEST_STATUS, 'pass')
@@ -202,8 +203,21 @@ class VitestPlugin extends CiPlugin {
         if (earlyFlakeAbortReason) {
           span.setTag(TEST_EARLY_FLAKE_ABORT_REASON, earlyFlakeAbortReason)
         }
-        span.finish(this.taskToFinishTime.get(task))
-        finishAllTraceSpans(span)
+        const finish = () => {
+          span.finish(this.taskToFinishTime.get(task))
+          finishAllTraceSpans(span)
+        }
+
+        if (finalStatus) {
+          if (promises && this.diBreakpointHitPromise) {
+            promises.hitBreakpointPromise = this.waitForPreparedDiBreakpointHit().then(finish)
+            return
+          }
+          finish()
+          this.cancelDiBreakpointHitWait()
+          return
+        }
+        finish()
       }
     })
 
@@ -212,6 +226,7 @@ class VitestPlugin extends CiPlugin {
       duration,
       error,
       shouldSetProbe,
+      shouldWaitForHitProbe,
       promises,
       hasFailedAllRetries,
       attemptToFixFailed,
@@ -227,7 +242,8 @@ class VitestPlugin extends CiPlugin {
           const { file, line, stackIndex, setProbePromise } = probeInformation
           this.runningTestProbe = { file, line }
           this.testErrorStackIndex = stackIndex
-          promises.setProbePromise = setProbePromise
+          this.prepareDiBreakpointHitWait()
+          promises.setProbePromise = this.waitForDiOperation(setProbePromise)
         }
       }
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'test', this.getTestTelemetryTags(span))
@@ -248,12 +264,31 @@ class VitestPlugin extends CiPlugin {
       if (earlyFlakeAbortReason) {
         span.setTag(TEST_EARLY_FLAKE_ABORT_REASON, earlyFlakeAbortReason)
       }
-      if (duration) {
-        span.finish(span._startTime + duration - MILLISECONDS_TO_SUBTRACT_FROM_FAILED_TEST_DURATION) // milliseconds
-      } else {
-        span.finish() // `duration` is empty for retries, so we'll use clock time
+      const finish = () => {
+        if (duration) {
+          span.finish(span._startTime + duration - MILLISECONDS_TO_SUBTRACT_FROM_FAILED_TEST_DURATION) // milliseconds
+        } else {
+          span.finish() // `duration` is empty for retries, so we'll use clock time
+        }
+        finishAllTraceSpans(span)
+      }
+
+      if (!shouldSetProbe && finalStatus && promises && this.diBreakpointHitPromise) {
+        promises.hitBreakpointPromise = this.waitForPreparedDiBreakpointHit().then(finish)
+        return
+      }
+      finish()
+      if (shouldWaitForHitProbe) {
+        this.prepareDiBreakpointHitWait()
+      } else if (!shouldSetProbe) {
+        this.cancelDiBreakpointHitWait()
+      }
+    })
+
+    this.addSub('ci:vitest:test:di:wait', ({ promises }) => {
+      if (this.di) {
+        promises.hitBreakpointPromise = this.waitForDiBreakpointHits()
       }
-      finishAllTraceSpans(span)
     })
 
     this.addSub('ci:vitest:test:skip', ({
@@ -289,6 +324,7 @@ class VitestPlugin extends CiPlugin {
       const {
         codeOwnersEntries,
         repositoryRoot,
+        testEnvironmentMetadata,
         requestErrorTags,
         testSuiteAbsolutePath,
         frameworkVersion,
@@ -298,6 +334,12 @@ class VitestPlugin extends CiPlugin {
 
       const testCommand = ctx.testCommand || 'vitest run'
       const { testSessionId, testModuleId } = ctx
+      if (testEnvironmentMetadata) {
+        this.testEnvironmentMetadata = {
+          ...this.testEnvironmentMetadata,
+          ...testEnvironmentMetadata,
+        }
+      }
       this._setRepositoryRoot(repositoryRoot, codeOwnersEntries)
       this.command = testCommand
       this.frameworkVersion = frameworkVersion

package/packages/dd-trace/src/aiguard/index.js

@@ -2,15 +2,11 @@
 
 const log = require('../log')
 const { incomingHttpRequestStart } = require('./channels')
-const openaiIntegration = require('./integrations/openai')
-const vercelAiIntegration = require('./integrations/vercel-ai')
+const integrations = require('./integrations')
 const AIGuard = require('./sdk')
 
 let isEnabled = false
 let aiguard
-let block
-let disableOpenAIIntegration
-let disableVercelAiIntegration
 
 function onIncomingHttpRequestStart () {
   // No-op: subscribing ensures the HTTP plugin spreads req onto the store
@@ -21,31 +17,30 @@ function enable (tracer, config) {
 
   try {
     aiguard = new AIGuard(tracer, config)
-    block = config.experimental?.aiguard?.block !== false
+    const block = config.experimental?.aiguard?.block !== false
 
     incomingHttpRequestStart.subscribe(onIncomingHttpRequestStart)
-    disableOpenAIIntegration = openaiIntegration.enable(aiguard, block)
-    disableVercelAiIntegration = vercelAiIntegration.enable(aiguard, block)
+    integrations.enable(aiguard, block)
 
     isEnabled = true
   } catch (err) {
     log.error('AIGuard: unexpected error during initialization: %s', err.message)
-    disable()
+    reset()
   }
 }
 
 function disable () {
   if (!isEnabled) return
 
+  reset()
+}
+
+function reset () {
   incomingHttpRequestStart.unsubscribe(onIncomingHttpRequestStart)
-  disableOpenAIIntegration?.()
-  disableVercelAiIntegration?.()
+  integrations.disable()
 
   aiguard = undefined
   isEnabled = false
-  block = false
-  disableOpenAIIntegration = undefined
-  disableVercelAiIntegration = undefined
 }
 
 module.exports = { enable, disable }

package/packages/dd-trace/src/aiguard/integrations/index.js

@@ -0,0 +1,34 @@
+'use strict'
+
+const openai = require('./openai')
+const vercelAi = require('./vercel-ai')
+
+let isEnabled = false
+
+/**
+ * Enables all AI Guard provider integrations.
+ *
+ * @param {object} aiguard
+ * @param {boolean} block
+ */
+function enable (aiguard, block) {
+  if (isEnabled) return
+
+  openai.enable(aiguard, block)
+  vercelAi.enable(aiguard, block)
+
+  isEnabled = true
+}
+
+function disable () {
+  vercelAi.disable()
+  openai.disable()
+  isEnabled = false
+}
+
+module.exports = {
+  enable,
+  disable,
+  openai,
+  vercelAi,
+}