dd-trace 6.7.0 → 6.9.0

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

@@ -15,6 +15,7 @@ const queryParsedChannel = channel('apm:next:query-parsed')
 
 const requests = new WeakSet()
 const nodeNextRequestsToNextRequests = new WeakMap()
+const requestErrors = new WeakMap()
 
 // Next.js <= 14.2.6
 const MIDDLEWARE_HEADER = 'x-middleware-invoke'
@@ -213,10 +214,8 @@ function wrapServeStatic (serveStatic) {
 }
 
 function finish (ctx, result, err) {
-  if (err) {
-    ctx.error = err
-    errorChannel.publish(ctx)
-  }
+  publishError(ctx.req, ctx, err)
+  requestErrors.delete(ctx.req)
 
   const maybeNextRequest = nodeNextRequestsToNextRequests.get(ctx.req)
   if (maybeNextRequest) {
@@ -226,6 +225,27 @@ function finish (ctx, result, err) {
   finishChannel.publish(ctx)
 }
 
+function publishError (req, ctx, error) {
+  if (!error) return
+
+  req = req.originalRequest || req
+  let errors = requestErrors.get(req)
+  if (errors?.has(error)) return
+
+  if (!errors) {
+    errors = new Set()
+    requestErrors.set(req, errors)
+  }
+  errors.add(error)
+
+  if (ctx) {
+    ctx.error = error
+    errorChannel.publish(ctx)
+  } else {
+    errorChannel.publish({ error })
+  }
+}
+
 // also wrapped in dist/server/future/route-handlers/app-route-route-handler.js
 // in versions below 13.3.0 that support middleware,
 // however, it is not provided as a class function or exported property
@@ -244,15 +264,11 @@ addHook({
   return NextRequestAdapter
 })
 
-// From next 15.4.1 each app-route build inlines its own copy of `fromNodeNextRequest`, so the hook
-// above no longer maps the node request to the app-route NextRequest and a thrown handler error
-// cannot reach `finish`. The app-route runtime reports real errors (redirect/notFound and other
-// control-flow signals excluded by next) through `RouteModule.onRequestError`, which next loads from
-// a precompiled `app-route*.runtime.{dev,prod}.js` bundle regardless of how the route chunk is
-// bundled. The bundler/experimental part of the name is matched with a pattern rather than
-// enumerated, so a variant next adds later is picked up without a code change.
-const patchedAppRouteModules = new WeakSet()
-
+// From Next 15.4.1, route modules execute through precompiled runtime bundles that bypass the
+// classic server hooks above. Match bundler and experimental filename variants without enumerating
+// them so App Routes, Pages APIs, and App Pages reuse the existing Next request lifecycle.
+const patchedRouteModules = new WeakSet()
+const COMPILED_RUNTIME_PATH = 'dist/compiled/next-server/'
 function wrapOnRequestError (onRequestError) {
   return function (req, error) {
     if (error) {
@@ -262,21 +278,137 @@ function wrapOnRequestError (onRequestError) {
   }
 }
 
-function instrumentAppRouteRuntime (runtime) {
-  const AppRouteRouteModule = runtime.AppRouteRouteModule
-  const proto = AppRouteRouteModule?.prototype
-  if (proto && typeof proto.onRequestError === 'function' && !patchedAppRouteModules.has(AppRouteRouteModule)) {
-    patchedAppRouteModules.add(AppRouteRouteModule)
+function getRoutePage (routeModule, fallbackPage) {
+  const definition = routeModule?.definition
+  if (typeof definition?.pathname === 'string') {
+    return { page: definition.pathname, isFilesystemPath: false }
+  }
+
+  if (typeof definition?.page === 'string') {
+    return { page: definition.page, isFilesystemPath: true }
+  }
+
+  return { page: fallbackPage, isFilesystemPath: false }
+}
+
+function publishRoutePage (ctx, routeModule, fallbackPage, isAppPath) {
+  if (!ctx || !pageLoadChannel.hasSubscribers) return
+
+  const pageData = getRoutePage(routeModule, fallbackPage)
+  if (pageData.page) {
+    pageLoadChannel.publish(isAppPath ? { ...pageData, isAppPath: true } : pageData)
+  }
+}
+
+function wrapAppRouteHandle (handle) {
+  return function (req, context) {
+    if (!startChannel.hasSubscribers && !queryParsedChannel.hasSubscribers) {
+      return handle.apply(this, arguments)
+    }
+
+    const res = { statusCode: 500 }
+    nodeNextRequestsToNextRequests.set(req, req)
+
+    return instrument(req, res, ctx => {
+      publishRoutePage(ctx, this, undefined, true)
+
+      return handle.apply(this, arguments).then(response => {
+        if (ctx) ctx.res.statusCode = response?.status || 200
+        return response
+      })
+    })
+  }
+}
+
+function instrumentRouteModule (RouteModule, method, wrapper, handleErrors) {
+  const proto = RouteModule?.prototype
+  if (!proto || patchedRouteModules.has(RouteModule)) return
+
+  patchedRouteModules.add(RouteModule)
+  if (typeof proto[method] === 'function') {
+    shimmer.wrap(proto, method, wrapper)
+  }
+  if (handleErrors && typeof proto.onRequestError === 'function') {
     shimmer.wrap(proto, 'onRequestError', wrapOnRequestError)
   }
+}
+
+function instrumentAppRouteRuntime (runtime) {
+  instrumentRouteModule(runtime.AppRouteRouteModule, 'handle', wrapAppRouteHandle, true)
   return runtime
 }
 
-addHook({
-  name: 'next',
-  versions: ['>=15.4.1'],
-  filePattern: String.raw`dist/compiled/next-server/app-route[\w-]*\.runtime\.(?:dev|prod)\.js$`,
-}, instrumentAppRouteRuntime)
+function wrapPagesApiRender (render) {
+  return function (req, res, context = {}) {
+    if (!startChannel.hasSubscribers && !queryParsedChannel.hasSubscribers) {
+      return render.apply(this, arguments)
+    }
+
+    return instrument(req, res, ctx => {
+      publishRoutePage(ctx, this, context.page, false)
+
+      const { onError } = context
+      return render.call(this, req, res, {
+        ...context,
+        onError: function (error) {
+          publishError(req, ctx, error)
+          return onError?.apply(this, arguments)
+        },
+      })
+    })
+  }
+}
+
+function instrumentPagesApiRuntime (runtime) {
+  const PagesAPIRouteModule = runtime.PagesAPIRouteModule || runtime.default
+  instrumentRouteModule(PagesAPIRouteModule, 'render', wrapPagesApiRender, false)
+  return runtime
+}
+
+function wrapAppPageRender (render) {
+  return function (req, res, context = {}) {
+    if (!startChannel.hasSubscribers && !queryParsedChannel.hasSubscribers) {
+      return render.apply(this, arguments)
+    }
+
+    return instrument(req, res, ctx => {
+      publishRoutePage(ctx, this, context.page, true)
+
+      return render.apply(this, arguments).then(result => {
+        const statusCode = result?.metadata?.statusCode
+        if (ctx && typeof statusCode === 'number') {
+          ctx.res.statusCode = statusCode
+        }
+
+        return result
+      }, error => {
+        if (ctx && (typeof ctx.res.statusCode !== 'number' || ctx.res.statusCode < 400)) {
+          ctx.res.statusCode = 500
+        }
+
+        throw error
+      })
+    })
+  }
+}
+
+function instrumentAppPageRuntime (runtime) {
+  const AppPageRouteModule = runtime.AppPageRouteModule || runtime.default
+  instrumentRouteModule(AppPageRouteModule, 'render', wrapAppPageRender, true)
+  return runtime
+}
+
+for (const [runtime, instrumentRuntime] of [
+  ['app-route', instrumentAppRouteRuntime],
+  ['pages-api', instrumentPagesApiRuntime],
+  ['app-page', instrumentAppPageRuntime],
+]) {
+  addHook({
+    name: 'next',
+    versions: ['>=15.4.1'],
+    filePattern: String.raw`${COMPILED_RUNTIME_PATH}${runtime}[\w-]*\.runtime\.(?:dev|prod)\.js$`,
+  }, instrumentRuntime)
+}
 
 addHook({
   name: 'next',

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

@@ -210,10 +210,24 @@ addHook({ name: 'openai', file: 'dist/api.js', versions: ['>=3.0.0 <4'] }, expor
   return exports
 })
 
+/**
+ * @typedef {{
+ *   methodName: string,
+ *   args: unknown[],
+ *   basePath?: string,
+ *   result?: Record<string, unknown>,
+ *   error?: unknown,
+ * }} OpenAiContext
+ */
+
 /**
  * For streamed responses, we need to accumulate all of the content in
  * the chunks, and let the combined content be the final response.
  * This way, spans look the same as when not streamed.
+ *
+ * @param {{ headers: unknown, url: string }} response
+ * @param {{ method: string }} options
+ * @param {OpenAiContext} ctx
  */
 function wrapStreamIterator (response, options, ctx) {
   return function (itr) {

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

@@ -1,6 +1,7 @@
 'use strict'
 
 const { errorMonitor } = require('node:events')
+const { performance } = require('node:perf_hooks')
 
 const shimmer = require('../../datadog-shimmer')
 const {
@@ -18,10 +19,22 @@ const finishPoolQueryCh = channel('datadog:pg:pool:query:finish')
 const poolConnectStartCh = channel('apm:pg:pool:connect:start')
 const poolConnectFinishCh = channel('apm:pg:pool:connect:finish')
 
+const poolAcquireStartCh = channel('apm:pg:pool:acquire:start')
+const poolAcquireFinishCh = channel('apm:pg:pool:acquire:finish')
+
 // Drivers like pg-promise reuse the same prepared-statement query object across executions; cache
 // the un-injected `text` so the wrap doesn't capture a previous DBM injection as the new original.
 const originalTextCache = new WeakMap()
 
+// Pool.query dispatches its client query synchronously from the connect callback, including nested
+// `_release` queue pulses, so the wait can cross that callback without retaining the client.
+const poolWaitClients = []
+const poolWaitTimes = []
+
+// Pool.query reports its internal acquire on the query span; explicit connects get an acquire span.
+// Pool.query calls connect synchronously, so a module flag reliably distinguishes the two.
+let acquiringForPoolQuery = false
+
 addHook({ name: 'pg', versions: ['>=8.0.3'], file: 'lib/native/client.js' }, Client => {
   shimmer.wrap(Client.prototype, 'query', query => wrapQuery(query))
   return Client
@@ -36,18 +49,74 @@ addHook({ name: 'pg', versions: ['>=8.0.3'] }, pg => {
   // pg defers a busy pool's connect callback and runs it in the releasing query's async context;
   // capture the caller's context and restore it around the callback so spans attach to the caller.
   shimmer.wrap(pg.Pool.prototype, 'connect', connect => function (cb) {
-    if (typeof cb !== 'function' || !poolConnectStartCh.hasSubscribers) {
+    // Pool.query always supplies a callback, so a missing callback is an explicit acquire.
+    if (typeof cb !== 'function') {
+      if (!poolAcquireStartCh.hasSubscribers) {
+        return connect.apply(this, arguments)
+      }
+
+      const start = acquireStart(this)
+      const acquireCtx = { poolOptions: this.options }
+      poolAcquireStartCh.publish(acquireCtx)
+
+      return connectForAcquire(connect, this, arguments, acquireCtx, start).then(client => {
+        acquireCtx.params = client.connectionParameters
+        finishAcquire(acquireCtx, start)
+        return client
+      }, error => {
+        acquireCtx.error = error
+        finishAcquire(acquireCtx, start)
+        throw error
+      })
+    }
+
+    if (!poolConnectStartCh.hasSubscribers) {
       return connect.apply(this, arguments)
     }
 
     const ctx = {}
-    arguments[0] = function (...args) {
-      return poolConnectFinishCh.runStores(ctx, cb, this, ...args)
+    const start = acquireStart(this)
+    let acquireCtx
+
+    if (acquiringForPoolQuery) {
+      arguments[0] = function (...args) {
+        const client = args[1]
+        if (client !== undefined) {
+          poolWaitClients.push(client)
+          poolWaitTimes.push(acquireWait(start))
+        }
+        try {
+          return poolConnectFinishCh.runStores(ctx, cb, this, ...args)
+        } finally {
+          if (client !== undefined) {
+            poolWaitClients.pop()
+            poolWaitTimes.pop()
+          }
+        }
+      }
+    } else {
+      acquireCtx = { poolOptions: this.options }
+      poolAcquireStartCh.publish(acquireCtx)
+
+      arguments[0] = function (...args) {
+        const client = args[1]
+        acquireCtx.error = args[0]
+        // A failed acquire has no client, so keep the parameters `connectForAcquire` snapshotted.
+        if (client !== undefined) {
+          acquireCtx.params = client.connectionParameters
+        }
+        finishAcquire(acquireCtx, start)
+        return poolConnectFinishCh.runStores(ctx, cb, this, ...args)
+      }
     }
 
     poolConnectStartCh.publish(ctx)
 
-    return connect.apply(this, arguments)
+    if (acquireCtx === undefined) {
+      return connect.apply(this, arguments)
+    }
+
+    return connectForAcquire(connect, this, arguments, acquireCtx, start)
   })
   shimmer.wrap(pg.Pool.prototype, 'query', query => wrapPoolQuery(query))
   return pg
@@ -83,6 +152,17 @@ function wrapQuery (query) {
       abortController,
       stream,
     }
+
+    if (poolWaitClients.length !== 0) {
+      for (let i = poolWaitClients.length - 1; i >= 0; i--) {
+        if (poolWaitClients[i] === this) {
+          ctx.poolWaitTime = poolWaitTimes[i]
+          poolWaitClients[i] = undefined
+          break
+        }
+      }
+    }
+
     const finish = (error, res) => {
       if (error) {
         ctx.error = error
@@ -185,10 +265,102 @@ function wrapQuery (query) {
 const finish = (ctx) => {
   finishPoolQueryCh.publish(ctx)
 }
+
+/**
+ * @typedef {{ database?: string, user?: string, host?: string, port?: number }} PoolConnectionParameters
+ * @typedef {{ connectionParameters?: PoolConnectionParameters }} PoolClient
+ * @typedef {{
+ *   options?: PoolConnectionParameters,
+ *   idleCount: number,
+ *   waitingCount: number,
+ *   _clients?: PoolClient[]
+ * }} InstrumentedPool
+ * @typedef {{
+ *   poolOptions?: PoolConnectionParameters,
+ *   params?: PoolConnectionParameters,
+ *   error?: unknown,
+ *   poolWaitTime?: number
+ * }} AcquireContext
+ * @typedef {{ length: number, [index: number]: unknown } & Iterable<unknown>} ArgumentsLike
+ */
+
+// pg drains its pending queue FIFO on the next tick, so an idle client is only ours when it
+// outnumbers the requests already queued ahead of us. That handoff is not a wait on the pool.
+/**
+ * @param {InstrumentedPool} pool
+ */
+function acquireStart (pool) {
+  return pool.idleCount > pool.waitingCount ? undefined : performance.now()
+}
+
+/**
+ * @param {number | undefined} start
+ */
+function acquireWait (start) {
+  return start === undefined ? 0 : performance.now() - start
+}
+
+/**
+ * @param {InstrumentedPool} pool
+ */
+function latestPoolConnectionParameters (pool) {
+  // pg-pool removes a failed client before invoking the acquire callback, so snapshot it while
+  // connect is still pending.
+  const clients = pool._clients
+  return clients?.at(-1)?.connectionParameters
+}
+
+/**
+ * @param {Function} connect
+ * @param {InstrumentedPool} pool
+ * @param {ArgumentsLike} args
+ * @param {AcquireContext} acquireCtx
+ * @param {number | undefined} start
+ */
+function connectForAcquire (connect, pool, args, acquireCtx, start) {
+  let result
+  try {
+    result = connect.apply(pool, args)
+  } catch (error) {
+    // pg throws synchronously when it cannot even build a client, from a malformed connection
+    // string or a caller-supplied `Client` constructor, so the span needs finishing here.
+    acquireCtx.error = error
+    finishAcquire(acquireCtx, start)
+    throw error
+  }
+
+  acquireCtx.params = latestPoolConnectionParameters(pool)
+  return result
+}
+
+/**
+ * @param {AcquireContext} ctx
+ * @param {number | undefined} start
+ */
+function finishAcquire (ctx, start) {
+  ctx.poolWaitTime = acquireWait(start)
+  poolAcquireFinishCh.publish(ctx)
+}
+
+/**
+ * @param {Function} query
+ * @param {InstrumentedPool} pool
+ * @param {unknown[]} args
+ */
+function acquireForPoolQuery (query, pool, args) {
+  acquiringForPoolQuery = true
+  try {
+    return query.apply(pool, args)
+  } finally {
+    acquiringForPoolQuery = false
+  }
+}
 function wrapPoolQuery (query) {
   return function (...args) {
     if (!startPoolQueryCh.hasSubscribers) {
-      return query.apply(this, args)
+      return poolConnectStartCh.hasSubscribers
+        ? acquireForPoolQuery(query, this, args)
+        : query.apply(this, args)
     }
 
     const pgQuery = args[0] !== null && typeof args[0] === 'object' ? args[0] : { text: args[0] }
@@ -218,7 +390,9 @@ function wrapPoolQuery (query) {
         })
       }
 
-      const retval = query.apply(this, args)
+      const retval = poolConnectStartCh.hasSubscribers
+        ? acquireForPoolQuery(query, this, args)
+        : query.apply(this, args)
 
       if (retval?.then) {
         retval.then(() => {