dd-trace 5.101.0 → 5.103.0

package/packages/datadog-plugin-electron/src/net.js

@@ -0,0 +1,82 @@
+'use strict'
+
+const HttpClientPlugin = require('../../datadog-plugin-http/src/client')
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+
+class ElectronNetPlugin extends CompositePlugin {
+  static id = 'electron:net'
+  static get plugins () {
+    return {
+      request: ElectronRequestPlugin,
+    }
+  }
+}
+
+class ElectronRequestPlugin extends HttpClientPlugin {
+  static id = 'electron:net:request'
+  static component = 'electron'
+  static operation = 'request'
+  static prefix = 'tracing:apm:electron:net:request'
+
+  bindStart (ctx) {
+    const args = ctx.args
+
+    let options = args[0]
+
+    if (typeof options === 'string') {
+      options = args[0] = { url: options }
+    } else if (!options) {
+      options = args[0] = {}
+    }
+
+    const headers = options.headers || {}
+
+    try {
+      if (typeof options === 'string') {
+        options = new URL(options)
+      } else if (options.url) {
+        options = new URL(options.url)
+      }
+    } catch {
+      // leave options as-is
+    }
+
+    options.headers = headers
+    ctx.args = { options }
+
+    const store = super.bindStart(ctx)
+
+    ctx.args = args
+
+    for (const name in options.headers) {
+      if (!headers[name]) {
+        args[0].headers ??= {}
+        args[0].headers[name] = options.headers[name]
+      }
+    }
+
+    return store
+  }
+
+  asyncStart (ctx) {
+    const reqHeaders = {}
+    const resHeaders = {}
+    const responseHead = ctx.res?._responseHead
+    const { statusCode } = responseHead || {}
+
+    for (const header in ctx.req._urlLoaderOptions?.headers || {}) {
+      reqHeaders[header.name] = header.value
+    }
+
+    for (const header in responseHead?.rawHeaders || {}) {
+      resHeaders[header.name] = header.value
+    }
+
+    ctx.req = { headers: reqHeaders }
+    ctx.res = { headers: resHeaders, statusCode }
+
+    this.finish(ctx)
+  }
+}
+
+module.exports = ElectronNetPlugin

package/packages/datadog-plugin-google-cloud-pubsub/src/consumer.js

@@ -122,8 +122,6 @@ class GoogleCloudPubsubConsumerPlugin extends ConsumerPlugin {
 
     const topicName = topic?.slice(topic.lastIndexOf('/') + 1) ??
       subscription.name.slice(subscription.name.lastIndexOf('/') + 1)
-    const baseService = this.tracer._service || 'unknown'
-    const serviceName = this.config.service || { name: `${baseService}-pubsub`, source: baseService }
 
     const meta = {
       'gcloud.project_id': subscription.pubsub.projectId,
@@ -133,8 +131,6 @@ class GoogleCloudPubsubConsumerPlugin extends ConsumerPlugin {
       'pubsub.subscription': subscription.name,
       'pubsub.subscription_type': 'pull',
       'messaging.operation': 'receive',
-      base_service: baseService,
-      service_override_type: 'custom',
     }
 
     if (batchRequestTraceId && batchRequestSpanId) {
@@ -168,7 +164,7 @@ class GoogleCloudPubsubConsumerPlugin extends ConsumerPlugin {
       childOf,
       resource: `Message from ${topicName}`,
       type: 'worker',
-      service: serviceName,
+      service: this.config.service || this.serviceName(),
       meta,
       metrics,
     }, ctx)

package/packages/datadog-plugin-google-cloud-pubsub/src/producer.js

@@ -54,9 +54,13 @@ class GoogleCloudPubsubProducerPlugin extends ProducerPlugin {
      * - Inject batch span context + metadata into all message attributes for downstream
      *   consumers to reconstruct the trace and understand batch relationships
      */
-    const spanLinkData = hasTraceContext
-      ? messages.slice(1).map(msg => this.#extractSpanLink(msg.attributes)).filter(Boolean)
-      : []
+    const spanLinkData = []
+    if (hasTraceContext) {
+      for (let i = 1; i < messageCount; i++) {
+        const link = this.#extractSpanLink(messages[i].attributes)
+        if (link) spanLinkData.push(link)
+      }
+    }
 
     const firstAttrs = messages[0]?.attributes
     const parentData = firstAttrs?.['x-datadog-trace-id'] && firstAttrs['x-datadog-parent-id']
@@ -107,35 +111,40 @@ class GoogleCloudPubsubProducerPlugin extends ProducerPlugin {
       ))
     }
 
-    for (let i = 0; i < messages.length; i++) {
+    const messageCountStr = String(messageCount)
+    const startTimeStr = String(Math.floor(batchSpan._startTime))
+    const dsmEnabled = this.config.dsmEnabled
+
+    for (let i = 0; i < messageCount; i++) {
       const msg = messages[i]
-      msg.attributes ??= {}
+      const attributes = msg.attributes ??= {}
 
       if (!hasTraceContext) {
-        this.tracer.inject(batchSpan, 'text_map', msg.attributes)
+        this.tracer.inject(batchSpan, 'text_map', attributes)
       }
 
-      Object.assign(msg.attributes, {
-        '_dd.pubsub_request.trace_id': batchTraceIdHex,
-        '_dd.pubsub_request.span_id': batchSpanIdHex,
-        '_dd.batch.size': String(messageCount),
-        '_dd.batch.index': String(i),
-        'gcloud.project_id': projectId,
-        'pubsub.topic': topic,
-        'x-dd-publish-start-time': String(Math.floor(batchSpan._startTime)),
-      })
+      // Assign keys one-by-one rather than via `Object.assign({...})` so V8
+      // keeps the attributes object on its existing hidden class instead of
+      // allocating a fresh literal per message.
+      attributes['_dd.pubsub_request.trace_id'] = batchTraceIdHex
+      attributes['_dd.pubsub_request.span_id'] = batchSpanIdHex
+      attributes['_dd.batch.size'] = messageCountStr
+      attributes['_dd.batch.index'] = String(i)
+      attributes['gcloud.project_id'] = projectId
+      attributes['pubsub.topic'] = topic
+      attributes['x-dd-publish-start-time'] = startTimeStr
 
       if (batchTraceIdUpper) {
-        msg.attributes['_dd.pubsub_request.p.tid'] = batchTraceIdUpper
+        attributes['_dd.pubsub_request.p.tid'] = batchTraceIdUpper
       }
 
-      if (this.config.dsmEnabled) {
+      if (dsmEnabled) {
         const dataStreamsContext = this.tracer.setCheckpoint(
           ['direction:out', `topic:${topic}`, 'type:google-pubsub'],
           batchSpan,
           getHeadersSize(msg)
         )
-        DsmPathwayCodec.encode(dataStreamsContext, msg.attributes)
+        DsmPathwayCodec.encode(dataStreamsContext, attributes)
       }
     }
 

package/packages/datadog-plugin-google-cloud-pubsub/src/pubsub-push-subscription.js

@@ -10,6 +10,8 @@ const pushReceiveSpans = new WeakMap()
 
 class GoogleCloudPubsubPushSubscriptionPlugin extends TracingPlugin {
   static get id () { return 'google-cloud-pubsub-push-subscription' }
+  static type = 'messaging'
+  static kind = 'consumer'
 
   constructor (...args) {
     super(...args)
@@ -150,7 +152,7 @@ class GoogleCloudPubsubPushSubscriptionPlugin extends TracingPlugin {
       childOf: parentContext,
       startTime,
       kind: 'consumer',
-      service: this.config.service || { name: `${this.tracer._service}-pubsub`, source: this.tracer._service },
+      service: this.config.service || this.serviceName(),
       meta: {
         component: 'google-cloud-pubsub',
         'pubsub.method': 'receive',

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

@@ -1,9 +1,7 @@
 'use strict'
 
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
-const { extractErrorIntoSpanEvent } = require('./utils')
-
-let tools
+const { extractErrorIntoSpanEvent, getSignature } = require('./utils')
 
 class GraphQLExecutePlugin extends TracingPlugin {
   static id = 'graphql'
@@ -54,35 +52,15 @@ class GraphQLExecutePlugin extends TracingPlugin {
 // span-related
 
 function addVariableTags (config, span, variableValues) {
-  const tags = {}
+  if (!variableValues || !config.variables) return
 
-  if (variableValues && config.variables) {
-    const variables = config.variables(variableValues)
-    for (const [param, value] of Object.entries(variables)) {
-      tags[`graphql.variables.${param}`] = value
-    }
+  const tags = {}
+  const variables = config.variables(variableValues)
+  for (const [param, value] of Object.entries(variables)) {
+    tags[`graphql.variables.${param}`] = value
   }
 
   span.addTags(tags)
 }
 
-function getSignature (document, operationName, operationType, calculate) {
-  if (calculate !== false && tools !== false) {
-    try {
-      try {
-        tools = tools || require('./tools')
-      } catch (e) {
-        tools = false
-        throw e
-      }
-
-      return tools.defaultEngineReportingSignature(document, operationName)
-    } catch {
-      // safety net
-    }
-  }
-
-  return [operationType, operationName].filter(Boolean).join(' ')
-}
-
 module.exports = GraphQLExecutePlugin

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

@@ -12,8 +12,6 @@ class GraphQLResolvePlugin extends TracingPlugin {
   start (fieldCtx) {
     const { info, rootCtx, args, path: pathAsArray, pathString } = fieldCtx
 
-    const path = getPath(this.config, pathAsArray)
-
     // we need to get the parent span to the field if it exists for correct span parenting
     // of nested fields
     const parentField = getParentField(rootCtx, pathString)
@@ -21,8 +19,10 @@ class GraphQLResolvePlugin extends TracingPlugin {
 
     fieldCtx.parent = parentField
 
-    if (!shouldInstrument(this.config, path)) return
-    const computedPathString = path.join('.')
+    if (!shouldInstrument(this.config, pathAsArray)) return
+    const computedPathString = this.config.collapse
+      ? buildCollapsedPathString(pathAsArray)
+      : pathString
 
     if (this.config.collapse) {
       if (rootCtx.fields[computedPathString]) return
@@ -37,7 +37,7 @@ class GraphQLResolvePlugin extends TracingPlugin {
     }
 
     const document = rootCtx.source
-    const fieldNode = info.fieldNodes.find(fieldNode => fieldNode.kind === 'Field')
+    const fieldNode = info.fieldNodes[0]
     const loc = this.config.source && document && fieldNode && fieldNode.loc
     const source = loc && document.slice(loc.start, loc.end)
 
@@ -78,9 +78,7 @@ class GraphQLResolvePlugin extends TracingPlugin {
     this.addTraceSub('updateField', (ctx) => {
       const { field, error, path: pathAsArray } = ctx
 
-      const path = getPath(this.config, pathAsArray)
-
-      if (!shouldInstrument(this.config, path)) return
+      if (!shouldInstrument(this.config, pathAsArray)) return
 
       const span = ctx?.currentStore?.span || this.activeSpan
       field.finishTime = span._getTime ? span._getTime() : 0
@@ -107,56 +105,53 @@ class GraphQLResolvePlugin extends TracingPlugin {
 
 // helpers
 
-function shouldInstrument (config, path) {
+function shouldInstrument (config, pathAsArray) {
+  if (config.depth < 0) return true
+
   let depth = 0
-  for (const item of path) {
-    if (typeof item === 'string') {
-      depth += 1
+  if (config.collapse) {
+    depth = pathAsArray.length
+  } else {
+    for (const segment of pathAsArray) {
+      if (typeof segment === 'string') depth += 1
     }
   }
 
-  return config.depth < 0 || config.depth >= depth
-}
-
-function getPath (config, pathAsArray) {
-  return config.collapse
-    ? withCollapse(pathAsArray)
-    : pathAsArray
+  return config.depth >= depth
 }
 
-function withCollapse (pathAsArray) {
-  return pathAsArray.map(segment => typeof segment === 'number' ? '*' : segment)
+function buildCollapsedPathString (pathAsArray) {
+  let result = ''
+  for (const segment of pathAsArray) {
+    if (result.length > 0) result += '.'
+    result += typeof segment === 'number' ? '*' : segment
+  }
+  return result
 }
 
 function getResolverInfo (info, args) {
-  let resolverInfo = null
-  const resolverVars = {}
+  let resolverVars
 
-  if (args) {
-    Object.assign(resolverVars, args)
+  if (args && Object.keys(args).length > 0) {
+    resolverVars = { ...args }
   }
 
-  let hasResolvers = false
   const directives = info.fieldNodes?.[0]?.directives
   if (Array.isArray(directives)) {
     for (const directive of directives) {
+      if (directive.arguments.length === 0) continue
+
       const argList = {}
       for (const argument of directive.arguments) {
         argList[argument.name.value] = argument.value.value
       }
 
-      if (directive.arguments.length > 0) {
-        hasResolvers = true
-        resolverVars[directive.name.value] = argList
-      }
+      resolverVars ??= {}
+      resolverVars[directive.name.value] = argList
     }
   }
 
-  if (hasResolvers || args && Object.keys(resolverVars).length) {
-    resolverInfo = { [info.fieldName]: resolverVars }
-  }
-
-  return resolverInfo
+  return resolverVars === undefined ? null : { [info.fieldName]: resolverVars }
 }
 
 function getParentField (parentCtx, pathToString) {

package/packages/datadog-plugin-graphql/src/tools/signature.js

@@ -1,9 +1,34 @@
-// file mostly untouched from apollo-graphql
+'use strict'
 
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const transforms_1 = require("./transforms");
-function defaultEngineReportingSignature(ast, operationName) {
-    return transforms_1.printWithReducedWhitespace(transforms_1.sortAST(transforms_1.removeAliases(transforms_1.hideLiterals(transforms_1.dropUnusedDefinitions(ast, operationName)))));
+Object.defineProperty(exports, '__esModule', { value: true })
+const transforms = require('./transforms')
+
+// Apollo Server / Yoga / Mercurius hand back the same parsed `DocumentNode`
+// from their own document caches per execute, so memoizing the signature on
+// the document keeps the visit/print pipeline off the hot path. The inner
+// Map keys on operationName since `separateOperations` picks a different
+// sub-document for each operation.
+const cache = new WeakMap()
+
+function defaultEngineReportingSignature (ast, operationName) {
+  const key = operationName == null ? '' : operationName
+  let inner = cache.get(ast)
+  if (inner !== undefined) {
+    const cached = inner.get(key)
+    if (cached !== undefined) {
+      return cached
+    }
+  }
+  const signature = transforms.printWithReducedWhitespace(
+    transforms.transformForSignature(
+      transforms.dropUnusedDefinitions(ast, operationName)
+    )
+  )
+  if (inner === undefined) {
+    inner = new Map()
+    cache.set(ast, inner)
+  }
+  inner.set(key, signature)
+  return signature
 }
-exports.defaultEngineReportingSignature = defaultEngineReportingSignature;
+exports.defaultEngineReportingSignature = defaultEngineReportingSignature

package/packages/datadog-plugin-graphql/src/tools/transforms.js

@@ -1,108 +1,126 @@
-// file mostly untouched from apollo-graphql
+'use strict'
 
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const ddGlobal = globalThis[Symbol.for('dd-trace')];
-const visitor_1 = ddGlobal.graphql_visitor;
-const printer_1 = ddGlobal.graphql_printer;
-const utilities_1 = ddGlobal.graphql_utilities;
-const lodash_sortby_1 = __importDefault(require("../../../../vendor/dist/lodash.sortby"));
-function hideLiterals(ast) {
-    return visitor_1.visit(ast, {
-        IntValue(node) {
-            return Object.assign({}, node, { value: "0" });
-        },
-        FloatValue(node) {
-            return Object.assign({}, node, { value: "0" });
-        },
-        StringValue(node) {
-            return Object.assign({}, node, { value: "", block: false });
-        },
-        ListValue(node) {
-            return Object.assign({}, node, { values: [] });
-        },
-        ObjectValue(node) {
-            return Object.assign({}, node, { fields: [] });
-        }
-    });
+Object.defineProperty(exports, '__esModule', { value: true })
+
+const ddGlobal = globalThis[Symbol.for('dd-trace')]
+const visitor = ddGlobal.graphql_visitor
+const printer = ddGlobal.graphql_printer
+const utilities = ddGlobal.graphql_utilities
+
+function dropUnusedDefinitions (ast, operationName) {
+  const separated = utilities.separateOperations(ast)[operationName]
+  if (!separated) {
+    return ast
+  }
+  return separated
 }
-exports.hideLiterals = hideLiterals;
-function hideStringAndNumericLiterals(ast) {
-    return visitor_1.visit(ast, {
-        IntValue(node) {
-            return Object.assign({}, node, { value: "0" });
-        },
-        FloatValue(node) {
-            return Object.assign({}, node, { value: "0" });
-        },
-        StringValue(node) {
-            return Object.assign({}, node, { value: "", block: false });
-        }
-    });
+
+// One walk replaces Apollo's `hideLiterals` + `removeAliases` + `sortAST` +
+// the `StringValue` pre-pass that used to live in `printWithReducedWhitespace`.
+// The byte output is unchanged: hideLiterals had already collapsed every
+// `StringValue.value` to '', so the original hex round-trip degenerated to
+// hex('') === '' anyway.
+function transformForSignature (ast) {
+  return visitor.visit(ast, {
+    IntValue (node) {
+      return { ...node, value: '0' }
+    },
+    FloatValue (node) {
+      return { ...node, value: '0' }
+    },
+    StringValue (node) {
+      return { ...node, value: '', block: false }
+    },
+    ListValue (node) {
+      return { ...node, values: [] }
+    },
+    ObjectValue (node) {
+      return { ...node, fields: [] }
+    },
+    Field (node) {
+      return {
+        ...node,
+        alias: undefined,
+        arguments: sortByName(node.arguments),
+      }
+    },
+    OperationDefinition (node) {
+      return {
+        ...node,
+        variableDefinitions: sortByVariableName(node.variableDefinitions),
+      }
+    },
+    SelectionSet (node) {
+      return { ...node, selections: sortByKindThenName(node.selections) }
+    },
+    FragmentSpread (node) {
+      return { ...node, directives: sortByName(node.directives) }
+    },
+    InlineFragment (node) {
+      return { ...node, directives: sortByName(node.directives) }
+    },
+    FragmentDefinition (node) {
+      return {
+        ...node,
+        directives: sortByName(node.directives),
+        variableDefinitions: sortByVariableName(node.variableDefinitions),
+      }
+    },
+    Directive (node) {
+      return { ...node, arguments: sortByName(node.arguments) }
+    },
+  })
 }
-exports.hideStringAndNumericLiterals = hideStringAndNumericLiterals;
-function dropUnusedDefinitions(ast, operationName) {
-    const separated = utilities_1.separateOperations(ast)[operationName];
-    if (!separated) {
-        return ast;
-    }
-    return separated;
+
+function printWithReducedWhitespace (ast) {
+  return printer.print(ast)
+    .replaceAll(/\s+/g, ' ')
+    .replaceAll(/ (?=[^_a-zA-Z0-9])|(?<=[^_a-zA-Z0-9]) /g, '')
 }
-exports.dropUnusedDefinitions = dropUnusedDefinitions;
-function sorted(items) {
-    if (items) {
-        return lodash_sortby_1.default.apply(null, arguments);
-    }
-    return undefined;
+
+function sortByName (items) {
+  if (!items) return
+  return [...items].sort(byName)
 }
-function sortAST(ast) {
-    return visitor_1.visit(ast, {
-        OperationDefinition(node) {
-            return Object.assign({}, node, { variableDefinitions: sorted(node.variableDefinitions, "variable.name.value") });
-        },
-        SelectionSet(node) {
-            return Object.assign({}, node, { selections: lodash_sortby_1.default(node.selections, "kind", "name.value") });
-        },
-        Field(node) {
-            return Object.assign({}, node, { arguments: sorted(node.arguments, "name.value") });
-        },
-        FragmentSpread(node) {
-            return Object.assign({}, node, { directives: sorted(node.directives, "name.value") });
-        },
-        InlineFragment(node) {
-            return Object.assign({}, node, { directives: sorted(node.directives, "name.value") });
-        },
-        FragmentDefinition(node) {
-            return Object.assign({}, node, { directives: sorted(node.directives, "name.value"), variableDefinitions: sorted(node.variableDefinitions, "variable.name.value") });
-        },
-        Directive(node) {
-            return Object.assign({}, node, { arguments: sorted(node.arguments, "name.value") });
-        }
-    });
+
+function byName (a, b) {
+  const left = a.name.value
+  const right = b.name.value
+  if (left < right) return -1
+  if (left > right) return 1
+  return 0
 }
-exports.sortAST = sortAST;
-function removeAliases(ast) {
-    return visitor_1.visit(ast, {
-        Field(node) {
-            return Object.assign({}, node, { alias: undefined });
-        }
-    });
+
+function sortByVariableName (items) {
+  if (!items) return
+  return [...items].sort(byVariableName)
 }
-exports.removeAliases = removeAliases;
-function printWithReducedWhitespace(ast) {
-    const sanitizedAST = visitor_1.visit(ast, {
-        StringValue(node) {
-            return Object.assign({}, node, { value: Buffer.from(node.value, "utf8").toString("hex"), block: false });
-        }
-    });
-    const withWhitespace = printer_1.print(sanitizedAST);
-    const minimizedButStillHex = withWhitespace
-        .replace(/\s+/g, " ")
-        .replace(/([^_a-zA-Z0-9]) /g, (_, c) => c)
-        .replace(/ ([^_a-zA-Z0-9])/g, (_, c) => c);
-    return minimizedButStillHex.replace(/"([a-f0-9]+)"/g, (_, hex) => JSON.stringify(Buffer.from(hex, "hex").toString("utf8")));
+
+function byVariableName (a, b) {
+  const left = a.variable.name.value
+  const right = b.variable.name.value
+  if (left < right) return -1
+  if (left > right) return 1
+  return 0
+}
+
+// SelectionSet children include InlineFragment, which has no `name`, so the
+// secondary key falls back to undefined and stable sort keeps sibling order.
+function sortByKindThenName (items) {
+  return [...items].sort(byKindThenName)
 }
-exports.printWithReducedWhitespace = printWithReducedWhitespace;
+
+function byKindThenName (a, b) {
+  if (a.kind < b.kind) return -1
+  if (a.kind > b.kind) return 1
+  const left = a.name?.value
+  const right = b.name?.value
+  if (left === right) return 0
+  if (left === undefined) return 1
+  if (right === undefined) return -1
+  return left < right ? -1 : 1
+}
+
+exports.dropUnusedDefinitions = dropUnusedDefinitions
+exports.transformForSignature = transformForSignature
+exports.printWithReducedWhitespace = printWithReducedWhitespace