dd-trace 5.95.0 → 5.97.0

package/packages/datadog-instrumentations/src/helpers/ai-messages.js

@@ -0,0 +1,182 @@
+'use strict'
+
+/**
+ * Converts a LanguageModelV2FilePart with an image mediaType to an AI guard style image_url content part.
+ *
+ * @param {{type: 'file', data: URL|string|Uint8Array, mediaType: string}} part
+ * @returns {{type: 'image_url', image_url: {url: string}}|undefined}
+ */
+function convertFilePartToImageUrl (part) {
+  const { data, mediaType } = part
+
+  if (data instanceof URL) {
+    return { type: 'image_url', image_url: { url: data.toString() } }
+  }
+
+  if (typeof data === 'string') {
+    if (data.startsWith('http') || data.startsWith('data:')) {
+      return { type: 'image_url', image_url: { url: data } }
+    }
+    return { type: 'image_url', image_url: { url: `data:${mediaType};base64,${data}` } }
+  }
+
+  if (data instanceof Uint8Array) {
+    return { type: 'image_url', image_url: { url: `data:${mediaType};base64,${Buffer.from(data).toString('base64')}` } }
+  }
+}
+
+/**
+ * Converts a LanguageModelV2Prompt to the AI guard style message format.
+ *
+ * Vercel AI v2 prompt entries use content arrays with typed parts (e.g. { type: 'text', text },
+ * { type: 'file', data, mediaType }). This function converts them to AI guard style messages.
+ * When file parts with image media types are present, the content is an array of text and
+ * image_url parts; otherwise it is a plain string.
+ *
+ * @param {Array<{role: string, content: string|Array<{type: string}>}>} prompt
+ * @returns {Array<{role: string, content?: string|Array<{type: string}>, tool_calls?: Array, tool_call_id?: string}>}
+ */
+function convertVercelPromptToMessages (prompt) {
+  if (!Array.isArray(prompt)) return []
+
+  const messages = []
+  for (const msg of prompt) {
+    switch (msg.role) {
+      case 'system':
+        messages.push({ role: 'system', content: typeof msg.content === 'string' ? msg.content : '' })
+        break
+
+      case 'user': {
+        if (!Array.isArray(msg.content)) break
+
+        const contentParts = []
+        for (const part of msg.content) {
+          if (part.type === 'text') {
+            contentParts.push({ type: 'text', text: part.text })
+          } else if (part.type === 'file' && part.mediaType?.startsWith('image/')) {
+            const converted = convertFilePartToImageUrl(part)
+            if (converted) contentParts.push(converted)
+          }
+        }
+
+        if (contentParts.length === 0) break
+
+        const hasImages = contentParts.some(p => p.type === 'image_url')
+        if (hasImages) {
+          messages.push({ role: 'user', content: contentParts })
+        } else {
+          messages.push({ role: 'user', content: contentParts.map(p => p.text).join('\n') })
+        }
+        break
+      }
+
+      case 'assistant': {
+        const textParts = []
+        const toolCalls = []
+        if (!Array.isArray(msg.content)) break
+
+        for (const part of msg.content) {
+          if (part.type === 'text') {
+            textParts.push(part.text)
+          } else if (part.type === 'tool-call') {
+            const args = part.args ?? part.input
+            toolCalls.push({
+              id: part.toolCallId,
+              function: {
+                name: part.toolName,
+                arguments: typeof args === 'string' ? args : JSON.stringify(args),
+              },
+            })
+          }
+        }
+
+        if (toolCalls.length > 0) {
+          messages.push({ role: 'assistant', tool_calls: toolCalls })
+        } else if (textParts.length > 0) {
+          messages.push({ role: 'assistant', content: textParts.join('\n') })
+        }
+        break
+      }
+
+      case 'tool': {
+        if (!Array.isArray(msg.content)) break
+
+        for (const part of msg.content) {
+          if (part.type === 'tool-result') {
+            const result = part.result ?? part.output
+            messages.push({
+              role: 'tool',
+              tool_call_id: part.toolCallId,
+              content: typeof result === 'string' ? result : JSON.stringify(result),
+            })
+          }
+        }
+        break
+      }
+    }
+  }
+  return messages
+}
+
+/**
+ * Converts LLM output tool calls to AI guard style message format.
+ *
+ * @param {Array<object>} inputMessages - The input messages already in AI guard style format
+ * @param {Array<{toolCallId: string, toolName: string, args?: unknown, input?: unknown}>} toolCalls
+ * @returns {Array<object>}
+ */
+function buildToolCallOutputMessages (inputMessages, toolCalls) {
+  return [
+    ...inputMessages,
+    {
+      role: 'assistant',
+      tool_calls: toolCalls.map(tc => {
+        const args = tc.args ?? tc.input
+        return {
+          id: tc.toolCallId,
+          function: {
+            name: tc.toolName,
+            arguments: typeof args === 'string' ? args : JSON.stringify(args),
+          },
+        }
+      }),
+    },
+  ]
+}
+
+/**
+ * Builds OpenAI-style output messages for the assistant's text response.
+ *
+ * @param {Array<object>} inputMessages - The input messages already in AI guard style format
+ * @param {string} text - The assistant's text response
+ * @returns {Array<object>}
+ */
+function buildTextOutputMessages (inputMessages, text) {
+  return [
+    ...inputMessages,
+    { role: 'assistant', content: text },
+  ]
+}
+
+/**
+ * Parses a Vercel AI content array and dispatches to the appropriate output message builder.
+ *
+ * @param {Array<object>} inputMessages - The input messages already in AI guard style format
+ * @param {Array<{type: string}>} content - Vercel AI content array from doGenerate/doStream result
+ * @returns {Array<object>}
+ */
+function buildOutputMessages (inputMessages, content) {
+  const toolCalls = content.filter(c => c.type === 'tool-call')
+  const text = content.filter(c => c.type === 'text').map(c => c.text).join('\n')
+  if (toolCalls.length) return buildToolCallOutputMessages(inputMessages, toolCalls)
+  if (text) return buildTextOutputMessages(inputMessages, text)
+  return inputMessages
+}
+
+module.exports = {
+  convertVercelPromptToMessages,
+  convertFilePartToImageUrl,
+  buildToolCallOutputMessages,
+  buildTextOutputMessages,
+  buildOutputMessages,
+}

package/packages/datadog-instrumentations/src/helpers/bundler-register.js

@@ -45,45 +45,73 @@ if (!dc.unsubscribe) {
   dc.unsubscribe = (channel, cb) => {
     if (dc.channel(channel).hasSubscribers) {
       dc.channel(channel).unsubscribe(cb)
+      return true
     }
+    return false
   }
 }
 
-function doHook (payload) {
-  const hook = hooks[payload.package]
+/**
+ * @param {string} name
+ */
+function doHook (name) {
+  const hook = hooks[name] ?? hooks[`node:${name}`]
   if (!hook) {
-    log.error('esbuild-wrapped %s missing in list of hooks', payload.package)
+    log.error('esbuild-wrapped %s missing in list of hooks', name)
     return
   }
 
   const hookFn = hook.fn ?? hook
   if (typeof hookFn !== 'function') {
-    log.error('esbuild-wrapped hook %s is not a function', payload.package)
+    log.error('esbuild-wrapped hook %s is not a function', name)
     return
   }
 
   try {
     hookFn()
   } catch {
-    log.error('esbuild-wrapped %s hook failed', payload.package)
+    log.error('esbuild-wrapped %s hook failed', name)
   }
 }
 
-dc.subscribe(CHANNEL, (payload) => {
-  doHook(payload)
+/** @type {Set<string>} */
+const instrumentedNodeModules = new Set()
 
-  if (!instrumentations[payload.package]) {
-    log.error('esbuild-wrapped %s missing in list of instrumentations', payload.package)
+/** @typedef {{ package: string, module: unknown, version: string, path: string }} Payload */
+dc.subscribe(CHANNEL, (message) => {
+  const payload = /** @type {Payload} */ (message)
+  const name = payload.package
+
+  const isPrefixedWithNode = name.startsWith('node:')
+
+  const isNodeModule = isPrefixedWithNode || !hooks[name]
+
+  if (isNodeModule) {
+    const nodeName = isPrefixedWithNode ? name.slice(5) : name
+    // Used for node: prefixed modules to prevent double instrumentation.
+    if (instrumentedNodeModules.has(nodeName)) {
+      return
+    }
+    instrumentedNodeModules.add(nodeName)
+  }
+
+  doHook(name)
+
+  const instrumentation = instrumentations[name] ?? instrumentations[`node:${name}`]
+
+  if (!instrumentation) {
+    log.error('esbuild-wrapped %s missing in list of instrumentations', name)
     return
   }
 
-  for (const { name, file, versions, hook } of instrumentations[payload.package]) {
-    if (payload.path !== filename(name, file)) continue
-    if (!matchVersion(payload.version, versions)) continue
+  for (const { file, versions, hook } of instrumentation) {
+    if (payload.path !== filename(name, file) || !matchVersion(payload.version, versions)) {
+      continue
+    }
 
     try {
       loadChannel.publish({ name, version: payload.version, file })
-      payload.module = hook(payload.module, payload.version)
+      payload.module = hook(payload.module, payload.version) ?? payload.module
     } catch (e) {
       log.error('Error executing bundler hook', e)
     }

package/packages/datadog-instrumentations/src/helpers/hook.js

@@ -1,17 +1,41 @@
 'use strict'
+
 const path = require('path')
+
 const iitm = require('../../../dd-trace/src/iitm')
 const ritm = require('../../../dd-trace/src/ritm')
+const log = require('../../../dd-trace/src/log')
+const requirePackageJson = require('../../../dd-trace/src/require-package-json')
+
+/**
+ * @param {string} moduleBaseDir
+ * @returns {string|undefined}
+ */
+function getVersion (moduleBaseDir) {
+  if (moduleBaseDir) {
+    return requirePackageJson(moduleBaseDir, /** @type {import('module').Module} */ (module)).version
+  }
+
+  return process.version
+}
 
 /**
  * This is called for every package/internal-module that dd-trace supports instrumentation for
  * In practice, `modules` is always an array with a single entry.
  *
+ * @overload
+ * @param {string[]} modules list of modules to hook into
+ * @param {object} hookOptions hook options
+ * @param {Function} onrequire callback to be executed upon encountering module
+ */
+/**
+ * @overload
  * @param {string[]} modules list of modules to hook into
  * @param {object} hookOptions hook options
  * @param {Function} onrequire callback to be executed upon encountering module
  */
 function Hook (modules, hookOptions, onrequire) {
+  // TODO: Rewrite this to use class syntax. The same should be done for ritm.
   if (!(this instanceof Hook)) return new Hook(modules, hookOptions, onrequire)
 
   if (typeof hookOptions === 'function') {
@@ -42,6 +66,13 @@ function Hook (modules, hookOptions, onrequire) {
       return result
     }
 
+    try {
+      moduleVersion ||= getVersion(moduleBaseDir)
+    } catch (error) {
+      log.error('Error getting version for "%s": %s', moduleName, error.message, error)
+      return
+    }
+
     if (
       isIitm &&
       moduleExports.default &&
@@ -66,10 +97,4 @@ function Hook (modules, hookOptions, onrequire) {
   })
 }
 
-Hook.prototype.unhook = function () {
-  this._ritmHook.unhook()
-  this._iitmHook.unhook()
-  this._patched = Object.create(null)
-}
-
 module.exports = Hook

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -1,6 +1,18 @@
 'use strict'
 
 module.exports = {
+  // Only list unprefixed node modules. They will automatically be instrumented as prefixed and unprefixed.
+  child_process: () => require('../child_process'),
+  crypto: () => require('../crypto'),
+  dns: () => require('../dns'),
+  fs: { serverless: false, fn: () => require('../fs') },
+  http: () => require('../http'),
+  http2: () => require('../http2'),
+  https: () => require('../http'),
+  net: () => require('../net'),
+  url: () => require('../url'),
+  vm: () => require('../vm'),
+  // Non Node.js modules
   '@anthropic-ai/sdk': { esmFirst: true, fn: () => require('../anthropic') },
   '@apollo/server': () => require('../apollo-server'),
   '@apollo/gateway': () => require('../apollo'),
@@ -47,31 +59,24 @@ module.exports = {
   bullmq: () => require('../bullmq'),
   bunyan: () => require('../bunyan'),
   'cassandra-driver': () => require('../cassandra-driver'),
-  child_process: () => require('../child_process'),
   connect: () => require('../connect'),
   cookie: () => require('../cookie'),
   'cookie-parser': () => require('../cookie-parser'),
   couchbase: () => require('../couchbase'),
-  crypto: () => require('../crypto'),
   cypress: () => require('../cypress'),
   'dd-trace-api': () => require('../dd-trace-api'),
-  dns: () => require('../dns'),
   elasticsearch: () => require('../elasticsearch'),
   express: () => require('../express'),
   'express-mongo-sanitize': () => require('../express-mongo-sanitize'),
   'express-session': () => require('../express-session'),
   fastify: () => require('../fastify'),
   'find-my-way': () => require('../find-my-way'),
-  fs: { serverless: false, fn: () => require('../fs') },
   'generic-pool': () => require('../generic-pool'),
   graphql: () => require('../graphql'),
   grpc: () => require('../grpc'),
   handlebars: () => require('../handlebars'),
   hapi: () => require('../hapi'),
   hono: { esmFirst: true, fn: () => require('../hono') },
-  http: () => require('../http'),
-  http2: () => require('../http2'),
-  https: () => require('../http'),
   ioredis: () => require('../ioredis'),
   iovalkey: () => require('../iovalkey'),
   'jest-circus': () => require('../jest'),
@@ -103,18 +108,8 @@ module.exports = {
   multer: () => require('../multer'),
   mysql: () => require('../mysql'),
   mysql2: () => require('../mysql2'),
-  net: () => require('../net'),
   next: () => require('../next'),
   'node-serialize': () => require('../node-serialize'),
-  'node:child_process': () => require('../child_process'),
-  'node:crypto': () => require('../crypto'),
-  'node:dns': () => require('../dns'),
-  'node:http': () => require('../http'),
-  'node:http2': () => require('../http2'),
-  'node:https': () => require('../http'),
-  'node:net': () => require('../net'),
-  'node:url': () => require('../url'),
-  'node:vm': () => require('../vm'),
   nyc: () => require('../nyc'),
   oracledb: () => require('../oracledb'),
   openai: { esmFirst: true, fn: () => require('../openai') },
@@ -142,9 +137,7 @@ module.exports = {
   tedious: () => require('../tedious'),
   tinypool: { esmFirst: true, fn: () => require('../vitest') },
   undici: () => require('../undici'),
-  url: () => require('../url'),
   vitest: { esmFirst: true, fn: () => require('../vitest') },
-  vm: () => require('../vm'),
   when: () => require('../when'),
   winston: () => require('../winston'),
   workerpool: () => require('../mocha'),

package/packages/datadog-instrumentations/src/helpers/instrument.js

@@ -1,11 +1,23 @@
 'use strict'
 
 const { AsyncResource } = require('async_hooks')
-const dc = require('dc-polyfill')
+const dc = /** @type {typeof import('node:diagnostics_channel')} */ (require('dc-polyfill'))
 const instrumentations = require('./instrumentations')
 const rewriterInstrumentations = require('./rewriter/instrumentations')
 
+/**
+ * @typedef {import('node:diagnostics_channel').Channel} Channel
+ * @typedef {import('node:diagnostics_channel').TracingChannel} TracingChannel
+ */
+
+/**
+ * @type {Record<string, Channel>}
+ */
 const channelMap = {}
+/**
+ * @param {string} name
+ * @returns {Channel}
+ */
 exports.channel = function (name) {
   const maybe = channelMap[name]
   if (maybe) return maybe
@@ -14,7 +26,14 @@ exports.channel = function (name) {
   return ch
 }
 
+/**
+ * @type {Record<string, TracingChannel>}
+ */
 const tracingChannelMap = {}
+/**
+ * @param {string} name
+ * @returns {TracingChannel}
+ */
 exports.tracingChannel = function (name) {
   const maybe = tracingChannelMap[name]
   if (maybe) return maybe
@@ -34,24 +53,19 @@ exports.getHooks = function getHooks (names) {
 
 /**
  * @param {object} args
- * @param {string|string[]} args.name module name
- * @param {string[]} args.versions array of semver range strings
+ * @param {string} args.name module name
+ * @param {string[]} [args.versions] array of semver range strings
  * @param {string} [args.file='index.js'] path to file within package to instrument
  * @param {string} [args.filePattern] pattern to match files within package to instrument
- * @param {boolean} [args.patchDefault] whether to patch the default export
- * @param {(moduleExports: unknown, version: string) => unknown} hook
+ * @param {boolean} [args.patchDefault=true] whether to patch the default export
+ * @param {(moduleExports: unknown, version: string, isIitm?: boolean) => unknown} [hook] Patches module exports
  */
 exports.addHook = function addHook ({ name, versions, file, filePattern, patchDefault }, hook) {
-  if (typeof name === 'string') {
-    name = [name]
+  if (!instrumentations[name]) {
+    instrumentations[name] = []
   }
 
-  for (const val of name) {
-    if (!instrumentations[val]) {
-      instrumentations[val] = []
-    }
-    instrumentations[val].push({ name: val, versions, file, filePattern, hook, patchDefault })
-  }
+  instrumentations[name].push({ versions, file, filePattern, hook, patchDefault })
 }
 
 exports.AsyncResource = AsyncResource