dd-trace 5.52.0 → 5.53.0

package/packages/datadog-plugin-playwright/src/index.js

@@ -97,7 +97,9 @@ class PlaywrightPlugin extends CiPlugin {
       this.numFailedTests = 0
     })
 
-    this.addSub('ci:playwright:test-suite:start', (testSuiteAbsolutePath) => {
+    this.addBind('ci:playwright:test-suite:start', (ctx) => {
+      const { testSuiteAbsolutePath } = ctx
+
       const store = storage('legacy').getStore()
       const testSuite = getTestSuitePath(testSuiteAbsolutePath, this.rootDir)
       const testSourceFile = getTestSuitePath(testSuiteAbsolutePath, this.repositoryRoot)
@@ -126,27 +128,28 @@ class PlaywrightPlugin extends CiPlugin {
         }
       })
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_CREATED, 'suite')
-      this.enter(testSuiteSpan, store)
+      ctx.parentStore = store
+      ctx.currentStore = { ...store, testSuiteSpan }
 
       this._testSuites.set(testSuiteAbsolutePath, testSuiteSpan)
+
+      return ctx.currentStore
     })
 
-    this.addSub('ci:playwright:test-suite:finish', ({ status, error }) => {
-      const store = storage('legacy').getStore()
-      const span = store && store.span
-      if (!span) return
+    this.addSub('ci:playwright:test-suite:finish', ({ testSuiteSpan, status, error }) => {
+      if (!testSuiteSpan) return
       if (error) {
-        span.setTag('error', error)
-        span.setTag(TEST_STATUS, 'fail')
+        testSuiteSpan.setTag('error', error)
+        testSuiteSpan.setTag(TEST_STATUS, 'fail')
       } else {
-        span.setTag(TEST_STATUS, status)
+        testSuiteSpan.setTag(TEST_STATUS, status)
       }
 
       if (status === 'fail' || error) {
         this.numFailedSuites++
       }
 
-      span.finish()
+      testSuiteSpan.finish()
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
     })
 
@@ -180,13 +183,14 @@ class PlaywrightPlugin extends CiPlugin {
       }
     })
 
-    this.addSub('ci:playwright:test:start', ({
-      testName,
-      testSuiteAbsolutePath,
-      testSourceLine,
-      browserName,
-      isDisabled
-    }) => {
+    this.addBind('ci:playwright:test:start', (ctx) => {
+      const {
+        testName,
+        testSuiteAbsolutePath,
+        testSourceLine,
+        browserName,
+        isDisabled
+      } = ctx
       const store = storage('legacy').getStore()
       const testSuite = getTestSuitePath(testSuiteAbsolutePath, this.rootDir)
       const testSourceFile = getTestSuitePath(testSuiteAbsolutePath, this.repositoryRoot)
@@ -203,7 +207,10 @@ class PlaywrightPlugin extends CiPlugin {
         span.setTag(TEST_MANAGEMENT_IS_DISABLED, 'true')
       }
 
-      this.enter(span, store)
+      ctx.parentStore = store
+      ctx.currentStore = { ...store, span }
+
+      return ctx.currentStore
     })
 
     this.addSub('ci:playwright:worker:report', (serializedTraces) => {
@@ -254,6 +261,7 @@ class PlaywrightPlugin extends CiPlugin {
     })
 
     this.addSub('ci:playwright:test:finish', ({
+      span,
       testStatus,
       steps,
       error,
@@ -271,8 +279,6 @@ class PlaywrightPlugin extends CiPlugin {
       isAtrRetry,
       onDone
     }) => {
-      const store = storage('legacy').getStore()
-      const span = store && store.span
       if (!span) return
 
       const isRUMActive = span.context()._tags[TEST_IS_RUM_ACTIVE]

package/packages/datadog-plugin-redis/src/index.js

@@ -8,6 +8,11 @@ class RedisPlugin extends CachePlugin {
   static get id () { return 'redis' }
   static get system () { return 'redis' }
 
+  constructor (...args) {
+    super(...args)
+    this._spanType = 'redis'
+  }
+
   start ({ db, command, args, connectionOptions = {}, connectionName }) {
     const resource = command
     const normalizedCommand = command.toUpperCase()
@@ -16,11 +21,11 @@ class RedisPlugin extends CachePlugin {
     this.startSpan({
       resource,
       service: this.serviceName({ pluginConfig: this.config, system: this.system, connectionName }),
-      type: 'redis',
+      type: this._spanType,
       meta: {
-        'db.type': 'redis',
+        'db.type': this._spanType,
         'db.name': db || '0',
-        'redis.raw_command': formatCommand(normalizedCommand, args),
+        [`${this._spanType}.raw_command`]: formatCommand(normalizedCommand, args),
         'out.host': connectionOptions.host,
         [CLIENT_PORT_KEY]: connectionOptions.port
       }

package/packages/datadog-plugin-vitest/src/index.js

@@ -95,19 +95,21 @@ class VitestPlugin extends CiPlugin {
       onDone(isFaulty)
     })
 
-    this.addSub('ci:vitest:test:start', ({
-      testName,
-      testSuiteAbsolutePath,
-      isRetry,
-      isNew,
-      isAttemptToFix,
-      isQuarantined,
-      isDisabled,
-      mightHitProbe,
-      isRetryReasonEfd,
-      isRetryReasonAttemptToFix,
-      isRetryReasonAtr
-    }) => {
+    this.addBind('ci:vitest:test:start', (ctx) => {
+      const {
+        testName,
+        testSuiteAbsolutePath,
+        isRetry,
+        isNew,
+        isAttemptToFix,
+        isQuarantined,
+        isDisabled,
+        mightHitProbe,
+        isRetryReasonEfd,
+        isRetryReasonAttemptToFix,
+        isRetryReasonAtr
+      } = ctx
+
       const testSuite = getTestSuitePath(testSuiteAbsolutePath, this.repositoryRoot)
       const store = storage('legacy').getStore()
 
@@ -146,18 +148,21 @@ class VitestPlugin extends CiPlugin {
         extraTags
       )
 
-      this.enter(span, store)
+      ctx.parentStore = store
+      ctx.currentStore = { ...store, span }
 
       // TODO: there might be multiple tests for which mightHitProbe is true, so activeTestSpan
       // might be wrongly overwritten.
       if (mightHitProbe) {
         this.activeTestSpan = span
       }
+
+      return ctx.currentStore
     })
 
-    this.addSub('ci:vitest:test:finish-time', ({ status, task, attemptToFixPassed, attemptToFixFailed }) => {
-      const store = storage('legacy').getStore()
-      const span = store?.span
+    this.addBind('ci:vitest:test:finish-time', (ctx) => {
+      const { status, task, attemptToFixPassed, attemptToFixFailed } = ctx
+      const span = ctx.currentStore?.span
 
       // we store the finish time to finish at a later hook
       // this is because the test might fail at a `afterEach` hook
@@ -171,13 +176,15 @@ class VitestPlugin extends CiPlugin {
         }
 
         this.taskToFinishTime.set(task, span._getTime())
+
+        ctx.parentStore = ctx.currentStore
+        ctx.currentStore = { ...ctx.currentStore, span }
       }
-    })
 
-    this.addSub('ci:vitest:test:pass', ({ task }) => {
-      const store = storage('legacy').getStore()
-      const span = store?.span
+      return ctx.currentStore
+    })
 
+    this.addSub('ci:vitest:test:pass', ({ span, task }) => {
       if (span) {
         this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'test', {
           hasCodeowners: !!span.context()._tags[TEST_CODE_OWNERS]
@@ -189,6 +196,7 @@ class VitestPlugin extends CiPlugin {
     })
 
     this.addSub('ci:vitest:test:error', ({
+      span,
       duration,
       error,
       shouldSetProbe,
@@ -196,9 +204,6 @@ class VitestPlugin extends CiPlugin {
       hasFailedAllRetries,
       attemptToFixFailed
     }) => {
-      const store = storage('legacy').getStore()
-      const span = store?.span
-
       if (span) {
         if (shouldSetProbe && this.di) {
           const probeInformation = this.addDiProbe(error)
@@ -252,10 +257,9 @@ class VitestPlugin extends CiPlugin {
       testSpan.finish()
     })
 
-    this.addSub('ci:vitest:test-suite:start', ({
-      testSuiteAbsolutePath,
-      frameworkVersion
-    }) => {
+    this.addBind('ci:vitest:test-suite:start', (ctx) => {
+      const { testSuiteAbsolutePath, frameworkVersion } = ctx
+
       this.command = process.env.DD_CIVISIBILITY_TEST_COMMAND
       this.frameworkVersion = frameworkVersion
       const testSessionSpanContext = this.tracer.extract('text_map', {
@@ -305,17 +309,18 @@ class VitestPlugin extends CiPlugin {
       })
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_CREATED, 'suite')
       const store = storage('legacy').getStore()
-      this.enter(testSuiteSpan, store)
+      ctx.parentStore = store
+      ctx.currentStore = { ...store, testSuiteSpan }
       this.testSuiteSpan = testSuiteSpan
+
+      return ctx.currentStore
     })
 
-    this.addSub('ci:vitest:test-suite:finish', ({ status, onFinish }) => {
-      const store = storage('legacy').getStore()
-      const span = store?.span
-      if (span) {
-        span.setTag(TEST_STATUS, status)
-        span.finish()
-        finishAllTraceSpans(span)
+    this.addSub('ci:vitest:test-suite:finish', ({ testSuiteSpan, status, onFinish }) => {
+      if (testSuiteSpan) {
+        testSuiteSpan.setTag(TEST_STATUS, status)
+        testSuiteSpan.finish()
+        finishAllTraceSpans(testSuiteSpan)
       }
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
       // TODO: too frequent flush - find for method in worker to decrease frequency
@@ -325,13 +330,19 @@ class VitestPlugin extends CiPlugin {
       }
     })
 
-    this.addSub('ci:vitest:test-suite:error', ({ error }) => {
-      const store = storage('legacy').getStore()
-      const span = store?.span
-      if (span && error) {
-        span.setTag('error', error)
-        span.setTag(TEST_STATUS, 'fail')
+    this.addBind('ci:vitest:test-suite:error', (ctx) => {
+      const { error } = ctx
+      const testSuiteSpan = ctx.currentStore?.testSuiteSpan
+
+      if (testSuiteSpan && error) {
+        testSuiteSpan.setTag('error', error)
+        testSuiteSpan.setTag(TEST_STATUS, 'fail')
+
+        ctx.parentStore = ctx.currentStore
+        ctx.currentStore = { ...ctx.currentStore, testSuiteSpan }
       }
+
+      return ctx.currentStore
     })
 
     this.addSub('ci:vitest:session:finish', ({

package/packages/datadog-shimmer/src/shimmer.js

@@ -1,12 +1,24 @@
 'use strict'
 
+/**
+ * @type {Set<string | symbol>}
+ */
 const skipMethods = new Set([
   'caller',
   'arguments',
   'name',
   'length'
 ])
+const skipMethodSize = skipMethods.size
 
+const nonConfigurableModuleExports = new WeakMap()
+
+/**
+ * Copies properties from the original function to the wrapped function.
+ *
+ * @param {Function} original - The original function.
+ * @param {Function} wrapped - The wrapped function.
+ */
 function copyProperties (original, wrapped) {
   if (original.constructor !== wrapped.constructor) {
     const proto = Object.getPrototypeOf(original)
@@ -23,7 +35,7 @@ function copyProperties (original, wrapped) {
   if (ownKeys.length !== 2) {
     for (const key of ownKeys) {
       if (skipMethods.has(key)) continue
-      const descriptor = Object.getOwnPropertyDescriptor(original, key)
+      const descriptor = /** @type {PropertyDescriptor} */ (Object.getOwnPropertyDescriptor(original, key))
       if (descriptor.writable && descriptor.enumerable && descriptor.configurable) {
         wrapped[key] = original[key]
       } else if (descriptor.writable || descriptor.configurable || !Object.hasOwn(wrapped, key)) {
@@ -33,6 +45,33 @@ function copyProperties (original, wrapped) {
   }
 }
 
+/**
+ * Copies properties from the original object to the wrapped object, skipping a specific key.
+ *
+ * @param {Record<string | symbol, unknown>} original - The original object.
+ * @param {Record<string | symbol, unknown>} wrapped - The wrapped object.
+ * @param {string | symbol} skipKey - The key to skip during copying.
+ */
+function copyObjectProperties (original, wrapped, skipKey) {
+  const ownKeys = Reflect.ownKeys(original)
+  for (const key of ownKeys) {
+    if (key === skipKey) continue
+    const descriptor = /** @type {PropertyDescriptor} */ (Object.getOwnPropertyDescriptor(original, key))
+    if (descriptor.writable && descriptor.enumerable && descriptor.configurable) {
+      wrapped[key] = original[key]
+    } else if (descriptor.writable || descriptor.configurable || !Object.hasOwn(wrapped, key)) {
+      Object.defineProperty(wrapped, key, descriptor)
+    }
+  }
+}
+
+/**
+ * Wraps a function with a wrapper function.
+ *
+ * @param {Function} original - The original function to wrap.
+ * @param {(original: Function) => Function} wrapper - The wrapper function.
+ * @returns {Function} The wrapped function.
+ */
 function wrapFunction (original, wrapper) {
   const wrapped = wrapper(original)
 
@@ -44,28 +83,55 @@ function wrapFunction (original, wrapper) {
   return wrapped
 }
 
-function wrap (target, name, wrapper) {
-  assertMethod(target, name)
+/**
+ * Wraps a method of an object with a wrapper function.
+ *
+ * @param {Record<string | symbol, unknown> | Function} target - The target
+ * object.
+ * @param {string | symbol} name - The property key of the method to wrap.
+ * @param {(original: Function) => (...args) => any} wrapper - The wrapper function.
+ * @param {{ replaceGetter?: boolean }} [options] - If `replaceGetter` is set to
+ * true, the getter is accessed and the getter is replaced with one that just
+ * returns the earlier retrieved value. Use with care! This may only be done in
+ * case the getter absolutely has no side effect and no setter is defined for the
+ * property.
+ * @returns {Record<string | symbol, unknown> | Function} The target object with
+ * the wrapped method.
+ */
+function wrap (target, name, wrapper, options) {
   if (typeof wrapper !== 'function') {
     throw new Error(wrapper ? 'Target is not a function' : 'No function provided')
   }
 
-  const original = target[name]
-  const wrapped = wrapper(original)
+  // No descriptor means original was on the prototype. This is not totally
+  // safe, since we define the property on the target. That could have an impact
+  // in case e.g., the own keys are checks.
+  const descriptor = Object.getOwnPropertyDescriptor(target, name) ?? {
+    value: target[name],
+    writable: true,
+    configurable: true,
+    enumerable: false
+  }
+
+  if (descriptor.set && (!descriptor.get || options?.replaceGetter)) {
+    // It is possible to support these cases by instrumenting both the getter
+    // and setter (or only the setter, in case that is a use case).
+    // For now, this is not supported due to the complexity and the fact that
+    // this is not a common use case.
+    throw new Error(options?.replaceGetter
+      ? 'Replacing a getter/setter pair is not supported. Implement if required.'
+      : 'Replacing setters is not supported. Implement if required.')
+  }
 
-  if (typeof original === 'function') copyProperties(original, wrapped)
+  const original = descriptor.value ?? options?.replaceGetter ? target[name] : descriptor.get
 
-  let descriptor = Object.getOwnPropertyDescriptor(target, name)
+  assertMethod(target, name, original)
 
-  // No descriptor means original was on the prototype
-  if (descriptor === undefined) {
-    descriptor = {
-      value: wrapped,
-      writable: true,
-      configurable: true,
-      enumerable: false
-    }
-  } else if (descriptor.writable) {
+  const wrapped = wrapper(original)
+
+  copyProperties(original, wrapped)
+
+  if (descriptor.writable) {
     // Fast path for assigned properties.
     if (descriptor.configurable && descriptor.enumerable) {
       target[name] = wrapped
@@ -73,25 +139,58 @@ function wrap (target, name, wrapper) {
     }
     descriptor.value = wrapped
   } else {
-    if (descriptor.get || descriptor.set) {
-      // TODO(BridgeAR): What happens in case there is a setter? This seems wrong?
-      // What happens in case the user does indeed set this to a different value?
-      // In that case the getter would potentially return the wrong value?
-      descriptor.get = () => wrapped
+    if (descriptor.get) {
+      // `replaceGetter` may only be used when the getter has no side effect.
+      if (options?.replaceGetter) {
+        descriptor.get = () => wrapped
+      } else {
+        descriptor.get = wrapped
+      }
     } else {
       descriptor.value = wrapped
     }
 
     if (descriptor.configurable === false) {
-      // TODO(BridgeAR): Bail out instead (throw). It is unclear if the newly
-      // created object is actually used. If it's not used, the wrapping would
-      // have had no effect without noticing. It is also unclear what would happen
-      // in case user code would check for properties to be own properties. That
-      // would fail with this code. A function being replaced with an object is
-      // also not possible.
-      return Object.create(target, {
-        [name]: descriptor
-      })
+      // TODO(BridgeAR): This currently only works on the most outer part. The
+      // moduleExports object.
+      //
+      // It would be possible to also implement it for non moduleExports objects
+      // by passing through the moduleExports object and the property names that
+      // are accessed. That way it would be possible to redefine the complete
+      // property chain. Example:
+      //
+      // shimmer.wrap(hapi.Server.prototype, 'start', wrapStart)
+      // shimmer.wrap(hapi.Server.prototype, 'ext', wrapExt)
+      //
+      // shimmer.wrap(hapi, 'Server', 'prototype', 'start', wrapStart)
+      // shimmer.wrap(hapi, 'Server', 'prototype', 'ext', wrapExt)
+      //
+      // That would however still not resolve the issue about the user replacing
+      // the return value so that the hook picks up the new hapi moduleExports
+      // object. To safely fix that, we would have to couple the register helper
+      // with this code. That way it would be possible to directly pass through
+      // the entries.
+
+      // In case more than a single property is not configurable and writable,
+      // Just reuse the already created object.
+      let moduleExports = nonConfigurableModuleExports.get(target)
+      if (!moduleExports) {
+        if (typeof target === 'function') {
+          const original = target
+          moduleExports = function (...args) { return original.apply(original, args) }
+          // This is a rare case. Accept the slight performance hit.
+          skipMethods.add(name)
+          copyProperties(target, moduleExports)
+          if (skipMethods.size === skipMethodSize + 1) {
+            skipMethods.delete(name)
+          }
+        } else {
+          moduleExports = Object.create(target)
+          copyObjectProperties(target, moduleExports, name)
+        }
+        nonConfigurableModuleExports.set(target, moduleExports)
+      }
+      target = moduleExports
     }
   }
 
@@ -100,6 +199,16 @@ function wrap (target, name, wrapper) {
   return target
 }
 
+/**
+ * Wraps multiple methods and or multiple objects with a wrapper function.
+ * May also receive a single method or object or a single method name.
+ *
+ * @param {Array<Record<string | symbol, unknown> | Function> |
+ *         Record<string | symbol, unknown> |
+ *         Function} targets - The target objects.
+ * @param {Array<string | symbol> | string | symbol} names - The property keys of the methods to wrap.
+ * @param {(original: Function) => (...args) => any} wrapper - The wrapper function.
+ */
 function massWrap (targets, names, wrapper) {
   targets = toArray(targets)
   names = toArray(names)
@@ -111,19 +220,35 @@ function massWrap (targets, names, wrapper) {
   }
 }
 
+/**
+ * Converts a value to an array if it is not already an array.
+ *
+ * @template T
+ * @param {T | T[]} maybeArray - The value to convert.
+ * @returns {T[]} The value as an array.
+ */
 function toArray (maybeArray) {
   return Array.isArray(maybeArray) ? maybeArray : [maybeArray]
 }
 
-function assertMethod (target, name) {
-  if (typeof target?.[name] !== 'function') {
+/**
+ * Asserts that a method is a function.
+ *
+ * @param {Record<string | symbol, unknown> | Function} target - The target object.
+ * @param {string | symbol} name - The property key of the method.
+ * @param {unknown} method - The method to assert.
+ * @throws {Error} If the method is not a function.
+ */
+function assertMethod (target, name, method) {
+  if (typeof method !== 'function') {
     let message = 'No target object provided'
 
     if (target) {
       if (typeof target !== 'object' && typeof target !== 'function') {
         message = 'Invalid target'
       } else {
-        message = target[name] ? `Original method ${name} is not a function` : `No original method ${name}`
+        name = String(name)
+        message = method ? `Original method ${name} is not a function` : `No original method ${name}`
       }
     }
 
@@ -131,6 +256,12 @@ function assertMethod (target, name) {
   }
 }
 
+/**
+ * Asserts that a target is not a class constructor.
+ *
+ * @param {Function} target - The target function.
+ * @throws {Error} If the target is a class constructor.
+ */
 function assertNotClass (target) {
   if (Function.prototype.toString.call(target).startsWith('class')) {
     throw new Error('Target is a native class constructor and cannot be wrapped.')

package/packages/dd-trace/src/appsec/graphql.js

@@ -38,8 +38,8 @@ function onGraphqlStartResolve ({ context, resolverInfo }) {
 
   if (!resolverInfo || typeof resolverInfo !== 'object') return
 
-  const actions = waf.run({ ephemeral: { [addresses.HTTP_INCOMING_GRAPHQL_RESOLVER]: resolverInfo } }, req)
-  const blockingAction = getBlockingAction(actions)
+  const result = waf.run({ ephemeral: { [addresses.HTTP_INCOMING_GRAPHQL_RESOLVER]: resolverInfo } }, req)
+  const blockingAction = getBlockingAction(result?.actions)
   if (blockingAction) {
     const requestData = graphqlRequestData.get(req)
     if (requestData?.isInGraphqlRequest) {

package/packages/dd-trace/src/appsec/index.js

@@ -34,6 +34,7 @@ const UserTracking = require('./user_tracking')
 const { storage } = require('../../../datadog-core')
 const graphql = require('./graphql')
 const rasp = require('./rasp')
+const { isInServerlessEnvironment } = require('../serverless')
 
 const responseAnalyzedSet = new WeakSet()
 
@@ -83,7 +84,9 @@ function enable (_config) {
     isEnabled = true
     config = _config
   } catch (err) {
-    log.error('[ASM] Unable to start AppSec', err)
+    if (!isInServerlessEnvironment()) {
+      log.error('[ASM] Unable to start AppSec', err)
+    }
 
     disable()
   }
@@ -106,7 +109,7 @@ function onRequestBodyParsed ({ req, res, body, abortController }) {
     }
   }, req)
 
-  handleResults(results, req, res, rootSpan, abortController)
+  handleResults(results?.actions, req, res, rootSpan, abortController)
 }
 
 function onRequestCookieParser ({ req, res, abortController, cookies }) {
@@ -121,7 +124,7 @@ function onRequestCookieParser ({ req, res, abortController, cookies }) {
     }
   }, req)
 
-  handleResults(results, req, res, rootSpan, abortController)
+  handleResults(results?.actions, req, res, rootSpan, abortController)
 }
 
 function incomingHttpStartTranslator ({ req, res, abortController }) {
@@ -149,9 +152,9 @@ function incomingHttpStartTranslator ({ req, res, abortController }) {
     persistent[addresses.HTTP_CLIENT_IP] = clientIp
   }
 
-  const actions = waf.run({ persistent }, req)
+  const results = waf.run({ persistent }, req)
 
-  handleResults(actions, req, res, rootSpan, abortController)
+  handleResults(results?.actions, req, res, rootSpan, abortController)
 }
 
 function incomingHttpEndTranslator ({ req, res }) {
@@ -198,7 +201,7 @@ function onPassportVerify ({ framework, login, user, success, abortController })
 
   const results = UserTracking.trackLogin(framework, login, user, success, rootSpan)
 
-  handleResults(results, store.req, store.req.res, rootSpan, abortController)
+  handleResults(results?.actions, store.req, store.req.res, rootSpan, abortController)
 }
 
 function onPassportDeserializeUser ({ user, abortController }) {
@@ -212,7 +215,7 @@ function onPassportDeserializeUser ({ user, abortController }) {
 
   const results = UserTracking.trackUser(user, rootSpan)
 
-  handleResults(results, store.req, store.req.res, rootSpan, abortController)
+  handleResults(results?.actions, store.req, store.req.res, rootSpan, abortController)
 }
 
 function onExpressSession ({ req, res, sessionId, abortController }) {
@@ -231,7 +234,7 @@ function onExpressSession ({ req, res, sessionId, abortController }) {
     }
   }, req)
 
-  handleResults(results, req, res, rootSpan, abortController)
+  handleResults(results?.actions, req, res, rootSpan, abortController)
 }
 
 function onRequestQueryParsed ({ req, res, query, abortController }) {
@@ -251,7 +254,7 @@ function onRequestQueryParsed ({ req, res, query, abortController }) {
     }
   }, req)
 
-  handleResults(results, req, res, rootSpan, abortController)
+  handleResults(results?.actions, req, res, rootSpan, abortController)
 }
 
 function onRequestProcessParams ({ req, res, abortController, params }) {
@@ -266,7 +269,7 @@ function onRequestProcessParams ({ req, res, abortController, params }) {
     }
   }, req)
 
-  handleResults(results, req, res, rootSpan, abortController)
+  handleResults(results?.actions, req, res, rootSpan, abortController)
 }
 
 function onResponseBody ({ req, res, body }) {
@@ -308,7 +311,7 @@ function onResponseWriteHead ({ req, res, abortController, statusCode, responseH
 
   responseAnalyzedSet.add(res)
 
-  handleResults(results, req, res, rootSpan, abortController)
+  handleResults(results?.actions, req, res, rootSpan, abortController)
 }
 
 function onResponseSetHeader ({ res, abortController }) {