dd-trace 5.62.0 → 5.63.0

package/README.md

@@ -22,11 +22,6 @@ Most of the documentation for `dd-trace` is available on these webpages:
 
 ## Version Release Lines and Maintenance
 
-> **Node.js v24 Notice**: We're currently adding compatibility for Node.js v24. To use the tracer with your application either continue to use Node.js v22 (LTS), or do both of the following as a workaround:
-> * Install v5.52.0 (or newer) of the tracer
-> * Set `--no-async-context-frame` either using a CLI argument or via `NODE_OPTIONS`
-> Once support for Node.js v24 is complete this flag will no longer be needed.
-
 | Release Line                                             | Latest Version                                                                                         | Node.js  | [SSI](https://docs.datadoghq.com/tracing/trace_collection/automatic_instrumentation/single-step-apm/?tab=linuxhostorvm) | [K8s Injection](https://docs.datadoghq.com/tracing/trace_collection/library_injection_local/?tab=kubernetes) |Status          |Initial Release | End of Life |
 | :---:                                                    | :---:                                                                                                  | :---:    | :---:  | :---:  | :---:           | :---:          | :---:       |
 | [`v1`](https://github.com/DataDog/dd-trace-js/tree/v1.x) | ![npm v1](https://img.shields.io/npm/v/dd-trace/legacy-v1?color=white&label=%20&style=flat-square)     | `>= v12` | NO | NO | **EOL** | 2021-07-13     | 2022-02-25  |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.62.0",
+  "version": "5.63.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -114,7 +114,7 @@
   ],
   "dependencies": {
     "@datadog/libdatadog": "0.7.0",
-    "@datadog/native-appsec": "10.0.1",
+    "@datadog/native-appsec": "10.1.0",
     "@datadog/native-iast-taint-tracking": "4.0.0",
     "@datadog/native-metrics": "3.1.1",
     "@datadog/pprof": "5.9.0",

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

@@ -0,0 +1,140 @@
+'use strict'
+
+const { addHook } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const { channel, tracingChannel } = require('dc-polyfill')
+const toolCreationChannel = channel('dd-trace:vercel-ai:tool')
+
+const TRACED_FUNCTIONS = {
+  generateText: wrapWithTracer,
+  streamText: wrapWithTracer,
+  generateObject: wrapWithTracer,
+  streamObject: wrapWithTracer,
+  embed: wrapWithTracer,
+  embedMany: wrapWithTracer,
+  tool: wrapTool
+}
+
+const vercelAiTracingChannel = tracingChannel('dd-trace:vercel-ai')
+const vercelAiSpanSetAttributesChannel = channel('dd-trace:vercel-ai:span:setAttributes')
+
+const noopTracer = {
+  startActiveSpan () {
+    const fn = arguments[arguments.length - 1]
+
+    const span = {
+      spanContext () { return { traceId: '', spanId: '', traceFlags: 0 } },
+      setAttribute () { return this },
+      setAttributes () { return this },
+      addEvent () { return this },
+      addLink () { return this },
+      addLinks () { return this },
+      setStatus () { return this },
+      updateName () { return this },
+      end () { return this },
+      isRecording () { return false },
+      recordException () { return this }
+    }
+
+    return fn(span)
+  }
+}
+
+function wrapTracer (tracer) {
+  if (Object.hasOwn(tracer, Symbol.for('_dd.wrapped'))) return
+
+  shimmer.wrap(tracer, 'startActiveSpan', function (startActiveSpan) {
+    return function () {
+      const name = arguments[0]
+      const options = arguments.length > 2 ? (arguments[1] ?? {}) : {} // startActiveSpan(name, fn)
+      const cb = arguments[arguments.length - 1]
+
+      const ctx = {
+        name,
+        attributes: options.attributes ?? {}
+      }
+
+      arguments[arguments.length - 1] = shimmer.wrapFunction(cb, function (originalCb) {
+        return function (span) {
+          shimmer.wrap(span, 'end', function (spanEnd) {
+            return function () {
+              vercelAiTracingChannel.asyncEnd.publish(ctx)
+              return spanEnd.apply(this, arguments)
+            }
+          })
+
+          shimmer.wrap(span, 'setAttributes', function (setAttributes) {
+            return function (attributes) {
+              vercelAiSpanSetAttributesChannel.publish({ ctx, attributes })
+              return setAttributes.apply(this, arguments)
+            }
+          })
+
+          shimmer.wrap(span, 'recordException', function (recordException) {
+            return function (exception) {
+              ctx.error = exception
+              vercelAiTracingChannel.error.publish(ctx)
+              return recordException.apply(this, arguments)
+            }
+          })
+
+          return originalCb.apply(this, arguments)
+        }
+      })
+
+      return vercelAiTracingChannel.start.runStores(ctx, () => {
+        const result = startActiveSpan.apply(this, arguments)
+        vercelAiTracingChannel.end.publish(ctx)
+        return result
+      })
+    }
+  })
+
+  Object.defineProperty(tracer, Symbol.for('_dd.wrapped'), { value: true })
+}
+
+function wrapWithTracer (fn) {
+  return function () {
+    const options = arguments[0]
+
+    options.experimental_telemetry ??= { isEnabled: true, tracer: noopTracer }
+    wrapTracer(options.experimental_telemetry.tracer)
+
+    return fn.apply(this, arguments)
+  }
+}
+
+function wrapTool (tool) {
+  return function () {
+    const args = arguments[0]
+    toolCreationChannel.publish(args)
+
+    return tool.apply(this, arguments)
+  }
+}
+
+// CJS exports
+addHook({
+  name: 'ai',
+  versions: ['>=4.0.0'],
+}, exports => {
+  for (const [fnName, patchingFn] of Object.entries(TRACED_FUNCTIONS)) {
+    exports = shimmer.wrap(exports, fnName, patchingFn, { replaceGetter: true })
+  }
+
+  return exports
+})
+
+// ESM exports
+addHook({
+  name: 'ai',
+  versions: ['>=4.0.0'],
+  file: 'dist/index.mjs'
+}, exports => {
+  for (const [fnName, patchingFn] of Object.entries(TRACED_FUNCTIONS)) {
+    exports = shimmer.wrap(exports, fnName, patchingFn, { replaceGetter: true })
+  }
+
+  return exports
+})

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

@@ -3,8 +3,7 @@
 const { errorMonitor } = require('events')
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -24,31 +23,50 @@ function wrapAllNames (names, action) {
   names.forEach(name => action(name))
 }
 
-// semver >=2 <3
-function wrapMaybeInvoke (_maybeInvoke) {
-  const wrapped = function (fn, args) {
-    if (!Array.isArray(args)) return _maybeInvoke.apply(this, arguments)
-
-    const callbackIndex = args.length - 1
-    const callback = args[callbackIndex]
+function wrapCallback (callback, ctx, channelPrefix) {
+  const callbackStartCh = channel(`${channelPrefix}:callback:start`)
+  const callbackFinishCh = channel(`${channelPrefix}:callback:finish`)
 
-    if (typeof callback === 'function') {
-      args[callbackIndex] = AsyncResource.bind(callback)
+  const wrapped = callbackStartCh.runStores(ctx, () => {
+    return function (...args) {
+      return callbackFinishCh.runStores(ctx, () => {
+        return callback.apply(this, args)
+      })
     }
-
-    return _maybeInvoke.apply(this, arguments)
-  }
+  })
+  Object.defineProperty(wrapped, '_dd_wrapped', { value: true })
   return wrapped
 }
 
 function wrapQuery (query) {
-  const wrapped = function (q, params, callback) {
-    if (typeof arguments[arguments.length - 1] === 'function') {
-      arguments[arguments.length - 1] = AsyncResource.bind(arguments[arguments.length - 1])
+  return function (q, params, callback) {
+    const cb = arguments[arguments.length - 1]
+    if (typeof cb === 'function') {
+      const ctx = {}
+      arguments[arguments.length - 1] = wrapCallback(cb, ctx, 'apm:couchbase:query')
     }
 
     return query.apply(this, arguments)
   }
+}
+
+function wrapCallbackFinish (callback, thisArg, _args, errorCh, finishCh, ctx, channelPrefix) {
+  const callbackStartCh = channel(`${channelPrefix}:callback:start`)
+  const callbackFinishCh = channel(`${channelPrefix}:callback:finish`)
+
+  const wrapped = callbackStartCh.runStores(ctx, () => {
+    return function finish (error, result) {
+      return callbackFinishCh.runStores(ctx, () => {
+        if (error) {
+          ctx.error = error
+          errorCh.publish(ctx)
+        }
+        finishCh.publish(ctx)
+        return callback.apply(thisArg, [error, result])
+      })
+    }
+  })
+  Object.defineProperty(wrapped, '_dd_wrapped', { value: true })
   return wrapped
 }
 
@@ -62,31 +80,24 @@ function wrap (prefix, fn) {
       return fn.apply(this, arguments)
     }
 
-    const callbackIndex = findCallbackIndex(arguments)
+    const callbackIndex = findCallbackIndex(arguments, 1)
 
     if (callbackIndex < 0) return fn.apply(this, arguments)
 
-    const callbackResource = new AsyncResource('bound-anonymous-fn')
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
-    return asyncResource.runInAsyncScope(() => {
-      const cb = callbackResource.bind(arguments[callbackIndex])
+    const ctx = { bucket: { name: this.name || this._name }, seedNodes: this._dd_hosts }
+    return startCh.runStores(ctx, () => {
+      const cb = arguments[callbackIndex]
 
-      startCh.publish({ bucket: { name: this.name || this._name }, seedNodes: this._dd_hosts })
-
-      arguments[callbackIndex] = shimmer.wrapFunction(cb, cb => asyncResource.bind(function (error, result) {
-        if (error) {
-          errorCh.publish(error)
-        }
-        finishCh.publish(result)
-        return cb.apply(this, arguments)
-      }))
+      arguments[callbackIndex] = shimmer.wrapFunction(cb, (cb) => {
+        return wrapCallbackFinish(cb, this, arguments, errorCh, finishCh, ctx, prefix)
+      })
 
       try {
         return fn.apply(this, arguments)
       } catch (error) {
+        ctx.error = error
         error.stack // trigger getting the stack at the original throwing point
-        errorCh.publish(error)
+        errorCh.publish(ctx)
 
         throw error
       }
@@ -95,6 +106,26 @@ function wrap (prefix, fn) {
   return wrapped
 }
 
+// semver >=2 <3
+function wrapMaybeInvoke (_maybeInvoke, channelPrefix) {
+  return function (fn, args) {
+    if (!Array.isArray(args)) return _maybeInvoke.apply(this, arguments)
+
+    const callbackIndex = findCallbackIndex(args, 0)
+
+    if (callbackIndex === -1) return _maybeInvoke.apply(this, arguments)
+
+    const callback = args[callbackIndex]
+
+    if (typeof callback === 'function' && !callback._dd_wrapped) {
+      const ctx = {}
+      args[callbackIndex] = wrapCallback(callback, ctx, channelPrefix)
+    }
+
+    return _maybeInvoke.apply(this, arguments)
+  }
+}
+
 // semver >=3
 
 function wrapCBandPromise (fn, name, startData, thisArg, args) {
@@ -104,36 +135,36 @@ function wrapCBandPromise (fn, name, startData, thisArg, args) {
 
   if (!startCh.hasSubscribers) return fn.apply(thisArg, args)
 
-  const asyncResource = new AsyncResource('bound-anonymous-fn')
-  const callbackResource = new AsyncResource('bound-anonymous-fn')
-
-  return asyncResource.runInAsyncScope(() => {
-    startCh.publish(startData)
-
+  const ctx = startData
+  return startCh.runStores(ctx, () => {
     try {
       const cbIndex = findCallbackIndex(args, 1)
       if (cbIndex >= 0) {
         // v3 offers callback or promises event handling
         // NOTE: this does not work with v3.2.0-3.2.1 cluster.query, as there is a bug in the couchbase source code
-        const cb = callbackResource.bind(args[cbIndex])
-        args[cbIndex] = shimmer.wrapFunction(cb, cb => asyncResource.bind(function (error, result) {
-          if (error) {
-            errorCh.publish(error)
-          }
-          finishCh.publish({ result })
-          return cb.apply(thisArg, arguments)
-        }))
+        args[cbIndex] = shimmer.wrapFunction(args[cbIndex], (cb) => {
+          return wrapCallbackFinish(cb, thisArg, args, errorCh, finishCh, ctx, `apm:couchbase:${name}`)
+        })
       }
       const res = fn.apply(thisArg, args)
 
       // semver >=3 will always return promise by default
       res.then(
-        asyncResource.bind((result) => finishCh.publish({ result })),
-        asyncResource.bind((err) => errorCh.publish(err)))
+        (result) => {
+          ctx.result = result
+          finishCh.publish(ctx)
+        },
+        (err) => {
+          ctx.error = err
+          errorCh.publish(ctx)
+          finishCh.publish(ctx)
+        }
+      )
       return res
     } catch (e) {
       e.stack
-      errorCh.publish(e)
+      ctx.error = e
+      errorCh.publish(ctx)
       throw e
     }
   })
@@ -160,11 +191,14 @@ function wrapV3Query (query) {
 
 // semver >=2 <3
 addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^2.6.12'] }, Bucket => {
+  shimmer.wrap(Bucket.prototype, '_maybeInvoke', maybeInvoke => {
+    return wrapMaybeInvoke(maybeInvoke, 'apm:couchbase:bucket:maybeInvoke')
+  })
+
   const startCh = channel('apm:couchbase:query:start')
   const finishCh = channel('apm:couchbase:query:finish')
   const errorCh = channel('apm:couchbase:query:error')
 
-  shimmer.wrap(Bucket.prototype, '_maybeInvoke', maybeInvoke => wrapMaybeInvoke(maybeInvoke))
   shimmer.wrap(Bucket.prototype, 'query', query => wrapQuery(query))
 
   shimmer.wrap(Bucket.prototype, '_n1qlReq', _n1qlReq => function (host, q, adhoc, emitter) {
@@ -176,24 +210,25 @@ addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^2.6.12'] }, Buc
 
     const n1qlQuery = getQueryResource(q)
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-    return asyncResource.runInAsyncScope(() => {
-      startCh.publish({ resource: n1qlQuery, bucket: { name: this.name || this._name }, seedNodes: this._dd_hosts })
-
-      emitter.once('rows', asyncResource.bind(() => {
-        finishCh.publish()
-      }))
+    const ctx = { resource: n1qlQuery, bucket: { name: this.name || this._name }, seedNodes: this._dd_hosts }
+    return startCh.runStores(ctx, () => {
+      emitter.once('rows', () => {
+        finishCh.publish(ctx)
+      })
 
-      emitter.once(errorMonitor, asyncResource.bind((error) => {
-        errorCh.publish(error)
-        finishCh.publish()
-      }))
+      emitter.once(errorMonitor, (error) => {
+        if (!error) return
+        ctx.error = error
+        errorCh.publish(ctx)
+        finishCh.publish(ctx)
+      })
 
       try {
         return _n1qlReq.apply(this, arguments)
       } catch (err) {
         err.stack // trigger getting the stack at the original throwing point
-        errorCh.publish(err)
+        ctx.error = err
+        errorCh.publish(ctx)
 
         throw err
       }
@@ -208,9 +243,11 @@ addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^2.6.12'] }, Buc
 })
 
 addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^2.6.12'] }, Cluster => {
-  shimmer.wrap(Cluster.prototype, '_maybeInvoke', maybeInvoke => wrapMaybeInvoke(maybeInvoke))
-  shimmer.wrap(Cluster.prototype, 'query', query => wrapQuery(query))
+  shimmer.wrap(Cluster.prototype, '_maybeInvoke', maybeInvoke => {
+    return wrapMaybeInvoke(maybeInvoke, 'apm:couchbase:cluster:maybeInvoke')
+  })
 
+  shimmer.wrap(Cluster.prototype, 'query', query => wrapQuery(query))
   shimmer.wrap(Cluster.prototype, 'openBucket', openBucket => {
     return function () {
       const bucket = openBucket.apply(this, arguments)

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/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/mongodb-core.js

@@ -199,17 +199,15 @@ function instrumentPromise (operation, command, instance, args, server, ns, ops,
   return startCh.runStores(ctx, () => {
     const promise = command.apply(instance, args)
 
-    return promise.then(function (res) {
+    promise.then(function (res) {
       ctx.result = res
-      return finishCh.runStores(ctx, () => {
-        return res
-      })
+      finishCh.publish(ctx)
     }, function (err) {
       ctx.error = err
       errorCh.publish(ctx)
       finishCh.publish(ctx)
-
-      throw err
     })
+
+    return promise
   })
 }

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

@@ -162,14 +162,16 @@ function instrument (req, res, handler, error) {
 
       // promise should only reject when propagateError is true:
       // https://github.com/vercel/next.js/blob/cee656238a/packages/next/server/api-utils/node.ts#L547
-      return promise.then(
+      promise.then(
         result => finish(ctx, result),
         err => finish(ctx, null, err)
       )
+      return promise
     } catch (e) {
       // this will probably never happen as the handler caller is an async function:
       // https://github.com/vercel/next.js/blob/cee656238a/packages/next/server/api-utils/node.ts#L420
-      return finish(ctx, null, e)
+      finish(ctx, null, e)
+      throw e
     }
   })
 }
@@ -198,12 +200,6 @@ function finish (ctx, result, err) {
   }
 
   finishChannel.publish(ctx)
-
-  if (err) {
-    throw err
-  }
-
-  return result
 }
 
 // also wrapped in dist/server/future/route-handlers/app-route-route-handler.js