dd-trace 5.105.0 → 5.107.0

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

@@ -18,57 +18,60 @@ const handleChannel = channel('apm:express:request:handle')
 const routeAddedChannel = channel('apm:express:route:added')
 
 function wrapHandle (handle) {
-  return function handleWithTrace (req, res) {
+  return function handleWithTrace (...args) {
     if (handleChannel.hasSubscribers) {
-      handleChannel.publish({ req })
+      handleChannel.publish({ req: args[0] })
     }
 
-    return handle.apply(this, arguments)
+    return Reflect.apply(handle, this, args)
   }
 }
 
 const responseJsonChannel = channel('datadog:express:response:json:start')
 
 function wrapResponseJson (json) {
-  return function wrappedJson (obj) {
+  return function wrappedJson (...args) {
     if (responseJsonChannel.hasSubscribers) {
-      // backward compat as express 4.x supports deprecated 3.x signature
-      if (arguments.length === 2 && typeof arguments[1] !== 'number') {
-        obj = arguments[1]
+      let obj = args[0]
+      // Deprecated express 3.x res.json(status, body) form, still honored by 4.x but not
+      // exercised by any suite (the unit harness can't drive res.json's freshness path).
+      /* istanbul ignore if */
+      if (args.length === 2 && typeof args[1] !== 'number') {
+        obj = args[1]
       }
 
       responseJsonChannel.publish({ req: this.req, res: this, body: obj })
     }
 
-    return json.apply(this, arguments)
+    return Reflect.apply(json, this, args)
   }
 }
 
 const responseRenderChannel = tracingChannel('datadog:express:response:render')
 
 function wrapResponseRender (render) {
-  return function wrappedRender (view, options, callback) {
+  return function wrappedRender (...args) {
     if (!responseRenderChannel.start.hasSubscribers) {
-      return render.apply(this, arguments)
+      return Reflect.apply(render, this, args)
     }
 
     const abortController = new AbortController()
     return responseRenderChannel.traceSync(
-      function (...args) {
+      function (...renderArgs) {
         if (abortController.signal.aborted) {
           throw abortController.signal.reason || new Error('Aborted')
         }
 
-        return render.apply(this, args)
+        return Reflect.apply(render, this, renderArgs)
       },
       {
         req: this.req,
-        view,
-        options,
+        view: args[0],
+        options: args[1],
         abortController,
       },
       this,
-      ...arguments
+      ...args
     )
   }
 }
@@ -172,7 +175,8 @@ addHook({ name: 'express', versions: ['4'], file: 'lib/express.js' }, express =>
 const queryParserReadCh = channel('datadog:query:read:finish')
 
 function publishQueryParsedAndNext (req, res, next) {
-  return shimmer.wrapFunction(next, next => function (...args) {
+  // Mirror next's name/arity so wrapCallback skips its per-call identity rewrite.
+  return shimmer.wrapCallback(next, original => function next (_error) {
     if (queryParserReadCh.hasSubscribers && req) {
       const abortController = new AbortController()
       const query = req.query
@@ -182,7 +186,7 @@ function publishQueryParsedAndNext (req, res, next) {
       if (abortController.signal.aborted) return
     }
 
-    return next.apply(this, args)
+    return original.apply(this, arguments)
   })
 }
 
@@ -194,9 +198,9 @@ addHook({
   return shimmer.wrapFunction(query, query => function (...args) {
     const queryMiddleware = query.apply(this, args)
 
-    return shimmer.wrapFunction(queryMiddleware, queryMiddleware => function (req, res, next) {
-      arguments[2] = publishQueryParsedAndNext(req, res, next)
-      return queryMiddleware.apply(this, arguments)
+    return shimmer.wrapFunction(queryMiddleware, queryMiddleware => function (...args) {
+      args[2] = publishQueryParsedAndNext(args[0], args[1], args[2])
+      return Reflect.apply(queryMiddleware, this, args)
     })
   })
 })

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

@@ -207,11 +207,14 @@ function preHandler (request, reply, done) {
 
 function preValidation (request, reply, done) {
   const req = getReq(request)
-  const res = getRes(reply)
   const ctx = parsingContexts.get(req)
-  ctx.res = res
 
-  if (!ctx) return processInContext(request, ctx, done, req)
+  // No stored context means the onRequest/preParsing fast path ran (no error /
+  // cookie / callback subscribers), so there is nothing to publish on; forward
+  // `done` instead of dereferencing a missing ctx in processInContext.
+  if (!ctx) return done()
+
+  ctx.res = getRes(reply)
 
   preValidationCh.runStores(ctx, processInContext, undefined, request, ctx, done, req)
 }
@@ -276,7 +279,7 @@ function wrapSend (send, req) {
     const ctx = { req }
     if (payload instanceof Error) {
       ctx.error = payload
-      errorChannel.publish(ctx)
+      publishError(ctx)
     } else if (canPublishResponsePayload(payload)) {
       const res = getRes(this)
       ctx.res = res
@@ -300,9 +303,18 @@ function getRouteConfig (request) {
   return request?.routeOptions?.config
 }
 
+let publishingError = false
+
 function publishError (ctx) {
-  if (ctx.error) {
-    errorChannel.publish(ctx)
+  // `errorChannel` is public: a subscriber that re-enters the hook pipeline while
+  // handling the error republishes here and recurses until the stack overflows.
+  if (ctx.error && !publishingError) {
+    publishingError = true
+    try {
+      errorChannel.publish(ctx)
+    } finally {
+      publishingError = false
+    }
   }
 
   return ctx.error

package/packages/datadog-instrumentations/src/helpers/openai-ai-guard.js

@@ -15,8 +15,8 @@ const aiguardChannel = dc.channel('dd-trace:ai:aiguard')
  * @typedef {object} ResourceHandler
  * @property {(callArgs: object) => (Array<object>|undefined)} getInputMessages
  * @property {(body: object) => Array<object>} getOutputMessages
- * @property {(inputMessages: Array<object>, outputMessages: Array<object>) => Promise<unknown>}
- *   publishOutputEvaluation
+ * @property {(inputMessages: Array<object>, outputMessages: Array<object>, parentSpan?: object)
+ *   => Promise<unknown>} publishOutputEvaluation
  */
 
 /**
@@ -24,17 +24,29 @@ const aiguardChannel = dc.channel('dd-trace:ai:aiguard')
  * @property {ResourceHandler} handler
  * @property {Array<object>} inputMessages
  * @property {() => Promise<void>} getInputEval
+ * @property {object} [parentSpan] - LLM span (`openai.request`) to nest `ai_guard` spans under.
+ *   Set by the instrumentation once the LLM span is active.
  */
 
 /**
  * Publishes already-converted AI-style messages to the AI Guard evaluation channel.
  *
+ * Subscribers push async work into `pending` and abort `abortController` to block.
+ *
  * @param {Array<object>} messages - AI-style messages to evaluate.
+ * @param {object} [parentSpan] - LLM span to use as the `ai_guard` span's parent.
  * @returns {Promise<void>}
  */
-function publishEvaluation (messages) {
-  return new Promise((resolve, reject) => {
-    aiguardChannel.publish({ messages, integration: 'openai', resolve, reject })
+function publishEvaluation (messages, parentSpan) {
+  const abortController = new AbortController()
+  const ctx = { messages, integration: 'openai', parentSpan, abortController, pending: [] }
+
+  aiguardChannel.publish(ctx)
+
+  return Promise.all(ctx.pending).then(() => {
+    if (abortController.signal.aborted) {
+      throw abortController.signal.reason
+    }
   })
 }
 
@@ -84,12 +96,13 @@ function getChatCompletionsOutputMessages (body) {
  *
  * @param {Array<object>} inputMessages
  * @param {Array<object>} outputMessages - One entry per choice
+ * @param {object} [parentSpan]
  * @returns {Promise<Array<void>>}
  */
-function publishChatCompletionsOutputEvaluation (inputMessages, outputMessages) {
+function publishChatCompletionsOutputEvaluation (inputMessages, outputMessages, parentSpan) {
   const evals = []
   for (const message of outputMessages) {
-    evals.push(publishEvaluation([...inputMessages, message]))
+    evals.push(publishEvaluation([...inputMessages, message], parentSpan))
   }
   return Promise.all(evals)
 }
@@ -157,10 +170,11 @@ function getResponsesOutputMessages (body) {
  *
  * @param {Array<object>} inputMessages
  * @param {Array<object>} outputMessages
+ * @param {object} [parentSpan]
  * @returns {Promise<void>}
  */
-function publishResponsesOutputEvaluation (inputMessages, outputMessages) {
-  return publishEvaluation([...inputMessages, ...outputMessages])
+function publishResponsesOutputEvaluation (inputMessages, outputMessages, parentSpan) {
+  return publishEvaluation([...inputMessages, ...outputMessages], parentSpan)
 }
 
 /**
@@ -215,8 +229,9 @@ function createGuard (baseResource, callArgs, stream) {
   if (!inputMessages) return null
 
   let inputEvalPromise
-  const getInputEval = () => (inputEvalPromise ??= publishEvaluation(inputMessages))
-  return { handler, inputMessages, getInputEval }
+  const guard = { handler, inputMessages, parentSpan: undefined }
+  guard.getInputEval = () => (inputEvalPromise ??= publishEvaluation(inputMessages, guard.parentSpan))
+  return guard
 }
 
 /**
@@ -257,7 +272,7 @@ function gateParse (parsedPromise, guard) {
 function evaluateOutput (guard, body) {
   const outputMessages = guard.handler.getOutputMessages(body)
   if (!outputMessages.length) return Promise.resolve()
-  return guard.handler.publishOutputEvaluation(guard.inputMessages, outputMessages)
+  return guard.handler.publishOutputEvaluation(guard.inputMessages, outputMessages, guard.parentSpan)
 }
 
 module.exports = {

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

@@ -219,7 +219,9 @@ function patch (http, methodName) {
             return setTimeout.apply(this, args)
           }
 
-          req.emit = function (eventName, arg) {
+          req.emit = function (...args) {
+            const eventName = args[0]
+            const arg = args[1]
             switch (eventName) {
               case 'response': {
                 const res = arg
@@ -233,7 +235,7 @@ function patch (http, methodName) {
                   break
                 }
 
-                const result = emit.apply(this, arguments)
+                const result = Reflect.apply(emit, this, args)
 
                 instrumentation.finalizeIfNeeded()
 
@@ -254,7 +256,7 @@ function patch (http, methodName) {
                 finish()
             }
 
-            return emit.apply(this, arguments)
+            return Reflect.apply(emit, this, args)
           }
 
           if (abortController.signal.aborted) {
@@ -292,17 +294,12 @@ function patch (http, methodName) {
 
   function normalizeOptions (inputURL) {
     if (typeof inputURL === 'string') {
-      try {
-        return urlToOptions(new url.URL(inputURL))
-      } catch {
-        // eslint-disable-next-line n/no-deprecated-api
-        return url.parse(inputURL)
-      }
-    } else if (inputURL instanceof url.URL) {
+      return urlToOptions(new url.URL(inputURL))
+    }
+    if (inputURL instanceof url.URL) {
       return urlToOptions(inputURL)
-    } else {
-      return inputURL
     }
+    return inputURL
   }
 
   function urlToOptions (url) {

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

@@ -37,28 +37,35 @@ addHook({ name: 'https' }, http => {
   return http
 })
 
-function wrapResponseEmit (emit) {
-  return function (eventName, event) {
+function wrapResponseEmit (originalEmit) {
+  // Named `emit` mirrors the response method so the one-time prototype wrap
+  // skips its name rewrite; rest params keep the per-event forwarding
+  // allocation-free.
+  return function emit (...args) {
     if (!finishServerCh.hasSubscribers) {
-      return emit.apply(this, arguments)
+      return Reflect.apply(originalEmit, this, args)
     }
 
+    const eventName = args[0]
     if ((eventName === 'finish' || eventName === 'close') && !requestFinishedSet.has(this)) {
       finishServerCh.publish({ req: this.req })
       requestFinishedSet.add(this)
     }
 
-    return emit.apply(this, arguments)
+    return Reflect.apply(originalEmit, this, args)
   }
 }
 
-function wrapEmit (emit) {
-  return function (eventName, req, res) {
+function wrapEmit (originalEmit) {
+  return function emit (...args) {
     if (!startServerCh.hasSubscribers) {
-      return emit.apply(this, arguments)
+      return Reflect.apply(originalEmit, this, args)
     }
 
+    const eventName = args[0]
     if (eventName === 'request') {
+      const req = args[1]
+      const res = args[2]
       res.req = req
 
       const abortController = new AbortController()
@@ -75,7 +82,7 @@ function wrapEmit (emit) {
           return this.listenerCount(eventName) > 0
         }
 
-        return emit.apply(this, arguments)
+        return Reflect.apply(originalEmit, this, args)
       } catch (err) {
         errorServerCh.publish(err)
 
@@ -84,16 +91,23 @@ function wrapEmit (emit) {
         exitServerCh.publish(ctx)
       }
     }
-    return emit.apply(this, arguments)
+    return Reflect.apply(originalEmit, this, args)
   }
 }
 
 function wrapWriteHead (writeHead) {
-  return function wrappedWriteHead (statusCode, reason, obj) {
+  // Rest params + Reflect.apply instead of named formals + `arguments`: naming
+  // params while reading `arguments` makes V8 materialise the mapped arguments
+  // object on every call, including the no-subscriber fast path.
+  return function wrappedWriteHead (...args) {
     if (!startWriteHeadCh.hasSubscribers) {
-      return writeHead.apply(this, arguments)
+      return Reflect.apply(writeHead, this, args)
     }
 
+    const statusCode = args[0]
+    const reason = args[1]
+    let obj = args[2]
+
     const abortController = new AbortController()
 
     if (typeof reason !== 'string') {
@@ -126,7 +140,7 @@ function wrapWriteHead (writeHead) {
       return this
     }
 
-    return writeHead.apply(this, arguments)
+    return Reflect.apply(writeHead, this, args)
   }
 }
 
@@ -157,9 +171,9 @@ function wrapWrite (write) {
 }
 
 function wrapSetHeader (setHeader) {
-  return function wrappedSetHeader (name, value) {
+  return function wrappedSetHeader (...args) {
     if (!startSetHeaderCh.hasSubscribers && !finishSetHeaderCh.hasSubscribers) {
-      return setHeader.apply(this, arguments)
+      return Reflect.apply(setHeader, this, args)
     }
 
     if (startSetHeaderCh.hasSubscribers) {
@@ -171,10 +185,10 @@ function wrapSetHeader (setHeader) {
       }
     }
 
-    const setHeaderResult = setHeader.apply(this, arguments)
+    const setHeaderResult = Reflect.apply(setHeader, this, args)
 
     if (finishSetHeaderCh.hasSubscribers) {
-      finishSetHeaderCh.publish({ name, value, res: this })
+      finishSetHeaderCh.publish({ name: args[0], value: args[1], res: this })
     }
 
     return setHeaderResult

package/packages/datadog-instrumentations/src/http2/client.js

@@ -11,14 +11,16 @@ const asyncEndChannel = channel('apm:http2:client:request:asyncEnd')
 const errorChannel = channel('apm:http2:client:request:error')
 
 function createWrapEmit (ctx) {
-  return function wrapEmit (emit) {
-    return function (event, arg1) {
-      ctx.eventName = event
-      ctx.eventData = arg1
+  return function wrapEmit (originalEmit) {
+    // Named `emit`/arity-1 mirrors the request method so the per-request wrap
+    // skips its name/length rewrite.
+    return function emit (eventName) {
+      ctx.eventName = eventName
+      ctx.eventData = arguments[1]
 
       return asyncStartChannel.runStores(ctx, () => {
         try {
-          return emit.apply(this, arguments)
+          return Reflect.apply(originalEmit, this, arguments)
         } finally {
           asyncEndChannel.publish(ctx)
         }
@@ -29,14 +31,14 @@ function createWrapEmit (ctx) {
 
 function createWrapRequest (authority, options) {
   return function wrapRequest (request) {
-    return function (headers) {
-      if (!startChannel.hasSubscribers) return request.apply(this, arguments)
+    return function (...args) {
+      if (!startChannel.hasSubscribers) return Reflect.apply(request, this, args)
 
-      const ctx = { headers, authority, options }
+      const ctx = { headers: args[0], authority, options }
 
       return startChannel.runStores(ctx, () => {
         try {
-          const req = request.apply(this, arguments)
+          const req = Reflect.apply(request, this, args)
 
           shimmer.wrap(req, 'emit', createWrapEmit(ctx))
 
@@ -54,13 +56,14 @@ function createWrapRequest (authority, options) {
 }
 
 function wrapConnect (connect) {
-  return function (authority, options) {
+  return function (...args) {
+    const authority = args[0]
     if (connectChannel.hasSubscribers) {
       connectChannel.publish({ authority })
     }
-    const session = connect.apply(this, arguments)
+    const session = Reflect.apply(connect, this, args)
 
-    shimmer.wrap(session, 'request', createWrapRequest(authority, options))
+    shimmer.wrap(session, 'request', createWrapRequest(authority, args[1]))
 
     return session
   }

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

@@ -26,21 +26,28 @@ function wrapCreateServer (createServer) {
   }
 }
 
-function wrapResponseEmit (emit, ctx) {
-  return function (eventName, event) {
+function wrapResponseEmit (originalEmit, ctx) {
+  // Named `emit`/arity-1 mirrors the response method so the per-response wrap
+  // skips its name/length rewrite.
+  return function emit (eventName) {
     ctx.req = this.req
     ctx.eventName = eventName
-    return emitCh.runStores(ctx, emit, this, ...arguments)
+    return emitCh.runStores(ctx, originalEmit, this, ...arguments)
   }
 }
 
-function wrapEmit (emit) {
-  return function (eventName, req, res) {
+function wrapEmit (originalEmit) {
+  // Named `emit` mirrors the server method so the one-time wrap skips its name
+  // rewrite; rest params keep the per-event forwarding allocation-free.
+  return function emit (...args) {
     if (!startServerCh.hasSubscribers) {
-      return emit.apply(this, arguments)
+      return Reflect.apply(originalEmit, this, args)
     }
 
+    const eventName = args[0]
     if (eventName === 'request') {
+      const req = args[1]
+      const res = args[2]
       res.req = req
 
       const ctx = { req, res }
@@ -48,7 +55,7 @@ function wrapEmit (emit) {
         shimmer.wrap(res, 'emit', emit => wrapResponseEmit(emit, ctx))
 
         try {
-          return emit.apply(this, arguments)
+          return Reflect.apply(originalEmit, this, args)
         } catch (error) {
           ctx.error = error
           errorServerCh.publish(ctx)
@@ -57,6 +64,6 @@ function wrapEmit (emit) {
         }
       })
     }
-    return emit.apply(this, arguments)
+    return Reflect.apply(originalEmit, this, args)
   }
 }

package/packages/datadog-instrumentations/src/jest/bail-reporter.js

@@ -0,0 +1,42 @@
+'use strict'
+
+const JEST_SESSION_STATE = Symbol.for('dd-trace:jest:session')
+
+class DatadogJestBailReporter {
+  /**
+   * @param {{ bail?: number, collectCoverage?: boolean, coverage?: boolean }} globalConfig
+   */
+  constructor (globalConfig) {
+    this.globalConfig = globalConfig
+  }
+
+  /**
+   * @param {Set<object>} _testContexts
+   * @param {{ numFailedTests?: number, numFailedTestSuites?: number, numRuntimeErrorTestSuites?: number }} results
+   * @returns {Promise<void> | void}
+   */
+  onRunComplete (_testContexts, results) {
+    const numBailFailures = getNumBailFailures(results)
+    if (
+      !this.globalConfig.bail ||
+      this.globalConfig.collectCoverage ||
+      this.globalConfig.coverage ||
+      numBailFailures < this.globalConfig.bail
+    ) {
+      return
+    }
+
+    return globalThis[JEST_SESSION_STATE]?.finishBailTestSession?.(results)
+  }
+}
+
+function getNumBailFailures (results) {
+  const numFailedTests = results?.numFailedTests || 0
+  const numFailedSuites = results?.numRuntimeErrorTestSuites === undefined
+    ? (numFailedTests === 0 ? results?.numFailedTestSuites || 0 : 0)
+    : results.numRuntimeErrorTestSuites
+
+  return numFailedTests + numFailedSuites
+}
+
+module.exports = DatadogJestBailReporter