dd-trace 5.110.0 → 5.112.0

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

@@ -1,12 +1,12 @@
 'use strict'
 
 const pick = require('../../datadog-core/src/utils/src/pick')
+const { DD_MAJOR } = require('../../../version')
 const CompositePlugin = require('../../dd-trace/src/plugins/composite')
 const log = require('../../dd-trace/src/log')
 const GraphQLExecutePlugin = require('./execute')
 const GraphQLParsePlugin = require('./parse')
 const GraphQLValidatePlugin = require('./validate')
-const GraphQLResolvePlugin = require('./resolve')
 
 class GraphQLPlugin extends CompositePlugin {
   static id = 'graphql'
@@ -15,7 +15,9 @@ class GraphQLPlugin extends CompositePlugin {
       execute: GraphQLExecutePlugin,
       parse: GraphQLParsePlugin,
       validate: GraphQLValidatePlugin,
-      resolve: GraphQLResolvePlugin,
+      // resolve plugin is absorbed into execute: per-field data is recorded
+      // synchronously in wrapResolve, and all graphql.resolve spans are
+      // materialized at execute end.
     }
   }
 
@@ -28,13 +30,25 @@ class GraphQLPlugin extends CompositePlugin {
 }
 
 // config validator helpers
+//
+// `collapse`, `depth`, `variables`, and `errorExtensions` arrive pre-merged on
+// `config`: plugin_manager seeds the `DD_TRACE_GRAPHQL_*` env values (already
+// parsed to their declared type) as the base and a programmatic
+// `tracer.use('graphql', …)` value overrides them. So these helpers only shape
+// the merged value — coerce, validate, and turn `variables` into a filter — and
+// never read the environment themselves.
 
 function validateConfig (config) {
+  const collapse = config.collapse === undefined || !!config.collapse
   return {
     ...config,
     depth: getDepth(config),
     variables: getVariablesFilter(config),
-    collapse: config.collapse === undefined || !!config.collapse,
+    collapse,
+    // v5 counted collapsed list indices toward `depth`, so the same query reached a
+    // different depth depending on `collapse`. v6 counts selection-set depth only.
+    countListIndices: DD_MAJOR < 6 && collapse,
+    errorExtensions: getErrorExtensions(config),
     hooks: getHooks(config),
   }
 }
@@ -52,21 +66,35 @@ function getVariablesFilter (config) {
   if (typeof config.variables === 'function') {
     return config.variables
   } else if (Array.isArray(config.variables)) {
-    return variables => pick(variables, config.variables)
+    return config.variables.length > 0 ? variables => pick(variables, config.variables) : null
   } else if (config.hasOwnProperty('variables')) {
     log.error('Expected `variables` to be an array or function.')
   }
   return null
 }
 
+function getErrorExtensions (config) {
+  if (Array.isArray(config.errorExtensions)) {
+    return config.errorExtensions.length > 0 ? config.errorExtensions : undefined
+  } else if (config.hasOwnProperty('errorExtensions')) {
+    log.error('Expected `errorExtensions` to be an array.')
+  }
+}
+
 const noop = () => {}
+const noopHooks = { execute: noop, parse: noop, validate: noop, resolve: undefined }
 
 function getHooks ({ hooks }) {
-  const execute = hooks?.execute ?? noop
-  const parse = hooks?.parse ?? noop
-  const validate = hooks?.validate ?? noop
-
-  return { execute, parse, validate }
+  if (!hooks) return noopHooks
+  return {
+    execute: hooks.execute ?? noop,
+    parse: hooks.parse ?? noop,
+    validate: hooks.validate ?? noop,
+    // No noop fallback: `resolve` runs per-field (hot path); the plugin
+    // gates with `if (this.config.hooks.resolve)` so the absent-hook case
+    // skips both the call and the payload-object allocation.
+    resolve: hooks.resolve,
+  }
 }
 
 module.exports = GraphQLPlugin

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

@@ -2,34 +2,54 @@
 
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
 
+const documentSources = new WeakMap()
+
 class GraphQLParsePlugin extends TracingPlugin {
   static id = 'graphql'
   static operation = 'parser'
+  static prefix = 'tracing:orchestrion:graphql:apm:graphql:parser'
 
   bindStart (ctx) {
+    const source = ctx.arguments?.[0]
+
     this.startSpan('graphql.parse', {
       service: this.config.service,
       type: 'graphql',
       meta: {},
     }, ctx)
 
+    ctx.ddSource = source
+
     return ctx.currentStore
   }
 
-  finish (ctx) {
-    const { source, document, docSource } = ctx
+  end (ctx) {
+    const source = ctx.ddSource
+    const document = ctx.result
     const span = ctx?.currentStore?.span || this.activeSpan
 
-    if (this.config.source && document) {
+    let docSource
+    if (document) {
+      if (source) {
+        docSource = source.body || source
+        documentSources.set(document, docSource)
+      } else {
+        docSource = documentSources.get(document)
+      }
+    }
+
+    if (this.config.source && docSource) {
       span.setTag('graphql.source', docSource)
     }
 
     this.config.hooks.parse(span, source, document)
 
-    super.finish(ctx)
+    span.finish()
 
     return ctx.parentStore
   }
 }
 
+GraphQLParsePlugin.documentSources = documentSources
+
 module.exports = GraphQLParsePlugin

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

@@ -1,5 +1,12 @@
 'use strict'
 
+/**
+ * @param {{ errorExtensions?: string[] }} config Resolved plugin config; `errorExtensions` lists the
+ *   GraphQL error `extensions` keys to copy onto the span event.
+ * @param {import('../../dd-trace/src/opentracing/span')} span
+ * @param {{ name?: string, message?: string, stack?: string, locations?: Array<{ line: number, column: number }>,
+ *   path?: Array<string|number>, extensions?: Record<string, unknown> }} exc
+ */
 function extractErrorIntoSpanEvent (config, span, exc) {
   const attributes = {}
 
@@ -29,8 +36,8 @@ function extractErrorIntoSpanEvent (config, span, exc) {
     attributes.message = exc.message
   }
 
-  if (config.DD_TRACE_GRAPHQL_ERROR_EXTENSIONS) {
-    for (const ext of config.DD_TRACE_GRAPHQL_ERROR_EXTENSIONS) {
+  if (config.errorExtensions) {
+    for (const ext of config.errorExtensions) {
       if (exc.extensions?.[ext]) {
         const value = exc.extensions[ext]
 

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

@@ -1,14 +1,18 @@
 'use strict'
 
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+const GraphQLParsePlugin = require('./parse')
 const { extractErrorIntoSpanEvent } = require('./utils')
 
 class GraphQLValidatePlugin extends TracingPlugin {
   static id = 'graphql'
   static operation = 'validate'
+  static prefix = 'tracing:orchestrion:graphql:apm:graphql:validate'
 
   bindStart (ctx) {
-    const { docSource, document } = ctx
+    // validate(schema, documentAST, rules, options, typeInfo)
+    const document = ctx.arguments?.[1]
+    const docSource = document ? GraphQLParsePlugin.documentSources.get(document) : undefined
     const source = this.config.source && document && docSource
 
     this.startSpan('graphql.validate', {
@@ -19,19 +23,26 @@ class GraphQLValidatePlugin extends TracingPlugin {
       },
     }, ctx)
 
+    ctx.ddDocument = document
+
     return ctx.currentStore
   }
 
-  finish (ctx) {
-    const { document, errors } = ctx
+  end (ctx) {
+    const document = ctx.ddDocument
+    const errors = ctx.result
     const span = ctx?.currentStore?.span || this.activeSpan
+
     this.config.hooks.validate(span, document, errors)
-    if (errors) {
+
+    if (errors?.length) {
+      span.setTag('error', errors[0])
       for (const err of errors) {
-        extractErrorIntoSpanEvent(this._tracerConfig, span, err)
+        extractErrorIntoSpanEvent(this.config, span, err)
       }
     }
-    super.finish(ctx)
+
+    span.finish()
 
     return ctx.parentStore
   }

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

@@ -1,6 +1,5 @@
 'use strict'
 
-const PushSubscriptionPlugin = require('../../datadog-plugin-google-cloud-pubsub/src/pubsub-push-subscription')
 const CompositePlugin = require('../../dd-trace/src/plugins/composite')
 const { enableGCPPubSubPushSubscription } = require('../../dd-trace/src/serverless')
 const log = require('../../dd-trace/src/log')
@@ -17,14 +16,13 @@ class HttpPlugin extends CompositePlugin {
   static get plugins () {
     const plugins = {}
 
-    // Load push subscription plugin first (if enabled) for GCP Cloud Run
+    // Load the push subscription plugin first (if enabled) for GCP Cloud Run.
+    // The require stays inside the gate so the pubsub plugin graph is not pulled
+    // into every process that instruments http — only GCP Cloud Run reaches it.
     if (enableGCPPubSubPushSubscription()) {
-      try {
-        plugins['pubsub-push-subscription'] = PushSubscriptionPlugin
-        log.debug('Loaded GCP Pub/Sub Push Subscription plugin for HTTP requests')
-      } catch (e) {
-        log.debug('Failed to load GCP Pub/Sub Push Subscription plugin:', e)
-      }
+      plugins['pubsub-push-subscription'] =
+        require('../../datadog-plugin-google-cloud-pubsub/src/pubsub-push-subscription')
+      log.debug('Loaded GCP Pub/Sub Push Subscription plugin for HTTP requests')
     }
 
     plugins.server = HttpServerPlugin

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

@@ -61,15 +61,6 @@ const isJestWorker = !!getEnvironmentVariable('JEST_WORKER_ID')
 // https://github.com/facebook/jest/blob/d6ad15b0f88a05816c2fe034dd6900d28315d570/packages/jest-worker/src/types.ts#L38
 const CHILD_MESSAGE_END = 2
 
-function withTimeout (promise, timeoutMs) {
-  return new Promise(resolve => {
-    realSetTimeout(resolve, timeoutMs)
-
-    // Also resolve if the original promise resolves
-    promise.then(resolve)
-  })
-}
-
 class JestPlugin extends CiPlugin {
   static id = 'jest'
 
@@ -177,7 +168,7 @@ class JestPlugin extends CiPlugin {
 
         this.telemetry.count(TELEMETRY_TEST_SESSION, {
           provider: this.ciProviderName,
-          autoInjected: !!this._tracerConfig.DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER,
+          autoInjected: !!this._tracerConfig.testOptimization.DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER,
         })
 
         appClosingTelemetry()
@@ -451,6 +442,7 @@ class JestPlugin extends CiPlugin {
       isAtrRetry,
       finalStatus,
       earlyFlakeAbortReason,
+      promises,
     }) => {
       span.setTag(TEST_STATUS, status)
       if (finalStatus) {
@@ -481,12 +473,33 @@ class JestPlugin extends CiPlugin {
         this.getTestTelemetryTags(span)
       )
 
-      span.finish()
-      finishAllTraceSpans(span)
-      this.activeTestSpan = null
+      const finish = () => {
+        span.finish()
+        finishAllTraceSpans(span)
+        this.activeTestSpan = null
+      }
+
+      if (finalStatus) {
+        if (promises?.hitBreakpointPromise) {
+          finish()
+          this.cancelDiBreakpointHitWait()
+          return
+        }
+        if (promises && this.diBreakpointHitPromise) {
+          promises.hitBreakpointPromise = this.waitForPreparedDiBreakpointHit().then(finish)
+          return
+        }
+        finish()
+        this.cancelDiBreakpointHitWait()
+        return
+      }
+      finish()
+      if (status === 'fail' && promises?.hitBreakpointPromise) {
+        this.prepareDiBreakpointHitWait()
+      }
     })
 
-    this.addSub('ci:jest:test:err', ({ span, error, shouldSetProbe, promises }) => {
+    this.addSub('ci:jest:test:err', ({ span, error, shouldSetProbe, shouldWaitForHitProbe, promises }) => {
       if (error && span) {
         span.setTag(TEST_STATUS, 'fail')
         span.setTag('error', getFormattedError(error, this.repositoryRoot))
@@ -494,8 +507,11 @@ class JestPlugin extends CiPlugin {
           const probeInformation = this.addDiProbe(error)
           if (probeInformation) {
             const { setProbePromise } = probeInformation
-            promises.isProbeReady = withTimeout(setProbePromise, 2000)
+            this.prepareDiBreakpointHitWait()
+            promises.isProbeReady = this.waitForDiOperation(setProbePromise)
           }
+        } else if (shouldWaitForHitProbe && this.di) {
+          promises.hitBreakpointPromise = this.waitForDiBreakpointHits()
         }
       }
     })

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

@@ -1,8 +1,5 @@
 'use strict'
 
-// Capture real Date.now at module load time, before any test can install fake timers.
-const realDateNow = Date.now.bind(Date)
-
 const CiPlugin = require('../../dd-trace/src/plugins/ci_plugin')
 const { storage } = require('../../datadog-core')
 
@@ -52,8 +49,6 @@ const {
   TELEMETRY_TEST_SESSION,
 } = require('../../dd-trace/src/ci-visibility/telemetry')
 
-const BREAKPOINT_SET_GRACE_PERIOD_MS = 200
-
 class MochaPlugin extends CiPlugin {
   static id = 'mocha'
 
@@ -263,6 +258,7 @@ class MochaPlugin extends CiPlugin {
         span.finish()
         finishAllTraceSpans(span)
         this.activeTestSpan = null
+        this.cancelDiBreakpointHitWait()
         if (this.di && this.libraryConfig?.isDiEnabled && this.runningTestProbe && isLastRetry) {
           this.removeDiProbe(this.runningTestProbe)
           this.runningTestProbe = null
@@ -307,8 +303,24 @@ class MochaPlugin extends CiPlugin {
       return ctx.currentStore
     })
 
-    this.addSub('ci:mocha:test:retry', ({ span, isFirstAttempt, willBeRetried, err, test, isAtrRetry }) => {
+    this.addSub('ci:mocha:test:retry', ({
+      span,
+      isFirstAttempt,
+      willBeRetried,
+      err,
+      test,
+      isAtrRetry,
+      promises,
+    }) => {
       if (span) {
+        const finishSpan = () => {
+          span.finish()
+          finishAllTraceSpans(span)
+          if (this.activeTestSpan === span) {
+            this.activeTestSpan = null
+          }
+        }
+
         span.setTag(TEST_STATUS, 'fail')
         if (!isFirstAttempt) {
           span.setTag(TEST_IS_RETRY, 'true')
@@ -330,21 +342,34 @@ class MochaPlugin extends CiPlugin {
         if (isFirstAttempt && willBeRetried && this.di && this.libraryConfig?.isDiEnabled) {
           const probeInformation = this.addDiProbe(err)
           if (probeInformation) {
-            const { file, line, stackIndex } = probeInformation
+            const { file, line, stackIndex, setProbePromise } = probeInformation
             this.runningTestProbe = { file, line }
             this.testErrorStackIndex = stackIndex
             test._ddShouldWaitForHitProbe = true
-            const waitUntil = realDateNow() + BREAKPOINT_SET_GRACE_PERIOD_MS
-            while (realDateNow() < waitUntil) {
-              // TODO: To avoid a race condition, we should wait until `probeInformation.setProbePromise` has resolved.
-              // However, Mocha doesn't have a mechanism for waiting asyncrounously here, so for now, we'll have to
-              // fall back to a fixed syncronous delay.
+            this.prepareDiBreakpointHitWait()
+            if (promises) {
+              promises.setProbePromise = this.waitForDiOperation(setProbePromise)
             }
           }
         }
 
-        span.finish()
-        finishAllTraceSpans(span)
+        if (!isFirstAttempt &&
+          willBeRetried &&
+          this.di &&
+          this.libraryConfig?.isDiEnabled &&
+          this.runningTestProbe &&
+          promises) {
+          promises.finishTestPromise = this.waitForInFlightDiBreakpointHits().then(finishSpan, finishSpan)
+          return
+        }
+
+        finishSpan()
+      }
+    })
+
+    this.addSub('ci:mocha:test:di:wait', ({ promises }) => {
+      if (this.di) {
+        promises.hitBreakpointPromise = this.waitForDiBreakpointHits()
       }
     })
 
@@ -427,7 +452,7 @@ class MochaPlugin extends CiPlugin {
         finishAllTraceSpans(this.testSessionSpan)
         this.telemetry.count(TELEMETRY_TEST_SESSION, {
           provider: this.ciProviderName,
-          autoInjected: !!this._tracerConfig.DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER,
+          autoInjected: !!this._tracerConfig.testOptimization.DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER,
         })
       }
       this.libraryConfig = null

package/packages/datadog-plugin-mongodb-core/src/bulk-write.js

@@ -0,0 +1,43 @@
+'use strict'
+
+const MongodbCoreQueryPlugin = require('./query')
+
+const MAX_RESOURCE_LENGTH = 10_000
+
+class MongodbCoreBulkWritePlugin extends MongodbCoreQueryPlugin {
+  // bulkWrite is higher-level than the wire commands `query` traces, so it has its own operation
+  // and thus its own `apm:mongodb:bulkwrite:*` channels. It reuses the query plugin's `id`,
+  // `component`, and collection-stripping `getPeerService`, and inherits `finish`, `error`, and the
+  // finish-time parent-store restore from the tracing/outbound base classes.
+  static operation = 'bulkwrite'
+
+  /**
+   * Open the parent span for a `Collection#bulkWrite`. The per-type wire commands nest as
+   * children and carry the statements, host, and DBM comment, so this span only records
+   * the namespace and resource.
+   *
+   * @param {{ ns: string }} ctx
+   */
+  bindStart (ctx) {
+    const { ns } = ctx
+    const serviceResult = this.serviceName({ pluginConfig: this.config })
+
+    this.startSpan(this.operationName(), {
+      service: serviceResult,
+      resource: truncate(`bulkWrite ${ns}`),
+      type: 'mongodb',
+      kind: 'client',
+      meta: {
+        'db.name': ns,
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+}
+
+function truncate (input) {
+  return input.length > MAX_RESOURCE_LENGTH ? input.slice(0, MAX_RESOURCE_LENGTH) : input
+}
+
+module.exports = MongodbCoreBulkWritePlugin