dd-trace 6.0.0 → 6.1.0

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

@@ -241,7 +241,7 @@ class GraphQLExecutePlugin extends TracingPlugin {
     if (res?.errors?.length) {
       span.setTag('error', res.errors[0])
       for (const err of res.errors) {
-        extractErrorIntoSpanEvent(this._tracerConfig, span, err)
+        extractErrorIntoSpanEvent(this.config, span, err)
       }
     }
 
@@ -271,6 +271,9 @@ class GraphQLExecutePlugin extends TracingPlugin {
     const loc = this.config.source && document && fieldNode && fieldNode.loc
     const source = loc && document.slice(loc.start, loc.end)
 
+    // ctx form: startSpan sets field.currentStore = { ...activeStore, span }
+    // without entering it. Only the field's first resolver call runs in that
+    // store (isFirst check in wrapResolve); siblings use field.parentStore.
     const span = this.startSpan('graphql.resolve', {
       service: this.config.service,
       resource: `${fieldName}:${returnType}`,
@@ -283,7 +286,9 @@ class GraphQLExecutePlugin extends TracingPlugin {
         'graphql.field.type': baseTypeName,
         'graphql.source': source,
       },
-    }, false)
+    }, field)
+
+    field.span = span
 
     if (fieldNode && this.config.variables && fieldNode.arguments) {
       const variables = this.config.variables(variableValues)
@@ -388,15 +393,22 @@ function wrapResolve (resolve) {
         pathString,
         collapsedKey: collapsedKey ?? pathString,
         span: null,
+        // Set by startResolveSpan; currentStore is used by the first resolver
+        // call only, siblings use parentStore (see the isFirst check below).
+        parentStore: null,
+        currentStore: null,
       }
       rootCtx.fields.set(fieldKey, field)
     }
 
     // Collapsed siblings still publish updateField (master's contract: one
     // publish per resolver call, even when the span is collapsed) and route
-    // through callInAsyncScope so the abort signal stops them mid-flight.
+    // through callInAsyncScope so the abort signal stops them mid-flight. They
+    // run in the parent store, not field.currentStore: the first sibling's
+    // synchronous resolver already finished the shared graphql.resolve span, so
+    // re-entering its store would parent user spans to a closed span.
     if (!isFirst) {
-      return callInAsyncScope(resolve, this, arguments, rootCtx.abortController, (err) => {
+      return callInAsyncScope(resolve, this, arguments, rootCtx.abortController, field.parentStore, (err) => {
         if (updateFieldCh.hasSubscribers) {
           updateFieldCh.publish({ rootCtx, field, error: err, pathString: field.pathString })
         }
@@ -406,9 +418,8 @@ function wrapResolve (resolve) {
     const executeSpan = rootCtx.executeSpan
     const startTime = executeSpan._getTime()
     const span = rootCtx.plugin.startResolveSpan(field, rootCtx, executeSpan, startTime)
-    field.span = span
 
-    return callInAsyncScope(resolve, this, arguments, rootCtx.abortController, (err, res) => {
+    return callInAsyncScope(resolve, this, arguments, rootCtx.abortController, field.currentStore, (err, res) => {
       const endTime = executeSpan._getTime()
       rootCtx.plugin.finishResolveSpan(span, field, err, res, endTime || startTime)
       if (updateFieldCh.hasSubscribers) {
@@ -446,16 +457,16 @@ function wrapFieldType (field) {
   wrapFields(unwrapped)
 }
 
-function callInAsyncScope (fn, thisArg, args, abortController, cb) {
-  cb ??= () => {}
-
+// Runs the resolver inside `store`, including any code after an internal
+// `await`. A `.then()` the caller attaches afterward runs outside `store`.
+function callInAsyncScope (fn, thisArg, args, abortController, store, cb) {
   if (abortController?.signal.aborted) {
     cb(null, null)
     throw new AbortError('Aborted')
   }
 
   try {
-    const result = fn.apply(thisArg, args)
+    const result = legacyStorage.run(store, () => fn.apply(thisArg, args))
     if (typeof result?.then === 'function') {
       return result.then(
         res => { cb(null, res); return res },

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

@@ -30,6 +30,13 @@ 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
@@ -41,6 +48,7 @@ function validateConfig (config) {
     // 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),
   }
 }
@@ -58,13 +66,21 @@ 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 }
 

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

@@ -38,7 +38,7 @@ class GraphQLValidatePlugin extends TracingPlugin {
     if (errors?.length) {
       span.setTag('error', errors[0])
       for (const err of errors) {
-        extractErrorIntoSpanEvent(this._tracerConfig, span, err)
+        extractErrorIntoSpanEvent(this.config, span, err)
       }
     }
 

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'
 
@@ -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()
       }
     })
 

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