dd-trace 5.106.0 → 5.107.0

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