dd-trace 6.13.0 → 6.14.0

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

@@ -3,69 +3,106 @@
 const { LRUCache } = require('../../../vendor/dist/lru-cache')
 
 /**
- * @typedef {{ signature?: string, type?: string, name?: string }} RequestOperation
+ * @typedef {{ signature: string, type: import('graphql').OperationTypeNode, name?: string }} RequestOperation
  */
 
-const operationTypes = new Set(['query', 'mutation', 'subscription'])
-
-// Mercurius funnels every operation through `fastifyGraphQl`, but the parsed
-// document — and therefore the operation signature/type/name — is only known
-// once mercurius parses internally. The top-level request span opens before
-// that, and on the JIT warm path neither parse/validate nor execute fires, so
-// the span would otherwise be left with only the provisional resource. The cold
-// path caches the computed metadata; the request boundary reads it back on the
-// warm path. Bounded so a flood of distinct queries can't grow it without limit.
-//
-// The key is the operation name plus the raw query text, not the source alone:
-// mercurius keys its document LRU by source but compiles the JIT for a single
-// `operationName`, and the compiled query then serves that operation for every
-// later request that shares the source — regardless of the `operationName` those
-// requests ask for. A source-only key would hand a warm request for operation B
-// the metadata of whichever operation was cached last for that source (A),
-// mislabeling the span. Operation names cannot contain a newline, so it is a
-// safe separator that keeps the two parts from colliding.
-const requestOperationCache = new LRUCache({ max: 500 })
-
-// Mercurius also accepts a pre-parsed document AST as the source, which reaches
-// the request boundary as an object rather than query text — so there is no
-// string to key the LRU by. Mercurius keys its own document LRU by that source
-// object's identity, and the same object reaches the boundary on the warm path,
-// so a WeakMap keyed by the caller-owned document recovers the metadata without
-// mutating the document and releases with it. The value carries the requested
-// operation name so a JIT-only sibling selection is not handed another
-// operation's metadata (same reason the string cache keys by operation name).
-/** @type {WeakMap<object, Map<string | undefined, RequestOperation>>} */
-const documentOperationCache = new WeakMap()
+const requestCacheMax = 500
 
 /**
- * @param {string} source - The raw query text; the same key mercurius uses.
- * @param {string | undefined} operationName - The requested operation name.
+ * @typedef {{
+ *   document: WeakRef<import('graphql').DocumentNode>,
+ *   operations: Map<string, RequestOperation>
+ * }} DocumentOperations
+ */
+
+/**
+ * @typedef {{
+ *   documentOperations: WeakMap<object, DocumentOperations>,
+ *   documents: import('lru-cache')<string, WeakRef<import('graphql').DocumentNode>>,
+ *   operations: import('lru-cache')<string, RequestOperation>
+ * }} RequestCache
+ */
+
+/** @type {WeakMap<object, RequestCache>} */
+const requestCaches = new WeakMap()
+
+/**
+ * @param {object | undefined} owner
+ * @param {boolean | number | undefined} configuredLimit
+ * @returns {RequestCache | undefined}
+ */
+function getRequestCache (owner, configuredLimit) {
+  if (!owner || configuredLimit === false || (typeof configuredLimit === 'number' && configuredLimit <= 0)) return
+
+  let requestCache = requestCaches.get(owner)
+  if (requestCache !== undefined) return requestCache
+
+  const max = typeof configuredLimit === 'number'
+    ? Math.min(Math.floor(configuredLimit), requestCacheMax)
+    : requestCacheMax
+  if (max <= 0) return
+
+  requestCache = {
+    documentOperations: new WeakMap(),
+    documents: new LRUCache({ max }),
+    operations: new LRUCache({ max }),
+  }
+  requestCaches.set(owner, requestCache)
+  return requestCache
+}
+
+/**
+ * @param {string | null | undefined} operationName
+ * @param {boolean} calculateSignature
  * @returns {string}
  */
-function requestOperationKey (source, operationName) {
-  return `${operationName ?? ''}\n${source}`
+function operationCacheKey (operationName, calculateSignature) {
+  return `${calculateSignature === false ? 0 : 1}\n${operationName ?? ''}`
 }
 
 /**
- * @param {unknown} source - Query text on the common path; a pre-parsed
- *   document AST otherwise. Any other shape (mercurius rejects it before
- *   execute) has no cache entry and yields undefined.
- * @param {string | undefined} operationName - The requested operation name.
+ * @param {unknown} source
+ * @param {string | null | undefined} operationName
+ * @param {boolean} calculateSignature
+ * @param {RequestCache | undefined} requestCache
  * @returns {RequestOperation | undefined}
  */
-function getCachedRequestOperation (source, operationName) {
+function getCachedRequestOperation (source, operationName, calculateSignature, requestCache) {
+  if (requestCache === undefined) return
+
+  const operationKey = operationCacheKey(operationName, calculateSignature)
   if (typeof source === 'string') {
-    return requestOperationCache.get(requestOperationKey(source, operationName))
+    // GraphQL operation names cannot contain newlines, so source text cannot collide with this prefix.
+    const key = `${operationKey}\n${source}`
+    let operation = requestCache.operations.get(key)
+    if (operation !== undefined) return operation
+
+    const document = requestCache.documents.get(source)?.deref()
+    if (document === undefined) return
+
+    operation = getRequestOperation(document, operationName, calculateSignature)
+    if (operation === undefined) return
+
+    requestCache.operations.set(key, operation)
+    return operation
   }
   if (source === null || typeof source !== 'object') return
-  return documentOperationCache.get(source)?.get(operationName)
+
+  const cached = requestCache.documentOperations.get(source)
+  if (cached === undefined) return
+
+  let operation = cached.operations.get(operationKey)
+  const document = cached.document.deref()
+  if (operation !== undefined || document === undefined) return operation
+
+  operation = getRequestOperation(document, operationName, calculateSignature)
+  if (operation === undefined) return
+
+  cached.operations.set(operationKey, operation)
+  return operation
 }
 
 /**
- * A string source keys the text LRU; a document AST keys the WeakMap. Any other
- * shape has no usable key — mercurius rejects it before execute, so the warm
- * path never reaches the request span for it either.
- *
  * @param {unknown} source
  * @returns {source is string | object}
  */
@@ -74,104 +111,139 @@ function isCacheableSource (source) {
 }
 
 /**
- * Select the operation definition matching `operationName`, or the first one
- * when no name is given (graphql/mercurius default selection).
- *
  * @param {import('graphql').DocumentNode | undefined} document
- * @param {string | undefined} operationName
+ * @param {string | null | undefined} operationName
  * @returns {import('graphql').OperationDefinitionNode | undefined}
  */
 function getOperation (document, operationName) {
-  /* istanbul ignore if: validate/execute only call this with a parsed GraphQL document. */
   if (!document || !Array.isArray(document.definitions)) return
 
+  let operation
   for (const definition of document.definitions) {
-    if (operationTypes.has(definition?.operation) &&
-        (!operationName || definition.name?.value === operationName)) {
-      return definition
+    if (definition.kind !== 'OperationDefinition') continue
+
+    if (operationName != null) {
+      if (definition.name?.value === operationName) return definition
+      continue
     }
+
+    if (operation !== undefined) return
+    operation = definition
   }
+
+  return operation
 }
 
 /**
- * Refine the top-level graphql.request span (mercurius) from the parsed
- * document and cache the metadata so the JIT warm path — where no sub-span
- * fires — can recover the same tags at the request boundary.
- *
- * This runs at the first boundary that has the document (validate on the cold
- * path, which also precedes a pre-execute validation failure). It is idempotent
- * across the later execute boundary via the `ddRequestRefined` flag, and a
- * no-op for graphql-js/apollo/yoga, which never open a request span.
- *
- * Every named operation in the document is cached, not just the selected one:
- * a multi-operation document parses once, and a later request may select a
- * sibling operation that mercurius then serves exclusively through its JIT path
- * (no execute span), so its metadata has to be ready before that happens.
- *
  * @param {import('../../dd-trace/src/opentracing/span') | undefined} requestSpan
- * @param {import('graphql').DocumentNode | undefined} document
- * @param {unknown} requestSource - The raw source the request boundary saw:
- *   query text on the common path, a pre-parsed document AST otherwise. The
- *   cache is keyed by it, not by the parsed document, so the request boundary
- *   recovers the metadata on the warm path from the same value mercurius keys
- *   its own document LRU by. Any other shape has no usable key and is not
- *   cached (the warm path never reaches this span for it either).
- * @param {string | undefined} operationName - The requested operation name.
- * @param {boolean} calculateSignature - The graphql plugin's `signature` config.
+ * @param {string} signature
+ * @param {import('graphql').OperationTypeNode | undefined} type
+ * @param {string | undefined} name
  */
-function refineRequestSpan (requestSpan, document, requestSource, operationName, calculateSignature) {
-  /* istanbul ignore if: validate only refines after the request span and parsed document exist. */
-  if (!requestSpan || requestSpan.ddRequestRefined || !document) return
+function refineRequestSpanMetadata (requestSpan, signature, type, name) {
+  if (!requestSpan || requestSpan.ddRequestRefined) return
   requestSpan.ddRequestRefined = true
 
-  const operation = getOperation(document, operationName)
-  const type = operation?.operation
-  const name = operation?.name?.value
-  const signature = getSignature(document, name, type, calculateSignature)
-
   if (signature) requestSpan.setTag('resource.name', signature)
   if (type) requestSpan.setTag('graphql.operation.type', type)
   if (name) requestSpan.setTag('graphql.operation.name', name)
+}
 
-  if (!isCacheableSource(requestSource)) return
-
-  // Cache the selected operation under the requested name (undefined selects
-  // the document's first operation, so it shares the entry with that name).
-  cacheRequestOperation(requestSource, operationName, { signature, type, name })
+/**
+ * @param {{
+ *   ddRequestRefined?: boolean,
+ *   setTag: (key: string, value: string) => unknown
+ * } | undefined} requestSpan
+ * @param {import('graphql').DocumentNode | undefined} document
+ * @param {unknown} requestSource
+ * @param {string | null | undefined} operationName
+ * @param {boolean} calculateSignature
+ * @param {boolean} validated
+ * @param {RequestCache | undefined} requestCache
+ */
+function refineRequestSpan (
+  requestSpan,
+  document,
+  requestSource,
+  operationName,
+  calculateSignature,
+  validated,
+  requestCache
+) {
+  /* istanbul ignore if: validate only refines after the request span and parsed document exist. */
+  if (!requestSpan || requestSpan.ddRequestRefined || !document) return
 
-  // Cache every named operation so a JIT-only sibling selection is labeled from
-  // this single parse instead of falling back to a bare operation name.
-  for (const definition of document.definitions) {
-    const definitionName = definition?.name?.value
-    if (definitionName === undefined || !operationTypes.has(definition.operation)) continue
-    if (definitionName === operationName) continue
-
-    cacheRequestOperation(requestSource, definitionName, {
-      signature: getSignature(document, definitionName, definition.operation, calculateSignature),
-      type: definition.operation,
-      name: definitionName,
-    })
-  }
+  const operation = getRequestOperation(document, operationName, calculateSignature)
+  if (operation === undefined) return
+
+  const { signature, type, name } = operation
+  refineRequestSpanMetadata(requestSpan, signature, type, name)
+
+  if (!validated || !requestCache || !isCacheableSource(requestSource)) return
+  cacheRequestOperation(
+    requestCache,
+    requestSource,
+    operationName,
+    calculateSignature,
+    operation,
+    document
+  )
 }
 
 /**
- * @param {string | import('graphql').DocumentNode} source - Query text keys the
- *   text LRU; a caller-owned document AST keys the WeakMap (never mutated).
- * @param {string | undefined} operationName - The requested operation name.
+ * @param {RequestCache} requestCache
+ * @param {string | object} source
+ * @param {string | null | undefined} operationName
+ * @param {boolean} calculateSignature
  * @param {RequestOperation} operation
+ * @param {import('graphql').DocumentNode} document
  */
-function cacheRequestOperation (source, operationName, operation) {
+function cacheRequestOperation (
+  requestCache,
+  source,
+  operationName,
+  calculateSignature,
+  operation,
+  document
+) {
+  const operationKey = operationCacheKey(operationName, calculateSignature)
+  const documentRef = new WeakRef(document)
   if (typeof source === 'string') {
-    requestOperationCache.set(requestOperationKey(source, operationName), operation)
+    requestCache.operations.set(`${operationKey}\n${source}`, operation)
+    requestCache.documents.set(source, documentRef)
     return
   }
 
-  let operations = documentOperationCache.get(source)
-  if (operations === undefined) {
-    operations = new Map()
-    documentOperationCache.set(source, operations)
+  let cached = requestCache.documentOperations.get(source)
+  if (cached === undefined) {
+    cached = {
+      document: documentRef,
+      operations: new Map(),
+    }
+    requestCache.documentOperations.set(source, cached)
+  } else {
+    cached.document = documentRef
+  }
+  cached.operations.set(operationKey, operation)
+}
+
+/**
+ * @param {import('graphql').DocumentNode} document
+ * @param {string | null | undefined} operationName
+ * @param {boolean} calculateSignature
+ * @returns {RequestOperation | undefined}
+ */
+function getRequestOperation (document, operationName, calculateSignature) {
+  const operation = getOperation(document, operationName)
+  if (operation === undefined) return
+
+  const type = operation.operation
+  const name = operation.name?.value
+  return {
+    signature: getSignature(document, name, type, calculateSignature),
+    type,
+    name,
   }
-  operations.set(operationName, operation)
 }
 
 /**
@@ -268,8 +340,25 @@ function isApolloHealthCheck (operation) {
     selection.directives?.length === 0
 }
 
+/**
+ * @param {import('graphql').GraphQLOutputType} type
+ * @returns {string}
+ */
+function getBaseTypeName (type) {
+  let current = type
+  while ('ofType' in current) current = current.ofType
+  return current.name
+}
+
 let tools
 
+/**
+ * @param {import('graphql').DocumentNode} document
+ * @param {string | undefined} operationName
+ * @param {import('graphql').OperationTypeNode} operationType
+ * @param {boolean} [calculate]
+ * @returns {string}
+ */
 function getSignature (document, operationName, operationType, calculate) {
   if (calculate !== false && tools !== false) {
     try {
@@ -286,22 +375,21 @@ function getSignature (document, operationName, operationType, calculate) {
     }
   }
 
-  if (operationType) {
-    if (operationName) {
-      return `${operationType} ${operationName}`
-    }
-    return operationType
+  if (operationName) {
+    return `${operationType} ${operationName}`
   }
-
-  return operationName ?? ''
+  return operationType
 }
 
 module.exports = {
   extractErrorIntoSpanEvent,
+  getBaseTypeName,
   getCachedRequestOperation,
   getOperation,
+  getRequestCache,
   getSignature,
   isApolloHealthCheck,
   isApolloHealthCheckSource,
   refineRequestSpan,
+  refineRequestSpanMetadata,
 }

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

@@ -1,12 +1,9 @@
 'use strict'
 
-const { storage } = require('../../datadog-core')
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
 const GraphQLParsePlugin = require('./parse')
 const { extractErrorIntoSpanEvent, isApolloHealthCheck, refineRequestSpan } = require('./utils')
 
-const legacyStorage = storage('legacy')
-
 class GraphQLValidatePlugin extends TracingPlugin {
   static id = 'graphql'
   static operation = 'validate'
@@ -28,26 +25,6 @@ class GraphQLValidatePlugin extends TracingPlugin {
     const docSource = document ? GraphQLParsePlugin.documentSources.get(document) : undefined
     const source = this.config.source && document && docSource
 
-    // Refine the top-level graphql.request span (mercurius) from the parsed
-    // document. validate is the first boundary that has it and precedes both
-    // execute and any pre-execute rejection (unknown field, GET mutation), so a
-    // failing request still ends up with a resource and operation tags. The
-    // request span, its operation name, and the raw source ride the active
-    // store the request boundary entered (validate's own `ctx.currentStore` is
-    // not populated yet). The cache is keyed by that raw source, not the parsed
-    // document — for a pre-parsed AST mercurius validates a structuredClone, so
-    // the document here is a different object from the one the boundary saw and
-    // recovers on the warm path. No-op for graphql-js/apollo/yoga, which never
-    // open a request span.
-    const requestStore = legacyStorage.getStore()
-    refineRequestSpan(
-      requestStore?.graphqlRequestSpan,
-      document,
-      requestStore?.graphqlRequestSource,
-      requestStore?.graphqlRequestOperationName,
-      this.config.signature
-    )
-
     this.startSpan('graphql.validate', {
       service: this.config.service,
       type: 'graphql',
@@ -68,6 +45,16 @@ class GraphQLValidatePlugin extends TracingPlugin {
     const errors = ctx.result
     const span = ctx?.currentStore?.span || this.activeSpan
 
+    refineRequestSpan(
+      ctx.currentStore?.graphqlRequestSpan,
+      document,
+      ctx.currentStore?.graphqlRequestSource,
+      ctx.currentStore?.graphqlRequestOperationName,
+      this.config.signature,
+      !errors?.length,
+      ctx.currentStore?.graphqlRequestCache
+    )
+
     if (errors?.length) {
       span.setTag('error', errors[0])
       for (const err of errors) {

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

@@ -113,7 +113,6 @@ class JestPlugin extends CiPlugin {
       hasUnskippableSuites,
       hasForcedToRunSuites,
       error,
-      isTestSessionFinalizationError,
       isEarlyFlakeDetectionEnabled,
       isEarlyFlakeDetectionFaulty,
       isTestManagementTestsEnabled,
@@ -124,9 +123,6 @@ class JestPlugin extends CiPlugin {
         this.testModuleSpan.setTag(TEST_STATUS, status)
 
         if (error) {
-          if (isTestSessionFinalizationError) {
-            this.tracer._exporter.setDeferredTestSuiteError?.(error)
-          }
           this.testSessionSpan.setTag('error', error)
           this.testModuleSpan.setTag('error', error)
         }
@@ -163,7 +159,6 @@ class JestPlugin extends CiPlugin {
           this.testSessionSpan.setTag(TEST_MANAGEMENT_ENABLED, 'true')
         }
 
-        this.tracer._exporter.exportDeferredTestSuiteSpans?.()
         this.testModuleSpan.finish()
         this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
         this.testSessionSpan.finish()
@@ -334,7 +329,6 @@ class JestPlugin extends CiPlugin {
       this.pendingTestSuiteFinishes.add(pendingFinish)
 
       const finish = () => {
-        this.tracer._exporter.deferTestSuiteSpan?.(testSuiteSpan)
         testSuiteSpan.finish()
         this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
         // Suites potentially run in a different process than the session,

package/packages/datadog-plugin-langchain/src/tracing.js

@@ -31,6 +31,13 @@ class BaseLangChainTracingPlugin extends TracingPlugin {
     }
   }
 
+  error (ctx) {
+    // NodeInterrupt or GraphInterrupt "errors" for control flow, do not mark as real errors
+    if (ctx.error?.is_bubble_up) return
+
+    super.error(ctx)
+  }
+
   bindStart (ctx) {
     // TODO(bengl): All this renaming is just so we don't have to change the existing handlers
     ctx.args = ctx.arguments