dd-trace 5.101.0 → 5.103.0

package/packages/datadog-plugin-graphql/src/utils.js

@@ -44,6 +44,35 @@ function extractErrorIntoSpanEvent (config, span, exc) {
   span.addEvent('dd.graphql.query.error', attributes, Date.now())
 }
 
+let tools
+
+function getSignature (document, operationName, operationType, calculate) {
+  if (calculate !== false && tools !== false) {
+    try {
+      try {
+        tools ||= require('./tools')
+      } catch (e) {
+        tools = false
+        throw e
+      }
+
+      return tools.defaultEngineReportingSignature(document, operationName)
+    } catch {
+      // safety net
+    }
+  }
+
+  if (operationType) {
+    if (operationName) {
+      return `${operationType} ${operationName}`
+    }
+    return operationType
+  }
+
+  return operationName ?? ''
+}
+
 module.exports = {
   extractErrorIntoSpanEvent,
+  getSignature,
 }

package/packages/datadog-plugin-grpc/src/client.js

@@ -86,12 +86,11 @@ class GrpcClientPlugin extends ClientPlugin {
       // The only scheme we want to support here is ipv[46]:port, although
       // more are supported by the library
       // https://github.com/grpc/grpc/blob/v1.60.0/doc/naming.md
-      const parts = peer.split(':')
-      if (/^\d+/.test(parts.at(-1))) {
-        const port = parts.at(-1)
-        const ip = parts.slice(0, -1).join(':')
-        span.setTag('network.destination.ip', ip)
-        span.setTag('network.destination.port', port)
+      const colonIndex = peer.lastIndexOf(':')
+      const tail = colonIndex === -1 ? '' : peer.slice(colonIndex + 1)
+      if (tail && /^\d+$/.test(tail)) {
+        span.setTag('network.destination.ip', peer.slice(0, colonIndex))
+        span.setTag('network.destination.port', tail)
       } else {
         span.setTag('network.destination.ip', peer)
       }
@@ -121,7 +120,7 @@ function inject (tracer, span, metadata) {
 
   tracer.inject(span, TEXT_MAP, carrier)
 
-  for (const key in carrier) {
+  for (const key of Object.keys(carrier)) {
     metadata.set(key, carrier[key])
   }
 }

package/packages/datadog-plugin-grpc/src/util.js

@@ -3,46 +3,81 @@
 const pick = require('../../datadog-core/src/utils/src/pick')
 const log = require('../../dd-trace/src/log')
 
+/**
+ * @typedef {object} ParsedMethodPath
+ * @property {string} name
+ * @property {string} service
+ * @property {string} package
+ */
+
+// Sentinel returned by `getFilter` when the user has not configured a metadata
+// filter. `addMetadataTags` short-circuits on this identity to skip the
+// `metadata.getMap()` clone in the default no-filter case.
 function getEmptyObject () {
   return {}
 }
 
-module.exports = {
-  getMethodMetadata (path, kind) {
-    const tags = {
-      path,
-      kind,
-      name: '',
-      service: '',
-      package: '',
+/**
+ * gRPC method paths are stable per service definition (e.g.
+ * `/pkg.Service/Method`); a service typically only has a small finite set.
+ * Cache the parsed `{name, service, package}` triple by path so we skip the
+ * `path.split('/')` + `serviceParts.split('.')` + `serviceParts.pop()` work
+ * on every call.
+ *
+ * @type {Map<string, ParsedMethodPath>}
+ */
+const methodPathCache = new Map()
+
+/**
+ * @param {string} path
+ * @returns {ParsedMethodPath}
+ */
+function parseMethodPath (path) {
+  const methodParts = path.split('/')
+
+  if (methodParts.length > 2) {
+    const serviceParts = methodParts[1].split('.')
+    return {
+      name: methodParts[2],
+      service: serviceParts.pop(),
+      package: serviceParts.join('.'),
     }
+  }
 
-    if (typeof path !== 'string') return tags
+  return { name: methodParts.at(-1), service: '', package: '' }
+}
 
-    const methodParts = path.split('/')
+module.exports = {
+  getEmptyObject,
 
-    if (methodParts.length > 2) {
-      const serviceParts = methodParts[1].split('.')
-      const name = methodParts[2]
-      const service = serviceParts.pop()
-      const pkg = serviceParts.join('.')
+  getMethodMetadata (path, kind) {
+    if (typeof path !== 'string') {
+      return { path, kind, name: '', service: '', package: '' }
+    }
 
-      tags.name = name
-      tags.service = service
-      tags.package = pkg
-    } else {
-      tags.name = methodParts.at(-1)
+    let parsed = methodPathCache.get(path)
+    if (parsed === undefined) {
+      parsed = parseMethodPath(path)
+      methodPathCache.set(path, parsed)
     }
 
-    return tags
+    return {
+      path,
+      kind,
+      name: parsed.name,
+      service: parsed.service,
+      package: parsed.package,
+    }
   },
 
   addMetadataTags (span, metadata, filter, type) {
     if (!metadata || typeof metadata.getMap !== 'function') return
+    // Default no-op filter: skip the full metadata clone via `getMap()`.
+    if (filter === getEmptyObject) return
 
     const values = filter(metadata.getMap())
 
-    for (const key in values) {
+    for (const key of Object.keys(values)) {
       span.setTag(`grpc.${type}.metadata.${key}`, values[key])
     }
   },

package/packages/datadog-plugin-http/src/client.js

@@ -39,10 +39,10 @@ class HttpClientPlugin extends ClientPlugin {
     // TODO delegate to super.startspan
     const span = this.startSpan(this.operationName(), {
       childOf,
-      integrationName: this.constructor.id,
+      integrationName: this.component,
       service: this.serviceName({ pluginConfig: this.config, sessionDetails: extractSessionDetails(options) }),
       meta: {
-        [COMPONENT]: this.constructor.id,
+        [COMPONENT]: this.component,
         'span.kind': 'client',
         'resource.name': method,
         'span.type': 'http',
@@ -79,11 +79,7 @@ class HttpClientPlugin extends ClientPlugin {
   }
 
   shouldInjectTraceHeaders (options, uri) {
-    if (!this.config.propagationFilter(uri)) {
-      return false
-    }
-
-    return true
+    return Boolean(this.config.propagationFilter(uri))
   }
 
   bindAsyncStart ({ parentStore }) {

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

@@ -21,6 +21,7 @@ const {
   TEST_SOURCE_START,
   TEST_ITR_UNSKIPPABLE,
   TEST_ITR_FORCED_RUN,
+  TEST_ITR_SKIPPING_ENABLED,
   TEST_CODE_OWNERS,
   ITR_CORRELATION_ID,
   TEST_SOURCE_FILE,
@@ -107,6 +108,7 @@ class JestPlugin extends CiPlugin {
       process.on('message', handler)
     }
     this.testSuiteSpanPerTestSuiteAbsolutePath = new Map()
+    this.pendingTestSuiteFinishes = new Set()
 
     this.addSub('ci:jest:session:finish', ({
       status,
@@ -123,58 +125,66 @@ class JestPlugin extends CiPlugin {
       isTestManagementTestsEnabled,
       onDone,
     }) => {
-      this.testSessionSpan.setTag(TEST_STATUS, status)
-      this.testModuleSpan.setTag(TEST_STATUS, status)
+      const finishSession = () => {
+        this.testSessionSpan.setTag(TEST_STATUS, status)
+        this.testModuleSpan.setTag(TEST_STATUS, status)
 
-      if (error) {
-        this.testSessionSpan.setTag('error', error)
-        this.testModuleSpan.setTag('error', error)
-      }
-
-      addIntelligentTestRunnerSpanTags(
-        this.testSessionSpan,
-        this.testModuleSpan,
-        {
-          isSuitesSkipped,
-          isSuitesSkippingEnabled,
-          isCodeCoverageEnabled,
-          testCodeCoverageLinesTotal,
-          skippingType: 'suite',
-          skippingCount: numSkippedSuites,
-          hasUnskippableSuites,
-          hasForcedToRunSuites,
+        if (error) {
+          this.testSessionSpan.setTag('error', error)
+          this.testModuleSpan.setTag('error', error)
         }
-      )
 
-      if (isEarlyFlakeDetectionEnabled) {
-        this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ENABLED, 'true')
-      }
-      if (isEarlyFlakeDetectionFaulty) {
-        this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ABORT_REASON, 'faulty')
-      }
-      if (isTestManagementTestsEnabled) {
-        this.testSessionSpan.setTag(TEST_MANAGEMENT_ENABLED, 'true')
-      }
+        addIntelligentTestRunnerSpanTags(
+          this.testSessionSpan,
+          this.testModuleSpan,
+          {
+            isSuitesSkipped,
+            isSuitesSkippingEnabled,
+            isCodeCoverageEnabled,
+            testCodeCoverageLinesTotal,
+            skippingType: 'suite',
+            skippingCount: numSkippedSuites,
+            hasUnskippableSuites,
+            hasForcedToRunSuites,
+          }
+        )
 
-      this.testModuleSpan.finish()
-      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
-      this.testSessionSpan.finish()
-      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'session', {
-        hasFailedTestReplay: this.libraryConfig?.isDiEnabled || undefined,
-      })
-      finishAllTraceSpans(this.testSessionSpan)
+        if (isEarlyFlakeDetectionEnabled) {
+          this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ENABLED, 'true')
+        }
+        if (isEarlyFlakeDetectionFaulty) {
+          this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ABORT_REASON, 'faulty')
+        }
+        if (isTestManagementTestsEnabled) {
+          this.testSessionSpan.setTag(TEST_MANAGEMENT_ENABLED, 'true')
+        }
 
-      this.telemetry.count(TELEMETRY_TEST_SESSION, {
-        provider: this.ciProviderName,
-        autoInjected: !!this._tracerConfig.DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER,
-      })
+        this.testModuleSpan.finish()
+        this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
+        this.testSessionSpan.finish()
+        this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'session', {
+          hasFailedTestReplay: this.libraryConfig?.isDiEnabled || undefined,
+        })
+        finishAllTraceSpans(this.testSessionSpan)
+
+        this.telemetry.count(TELEMETRY_TEST_SESSION, {
+          provider: this.ciProviderName,
+          autoInjected: !!this._tracerConfig.DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER,
+        })
+
+        appClosingTelemetry()
+        this.tracer._exporter.flush(() => {
+          if (onDone) {
+            onDone()
+          }
+        })
+      }
 
-      appClosingTelemetry()
-      this.tracer._exporter.flush(() => {
-        if (onDone) {
-          onDone()
-        }
-      })
+      if (this.pendingTestSuiteFinishes.size > 0) {
+        Promise.all(this.pendingTestSuiteFinishes).then(finishSession)
+      } else {
+        finishSession()
+      }
     })
 
     // Test suites can be run in a different process from jest's main one.
@@ -197,6 +207,7 @@ class JestPlugin extends CiPlugin {
         config._ddIsDiEnabled = this.libraryConfig?.isDiEnabled ?? false
         config._ddIsKnownTestsEnabled = this.libraryConfig?.isKnownTestsEnabled ?? false
         config._ddIsImpactedTestsEnabled = this.libraryConfig?.isImpactedTestsEnabled ?? false
+        config._ddItrSkippingEnabledTags = this.getSessionItrSkippingEnabledTags()
       }
     })
 
@@ -217,6 +228,7 @@ class JestPlugin extends CiPlugin {
         _ddForcedToRun,
         _ddUnskippable,
         _ddTestCodeCoverageEnabled,
+        _ddItrSkippingEnabledTags: itrSkippingEnabledTags,
       } = testEnvironmentOptions
 
       const testSessionSpanContext = this.tracer.extract('text_map', {
@@ -228,6 +240,7 @@ class JestPlugin extends CiPlugin {
         ...getTestSuiteCommonTags(testCommand, frameworkVersion, testSuite, 'jest'),
         // requestErrorTags from test env options may be undefined
         ...(requestErrorTags !== undefined && requestErrorTags !== null ? requestErrorTags : {}),
+        ...(itrSkippingEnabledTags !== undefined && itrSkippingEnabledTags !== null ? itrSkippingEnabledTags : {}),
       }
 
       if (_ddUnskippable) {
@@ -305,10 +318,18 @@ class JestPlugin extends CiPlugin {
       }
     })
 
-    this.addSub('ci:jest:test-suite:finish', ({ status, errorMessage, error, testSuiteAbsolutePath }) => {
+    this.addSub('ci:jest:test-suite:finish', ({
+      status,
+      errorMessage,
+      error,
+      testSuiteAbsolutePath,
+      waitForFinish,
+      onDone,
+    }) => {
       const testSuiteSpan = this.testSuiteSpanPerTestSuiteAbsolutePath.get(testSuiteAbsolutePath)
       if (!testSuiteSpan) {
         log.warn('"ci:jest:test-suite:finish": no span found for test suite absolute path %s', testSuiteAbsolutePath)
+        onDone?.()
         return
       }
       testSuiteSpan.setTag(TEST_STATUS, status)
@@ -319,8 +340,13 @@ class JestPlugin extends CiPlugin {
         testSuiteSpan.setTag('error', new Error(errorMessage))
         testSuiteSpan.setTag(TEST_STATUS, 'fail')
       }
-      // We need to give the potential error in 'ci:jest:test-suite:error' time to be published
-      process.nextTick(() => {
+      let resolvePendingFinish
+      const pendingFinish = new Promise(resolve => {
+        resolvePendingFinish = resolve
+      })
+      this.pendingTestSuiteFinishes.add(pendingFinish)
+
+      const finish = () => {
         testSuiteSpan.finish()
         this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
         // Suites potentially run in a different process than the session,
@@ -334,7 +360,19 @@ class JestPlugin extends CiPlugin {
         }
         this.removeAllDiProbes()
         this.testSuiteSpanPerTestSuiteAbsolutePath.delete(testSuiteAbsolutePath)
-      })
+        this.pendingTestSuiteFinishes.delete(pendingFinish)
+        resolvePendingFinish()
+        if (onDone) {
+          onDone()
+        }
+      }
+
+      if (waitForFinish) {
+        // Give late async work time to run before Jest restarts a worker because of workerIdleMemoryLimit.
+        realSetTimeout(finish)
+      } else {
+        process.nextTick(finish)
+      }
     })
 
     this.addSub('ci:jest:test-suite:error', ({ error, errorMessage, testSuiteAbsolutePath }) => {
@@ -558,6 +596,10 @@ class JestPlugin extends CiPlugin {
       extraTags[TEST_HAS_DYNAMIC_NAME] = 'true'
     }
     const testSuiteSpan = this.testSuiteSpanPerTestSuiteAbsolutePath.get(testSuiteAbsolutePath) || this.testSuiteSpan
+    const skippingEnabled = testSuiteSpan?.context()._tags?.[TEST_ITR_SKIPPING_ENABLED]
+    if (skippingEnabled !== undefined) {
+      extraTags[TEST_ITR_SKIPPING_ENABLED] = skippingEnabled
+    }
 
     return super.startTestSpan(name, suite, testSuiteSpan, extraTags)
   }

package/packages/datadog-plugin-jest/src/util.js

@@ -3,7 +3,7 @@
 const { readFileSync } = require('fs')
 const { parse } = require('../../../vendor/dist/jest-docblock')
 
-const { getTestSuitePath, getEfdRetryCount } = require('../../dd-trace/src/plugins/util/test')
+const { getTestSuitePath } = require('../../dd-trace/src/plugins/util/test')
 const log = require('../../dd-trace/src/log')
 
 /**
@@ -172,5 +172,4 @@ module.exports = {
   getJestTestName,
   getJestSuitesToRun,
   isMarkedAsUnskippable,
-  getEfdRetryCount,
 }

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

@@ -105,6 +105,7 @@ class MochaPlugin extends CiPlugin {
           'mocha'
         ),
         ...this.getSessionRequestErrorTags(),
+        ...this.getSessionItrSkippingEnabledTags(),
       }
       if (isUnskippable) {
         testSuiteMetadata[TEST_ITR_UNSKIPPABLE] = 'true'
@@ -218,12 +219,16 @@ class MochaPlugin extends CiPlugin {
       isAttemptToFixRetry,
       isAtrRetry,
       finalStatus,
+      earlyFlakeAbortReason,
     }) => {
       if (span) {
         span.setTag(TEST_STATUS, status)
         if (finalStatus) {
           span.setTag(TEST_FINAL_STATUS, finalStatus)
         }
+        if (earlyFlakeAbortReason) {
+          span.setTag(TEST_EARLY_FLAKE_ABORT_REASON, earlyFlakeAbortReason)
+        }
         if (hasBeenRetried) {
           span.setTag(TEST_IS_RETRY, 'true')
           if (isAtrRetry) {

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

@@ -90,9 +90,8 @@ class MongodbCorePlugin extends DatabasePlugin {
   }
 }
 
-function sanitizeBigInt (data) {
-  return JSON.stringify(data, (_key, value) => typeof value === 'bigint' ? value.toString() : value)
-}
+const MAX_DEPTH = 10
+const MAX_QUERY_LENGTH = 10_000
 
 function extractQuery (statements) {
   if (statements.length === 1 && statements[0].q) return statements[0].q
@@ -100,7 +99,7 @@ function extractQuery (statements) {
   const extractedQueries = []
   for (let i = 0; i < statements.length; i++) {
     if (statements[i].q) {
-      extractedQueries.push(limitDepth(statements[i].q))
+      extractedQueries.push(statements[i].q)
     }
   }
 
@@ -110,12 +109,12 @@ function extractQuery (statements) {
 function getQuery (cmd) {
   if (!cmd || (typeof cmd !== 'object' && !Array.isArray(cmd))) return
 
-  if (Array.isArray(cmd)) return sanitizeBigInt(extractQuery(cmd))
-  if (cmd.query) return sanitizeBigInt(limitDepth(cmd.query))
-  if (cmd.filter) return sanitizeBigInt(limitDepth(cmd.filter))
-  if (cmd.pipeline) return sanitizeBigInt(limitDepth(cmd.pipeline))
-  if (cmd.deletes) return sanitizeBigInt(extractQuery(cmd.deletes))
-  if (cmd.updates) return sanitizeBigInt(extractQuery(cmd.updates))
+  if (Array.isArray(cmd)) return sanitiseAndStringify(extractQuery(cmd))
+  if (cmd.query) return sanitiseAndStringify(cmd.query)
+  if (cmd.filter) return sanitiseAndStringify(cmd.filter)
+  if (cmd.pipeline) return sanitiseAndStringify(cmd.pipeline)
+  if (cmd.deletes) return sanitiseAndStringify(extractQuery(cmd.deletes))
+  if (cmd.updates) return sanitiseAndStringify(extractQuery(cmd.updates))
 }
 
 function getResource (plugin, ns, query, operationName) {
@@ -129,72 +128,40 @@ function getResource (plugin, ns, query, operationName) {
 }
 
 function truncate (input) {
-  return input.slice(0, Math.min(input.length, 10_000))
-}
-
-function shouldSimplify (input) {
-  return !isObject(input) || typeof input.toJSON === 'function'
+  return input.length > MAX_QUERY_LENGTH ? input.slice(0, MAX_QUERY_LENGTH) : input
 }
 
-function shouldHide (input) {
-  return Buffer.isBuffer(input) || typeof input === 'function' || isBinary(input)
-}
-
-function limitDepth (input) {
-  if (isBSON(input)) {
-    input = input.toJSON()
-  }
-
-  if (shouldHide(input)) return '?'
-  if (shouldSimplify(input)) return input
-
-  const output = {}
-  const queue = [{
-    input,
-    output,
-    depth: 0,
-  }]
-
-  while (queue.length) {
-    const {
-      input, output, depth,
-    } = queue.pop()
-    const nextDepth = depth + 1
-    for (const key of Object.keys(input)) {
-      let child = input[key]
-      if (typeof child === 'function') continue
-
-      if (isBSON(child)) {
-        child = typeof child.toJSON === 'function' ? child.toJSON() : '?'
-      }
-
-      if (depth >= 10 || shouldHide(child)) {
-        output[key] = '?'
-      } else if (shouldSimplify(child)) {
-        output[key] = child
-      } else {
-        queue.push({
-          input: child,
-          output: output[key] = {},
-          depth: nextDepth,
-        })
+// Single-pass sanitisation. The replacer:
+// - skips functions and coerces bigint to its decimal string,
+// - returns '?' for Buffer / BSON Binary on the *original* value (JSON.stringify already invoked
+//   toJSON before calling us; Buffer / Binary do have toJSON outputs we want to suppress),
+// - lets JSON.stringify call toJSON on other BSON types (ObjectId, Long, Decimal128, Date, Timestamp, ...)
+//   so the result lands here as a primitive or plain object,
+// - returns '?' for BSON types without toJSON (MinKey, MaxKey) where `value === original`,
+// - tracks depth via an ancestor stack so cycles and depth >= MAX_DEPTH collapse to '?'.
+function sanitiseAndStringify (input) {
+  const ancestors = []
+  return JSON.stringify(input, function (key, value) {
+    if (typeof value === 'function') return
+    if (typeof value === 'bigint') return value.toString()
+
+    const original = key === '' ? value : this[key]
+    if (typeof original === 'object' && original !== null) {
+      if (Buffer.isBuffer(original)) return '?'
+      const bsontype = original._bsontype
+      if (bsontype !== undefined && (bsontype === 'Binary' || value === original)) {
+        return '?'
       }
     }
-  }
 
-  return output
-}
+    if (value === null || typeof value !== 'object') return value
 
-function isObject (val) {
-  return val !== null && typeof val === 'object' && !Array.isArray(val)
-}
-
-function isBSON (val) {
-  return val && val._bsontype && !isBinary(val)
-}
+    while (ancestors.length > 0 && ancestors.at(-1) !== this) ancestors.pop()
+    if (ancestors.length >= MAX_DEPTH || ancestors.includes(value)) return '?'
+    ancestors.push(value)
 
-function isBinary (val) {
-  return val && val._bsontype === 'Binary'
+    return value
+  })
 }
 
 function isHeartbeat (ops, config) {

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

@@ -1,7 +1,7 @@
 'use strict'
 
 const { storage } = require('../../datadog-core')
-const CLIENT_PORT_KEY = require('../../dd-trace/src/constants')
+const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
 const DatabasePlugin = require('../../dd-trace/src/plugins/database')
 
 class MySQLPlugin extends DatabasePlugin {

package/packages/datadog-plugin-openai/src/services.js

@@ -36,7 +36,8 @@ module.exports.init = function (tracerConfig) {
 
   interval = setInterval(() => {
     metrics.flush()
-  }, FLUSH_INTERVAL).unref()
+  }, FLUSH_INTERVAL)
+  interval.unref?.()
 
   return { metrics, logger }
 }