dd-trace 5.55.0 → 5.57.0

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

@@ -6,8 +6,14 @@ const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const errorChannel = channel('apm:fastify:middleware:error')
 const handleChannel = channel('apm:fastify:request:handle')
 const routeAddedChannel = channel('apm:fastify:route:added')
+const bodyParserReadCh = channel('datadog:fastify:body-parser:finish')
+const queryParamsReadCh = channel('datadog:fastify:query-params:finish')
+const cookieParserReadCh = channel('datadog:fastify-cookie:read:finish')
+const responsePayloadReadCh = channel('datadog:fastify:response:finish')
+const pathParamsReadCh = channel('datadog:fastify:path-params:finish')
 
 const parsingResources = new WeakMap()
+const cookiesPublished = new WeakSet()
 
 function wrapFastify (fastify, hasParsingEvents) {
   if (typeof fastify !== 'function') return fastify
@@ -45,26 +51,46 @@ function wrapAddHook (addHook) {
       const req = getReq(request)
 
       try {
-        if (typeof done === 'function') {
-          done = arguments[arguments.length - 1]
+        // done callback is always the last argument
+        const doneCallback = arguments[arguments.length - 1]
 
+        if (typeof doneCallback === 'function') {
           arguments[arguments.length - 1] = function (err) {
             publishError(err, req)
 
+            const hasCookies = request.cookies && Object.keys(request.cookies).length > 0
+
+            if (cookieParserReadCh.hasSubscribers && hasCookies && !cookiesPublished.has(req)) {
+              const res = getRes(reply)
+              const abortController = new AbortController()
+
+              cookieParserReadCh.publish({
+                req,
+                res,
+                abortController,
+                cookies: request.cookies
+              })
+
+              cookiesPublished.add(req)
+
+              if (abortController.signal.aborted) return
+            }
+
             if (name === 'onRequest' || name === 'preParsing') {
               const parsingResource = new AsyncResource('bound-anonymous-fn')
 
               parsingResources.set(req, parsingResource)
 
               return parsingResource.runInAsyncScope(() => {
-                return done.apply(this, arguments)
+                return doneCallback.apply(this, arguments)
               })
             }
-            return done.apply(this, arguments)
+            return doneCallback.apply(this, arguments)
           }
 
           return fn.apply(this, arguments)
         }
+
         const promise = fn.apply(this, arguments)
 
         if (promise && typeof promise.catch === 'function') {
@@ -106,11 +132,52 @@ function preHandler (request, reply, done) {
 
 function preValidation (request, reply, done) {
   const req = getReq(request)
+  const res = getRes(reply)
   const parsingResource = parsingResources.get(req)
 
-  if (!parsingResource) return done()
+  const processInContext = () => {
+    let abortController
 
-  parsingResource.runInAsyncScope(() => done())
+    if (queryParamsReadCh.hasSubscribers && request.query) {
+      abortController ??= new AbortController()
+
+      queryParamsReadCh.publish({
+        req,
+        res,
+        abortController,
+        query: request.query
+      })
+
+      if (abortController.signal.aborted) return
+    }
+
+    if (bodyParserReadCh.hasSubscribers && request.body) {
+      abortController ??= new AbortController()
+
+      bodyParserReadCh.publish({ req, res, body: request.body, abortController })
+
+      if (abortController.signal.aborted) return
+    }
+
+    if (pathParamsReadCh.hasSubscribers && request.params) {
+      abortController ??= new AbortController()
+
+      pathParamsReadCh.publish({
+        req,
+        res,
+        abortController,
+        params: request.params
+      })
+
+      if (abortController.signal.aborted) return
+    }
+
+    done()
+  }
+
+  if (!parsingResource) return processInContext()
+
+  parsingResource.runInAsyncScope(processInContext)
 }
 
 function preParsing (request, reply, payload, done) {
@@ -126,9 +193,12 @@ function preParsing (request, reply, payload, done) {
 }
 
 function wrapSend (send, req) {
-  return function sendWithTrace (error) {
-    if (error instanceof Error) {
-      errorChannel.publish({ req, error })
+  return function sendWithTrace (payload) {
+    if (payload instanceof Error) {
+      errorChannel.publish({ req, error: payload })
+    } else if (canPublishResponsePayload(payload)) {
+      const res = getRes(this)
+      responsePayloadReadCh.publish({ req, res, body: payload })
     }
 
     return send.apply(this, arguments)
@@ -159,6 +229,18 @@ function onRoute (routeOptions) {
   routeAddedChannel.publish({ routeOptions, onRoute })
 }
 
+// send() payload types: https://fastify.dev/docs/latest/Reference/Reply/#senddata
+function canPublishResponsePayload (payload) {
+  return responsePayloadReadCh.hasSubscribers &&
+    payload &&
+    typeof payload === 'object' &&
+    typeof payload.pipe !== 'function' && // Node streams
+    typeof payload.body?.pipe !== 'function' && // Response with body stream
+    !Buffer.isBuffer(payload) && // Buffer
+    !(payload instanceof ArrayBuffer) && // ArrayBuffer
+    !ArrayBuffer.isView(payload) // TypedArray
+}
+
 addHook({ name: 'fastify', versions: ['>=3'] }, fastify => {
   const wrapped = shimmer.wrapFunction(fastify, fastify => wrapFastify(fastify, true))
 

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

@@ -26,14 +26,29 @@ if (!dc.unsubscribe) {
   }
 }
 
-dc.subscribe(CHANNEL, (payload) => {
-  try {
-    hooks[payload.package]()
-  } catch (err) {
+function doHook (payload) {
+  const hook = hooks[payload.package]
+  if (!hook) {
     log.error('esbuild-wrapped %s missing in list of hooks', payload.package)
-    throw err
+    return
+  }
+
+  const hookFn = hook.fn ?? hook
+  if (typeof hookFn !== 'function') {
+    log.error('esbuild-wrapped hook %s is not a function', payload.package)
+    return
   }
 
+  try {
+    hookFn()
+  } catch {
+    log.error('esbuild-wrapped %s hook failed', payload.package)
+  }
+}
+
+dc.subscribe(CHANNEL, (payload) => {
+  doHook(payload)
+
   if (!instrumentations[payload.package]) {
     log.error('esbuild-wrapped %s missing in list of instrumentations', payload.package)
     return

package/packages/datadog-instrumentations/src/helpers/check-require-cache.js

@@ -55,7 +55,7 @@ module.exports.checkForRequiredModules = function () {
     if (naughties.has(pkg)) continue
     if (!(pkg in packages)) continue
 
-    warnings.push(`Warning: Package '${pkg}' was loaded before dd-trace! This may break instrumentation.`)
+    warnings.push(() => `Warning: Package '${pkg}' was loaded before dd-trace! This may break instrumentation.`)
 
     naughties.add(pkg)
     didWarn = true
@@ -87,7 +87,7 @@ module.exports.checkForPotentialConflicts = function () {
     if (naughties.has(pkg)) continue
     if (!potentialConflicts.has(pkg)) continue
 
-    warnings.push(`Warning: Package '${pkg}' may cause conflicts with dd-trace.`)
+    warnings.push(() => `Warning: Package '${pkg}' may cause conflicts with dd-trace.`)
 
     naughties.add(pkg)
     didWarn = true

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

@@ -24,6 +24,7 @@ module.exports = {
   '@node-redis/client': () => require('../redis'),
   '@opensearch-project/opensearch': () => require('../opensearch'),
   '@opentelemetry/sdk-trace-node': () => require('../otel-sdk-trace'),
+  '@prisma/client': () => require('../prisma'),
   '@redis/client': () => require('../redis'),
   '@smithy/smithy-client': () => require('../aws-sdk'),
   '@vitest/runner': { esmFirst: true, fn: () => require('../vitest') },

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

@@ -9,6 +9,7 @@ const log = require('../../../dd-trace/src/log')
 const checkRequireCache = require('./check-require-cache')
 const telemetry = require('../../../dd-trace/src/guardrails/telemetry')
 const { isInServerlessEnvironment } = require('../../../dd-trace/src/serverless')
+const { isFalse, isTrue, normalizePluginEnvName } = require('../../../dd-trace/src/util')
 const { getEnvironmentVariables } = require('../../../dd-trace/src/config-helper')
 
 const envs = getEnvironmentVariables()
@@ -22,16 +23,22 @@ const hooks = require('./hooks')
 const instrumentations = require('./instrumentations')
 const names = Object.keys(hooks)
 const pathSepExpr = new RegExp(`\\${path.sep}`, 'g')
+
 const disabledInstrumentations = new Set(
-  DD_TRACE_DISABLED_INSTRUMENTATIONS ? DD_TRACE_DISABLED_INSTRUMENTATIONS.split(',') : []
+  DD_TRACE_DISABLED_INSTRUMENTATIONS?.split(',').map(name => normalizePluginEnvName(name, true)) ?? []
 )
+const reenabledInstrumentations = new Set()
 
 // Check for DD_TRACE_<INTEGRATION>_ENABLED environment variables
 for (const [key, value] of Object.entries(envs)) {
   const match = key.match(/^DD_TRACE_(.+)_ENABLED$/)
-  if (match && (value?.toLowerCase() === 'false' || value === '0')) {
-    const integration = match[1].toLowerCase()
-    disabledInstrumentations.add(integration)
+  if (match && value) {
+    const integration = normalizePluginEnvName(match[1], true)
+    if (isFalse(value)) {
+      disabledInstrumentations.add(integration)
+    } else if (isTrue(value)) {
+      reenabledInstrumentations.add(integration)
+    }
   }
 }
 
@@ -58,7 +65,8 @@ const allInstrumentations = {}
 
 // TODO: make this more efficient
 for (const packageName of names) {
-  if (disabledInstrumentations.has(packageName)) continue
+  const normalizedPackageName = normalizePluginEnvName(packageName, true)
+  if (disabledInstrumentations.has(normalizedPackageName)) continue
 
   const hookOptions = {}
 
@@ -67,6 +75,10 @@ for (const packageName of names) {
   if (typeof hook === 'object') {
     if (hook.serverless === false && isInServerlessEnvironment()) continue
 
+    // some integrations are disabled by default, but can be enabled by setting
+    // the DD_TRACE_<INTEGRATION>_ENABLED environment variable to true
+    if (hook.disabled && !reenabledInstrumentations.has(normalizedPackageName)) continue
+
     hookOptions.internals = hook.esmFirst
     hook = hook.fn
   }

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

@@ -2,8 +2,7 @@
 
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -22,14 +21,9 @@ addHook({ name: 'ioredis', versions: ['>=2'] }, Redis => {
     const db = options.db
     const connectionOptions = { host: options.host, port: options.port }
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-    return asyncResource.runInAsyncScope(() => {
-      startCh.publish({ db, command: command.name, args: command.args, connectionOptions, connectionName })
-
-      const onResolve = asyncResource.bind(() => finish(finishCh, errorCh))
-      const onReject = asyncResource.bind(err => finish(finishCh, errorCh, err))
-
-      command.promise.then(onResolve, onReject)
+    const ctx = { db, command: command.name, args: command.args, connectionOptions, connectionName }
+    return startCh.runStores(ctx, () => {
+      command.promise.then(() => finish(finishCh, errorCh, ctx), err => finish(finishCh, errorCh, ctx, err))
 
       try {
         return sendCommand.apply(this, arguments)
@@ -43,9 +37,10 @@ addHook({ name: 'ioredis', versions: ['>=2'] }, Redis => {
   return Redis
 })
 
-function finish (finishCh, errorCh, error) {
+function finish (finishCh, errorCh, ctx, error) {
   if (error) {
-    errorCh.publish(error)
+    ctx.error = error
+    errorCh.publish(ctx)
   }
-  finishCh.publish()
+  finishCh.publish(ctx)
 }

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

@@ -2,8 +2,7 @@
 
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -22,19 +21,15 @@ addHook({ name: 'iovalkey', versions: ['>=0.0.1'] }, Valkey => {
     const db = options.db
     const connectionOptions = { host: options.host, port: options.port }
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-    return asyncResource.runInAsyncScope(() => {
-      startCh.publish({ db, command: command.name, args: command.args, connectionOptions, connectionName })
-
-      const onResolve = asyncResource.bind(() => finishCh.publish())
-      const onReject = asyncResource.bind(err => finish(finishCh, errorCh, err))
-
-      command.promise.then(onResolve, onReject)
+    const ctx = { db, command: command.name, args: command.args, connectionOptions, connectionName }
+    return startCh.runStores(ctx, () => {
+      command.promise.then(() => finish(finishCh, errorCh, ctx), err => finish(finishCh, errorCh, ctx, err))
 
       try {
         return sendCommand.apply(this, arguments)
       } catch (err) {
-        errorCh.publish(err)
+        ctx.error = err
+        errorCh.publish(ctx)
 
         throw err
       }
@@ -43,9 +38,10 @@ addHook({ name: 'iovalkey', versions: ['>=0.0.1'] }, Valkey => {
   return Valkey
 })
 
-function finish (finishCh, errorCh, error) {
+function finish (finishCh, errorCh, ctx, error) {
   if (error) {
-    errorCh.publish(error)
+    ctx.error = error
+    errorCh.publish(ctx)
   }
-  finishCh.publish()
+  finishCh.publish(ctx)
 }