dd-trace 5.79.0 → 5.81.0

package/packages/datadog-esbuild/index.js

@@ -245,28 +245,45 @@ ${build.initialOptions.banner.js}`
         }
       }
 
-      const packageJson = JSON.parse(fs.readFileSync(pathToPackageJson).toString())
+      try {
+        const packageJson = JSON.parse(fs.readFileSync(pathToPackageJson).toString())
 
-      const isESM = isESMFile(fullPathToModule, pathToPackageJson, packageJson)
-      if (isESM && !interceptedESMModules.has(fullPathToModule)) {
-        fullPathToModule += ESM_INTERCEPTED_SUFFIX
-      }
+        const isESM = isESMFile(fullPathToModule, pathToPackageJson, packageJson)
+        if (isESM && !interceptedESMModules.has(fullPathToModule)) {
+          fullPathToModule += ESM_INTERCEPTED_SUFFIX
+        }
 
-      if (DEBUG) console.log(`RESOLVE: ${args.path}@${packageJson.version}`)
+        if (DEBUG) console.log(`RESOLVE: ${args.path}@${packageJson.version}`)
 
-      // https://esbuild.github.io/plugins/#on-resolve-arguments
-      return {
-        path: fullPathToModule,
-        pluginData: {
-          version: packageJson.version,
-          pkg: extracted.pkg,
-          path: extracted.path,
-          full: fullPathToModule,
-          raw: args.path,
-          pkgOfInterest: true,
-          kind: args.kind,
-          internal,
-          isESM
+        // https://esbuild.github.io/plugins/#on-resolve-arguments
+        return {
+          path: fullPathToModule,
+          pluginData: {
+            version: packageJson.version,
+            pkg: extracted.pkg,
+            path: extracted.path,
+            full: fullPathToModule,
+            raw: args.path,
+            pkgOfInterest: true,
+            kind: args.kind,
+            internal,
+            isESM
+          }
+        }
+      } catch (e) {
+        // Skip vendored dependencies which never have a `package.json`. This
+        // will use the default resolve logic of ESBuild which is what we want
+        // since those files should be treated as regular files and not modules
+        // even though they are in a `node_modules` folder.
+        if (e.code === 'ENOENT') {
+          if (DEBUG) {
+            console.log([
+              'Skipping `package.json` lookup.',
+              'This usually means the package was vendored but could indicate an issue otherwise.'
+            ].join(' '))
+          }
+        } else {
+          throw e
         }
       }
     }

package/packages/datadog-esbuild/src/utils.js

@@ -65,7 +65,11 @@ function getSource (url, { format }) {
 /**
  * Generates the pieces of code for the proxy module before the path
  *
- * @param {Object} moduleData { path, internal, context, excludeDefault }
+ * @param {object} moduleData
+ * @param {string} moduleData.path
+ * @param {boolean} moduleData.internal
+ * @param {object} moduleData.context
+ * @param {boolean} moduleData.excludeDefault
  * @returns {Promise<Map>}
  */
 async function processModule ({ path, internal, context, excludeDefault }) {

package/packages/datadog-instrumentations/index.js

@@ -2,3 +2,4 @@
 
 require('./src/helpers/bundler-register')
 require('./src/helpers/register')
+require('./src/helpers/rewriter/loader')

package/packages/datadog-instrumentations/src/anthropic.js

@@ -112,4 +112,16 @@ for (const extension of extensions) {
 
     return exports
   })
+
+  addHook({
+    name: '@anthropic-ai/sdk',
+    file: `resources/beta/messages/messages.${extension}`,
+    versions: ['>=0.33.0']
+  }, exports => {
+    const Messages = exports.Messages
+
+    shimmer.wrap(Messages.prototype, 'create', wrapCreate)
+
+    return exports
+  })
 }

package/packages/datadog-instrumentations/src/aws-sdk.js

@@ -3,6 +3,8 @@
 const { channel, addHook } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
+const patchedClientConfigProtocols = new WeakSet()
+
 function wrapRequest (send) {
   return function wrappedRequest (cb) {
     if (!this.service) return send.apply(this, arguments)
@@ -34,10 +36,11 @@ function wrapRequest (send) {
   }
 }
 
-function wrapDeserialize (deserialize, channelSuffix) {
+function wrapDeserialize (deserialize, channelSuffix, responseIndex = 0) {
   const headersCh = channel(`apm:aws:response:deserialize:${channelSuffix}`)
 
-  return function (response) {
+  return function () {
+    const response = arguments[responseIndex]
     if (headersCh.hasSubscribers) {
       headersCh.publish({ headers: response.headers })
     }
@@ -66,6 +69,14 @@ function wrapSmithySend (send) {
 
     if (typeof command.deserialize === 'function') {
       shimmer.wrap(command, 'deserialize', deserialize => wrapDeserialize(deserialize, channelSuffix))
+    } else if (this.config?.protocol?.deserializeResponse && !patchedClientConfigProtocols.has(this.config.protocol)) {
+      shimmer.wrap(
+        this.config.protocol,
+        'deserializeResponse',
+        deserializeResponse => wrapDeserialize(deserializeResponse, channelSuffix, 2)
+      )
+
+      patchedClientConfigProtocols.add(this.config.protocol)
     }
 
     const ctx = {

package/packages/datadog-instrumentations/src/azure-service-bus.js

@@ -8,57 +8,64 @@ const shimmer = require('../../datadog-shimmer')
 const dc = require('dc-polyfill')
 
 const producerCh = dc.tracingChannel('apm:azure-service-bus:send')
+const isItDefault = new WeakSet()
 
-addHook({ name: '@azure/service-bus', versions: ['>=7.9.2'], patchDefault: false }, (obj) => {
+addHook({ name: '@azure/service-bus', versions: ['>=7.9.2'] }, (obj) => {
   const ServiceBusClient = obj.ServiceBusClient
-  let didItShim = false
   shimmer.wrap(ServiceBusClient.prototype, 'createSender',
     createSender => function (queueOrTopicName) {
       const sender = createSender.apply(this, arguments)
-      if (didItShim) return sender
       const senderPrototype = sender.constructor.prototype
       const senderSenderPrototype = sender._sender.constructor.prototype
-      shimmer.wrap(senderPrototype, 'scheduleMessages', scheduleMessages =>
-        function (msg, scheduledEnqueueTimeUtc) {
-          const functionName = scheduleMessages.name
+
+      if (!isItDefault.has(senderPrototype)) {
+        isItDefault.add(senderPrototype)
+
+        shimmer.wrap(senderPrototype, 'scheduleMessages', scheduleMessages =>
+          function (msg, scheduledEnqueueTimeUtc) {
+            const functionName = scheduleMessages.name
+            const config = this._context.config
+            const entityPath = this._entityPath
+            return producerCh.tracePromise(
+              scheduleMessages,
+              { config, entityPath, functionName, msg, scheduledEnqueueTimeUtc },
+              this, ...arguments
+            )
+          })
+
+        shimmer.wrap(senderPrototype, 'createMessageBatch', createMessageBatch => async function () {
+          const batch = await createMessageBatch.apply(this, arguments)
+          shimmer.wrap(batch, 'tryAddMessage', tryAddMessage => function (msg) {
+            const functionName = tryAddMessage.name
+            const config = this._context.config
+            return producerCh.tracePromise(
+              tryAddMessage, { config, functionName, batch, msg }, this, ...arguments)
+          })
+          return batch
+        })
+      }
+
+      if (!isItDefault.has(senderSenderPrototype)) {
+        isItDefault.add(senderSenderPrototype)
+
+        shimmer.wrap(senderSenderPrototype, 'send', send => function (msg) {
+          const functionName = send.name
           const config = this._context.config
-          const entityPath = this._entityPath
+          const entityPath = this.entityPath
           return producerCh.tracePromise(
-            scheduleMessages,
-            { config, entityPath, functionName, msg, scheduledEnqueueTimeUtc },
-            this, ...arguments
+            send, { config, entityPath, functionName, msg }, this, ...arguments
           )
         })
 
-      shimmer.wrap(senderPrototype, 'createMessageBatch', createMessageBatch => async function () {
-        const batch = await createMessageBatch.apply(this, arguments)
-        shimmer.wrap(batch.constructor.prototype, 'tryAddMessage', tryAddMessage => function (msg) {
-          const functionName = tryAddMessage.name
+        shimmer.wrap(senderSenderPrototype, 'sendBatch', sendBatch => function (msg) {
+          const functionName = sendBatch.name
           const config = this._context.config
+          const entityPath = this.entityPath
           return producerCh.tracePromise(
-            tryAddMessage, { config, functionName, batch, msg }, this, ...arguments)
+            sendBatch, { config, entityPath, functionName, msg }, this, ...arguments
+          )
         })
-        return batch
-      })
-
-      shimmer.wrap(senderSenderPrototype, 'send', send => function (msg) {
-        const functionName = send.name
-        const config = this._context.config
-        const entityPath = this.entityPath
-        return producerCh.tracePromise(
-          send, { config, entityPath, functionName, msg }, this, ...arguments
-        )
-      })
-
-      shimmer.wrap(senderSenderPrototype, 'sendBatch', sendBatch => function (msg) {
-        const functionName = sendBatch.name
-        const config = this._context.config
-        const entityPath = this.entityPath
-        return producerCh.tracePromise(
-          sendBatch, { config, entityPath, functionName, msg }, this, ...arguments
-        )
-      })
-      didItShim = true
+      }
       return sender
     })
   return obj

package/packages/datadog-instrumentations/src/cucumber.js

@@ -1,5 +1,5 @@
 'use strict'
-const { createCoverageMap } = require('istanbul-lib-coverage')
+const { createCoverageMap } = require('../../../vendor/dist/istanbul-lib-coverage')
 
 const { addHook, channel } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
@@ -43,7 +43,7 @@ const {
   CUCUMBER_WORKER_TRACE_PAYLOAD_CODE,
   getIsFaultyEarlyFlakeDetection
 } = require('../../dd-trace/src/plugins/util/test')
-const satisfies = require('semifies')
+const satisfies = require('../../../vendor/dist/semifies')
 
 const isMarkedAsUnskippable = (pickle) => {
   return pickle.tags.some(tag => tag.name === '@datadog:unskippable')

package/packages/datadog-instrumentations/src/find-my-way.js

@@ -9,13 +9,13 @@ function wrapOn (on) {
   return function onWithTrace (method, path, opts) {
     const index = typeof opts === 'function' ? 2 : 3
     const handler = arguments[index]
-    const wrapper = shimmer.wrapFunction(handler, handler => function (req) {
-      routeChannel.publish({ req, route: path })
-
-      return handler.apply(this, arguments)
-    })
 
     if (typeof handler === 'function') {
+      const wrapper = shimmer.wrapFunction(handler, handler => function (req) {
+        routeChannel.publish({ req, route: path })
+
+        return handler.apply(this, arguments)
+      })
       arguments[index] = wrapper
     }
 
@@ -24,6 +24,7 @@ function wrapOn (on) {
 }
 
 addHook({ name: 'find-my-way', versions: ['>=1'] }, Router => {
+  // No need to wrap the off method as it would not contain the handler function.
   shimmer.wrap(Router.prototype, 'on', wrapOn)
 
   return Router

package/packages/datadog-instrumentations/src/google-genai.js

@@ -0,0 +1,120 @@
+'use strict'
+
+const { addHook } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+const tracingChannel = require('dc-polyfill').tracingChannel
+const channel = require('dc-polyfill').channel
+
+const genaiTracingChannel = tracingChannel('apm:google:genai:request')
+const onStreamedChunkCh = channel('apm:google:genai:request:chunk')
+
+function wrapGenerateContent (method) {
+  return function wrappedGenerateContent (original) {
+    return function (...args) {
+      if (!genaiTracingChannel.start.hasSubscribers) {
+        return original.apply(this, args)
+      }
+
+      const normalizedName = normalizeMethodName(method)
+
+      const ctx = { args, methodName: normalizedName }
+
+      return genaiTracingChannel.start.runStores(ctx, () => {
+        let result
+        try {
+          result = original.apply(this, arguments)
+        } catch (error) {
+          finish(ctx, null, error)
+          throw error
+        } finally {
+          genaiTracingChannel.end.publish(ctx)
+        }
+        return result.then(response => {
+          if (response[Symbol.asyncIterator]) {
+            shimmer.wrap(response, Symbol.asyncIterator, iterator => wrapStreamIterator(iterator, ctx))
+          } else {
+            finish(ctx, response, null)
+          }
+          return response
+        }).catch(error => {
+          finish(ctx, null, error)
+          throw error
+        })
+      })
+    }
+  }
+}
+
+function wrapStreamIterator (iterator, ctx) {
+  return function () {
+    const itr = iterator.apply(this, arguments)
+    shimmer.wrap(itr, 'next', next => function () {
+      return next.apply(this, arguments)
+        .then(res => {
+          const { done, value: chunk } = res
+          onStreamedChunkCh.publish({ ctx, chunk, done })
+
+          if (done) {
+            finish(ctx)
+          }
+
+          return res
+        })
+        .catch(error => {
+          finish(ctx, null, error)
+          throw error
+        })
+    })
+
+    return itr
+  }
+}
+function finish (ctx, result, error) {
+  if (error) {
+    ctx.error = error
+    genaiTracingChannel.error.publish(ctx)
+  }
+
+  // streamed responses are handled and set separately
+  ctx.result ??= result
+
+  genaiTracingChannel.asyncEnd.publish(ctx)
+}
+// Hook the main package entry point
+addHook({
+  name: '@google/genai',
+  versions: ['>=1.19.0']
+}, exports => {
+  // Wrap GoogleGenAI to intercept when it creates Models instances
+  if (!exports.GoogleGenAI) return exports
+
+  shimmer.wrap(exports, 'GoogleGenAI', GoogleGenAI => {
+    return class extends GoogleGenAI {
+      constructor (...args) {
+        super(...args)
+
+        // We are patching the instance instead of the prototype because when it is compiled from
+        // typescript, the models property is not available on the prototype.
+        if (this.models) {
+          if (this.models.generateContent) {
+            shimmer.wrap(this.models, 'generateContent', wrapGenerateContent('generateContent'))
+          }
+          if (this.models.generateContentStream) {
+            shimmer.wrap(this.models, 'generateContentStream', wrapGenerateContent('generateContentStream'))
+          }
+          if (this.models.embedContent) {
+            shimmer.wrap(this.models, 'embedContent', wrapGenerateContent('embedContent'))
+          }
+        }
+      }
+    }
+  })
+  return exports
+})
+
+function normalizeMethodName (methodName) {
+  // Convert camelCase to snake_case and add Models prefix
+  return 'Models.' + methodName
+    .replaceAll(/([a-z0-9])([A-Z])/g, '$1_$2')
+    .toLowerCase()
+}

package/packages/datadog-instrumentations/src/graphql.js

@@ -6,6 +6,8 @@ const {
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
+const ddGlobal = globalThis[Symbol.for('dd-trace')] ??= {}
+
 /** cached objects */
 
 const contexts = new WeakMap()
@@ -360,3 +362,21 @@ addHook({ name: 'graphql', file: 'validation/validate.js', versions: ['>=0.10']
 
   return validate
 })
+
+addHook({ name: 'graphql', file: 'language/printer.js', versions: ['>=0.10'] }, printer => {
+  // HACK: It's possible `graphql` is loaded before `@apollo/gateway` so we
+  //       can't use a channel as the latter plugin would load after the publish
+  //       happened. Not sure how to handle this so for now use a global.
+  ddGlobal.graphql_printer = printer
+  return printer
+})
+
+addHook({ name: 'graphql', file: 'language/visitor.js', versions: ['>=0.10'] }, visitor => {
+  ddGlobal.graphql_visitor = visitor
+  return visitor
+})
+
+addHook({ name: 'graphql', file: 'utilities/index.js', versions: ['>=0.10'] }, utilities => {
+  ddGlobal.graphql_utilities = utilities
+  return utilities
+})

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

@@ -8,6 +8,7 @@ const ritm = require('../../../dd-trace/src/ritm')
  * In practice, `modules` is always an array with a single entry.
  *
  * @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) {

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

@@ -13,6 +13,7 @@ module.exports = {
   '@playwright/test': () => require('../playwright'),
   '@elastic/elasticsearch': () => require('../elasticsearch'),
   '@elastic/transport': () => require('../elasticsearch'),
+  '@google/genai': () => require('../google-genai'),
   '@google-cloud/pubsub': () => require('../google-cloud-pubsub'),
   '@google-cloud/vertexai': () => require('../google-cloud-vertexai'),
   '@graphql-tools/executor': () => require('../graphql'),

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

@@ -2,6 +2,7 @@
 
 const dc = require('dc-polyfill')
 const instrumentations = require('./instrumentations')
+const rewriterInstrumentations = require('./rewriter/instrumentations')
 const { AsyncResource } = require('async_hooks')
 
 const channelMap = {}
@@ -22,13 +23,23 @@ exports.tracingChannel = function (name) {
   return tc
 }
 
+exports.getHooks = function getHooks (names) {
+  names = [names].flat()
+
+  return rewriterInstrumentations
+    .map(inst => inst.module)
+    .filter(({ name }) => names.includes(name))
+    .map(({ name, versionRange, filePath }) => ({ name, versions: [versionRange], file: filePath }))
+}
+
 /**
  * @param {object} args
  * @param {string|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 Function hook
+ * @param {boolean} [args.patchDefault] whether to patch the default export
+ * @param {(moduleExports: unknown, version: string) => unknown} hook
  */
 exports.addHook = function addHook ({ name, versions, file, filePattern, patchDefault }, hook) {
   if (typeof name === 'string') {

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

@@ -2,7 +2,7 @@
 
 const { channel } = require('dc-polyfill')
 const path = require('path')
-const satisfies = require('semifies')
+const satisfies = require('../../../../vendor/dist/semifies')
 const Hook = require('./hook')
 const requirePackageJson = require('../../../dd-trace/src/require-package-json')
 const log = require('../../../dd-trace/src/log')
@@ -10,6 +10,7 @@ const checkRequireCache = require('./check-require-cache')
 const telemetry = require('../../../dd-trace/src/guardrails/telemetry')
 const { isInServerlessEnvironment } = require('../../../dd-trace/src/serverless')
 const { getEnvironmentVariables } = require('../../../dd-trace/src/config-helper')
+const rewriter = require('./rewriter')
 
 const envs = getEnvironmentVariables()
 
@@ -48,6 +49,10 @@ if (DD_TRACE_DEBUG && DD_TRACE_DEBUG.toLowerCase() !== 'false') {
 const seenCombo = new Set()
 const allInstrumentations = {}
 
+for (const inst of disabledInstrumentations) {
+  rewriter.disable(inst)
+}
+
 // TODO: make this more efficient
 for (const packageName of names) {
   if (disabledInstrumentations.has(packageName)) continue

package/packages/datadog-instrumentations/src/helpers/rewriter/compiler.js

@@ -0,0 +1,27 @@
+'use strict'
+
+let meriyah
+let astring
+let esquery
+
+module.exports = {
+  parse: (...args) => {
+    meriyah ??= require('../../../../../vendor/dist/meriyah')
+
+    return meriyah.parse(...args)
+  },
+
+  generate: (...args) => {
+    astring ??= require('../../../../../vendor/dist/astring')
+
+    return astring.generate(...args)
+  },
+
+  traverse: (ast, query, visitor) => {
+    esquery ??= require('../../../../../vendor/dist/esquery').default
+
+    const selector = esquery.parse(query)
+
+    return esquery.traverse(ast, selector, visitor)
+  },
+}