dd-trace 5.104.0 → 5.105.0

package/packages/datadog-instrumentations/src/helpers/promise-instrumentor.js

@@ -0,0 +1,42 @@
+'use strict'
+
+const dc = require('dc-polyfill')
+
+const { channel } = require('./instrument')
+
+/**
+ * Shimmer-compatible instrumentor for promise-returning APIs (e.g. `dns.promises.lookup`).
+ * Mirrors `createCallbackInstrumentor`'s channel triplet (`<prefix>:start`, `:finish`, `:error`)
+ * so a plugin subscribing to those channels for the callback variant works for the promise
+ * variant unchanged. `:finish` is the `tracingChannel` `asyncEnd` slot, so it fires after the
+ * promise settles with `ctx.result` set to the resolved value.
+ *
+ * @param {string} prefix
+ * @returns {(buildContext: (thisArg: unknown, args: unknown[]) => object | undefined) =>
+ *   (fn: Function) => Function}
+ */
+function createPromiseInstrumentor (prefix) {
+  const start = channel(prefix + ':start')
+  const finish = channel(prefix + ':finish')
+  const error = channel(prefix + ':error')
+  const tracing = dc.tracingChannel({
+    start,
+    end: channel(prefix + ':end'),
+    asyncStart: channel(prefix + ':asyncStart'),
+    asyncEnd: finish,
+    error,
+  })
+
+  return function instrument (buildContext) {
+    return function wrap (fn) {
+      return function (...args) {
+        if (!start.hasSubscribers) return fn.apply(this, args)
+        const ctx = buildContext(this, args)
+        if (ctx === undefined) return fn.apply(this, args)
+        return tracing.tracePromise(fn, ctx, this, ...args)
+      }
+    }
+  }
+}
+
+module.exports = { createPromiseInstrumentor }

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

@@ -133,7 +133,7 @@ for (const name of names) {
         try {
           loadChannel.publish({ name })
 
-          moduleExports = hook(moduleExports, moduleVersion, isIitm) ?? moduleExports
+          moduleExports = hook(moduleExports, moduleVersion, isIitm, { moduleBaseDir, moduleName }) ?? moduleExports
         } catch (error) {
           log.info('Error during ddtrace instrumentation of application, aborting.', error)
           telemetry('error', [

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

@@ -5,7 +5,7 @@ const { join } = require('path')
 const { pathToFileURL } = require('url')
 const log = require('../../../../dd-trace/src/log')
 const { create } = require('../../../../../vendor/dist/@apm-js-collab/code-transformer')
-const { traceAsyncIterator, traceIterator } = require('./transforms')
+const { waitForAsyncEnd } = require('./transforms')
 const instrumentations = require('./instrumentations')
 
 // `dc-polyfill` is referenced from injected `require()` (CJS) and `import`
@@ -34,8 +34,7 @@ const matcherCjs = create(instrumentations, dcPolyfillCjs)
 const matcherEsm = create(instrumentations, dcPolyfillEsm)
 
 for (const matcher of [matcherCjs, matcherEsm]) {
-  matcher.addTransform('traceIterator', traceIterator)
-  matcher.addTransform('traceAsyncIterator', traceAsyncIterator)
+  matcher.addTransform('waitForAsyncEnd', waitForAsyncEnd)
 }
 
 function rewrite (content, filename, format) {

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/azure-cosmos.js

@@ -0,0 +1,50 @@
+'use strict'
+
+module.exports = [{
+  module: {
+    name: '@azure/cosmos',
+    versionRange: '>=4.4.1',
+    filePath: 'dist/browser/plugins/Plugin.js',
+  },
+  functionQuery: {
+    functionName: 'executePlugins',
+    kind: 'Async',
+  },
+  channelName: 'executePlugins',
+},
+{
+  module: {
+    name: '@azure/cosmos',
+    versionRange: '>=4.4.1',
+    filePath: 'dist/commonjs/plugins/Plugin.js',
+  },
+  functionQuery: {
+    functionName: 'executePlugins',
+    kind: 'Async',
+  },
+  channelName: 'executePlugins',
+},
+{
+  module: {
+    name: '@azure/cosmos',
+    versionRange: '>=4.4.1',
+    filePath: 'dist/esm/plugins/Plugin.js',
+  },
+  functionQuery: {
+    functionName: 'executePlugins',
+    kind: 'Async',
+  },
+  channelName: 'executePlugins',
+},
+{
+  module: {
+    name: '@azure/cosmos',
+    versionRange: '>=4.4.1',
+    filePath: 'dist/react-native/plugins/Plugin.js',
+  },
+  functionQuery: {
+    functionName: 'executePlugins',
+    kind: 'Async',
+  },
+  channelName: 'executePlugins',
+}]

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

@@ -2,8 +2,10 @@
 
 module.exports = [
   ...require('./ai'),
+  ...require('./azure-cosmos'),
   ...require('./bullmq'),
   ...require('./langchain'),
   ...require('./langgraph'),
   ...require('./modelcontextprotocol-sdk'),
+  ...require('./playwright'),
 ]

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

@@ -10,9 +10,10 @@ module.exports = [
     functionQuery: {
       methodName: 'stream',
       className: 'Pregel',
+      kind: 'Async',
+      returnKind: 'AsyncIterator',
     },
     channelName: 'Pregel_stream',
-    transform: 'traceAsyncIterator',
   },
   {
     module: {
@@ -23,8 +24,9 @@ module.exports = [
     functionQuery: {
       methodName: 'stream',
       className: 'Pregel',
+      kind: 'Async',
+      returnKind: 'AsyncIterator',
     },
     channelName: 'Pregel_stream',
-    transform: 'traceAsyncIterator',
   },
 ]

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

@@ -0,0 +1,85 @@
+'use strict'
+
+// Playwright 1.60 bundles several former hook targets into local classes/functions.
+// Keep these rewrites limited to private bundled internals that addHook cannot wrap.
+module.exports = [
+  {
+    module: {
+      name: 'playwright',
+      versionRange: '>=1.60.0',
+      filePath: 'lib/runner/index.js',
+    },
+    functionQuery: {
+      className: 'Dispatcher',
+      methodName: 'run',
+      kind: 'Async',
+    },
+    channelName: 'Dispatcher_run',
+  },
+  {
+    module: {
+      name: 'playwright',
+      versionRange: '>=1.60.0',
+      filePath: 'lib/runner/index.js',
+    },
+    functionQuery: {
+      className: 'Dispatcher',
+      methodName: '_createWorker',
+      kind: 'Sync',
+    },
+    channelName: 'Dispatcher_createWorker',
+  },
+  {
+    module: {
+      name: 'playwright',
+      versionRange: '>=1.60.0',
+      filePath: 'lib/runner/index.js',
+    },
+    functionQuery: {
+      className: 'ProcessHost',
+      methodName: 'startRunner',
+      kind: 'Async',
+    },
+    channelName: 'ProcessHost_startRunner',
+  },
+  {
+    module: {
+      name: 'playwright',
+      versionRange: '>=1.60.0',
+      filePath: 'lib/runner/index.js',
+    },
+    functionQuery: {
+      functionName: 'createRootSuite',
+      kind: 'Async',
+    },
+    channelName: 'createRootSuite',
+  },
+  {
+    module: {
+      name: 'playwright-core',
+      versionRange: '>=1.60.0',
+      filePath: 'lib/coreBundle.js',
+    },
+    astQuery: 'AssignmentExpression[left.name="Page2"] > ClassExpression > ClassBody > ' +
+      'MethodDefinition[kind="method"][key.name="goto"] > FunctionExpression[async], ' +
+      'VariableDeclarator[id.name="Page2"] > ClassExpression > ClassBody > ' +
+      'MethodDefinition[kind="method"][key.name="goto"] > FunctionExpression[async], ' +
+      'ClassDeclaration[id.name="Page2"] > ClassBody > ' +
+      'MethodDefinition[kind="method"][key.name="goto"] > FunctionExpression[async]',
+    functionQuery: {
+      methodName: 'goto',
+      kind: 'Async',
+    },
+    channelName: 'Page_goto',
+  },
+  {
+    module: {
+      name: 'playwright-core',
+      versionRange: '>=1.60.0',
+      filePath: 'lib/coreBundle.js',
+    },
+    astQuery: 'ReturnStatement > CallExpression[callee.object.name="promise"][callee.property.name="then"]',
+    channelName: 'Page_goto',
+    transform: 'waitForAsyncEnd',
+  },
+]

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

@@ -1,246 +1,47 @@
 'use strict'
 
-// TODO: Move traceIterator to Orchestrion.
-
-const { parse, query, traverse } = require('./compiler')
-
-const tracingChannelPredicate = (node) => (
-  node.specifiers?.[0]?.local?.name === 'tr_ch_apm_tracingChannel' ||
-    node.declarations?.[0]?.id?.properties?.[0]?.value?.name === 'tr_ch_apm_tracingChannel'
-)
-
-const transforms = module.exports = {
-  /**
-   * @param {{ dcModule: string, moduleType: 'esm' | 'cjs' }} state
-   * @param {import('estree').Program} node
-   */
-  tracingChannelImport ({ dcModule, moduleType }, node) {
-    if (node.body.some(tracingChannelPredicate)) return
-
-    // The vendored matcher state exposes `moduleType` (`esm` / `cjs`), so we
-    // read that field directly. Naming it `sourceType` here used to silently
-    // pick the CJS branch for every ESM file, leaving `require()` baked into
-    // pure ESM modules like `@langchain/langgraph/dist/pregel/index.js`.
-    const isModule = moduleType === 'esm'
-
-    const index = node.body.findIndex(child => child.directive === 'use strict')
-    const code = isModule
-      ? `import tr_ch_apm_dc from "${dcModule}"; const {tracingChannel: tr_ch_apm_tracingChannel} = tr_ch_apm_dc`
-      : `const {tracingChannel: tr_ch_apm_tracingChannel} = require("${dcModule}")`
-
-    node.body.splice(index + 1, 0, ...parse(code, { isModule }).body)
-  },
-
-  tracingChannelDeclaration (state, node) {
-    const { channelName, module: { name } } = state
-    const channelVariable = 'tr_ch_apm$' + channelName.replaceAll(':', '_')
-
-    if (node.body.some(child => child.declarations?.[0]?.id?.name === channelVariable)) return
-
-    transforms.tracingChannelImport(state, node)
-
-    const index = node.body.findIndex(tracingChannelPredicate)
-    const code = `
-      const ${channelVariable} = tr_ch_apm_tracingChannel("orchestrion:${name}:${channelName}")
-    `
-
-    node.body.splice(index + 1, 0, parse(code).body[0])
-  },
-
-  traceAsyncIterator: traceAny,
-  traceIterator: traceAny,
-}
-
-function traceAny (state, node, _parent, ancestry) {
-  const program = ancestry[ancestry.length - 1]
-
-  if (node.type === 'ClassDeclaration' || node.type === 'ClassExpression') {
-    traceInstanceMethod(state, node, program)
-  } else {
-    traceFunction(state, node, program)
-  }
-}
-
-function traceFunction (state, node, program) {
-  transforms.tracingChannelDeclaration(state, program)
-
-  node.body = wrap(state, {
-    type: 'FunctionExpression',
-    params: node.params,
-    body: node.body,
-    async: node.async,
-    expression: false,
-    generator: node.generator,
-  }, program)
-
-  // The original function no longer contains any calls to `await` or `yield` as
-  // the function body is copied to the internal wrapped function, so we set
-  // these to false to avoid altering the return value of the wrapper. The old
-  // values are instead copied to the new AST node above.
-  node.generator = false
-  node.async = false
-
-  wrapSuper(state, node)
-}
-
-function traceInstanceMethod (state, node, program) {
-  const { functionQuery, operator } = state
-  const { methodName } = functionQuery
-
-  const classBody = node.body
-
-  // If the method exists on the class, we return as it will be patched later
-  // while traversing child nodes later on.
-  if (classBody.body.some(({ key }) => key.name === methodName)) return
-
-  // Method doesn't exist on the class so we assume an instance method and
-  // wrap it in the constructor instead.
-  let ctor = classBody.body.find(({ kind }) => kind === 'constructor')
-
-  transforms.tracingChannelDeclaration(state, program)
-
-  if (!ctor) {
-    ctor = parse(
-      node.superClass
-        ? 'class A { constructor (...args) { super(...args) } }'
-        : 'class A { constructor () {} }'
-    ).body[0].body.body[0] // Extract constructor from dummy class body.
-
-    classBody.body.unshift(ctor)
-  }
-
-  const ctorBody = parse(`
-    const __apm$${methodName} = this["${methodName}"]
-    this["${methodName}"] = function () {}
-  `).body
-
-  // Extract only right-hand side function of line 2.
-  const fn = ctorBody[1].expression.right
-
-  fn.async = operator === 'tracePromise'
-  fn.body = wrap(state, { type: 'Identifier', name: `__apm$${methodName}` }, program)
-
-  wrapSuper(state, fn)
-
-  ctor.value.body.body.push(...ctorBody)
-}
-
-function wrap (state, node, program) {
-  const { operator } = state
-
-  if (operator === 'traceAsyncIterator') return wrapIterator(state, node, program)
-  if (operator === 'traceIterator') return wrapIterator(state, node, program)
-}
-
-function wrapSuper (_state, node) {
-  const members = new Set()
-
-  traverse(
-    node.body,
-    '[object.type=Super]',
-    (node, parent) => {
-      const { name } = node.property
-
-      let child
-
-      if (parent.callee) {
-        // This is needed because for generator functions we have to move the
-        // original function to a nested wrapped function, but we can't use an
-        // arrow function because arrow function cannot be generator functions,
-        // and `super` cannot be called from a nested function, so we have to
-        // rewrite any `super` call to not use the keyword.
-        const { expression } = parse(`__apm$super['${name}'].call(this)`).body[0]
-
-        parent.callee = child = expression.callee
-        parent.arguments.unshift(...expression.arguments)
-      } else {
-        parent.expression = child = parse(`__apm$super['${name}']`).body[0]
-      }
-
-      child.computed = parent.callee.computed
-      child.optional = parent.callee.optional
-
-      members.add(name)
-    }
-  )
-
-  for (const name of members) {
-    const member = parse(`
-      class Wrapper {
-        wrapper () {
-          __apm$super['${name}'] = super['${name}']
-        }
-      }
-    `).body[0].body.body[0].value.body.body[0]
-
-    node.body.body.unshift(member)
-  }
-
-  if (members.size > 0) {
-    node.body.body.unshift(parse('const __apm$super = {}').body[0])
+// Custom transforms registered via InstrumentationMatcher.addTransform().
+//
+// Use this file for transforms that are not yet supported upstream in
+// @apm-js-collab/code-transformer (Orchestrion) or that cannot land there
+// for dd-trace-specific reasons. Once a transform is available natively in
+// the library, replace the custom registration with the built-in option and
+// remove the entry here.
+
+const { parse, query } = require('./compiler')
+
+module.exports = { waitForAsyncEnd }
+
+/**
+ * Injects a wait for `ctx.asyncEndPromise` into a generated `tracePromise`
+ * wrapper's native-Promise fulfillment handler.
+ *
+ * @param {object} _state
+ * @param {import('estree').CallExpression} node
+ * @returns {void}
+ */
+function waitForAsyncEnd (_state, node) {
+  const onFulfilled = node.arguments[0]
+  const statements = onFulfilled?.body?.body
+
+  if (!statements || query(onFulfilled.body, '[id.name=__apm$asyncEndPromise]').length > 0) {
+    return
   }
-}
 
-function wrapIterator (state, node, program) {
-  const { channelName, operator } = state
-  const baseChannel = channelName.replaceAll(':', '_')
-  const channelVariable = 'tr_ch_apm$' + baseChannel
-  const nextChannel = baseChannel + '_next'
-  const traceMethod = operator === 'traceAsyncIterator' ? 'tracePromise' : 'traceSync'
-  const traceNext = `tr_ch_apm$${nextChannel}.${traceMethod}`
+  const returnIndex = statements.findIndex(statement => (
+    statement.type === 'ReturnStatement' && statement.argument?.name === 'result'
+  ))
 
-  transforms.tracingChannelDeclaration({ ...state, channelName: nextChannel }, program)
+  if (returnIndex === -1) return
 
-  const wrapper = parse(`
+  const waitStatements = parse(`
     function wrapper () {
-      const __apm$traced = () => {
-        const __apm$wrapped = () => {};
-        return __apm$wrapped.apply(this, arguments);
-      };
-
-      if (!${channelVariable}.start.hasSubscribers) return __apm$traced();
-
-      {
-        const wrap = iter => {
-          const { next: iterNext, return: iterReturn, throw: iterThrow } = iter;
-
-          iter.next = (...args) => ${traceNext}(iterNext, ctx, iter, ...args);
-          iter.return = (...args) => ${traceNext}(iterReturn, ctx, iter, ...args);
-          iter.throw = (...args) => ${traceNext}(iterThrow, ctx, iter, ...args);
-
-          return iter;
-        };
-        const ctx = {
-          arguments,
-          self: this,
-          moduleVersion: "1.0.0"
-        };
-        const iter = ${channelVariable}.traceSync(__apm$traced, ctx);
-
-        if (typeof iter.then !== 'function') return wrap(iter);
-
-        return iter.then(result => {
-          ctx.result = result;
-
-          ${channelVariable}.asyncStart.publish(ctx);
-          ${channelVariable}.asyncEnd.publish(ctx);
-
-          return wrap(result);
-        }, err => {
-          ctx.error = err;
-
-          ${channelVariable}.error.publish(ctx);
-          ${channelVariable}.asyncStart.publish(ctx);
-          ${channelVariable}.asyncEnd.publish(ctx);
-
-          return Promise.reject(err);
-        });
-      };
+      const __apm$asyncEndPromise = __apm$ctx.asyncEndPromise;
+      if (__apm$asyncEndPromise && typeof __apm$asyncEndPromise.then === 'function') {
+        return __apm$asyncEndPromise.then(() => result, () => result);
+      }
     }
-  `).body[0].body // Extract only block statement of function body.
-
-  // Replace the right-hand side assignment of `const __apm$wrapped = () => {}`.
-  query(wrapper, '[id.name=__apm$wrapped]')[0].init = node
+  `).body[0].body.body
 
-  return wrapper
+  statements.splice(returnIndex, 0, ...waitStatements)
 }

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

@@ -14,6 +14,11 @@ const enterChannel = channel('apm:hono:middleware:enter')
 const exitChannel = channel('apm:hono:middleware:exit')
 const finishChannel = channel('apm:hono:middleware:finish')
 
+// Tracks handlers registered via `app.use()` so route-publishing wrappers
+// installed by `wrapRouterAdd` can skip middleware-only matches (a request
+// matching only middleware should keep the bare HTTP-method resource name).
+const middlewareHandlers = new WeakSet()
+
 // `app.request()` and non-node adapters call `app.fetch` without an `incoming`
 // IncomingMessage; the APM `web` helpers depend on one, so the wrappers below
 // skip publishing whenever it is missing.
@@ -27,6 +32,53 @@ function wrapFetch (fetch) {
   }
 }
 
+function wrapUse (originalUse) {
+  return function (arg1, ...handlers) {
+    if (typeof arg1 === 'function') middlewareHandlers.add(arg1)
+    for (const h of handlers) middlewareHandlers.add(h)
+    return originalUse.call(this, arg1, ...handlers)
+  }
+}
+
+// `app.basePath()` returns a clone Hono instance built via the library's
+// internal class binding, so it never hits our instrumented constructor. The
+// clone shares the parent router (so `router.add` stays wrapped), but its
+// `use` is a fresh per-instance method that must be wrapped too, otherwise
+// middleware registered on the sub-app never lands in `middlewareHandlers`.
+function wrapBasePath (originalBasePath) {
+  return function (path) {
+    const clone = originalBasePath.apply(this, arguments)
+    shimmer.wrap(clone, 'use', wrapUse)
+    shimmer.wrap(clone, 'basePath', wrapBasePath)
+    return clone
+  }
+}
+
+function wrapRouterAdd (originalAdd) {
+  return function (method, path, handlerData) {
+    const handler = handlerData?.[0]
+    if (typeof handler === 'function' && !middlewareHandlers.has(handler)) {
+      const meta = handlerData[1]
+      const wrappedHandler = function (context, next) {
+        const req = context.env?.incoming
+        if (req && routeChannel.hasSubscribers) {
+          routeChannel.publish({ req, route: meta?.path })
+        }
+        return handler.apply(this, arguments)
+      }
+      handlerData = [wrappedHandler, meta]
+    }
+    return originalAdd.call(this, method, path, handlerData)
+  }
+}
+
+function instrumentHonoInstance (instance) {
+  shimmer.wrap(instance, 'fetch', wrapFetch)
+  shimmer.wrap(instance, 'use', wrapUse)
+  shimmer.wrap(instance, 'basePath', wrapBasePath)
+  shimmer.wrap(instance.router, 'add', wrapRouterAdd)
+}
+
 function onErrorFn (error, _context_) {
   throw error
 }
@@ -74,7 +126,6 @@ function wrapMiddleware (middleware, route) {
         if (!req) {
           return middleware.apply(this, arguments)
         }
-        routeChannel.publish({ req, route })
         enterChannel.publish({ req, name, route })
         if (typeof next === 'function') {
           arguments[1] = wrapNext(req, route, next)
@@ -113,7 +164,7 @@ addHook({
   class Hono extends hono.Hono {
     constructor (...args) {
       super(...args)
-      shimmer.wrap(this, 'fetch', wrapFetch)
+      instrumentHonoInstance(this)
     }
   }
 
@@ -130,7 +181,7 @@ addHook({
   class Hono extends hono.Hono {
     constructor (...args) {
       super(...args)
-      shimmer.wrap(this, 'fetch', wrapFetch)
+      instrumentHonoInstance(this)
     }
   }
 

package/packages/datadog-instrumentations/src/http/server.js

@@ -43,7 +43,7 @@ function wrapResponseEmit (emit) {
       return emit.apply(this, arguments)
     }
 
-    if (['finish', 'close'].includes(eventName) && !requestFinishedSet.has(this)) {
+    if ((eventName === 'finish' || eventName === 'close') && !requestFinishedSet.has(this)) {
       finishServerCh.publish({ req: this.req })
       requestFinishedSet.add(this)
     }
@@ -51,6 +51,7 @@ function wrapResponseEmit (emit) {
     return emit.apply(this, arguments)
   }
 }
+
 function wrapEmit (emit) {
   return function (eventName, req, res) {
     if (!startServerCh.hasSubscribers) {
@@ -61,8 +62,12 @@ function wrapEmit (emit) {
       res.req = req
 
       const abortController = new AbortController()
+      // Single ctx shared with `exitServerCh` below and forwarded by the
+      // server plugin to `incomingHttpRequestStart`; existing subscribers
+      // only read the message, so the reuse is safe.
+      const ctx = { req, res, abortController }
 
-      startServerCh.publish({ req, res, abortController })
+      startServerCh.publish(ctx)
 
       try {
         if (abortController.signal.aborted) {
@@ -76,7 +81,7 @@ function wrapEmit (emit) {
 
         throw err
       } finally {
-        exitServerCh.publish({ req })
+        exitServerCh.publish(ctx)
       }
     }
     return emit.apply(this, arguments)
@@ -107,7 +112,7 @@ function wrapWriteHead (writeHead) {
     }
 
     // this doesn't support explicit duplicate headers, but it's an edge case
-    const responseHeaders = Object.assign(this.getHeaders(), obj)
+    const responseHeaders = obj === undefined ? this.getHeaders() : Object.assign(this.getHeaders(), obj)
 
     startWriteHeadCh.publish({
       req: this.req,