dd-trace 5.104.0 → 5.105.0

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

@@ -3,6 +3,7 @@
 const dc = require('dc-polyfill')
 const shimmer = require('../../datadog-shimmer')
 const { addHook } = require('./helpers/instrument')
+const aiGuard = require('./helpers/openai-ai-guard')
 
 const ch = dc.tracingChannel('apm:openai:request')
 const onStreamedChunkCh = dc.channel('apm:openai:request:chunk')
@@ -216,15 +217,20 @@ for (const extension of extensions) {
 
       for (const methodName of methods) {
         shimmer.wrap(targetPrototype, methodName, methodFn => function (...args) {
-          if (!ch.start.hasSubscribers) {
+          if (!ch.start.hasSubscribers && !aiGuard.hasSubscribers()) {
             return methodFn.apply(this, args)
           }
-
           // The OpenAI library lets you set `stream: true` on the options arg to any method
           // However, we only want to handle streamed responses in specific cases
           // chat.completions and completions
           const stream = streamedResponse && getOption(args, 'stream', false)
 
+          const guard = aiGuard.createGuard(baseResource, args[0], stream)
+
+          if (!ch.start.hasSubscribers && !guard) {
+            return methodFn.apply(this, args)
+          }
+
           const client = this._client || this.client
 
           const ctx = {
@@ -249,7 +255,7 @@ for (const extension of extensions) {
                   const parsedPromise = origApiPromParse.apply(this, args)
                     .then(body => Promise.all([this.responsePromise, body]))
 
-                  return handleUnwrappedAPIPromise(parsedPromise, ctx, stream)
+                  return handleUnwrappedAPIPromise(parsedPromise, ctx, stream, guard)
                 })
 
                 return unwrappedPromise
@@ -262,9 +268,11 @@ for (const extension of extensions) {
               const parsedPromise = origApiPromParse.apply(this, args)
                 .then(body => Promise.all([this.responsePromise, body]))
 
-              return handleUnwrappedAPIPromise(parsedPromise, ctx, stream)
+              return handleUnwrappedAPIPromise(parsedPromise, ctx, stream, guard)
             })
 
+            if (guard) aiGuard.wrapAsResponse(apiProm, guard)
+
             ch.end.publish(ctx)
 
             return apiProm
@@ -276,8 +284,10 @@ for (const extension of extensions) {
   }
 }
 
-function handleUnwrappedAPIPromise (apiProm, ctx, stream) {
-  return apiProm
+function handleUnwrappedAPIPromise (apiProm, ctx, stream, guard) {
+  const guardedApiProm = guard ? aiGuard.gateParse(apiProm, guard) : apiProm
+
+  return guardedApiProm
     .then(([{ response, options }, body]) => {
       if (stream) {
         if (body.iterator) {
@@ -287,22 +297,27 @@ function handleUnwrappedAPIPromise (apiProm, ctx, stream) {
             body.response.body, Symbol.asyncIterator, wrapStreamIterator(response, options, ctx)
           )
         }
-      } else {
-        finish(ctx, {
-          headers: response.headers,
-          data: body,
-          request: {
-            path: response.url,
-            method: options.method,
-          },
-        })
+        return body
       }
 
-      return body
+      finish(ctx, {
+        headers: response.headers,
+        data: body,
+        request: {
+          path: response.url,
+          method: options.method,
+        },
+      })
+
+      if (!guard) return body
+
+      return aiGuard.evaluateOutput(guard, body).then(() => body)
     })
     .catch(error => {
-      finish(ctx, undefined, error)
-
+      // ctx.result is set inside finish(); if absent, finish never ran (sync throw in
+      // success branch, before-model block, or openai error) — record the error now.
+      // If finish already ran successfully (after-model block), don't double-publish.
+      if (!ctx.result) finish(ctx, undefined, error)
       throw error
     })
 }

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

@@ -22,7 +22,7 @@ function finish (ctx) {
 
 addHook({ name: 'oracledb', versions: ['>=5'], file: 'lib/oracledb.js' }, oracledb => {
   shimmer.wrap(oracledb.Connection.prototype, 'execute', execute => {
-    return function wrappedExecute (dbQuery, ...args) {
+    return function wrappedExecute (dbQuery) {
       if (!startChannel.hasSubscribers) {
         return execute.apply(this, arguments)
       }
@@ -72,6 +72,11 @@ addHook({ name: 'oracledb', versions: ['>=5'], file: 'lib/oracledb.js' }, oracle
       }
 
       return startChannel.runStores(ctx, () => {
+        // bindStart is skipped when tracing is suppressed (legacy store is `noop`),
+        // leaving ctx.injected unset — do not overwrite the caller's SQL argument.
+        if (ctx.injected !== undefined) {
+          arguments[0] = ctx.injected
+        }
         try {
           let result = execute.apply(this, arguments)
 

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

@@ -6,7 +6,16 @@ const {
   addHook,
 } = require('./helpers/instrument')
 
+/**
+ * @param {string} symbol
+ * @param {(original: Function) => Function} wrapper
+ * @param {Function} pino
+ */
 function wrapPino (symbol, wrapper, pino) {
+  /**
+   * @param {unknown[]} args
+   * @returns {unknown}
+   */
   return function pinoWithTrace (...args) {
     const instance = pino.apply(this, args)
 
@@ -22,15 +31,18 @@ function wrapPino (symbol, wrapper, pino) {
 }
 
 function wrapAsJson (asJson) {
-  const ch = channel('apm:pino:log')
+  const jsonCh = channel('apm:pino:log:json')
   return function asJsonWithTrace (obj, msg, num, time) {
     obj = arguments[0] = obj || {}
 
-    const payload = { message: obj }
-    ch.publish(payload)
-    arguments[0] = payload.message
+    // Caller-provided `dd` wins -- skip the splice so a bespoke `dd` survives.
+    if (!jsonCh.hasSubscribers || Object.hasOwn(obj, 'dd')) {
+      return asJson.apply(this, arguments)
+    }
 
-    return asJson.apply(this, arguments)
+    const payload = { line: asJson.apply(this, arguments) }
+    jsonCh.publish(payload)
+    return payload.line
   }
 }