dd-trace 5.102.0 → 5.104.0

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

@@ -0,0 +1,143 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const ConsumerPlugin = require('../../dd-trace/src/plugins/consumer')
+const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
+
+class ElectronIpcPlugin extends CompositePlugin {
+  static id = 'electron:ipc'
+  static get plugins () {
+    return {
+      main: ElectronMainPlugin,
+      renderer: ElectronRendererPlugin,
+    }
+  }
+}
+
+class ElectronMainPlugin extends CompositePlugin {
+  static id = 'electron:ipc:main'
+  static get plugins () {
+    return {
+      receive: ElectronMainReceivePlugin,
+      handle: ElectronMainHandlePlugin,
+      send: ElectronMainSendPlugin,
+    }
+  }
+}
+
+class ElectronRendererPlugin extends CompositePlugin {
+  static id = 'electron:ipc:renderer'
+  static get plugins () {
+    return {
+      receive: ElectronRendererReceivePlugin,
+      send: ElectronRendererSendPlugin,
+    }
+  }
+}
+
+class ElectronRendererReceivePlugin extends ConsumerPlugin {
+  static id = 'electron:ipc:renderer:receive'
+  static component = 'electron'
+  static operation = 'receive'
+  static prefix = 'tracing:apm:electron:ipc:renderer:receive'
+
+  bindStart (ctx) {
+    const { args, channel } = ctx
+
+    if (channel?.startsWith('datadog:')) return
+
+    const childOf = this._tracer.extract('text_map', args[args.length - 1])
+
+    if (childOf) {
+      args.pop()
+    }
+
+    this.startSpan({
+      childOf,
+      resource: channel,
+      type: 'worker',
+      meta: {},
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  asyncEnd (ctx) {
+    this.finish(ctx)
+  }
+}
+
+class ElectronRendererSendPlugin extends ProducerPlugin {
+  static id = 'electron:ipc:renderer:send'
+  static component = 'electron'
+  static operation = 'send'
+  static prefix = 'tracing:apm:electron:ipc:renderer:send'
+
+  bindStart (ctx) {
+    const { args, channel } = ctx
+
+    if (channel?.startsWith('datadog:')) return
+
+    const span = this.startSpan({
+      resource: channel,
+      meta: {},
+    }, ctx)
+
+    if (this._shouldInject(ctx)) {
+      const carrier = {}
+
+      this._tracer.inject(span, 'text_map', carrier)
+
+      args.push(carrier)
+    }
+
+    return ctx.currentStore
+  }
+
+  end (ctx) {
+    if (ctx.hasOwnProperty('result')) {
+      this.finish(ctx)
+    }
+  }
+
+  asyncEnd (ctx) {
+    this.finish(ctx)
+  }
+
+  // Renderer can always inject since main is guaranteed to be patched.
+  _shouldInject () {
+    return true
+  }
+}
+
+class ElectronMainReceivePlugin extends ElectronRendererReceivePlugin {
+  static id = 'electron:ipc:main:receive'
+  static prefix = 'tracing:apm:electron:ipc:main:receive'
+}
+
+class ElectronMainHandlePlugin extends ElectronMainReceivePlugin {
+  static id = 'electron:ipc:main:handle'
+  static prefix = 'tracing:apm:electron:ipc:main:handle'
+}
+
+class ElectronMainSendPlugin extends ElectronRendererSendPlugin {
+  static id = 'electron:ipc:main:send'
+  static prefix = 'tracing:apm:electron:ipc:main:send'
+
+  constructor (...args) {
+    super(...args)
+
+    this._renderers = new WeakSet()
+
+    this.addSub('apm:electron:ipc:renderer:patched', event => {
+      this._renderers.add(event.sender)
+    })
+  }
+
+  // Only inject when the renderer was patched.
+  _shouldInject ({ self }) {
+    return this._renderers.has(self)
+  }
+}
+
+module.exports = ElectronIpcPlugin

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/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-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