@depup/dd-trace 5.90.0-depup.0

package/packages/datadog-plugin-google-cloud-vertexai/src/tracing.js

@@ -0,0 +1,49 @@
+'use strict'
+
+const { MEASURED } = require('../../../ext/tags')
+const { storage } = require('../../datadog-core')
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+const makeUtilities = require('../../dd-trace/src/plugins/util/llm')
+
+const {
+  extractModel,
+} = require('./utils')
+
+class GoogleCloudVertexAITracingPlugin extends TracingPlugin {
+  static id = 'google-cloud-vertexai'
+  static prefix = 'tracing:apm:vertexai:request'
+
+  constructor () {
+    super(...arguments)
+
+    Object.assign(this, makeUtilities('vertexai', this._tracerConfig))
+  }
+
+  bindStart (ctx) {
+    const { instance, resource } = ctx
+
+    const span = this.startSpan('vertexai.request', {
+      service: this.config.service,
+      resource,
+      kind: 'client',
+      meta: {
+        [MEASURED]: 1,
+        'vertexai.request.model': extractModel(instance),
+      },
+    }, false)
+
+    const store = storage('legacy').getStore() || {}
+    ctx.currentStore = { ...store, span }
+
+    return ctx.currentStore
+  }
+
+  asyncEnd (ctx) {
+    const span = ctx.currentStore?.span
+    if (!span) return
+
+    span.finish()
+  }
+}
+
+module.exports = GoogleCloudVertexAITracingPlugin

package/packages/datadog-plugin-google-cloud-vertexai/src/utils.js

@@ -0,0 +1,21 @@
+'use strict'
+
+function extractModel (instance) {
+  const model = instance.model || instance.resourcePath || instance.publisherModelEndpoint
+  return model?.split('/').pop()
+}
+
+function extractSystemInstructions (instance) {
+  // systemInstruction is either a string or a Content object
+  // Content objects have parts (Part[]) and a role
+  const systemInstruction = instance.systemInstruction
+  if (!systemInstruction) return []
+  if (typeof systemInstruction === 'string') return [systemInstruction]
+
+  return systemInstruction.parts?.map(part => part.text)
+}
+
+module.exports = {
+  extractModel,
+  extractSystemInstructions,
+}

package/packages/datadog-plugin-google-genai/src/index.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const GenAiLLMObsPlugin = require('../../dd-trace/src/llmobs/plugins/genai')
+const GenAiTracingPlugin = require('./tracing')
+
+class GenAiPlugin extends CompositePlugin {
+  static id = 'google-genai'
+  static get plugins () {
+    return {
+      llmobs: GenAiLLMObsPlugin,
+      tracing: GenAiTracingPlugin,
+    }
+  }
+}
+
+module.exports = GenAiPlugin

package/packages/datadog-plugin-google-genai/src/tracing.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing.js')
+
+class GenAiTracingPlugin extends TracingPlugin {
+  static id = 'google-genai'
+  static operation = 'request'
+  static prefix = 'tracing:apm:google:genai:request'
+
+  static get type () { return 'web' }
+  static get kind () { return 'client' }
+
+  bindStart (ctx) {
+    const { args, methodName } = ctx
+
+    const inputs = args[0]
+    const model = inputs?.model || 'unknown'
+
+    this.startSpan('google_genai.request', {
+      meta: {
+        'resource.name': methodName,
+        'google_genai.request.model': model,
+        'google_genai.request.provider': 'google',
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  asyncEnd (ctx) {
+    const { span } = ctx.currentStore
+    if (!span) return
+
+    if (ctx.result) {
+      span.setTag('google_genai.response.model', ctx.result.modelVersion || ctx.inputs?.model)
+    }
+    span.finish()
+  }
+}
+
+module.exports = GenAiTracingPlugin

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

@@ -0,0 +1,88 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+const { extractErrorIntoSpanEvent } = require('./utils')
+
+let tools
+
+class GraphQLExecutePlugin extends TracingPlugin {
+  static id = 'graphql'
+  static operation = 'execute'
+  static type = 'graphql'
+  static kind = 'server'
+
+  bindStart (ctx) {
+    const { operation, args, docSource } = ctx
+
+    const type = operation && operation.operation
+    const name = operation && operation.name && operation.name.value
+    const document = args.document
+    const source = this.config.source && document && docSource
+
+    const span = this.startSpan(this.operationName(), {
+      service: this.config.service || this.serviceName(),
+      resource: getSignature(document, name, type, this.config.signature),
+      kind: this.constructor.kind,
+      type: this.constructor.type,
+      meta: {
+        'graphql.operation.type': type,
+        'graphql.operation.name': name,
+        'graphql.source': source,
+      },
+    }, ctx)
+
+    addVariableTags(this.config, span, args.variableValues)
+
+    return ctx.currentStore
+  }
+
+  finish (ctx) {
+    const { res, args } = ctx
+    const span = ctx?.currentStore?.span || this.activeSpan
+    this.config.hooks.execute(span, args, res)
+    if (res?.errors) {
+      for (const err of res.errors) {
+        extractErrorIntoSpanEvent(this._tracerConfig, span, err)
+      }
+    }
+    super.finish(ctx)
+
+    return ctx.parentStore
+  }
+}
+
+// span-related
+
+function addVariableTags (config, span, variableValues) {
+  const tags = {}
+
+  if (variableValues && config.variables) {
+    const variables = config.variables(variableValues)
+    for (const param in variables) {
+      tags[`graphql.variables.${param}`] = variables[param]
+    }
+  }
+
+  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/index.js

@@ -0,0 +1,72 @@
+'use strict'
+
+const pick = require('../../datadog-core/src/utils/src/pick')
+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'
+  static get plugins () {
+    return {
+      execute: GraphQLExecutePlugin,
+      parse: GraphQLParsePlugin,
+      validate: GraphQLValidatePlugin,
+      resolve: GraphQLResolvePlugin,
+    }
+  }
+
+  /**
+   * @override
+   */
+  configure (config) {
+    return super.configure(validateConfig(config))
+  }
+}
+
+// config validator helpers
+
+function validateConfig (config) {
+  return {
+    ...config,
+    depth: getDepth(config),
+    variables: getVariablesFilter(config),
+    collapse: config.collapse === undefined || !!config.collapse,
+    hooks: getHooks(config),
+  }
+}
+
+function getDepth (config) {
+  if (typeof config.depth === 'number') {
+    return config.depth
+  } else if (config.hasOwnProperty('depth')) {
+    log.error('Expected `depth` to be a integer.')
+  }
+  return -1
+}
+
+function getVariablesFilter (config) {
+  if (typeof config.variables === 'function') {
+    return config.variables
+  } else if (Array.isArray(config.variables)) {
+    return variables => pick(variables, config.variables)
+  } else if (config.hasOwnProperty('variables')) {
+    log.error('Expected `variables` to be an array or function.')
+  }
+  return null
+}
+
+const noop = () => {}
+
+function getHooks ({ hooks }) {
+  const execute = hooks?.execute ?? noop
+  const parse = hooks?.parse ?? noop
+  const validate = hooks?.validate ?? noop
+
+  return { execute, parse, validate }
+}
+
+module.exports = GraphQLPlugin

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

@@ -0,0 +1,35 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+
+class GraphQLParsePlugin extends TracingPlugin {
+  static id = 'graphql'
+  static operation = 'parser'
+
+  bindStart (ctx) {
+    this.startSpan('graphql.parse', {
+      service: this.config.service,
+      type: 'graphql',
+      meta: {},
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  finish (ctx) {
+    const { source, document, docSource } = ctx
+    const span = ctx?.currentStore?.span || this.activeSpan
+
+    if (this.config.source && document) {
+      span.setTag('graphql.source', docSource)
+    }
+
+    this.config.hooks.parse(span, source, document)
+
+    super.finish(ctx)
+
+    return ctx.parentStore
+  }
+}
+
+module.exports = GraphQLParsePlugin

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

@@ -0,0 +1,191 @@
+'use strict'
+
+const dc = require('dc-polyfill')
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+
+const collapsedPathSym = Symbol('collapsedPaths')
+
+class GraphQLResolvePlugin extends TracingPlugin {
+  static id = 'graphql'
+  static operation = 'resolve'
+
+  start (fieldCtx) {
+    const { info, rootCtx, args } = fieldCtx
+
+    const path = getPath(info, this.config)
+
+    // we need to get the parent span to the field if it exists for correct span parenting
+    // of nested fields
+    const parentField = getParentField(rootCtx, pathToArray(info && info.path))
+    const childOf = parentField?.ctx?.currentStore?.span
+
+    fieldCtx.parent = parentField
+
+    if (!shouldInstrument(this.config, path)) return
+    const computedPathString = path.join('.')
+
+    if (this.config.collapse) {
+      if (rootCtx.fields[computedPathString]) return
+
+      if (!rootCtx[collapsedPathSym]) {
+        rootCtx[collapsedPathSym] = {}
+      } else if (rootCtx[collapsedPathSym][computedPathString]) {
+        return
+      }
+
+      rootCtx[collapsedPathSym][computedPathString] = true
+    }
+
+    const document = rootCtx.source
+    const fieldNode = info.fieldNodes.find(fieldNode => fieldNode.kind === 'Field')
+    const loc = this.config.source && document && fieldNode && fieldNode.loc
+    const source = loc && document.slice(loc.start, loc.end)
+
+    const span = this.startSpan('graphql.resolve', {
+      service: this.config.service,
+      resource: `${info.fieldName}:${info.returnType}`,
+      childOf,
+      type: 'graphql',
+      meta: {
+        'graphql.field.name': info.fieldName,
+        'graphql.field.path': computedPathString,
+        'graphql.field.type': info.returnType.name,
+        'graphql.source': source,
+      },
+    }, fieldCtx)
+
+    if (fieldNode && this.config.variables && fieldNode.arguments) {
+      const variables = this.config.variables(info.variableValues)
+
+      for (const arg of fieldNode.arguments) {
+        if (arg.value?.name && arg.value.kind === 'Variable' && variables[arg.value.name.value]) {
+          const name = arg.value.name.value
+          span.setTag(`graphql.variables.${name}`, variables[name])
+        }
+      }
+    }
+
+    if (this.resolverStartCh.hasSubscribers) {
+      this.resolverStartCh.publish({ ctx: rootCtx, resolverInfo: getResolverInfo(info, args) })
+    }
+
+    return fieldCtx.currentStore
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.addTraceSub('updateField', (ctx) => {
+      const { field, info, error } = ctx
+
+      const path = getPath(info, this.config)
+
+      if (!shouldInstrument(this.config, path)) return
+
+      const span = ctx?.currentStore?.span || this.activeSpan
+      field.finishTime = span._getTime ? span._getTime() : 0
+      field.error = field.error || error
+    })
+
+    this.resolverStartCh = dc.channel('datadog:graphql:resolver:start')
+  }
+
+  configure (config) {
+    // this will disable resolve subscribers if `config.depth` is set to 0
+    super.configure(config.depth === 0 ? false : config)
+  }
+
+  finish (ctx) {
+    const { finishTime } = ctx
+
+    const span = ctx?.currentStore?.span || this.activeSpan
+    span.finish(finishTime)
+
+    return ctx.parentStore
+  }
+}
+
+// helpers
+
+function shouldInstrument (config, path) {
+  let depth = 0
+  for (const item of path) {
+    if (typeof item === 'string') {
+      depth += 1
+    }
+  }
+
+  return config.depth < 0 || config.depth >= depth
+}
+
+function getPath (info, config) {
+  const responsePathAsArray = config.collapse
+    ? withCollapse(pathToArray)
+    : pathToArray
+  return responsePathAsArray(info && info.path)
+}
+
+function pathToArray (path) {
+  const flattened = []
+  let curr = path
+  while (curr) {
+    flattened.push(curr.key)
+    curr = curr.prev
+  }
+  return flattened.reverse()
+}
+
+function withCollapse (responsePathAsArray) {
+  return function () {
+    return responsePathAsArray.apply(this, arguments)
+      .map(segment => typeof segment === 'number' ? '*' : segment)
+  }
+}
+
+function getResolverInfo (info, args) {
+  let resolverInfo = null
+  const resolverVars = {}
+
+  if (args) {
+    Object.assign(resolverVars, args)
+  }
+
+  let hasResolvers = false
+  const directives = info.fieldNodes?.[0]?.directives
+  if (Array.isArray(directives)) {
+    for (const directive of directives) {
+      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
+      }
+    }
+  }
+
+  if (hasResolvers || args && Object.keys(resolverVars).length) {
+    resolverInfo = { [info.fieldName]: resolverVars }
+  }
+
+  return resolverInfo
+}
+
+function getParentField (parentCtx, path) {
+  for (let i = path.length - 1; i > 0; i--) {
+    const field = getField(parentCtx, path.slice(0, i))
+    if (field) {
+      return field
+    }
+  }
+
+  return null
+}
+
+function getField (parentCtx, path) {
+  return parentCtx.fields[path.join('.')]
+}
+
+module.exports = GraphQLResolvePlugin

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

@@ -0,0 +1,6 @@
+// file mostly untouched from apollo-graphql
+
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var signature_1 = require("./signature");
+exports.defaultEngineReportingSignature = signature_1.defaultEngineReportingSignature;

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

@@ -0,0 +1,9 @@
+// file mostly untouched from apollo-graphql
+
+"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)))));
+}
+exports.defaultEngineReportingSignature = defaultEngineReportingSignature;

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

@@ -0,0 +1,108 @@
+// file mostly untouched from apollo-graphql
+
+"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: [] });
+        }
+    });
+}
+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 });
+        }
+    });
+}
+exports.hideStringAndNumericLiterals = hideStringAndNumericLiterals;
+function dropUnusedDefinitions(ast, operationName) {
+    const separated = utilities_1.separateOperations(ast)[operationName];
+    if (!separated) {
+        return ast;
+    }
+    return separated;
+}
+exports.dropUnusedDefinitions = dropUnusedDefinitions;
+function sorted(items) {
+    if (items) {
+        return lodash_sortby_1.default.apply(null, arguments);
+    }
+    return undefined;
+}
+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") });
+        }
+    });
+}
+exports.sortAST = sortAST;
+function removeAliases(ast) {
+    return visitor_1.visit(ast, {
+        Field(node) {
+            return Object.assign({}, node, { alias: undefined });
+        }
+    });
+}
+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")));
+}
+exports.printWithReducedWhitespace = printWithReducedWhitespace;

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

@@ -0,0 +1,49 @@
+'use strict'
+
+function extractErrorIntoSpanEvent (config, span, exc) {
+  const attributes = {}
+
+  if (exc.name) {
+    attributes.type = exc.name
+  }
+
+  if (exc.stack) {
+    attributes.stacktrace = exc.stack
+  }
+
+  if (exc.locations) {
+    attributes.locations = []
+    for (const location of exc.locations) {
+      attributes.locations.push(`${location.line}:${location.column}`)
+    }
+  }
+
+  if (exc.path) {
+    attributes.path = exc.path.map(String)
+  }
+
+  if (exc.message) {
+    attributes.message = exc.message
+  }
+
+  if (config.graphqlErrorExtensions) {
+    for (const ext of config.graphqlErrorExtensions) {
+      if (exc.extensions?.[ext]) {
+        const value = exc.extensions[ext]
+
+        // We should only stringify the value if it is not of type number or boolean
+        if (typeof value === 'number' || typeof value === 'boolean') {
+          attributes[`extensions.${ext}`] = value
+        } else {
+          attributes[`extensions.${ext}`] = String(value)
+        }
+      }
+    }
+  }
+
+  span.addEvent('dd.graphql.query.error', attributes, Date.now())
+}
+
+module.exports = {
+  extractErrorIntoSpanEvent,
+}