dd-trace 5.61.1 → 5.63.0

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

@@ -2,8 +2,7 @@
 
 const {
   addHook,
-  channel,
-  AsyncResource
+  channel
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -89,29 +88,28 @@ function wrapParse (parse) {
       return parse.apply(this, arguments)
     }
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
-    return asyncResource.runInAsyncScope(() => {
-      parseStartCh.publish()
-      let document
+    const ctx = { source }
+    return parseStartCh.runStores(ctx, () => {
       try {
-        document = parse.apply(this, arguments)
-        const operation = getOperation(document)
+        ctx.document = parse.apply(this, arguments)
+        const operation = getOperation(ctx.document)
 
-        if (!operation) return document
+        if (!operation) return ctx.document
 
         if (source) {
-          documentSources.set(document, source.body || source)
+          documentSources.set(ctx.document, source.body || source)
         }
+        ctx.docSource = documentSources.get(ctx.document)
 
-        return document
+        return ctx.document
       } catch (err) {
         err.stack
-        parseErrorCh.publish(err)
+        ctx.error = err
+        parseErrorCh.publish(ctx)
 
         throw err
       } finally {
-        parseFinishCh.publish({ source, document, docSource: documentSources.get(document) })
+        parseFinishCh.publish(ctx)
       }
     })
   }
@@ -123,25 +121,25 @@ function wrapValidate (validate) {
       return validate.apply(this, arguments)
     }
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
-    return asyncResource.runInAsyncScope(() => {
-      validateStartCh.publish({ docSource: documentSources.get(document), document })
-
+    const ctx = { docSource: documentSources.get(document), document }
+    return validateStartCh.runStores(ctx, () => {
       let errors
       try {
         errors = validate.apply(this, arguments)
         if (errors && errors[0]) {
-          validateErrorCh.publish(errors && errors[0])
+          ctx.error = errors && errors[0]
+          validateErrorCh.publish(ctx)
         }
         return errors
       } catch (err) {
         err.stack
-        validateErrorCh.publish(err)
+        ctx.error = err
+        validateErrorCh.publish(ctx)
 
         throw err
       } finally {
-        validateFinishCh.publish({ document, errors })
+        ctx.errors = errors
+        validateFinishCh.publish(ctx)
       }
     })
   }
@@ -155,44 +153,46 @@ function wrapExecute (execute) {
         return exe.apply(this, arguments)
       }
 
-      const asyncResource = new AsyncResource('bound-anonymous-fn')
-      return asyncResource.runInAsyncScope(() => {
-        const args = normalizeArgs(arguments, defaultFieldResolver)
-        const schema = args.schema
-        const document = args.document
-        const source = documentSources.get(document)
-        const contextValue = args.contextValue
-        const operation = getOperation(document, args.operationName)
-
-        if (contexts.has(contextValue)) {
-          return exe.apply(this, arguments)
-        }
+      const args = normalizeArgs(arguments, defaultFieldResolver)
+      const schema = args.schema
+      const document = args.document
+      const source = documentSources.get(document)
+      const contextValue = args.contextValue
+      const operation = getOperation(document, args.operationName)
+
+      if (contexts.has(contextValue)) {
+        return exe.apply(this, arguments)
+      }
+
+      const ctx = {
+        operation,
+        args,
+        docSource: documentSources.get(document),
+        source,
+        fields: {},
+        abortController: new AbortController()
+      }
 
+      return startExecuteCh.runStores(ctx, () => {
         if (schema) {
           wrapFields(schema._queryType)
           wrapFields(schema._mutationType)
         }
 
-        startExecuteCh.publish({
-          operation,
-          args,
-          docSource: documentSources.get(document)
-        })
-
-        const context = { source, asyncResource, fields: {}, abortController: new AbortController() }
-
-        contexts.set(contextValue, context)
+        contexts.set(contextValue, ctx)
 
-        return callInAsyncScope(exe, asyncResource, this, arguments, context.abortController, (err, res) => {
-          if (finishResolveCh.hasSubscribers) finishResolvers(context)
+        return callInAsyncScope(exe, this, arguments, ctx.abortController, (err, res) => {
+          if (finishResolveCh.hasSubscribers) finishResolvers(ctx)
 
           const error = err || (res && res.errors && res.errors[0])
 
           if (error) {
-            executeErrorCh.publish(error)
+            ctx.error = error
+            executeErrorCh.publish(ctx)
           }
 
-          finishExecuteCh.publish({ res, args, context })
+          ctx.res = res
+          finishExecuteCh.publish(ctx)
         })
       })
     }
@@ -205,14 +205,17 @@ function wrapResolve (resolve) {
   function resolveAsync (source, args, contextValue, info) {
     if (!startResolveCh.hasSubscribers) return resolve.apply(this, arguments)
 
-    const context = contexts.get(contextValue)
+    const ctx = contexts.get(contextValue)
 
-    if (!context) return resolve.apply(this, arguments)
+    if (!ctx) return resolve.apply(this, arguments)
 
-    const field = assertField(context, info, args)
+    const field = assertField(ctx, info, args)
 
-    return callInAsyncScope(resolve, field.asyncResource, this, arguments, context.abortController, (err) => {
-      updateFieldCh.publish({ field, info, err })
+    return callInAsyncScope(resolve, this, arguments, ctx.abortController, (err) => {
+      field.ctx.error = err
+      field.ctx.info = info
+      field.ctx.field = field
+      updateFieldCh.publish(field.ctx)
     })
   }
 
@@ -221,32 +224,30 @@ function wrapResolve (resolve) {
   return resolveAsync
 }
 
-function callInAsyncScope (fn, aR, thisArg, args, abortController, cb) {
+function callInAsyncScope (fn, thisArg, args, abortController, cb) {
   cb = cb || (() => {})
 
-  return aR.runInAsyncScope(() => {
-    if (abortController?.signal.aborted) {
-      cb(null, null)
-      throw new AbortError('Aborted')
-    }
+  if (abortController?.signal.aborted) {
+    cb(null, null)
+    throw new AbortError('Aborted')
+  }
 
-    try {
-      const result = fn.apply(thisArg, args)
-      if (result && typeof result.then === 'function') {
-        // bind callback to this scope
-        result.then(
-          aR.bind(res => cb(null, res)),
-          aR.bind(err => cb(err))
-        )
-      } else {
-        cb(null, result)
-      }
-      return result
-    } catch (err) {
-      cb(err)
-      throw err
+  try {
+    const result = fn.apply(thisArg, args)
+    if (result && typeof result.then === 'function') {
+      // bind callback to this scope
+      result.then(
+        res => cb(null, res),
+        err => cb(err)
+      )
+    } else {
+      cb(null, result)
     }
-  })
+    return result
+  } catch (err) {
+    cb(err)
+    throw err
+  }
 }
 
 function pathToArray (path) {
@@ -259,59 +260,26 @@ function pathToArray (path) {
   return flattened.reverse()
 }
 
-function assertField (context, info, args) {
+function assertField (rootCtx, info, args) {
   const pathInfo = info && info.path
 
   const path = pathToArray(pathInfo)
 
   const pathString = path.join('.')
-  const fields = context.fields
+  const fields = rootCtx.fields
 
   let field = fields[pathString]
 
   if (!field) {
-    const parent = getParentField(context, path)
-
-    // we want to spawn the new span off of the parent, not a new async resource
-    parent.asyncResource.runInAsyncScope(() => {
-      /* this child resource will run a branched scope off of the parent resource, which
-      accesses the parent span from the storage unit in its own scope */
-      const childResource = new AsyncResource('bound-anonymous-fn')
-
-      childResource.runInAsyncScope(() => {
-        startResolveCh.publish({
-          info,
-          context,
-          args
-        })
-      })
-
-      field = fields[pathString] = {
-        parent,
-        asyncResource: childResource,
-        error: null
-      }
-    })
-  }
-
-  return field
-}
-
-function getParentField (context, path) {
-  for (let i = path.length - 1; i > 0; i--) {
-    const field = getField(context, path.slice(0, i))
-    if (field) {
-      return field
+    const fieldCtx = { info, rootCtx, args }
+    startResolveCh.publish(fieldCtx)
+    field = fields[pathString] = {
+      error: null,
+      ctx: fieldCtx
     }
   }
 
-  return {
-    asyncResource: context.asyncResource
-  }
-}
-
-function getField (context, path) {
-  return context.fields[path.join('.')]
+  return field
 }
 
 function wrapFields (type) {
@@ -349,13 +317,13 @@ function wrapFieldType (field) {
 function finishResolvers ({ fields }) {
   Object.keys(fields).reverse().forEach(key => {
     const field = fields[key]
-    const asyncResource = field.asyncResource
-    asyncResource.runInAsyncScope(() => {
-      if (field.error) {
-        resolveErrorCh.publish(field.error)
-      }
-      finishResolveCh.publish(field.finishTime)
-    })
+    field.ctx.finishTime = field.finishTime
+    field.ctx.field = field
+    if (field.error) {
+      field.ctx.error = field.error
+      resolveErrorCh.publish(field.ctx)
+    }
+    finishResolveCh.publish(field.ctx)
   })
 }
 

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

@@ -30,6 +30,7 @@ module.exports = {
   '@smithy/smithy-client': () => require('../aws-sdk'),
   '@vitest/runner': { esmFirst: true, fn: () => require('../vitest') },
   aerospike: () => require('../aerospike'),
+  ai: () => require('../ai'),
   amqp10: () => require('../amqp10'),
   amqplib: () => require('../amqplib'),
   avsc: () => require('../avsc'),

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

@@ -9,7 +9,6 @@ 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()
@@ -25,22 +24,8 @@ const names = Object.keys(hooks)
 const pathSepExpr = new RegExp(`\\${path.sep}`, 'g')
 
 const disabledInstrumentations = new Set(
-  DD_TRACE_DISABLED_INSTRUMENTATIONS?.split(',').map(name => normalizePluginEnvName(name, true)) ?? []
+  DD_TRACE_DISABLED_INSTRUMENTATIONS?.split(',')
 )
-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) {
-    const integration = normalizePluginEnvName(match[1], true)
-    if (isFalse(value)) {
-      disabledInstrumentations.add(integration)
-    } else if (isTrue(value)) {
-      reenabledInstrumentations.add(integration)
-    }
-  }
-}
 
 const loadChannel = channel('dd-trace:instrumentation:load')
 
@@ -65,8 +50,7 @@ const allInstrumentations = {}
 
 // TODO: make this more efficient
 for (const packageName of names) {
-  const normalizedPackageName = normalizePluginEnvName(packageName, true)
-  if (disabledInstrumentations.has(normalizedPackageName)) continue
+  if (disabledInstrumentations.has(packageName)) continue
 
   const hookOptions = {}
 
@@ -75,10 +59,6 @@ for (const packageName of names) {
   if (hook !== null && 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/hono.js

@@ -17,8 +17,14 @@ function wrapFetch (fetch) {
   }
 }
 
+function onErrorFn (error, _context_) {
+  throw error
+}
+
 function wrapCompose (compose) {
-  return function (middleware, onError, onNotFound) {
+  return function (middlewares, onError, onNotFound) {
+    onError ??= onErrorFn
+
     const instrumentedOnError = (...args) => {
       const [error, context] = args
       const req = context.env.incoming
@@ -26,23 +32,20 @@ function wrapCompose (compose) {
       return onError(...args)
     }
 
-    const instrumentedMiddlewares = middleware.map(h => {
+    const instrumentedMiddlewares = middlewares.map(h => {
       const [[fn, meta], params] = h
 
-      // TODO: handle middleware instrumentation
       const instrumentedFn = (...args) => {
         const context = args[0]
-        const req = context.env.incoming
-        const route = meta.path
         routeChannel.publish({
-          req,
-          route
+          req: context.env.incoming,
+          route: meta?.path
         })
         return fn(...args)
       }
       return [[instrumentedFn, meta], params]
     })
-    return compose.apply(this, [instrumentedMiddlewares, instrumentedOnError, onNotFound])
+    return compose.call(this, instrumentedMiddlewares, instrumentedOnError, onNotFound)
   }
 }
 

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

@@ -5,14 +5,13 @@
 
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 
 const startServerCh = channel('apm:http2:server:request:start')
 const errorServerCh = channel('apm:http2:server:request:error')
-const finishServerCh = channel('apm:http2:server:request:finish')
+const emitCh = channel('apm:http2:server:response:emit')
 
 const names = ['http2', 'node:http2']
 
@@ -30,18 +29,14 @@ function wrapCreateServer (createServer) {
   }
 }
 
-function wrapResponseEmit (emit) {
-  const asyncResource = new AsyncResource('bound-anonymous-fn')
+function wrapResponseEmit (emit, ctx) {
   return function (eventName, event) {
-    return asyncResource.runInAsyncScope(() => {
-      if (eventName === 'close' && finishServerCh.hasSubscribers) {
-        finishServerCh.publish({ req: this.req })
-      }
-
-      return emit.apply(this, arguments)
-    })
+    ctx.req = this.req
+    ctx.eventName = eventName
+    return emitCh.runStores(ctx, emit, this, ...arguments)
   }
 }
+
 function wrapEmit (emit) {
   return function (eventName, req, res) {
     if (!startServerCh.hasSubscribers) {
@@ -51,18 +46,17 @@ function wrapEmit (emit) {
     if (eventName === 'request') {
       res.req = req
 
-      const asyncResource = new AsyncResource('bound-anonymous-fn')
-      return asyncResource.runInAsyncScope(() => {
-        startServerCh.publish({ req, res })
-
-        shimmer.wrap(res, 'emit', wrapResponseEmit)
+      const ctx = { req, res }
+      return startServerCh.runStores(ctx, () => {
+        shimmer.wrap(res, 'emit', emit => wrapResponseEmit(emit, ctx))
 
         try {
           return emit.apply(this, arguments)
-        } catch (err) {
-          errorServerCh.publish(err)
+        } catch (error) {
+          ctx.error = error
+          errorServerCh.publish(ctx)
 
-          throw err
+          throw error
         }
       })
     }

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

@@ -1,10 +1,11 @@
 'use strict'
 
-const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+const { addHook, channel } = require('./helpers/instrument')
 const { wrapThen } = require('./helpers/promise')
 const shimmer = require('../../datadog-shimmer')
 
 const startRawQueryCh = channel('datadog:knex:raw:start')
+const rawQuerySubscribes = channel('datadog:knex:raw:subscribes')
 const finishRawQueryCh = channel('datadog:knex:raw:finish')
 
 patch('lib/query/builder.js')
@@ -22,8 +23,8 @@ function patch (file) {
   })
 }
 
-function finish () {
-  finishRawQueryCh.publish()
+function finish (context, cb) {
+  finishRawQueryCh.runStores(context, cb)
 }
 
 addHook({
@@ -43,21 +44,18 @@ addHook({
       return raw.apply(this, arguments)
     }
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
-    return asyncResource.runInAsyncScope(() => {
-      startRawQueryCh.publish({ sql, dialect: this.dialect })
-
+    const context = { sql, dialect: this.dialect }
+    return startRawQueryCh.runStores(context, () => {
       const rawResult = raw.apply(this, arguments)
       shimmer.wrap(rawResult, 'then', originalThen => function () {
-        return asyncResource.runInAsyncScope(() => {
-          arguments[0] = wrapCallbackWithFinish(arguments[0], finish)
-          if (arguments[1]) arguments[1] = wrapCallbackWithFinish(arguments[1], finish)
+        return rawQuerySubscribes.runStores(context, () => {
+          arguments[0] = wrapCallbackWithFinish(arguments[0], finish, context)
+          if (arguments[1]) arguments[1] = wrapCallbackWithFinish(arguments[1], finish, context)
 
           const originalThenResult = originalThen.apply(this, arguments)
 
           shimmer.wrap(originalThenResult, 'catch', originalCatch => function () {
-            arguments[0] = wrapCallbackWithFinish(arguments[0], finish)
+            arguments[0] = wrapCallbackWithFinish(arguments[0], finish, context)
             return originalCatch.apply(this, arguments)
           })
 
@@ -66,8 +64,8 @@ addHook({
       })
 
       shimmer.wrap(rawResult, 'asCallback', originalAsCallback => function () {
-        return asyncResource.runInAsyncScope(() => {
-          arguments[0] = wrapCallbackWithFinish(arguments[0], finish)
+        return rawQuerySubscribes.runStores(context, () => {
+          arguments[0] = wrapCallbackWithFinish(arguments[0], finish, context)
           return originalAsCallback.apply(this, arguments)
         })
       })
@@ -75,14 +73,14 @@ addHook({
       return rawResult
     })
   })
+
   return Knex
 })
 
-function wrapCallbackWithFinish (callback, finish) {
+function wrapCallbackWithFinish (callback, finish, context) {
   if (typeof callback !== 'function') return callback
 
   return shimmer.wrapFunction(callback, callback => function () {
-    finish()
-    callback.apply(this, arguments)
+    finish(context, () => callback.apply(this, arguments))
   })
 }

package/packages/datadog-instrumentations/src/microgateway-core.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const shimmer = require('../../datadog-shimmer')
-const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+const { addHook, channel } = require('./helpers/instrument')
 
 const handleChannel = channel('apm:microgateway-core:request:handle')
 const routeChannel = channel('apm:microgateway-core:request:route')
@@ -11,18 +11,18 @@ const name = 'microgateway-core'
 
 // TODO Remove " <=3.0.0" when "volos-util-apigee" module is fixed
 const versions = ['>=2.1 <=3.0.0']
-const requestResources = new WeakMap()
+const requestContexts = new WeakMap()
 
 function wrapConfigProxyFactory (configProxyFactory) {
   return function () {
     const configProxy = configProxyFactory.apply(this, arguments)
 
     return function (req, res, next) {
-      const requestResource = new AsyncResource('bound-anonymous-fn')
+      const ctx = { req, res }
 
-      requestResources.set(req, requestResource)
+      requestContexts.set(req, ctx)
 
-      handleChannel.publish({ req, res })
+      handleChannel.publish(ctx)
 
       return configProxy.apply(this, arguments)
     }
@@ -43,18 +43,19 @@ function wrapPluginsFactory (pluginsFactory) {
 
 function wrapNext (req, res, next) {
   return shimmer.wrapFunction(next, next => function nextWithTrace (err) {
-    const requestResource = requestResources.get(req)
+    const ctx = requestContexts.get(req)
 
-    requestResource.runInAsyncScope(() => {
-      if (err) {
-        errorChannel.publish(err)
-      }
-
-      if (res.proxy && res.proxy.base_path) {
-        routeChannel.publish({ req, res, route: res.proxy.base_path })
-      }
-    })
+    if (err) {
+      ctx.error = err
+      errorChannel.publish(ctx)
+    }
 
+    if (res.proxy && res.proxy.base_path) {
+      ctx.req = req
+      ctx.res = res
+      ctx.route = res.proxy.base_path
+      routeChannel.publish(ctx)
+    }
     return next.apply(this, arguments)
   })
 }