dd-trace 5.102.0 → 5.104.0

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

@@ -15,10 +15,12 @@ const {
   CUCUMBER_WORKER_TRACE_PAYLOAD_CODE,
   getIsFaultyEarlyFlakeDetection,
   getEfdRetryCount,
+  getMaxEfdRetryCount,
   recordAttemptToFixExecution,
   collectAttemptToFixExecutionsFromTraces,
   logAttemptToFixTestExecution,
   logTestOptimizationSummary,
+  getTestOptimizationRequestResults,
 } = require('../../dd-trace/src/plugins/util/test')
 const satisfies = require('../../../vendor/dist/semifies')
 const { addHook, channel } = require('./helpers/instrument')
@@ -51,6 +53,8 @@ const itrSkippedSuitesCh = channel('ci:cucumber:itr:skipped-suites')
 
 const getCodeCoverageCh = channel('ci:nyc:get-coverage')
 
+const DD_EFD_RETRY_COUNT_MESSAGE = '_ddEfdRetryCount'
+
 const isMarkedAsUnskippable = (pickle) => {
   return pickle.tags.some(tag => tag.name === '@datadog:unskippable')
 }
@@ -67,7 +71,7 @@ const atrStatusesByScenarioKey = new Map()
 const numRetriesByPickleId = new Map()
 const efdRetryCountByPickleId = new Map()
 const efdSlowAbortedPickleIds = new Set()
-const testCaseStartedTimesById = new Map()
+const finishedParallelSuites = new Set()
 const numAttemptToCtx = new Map()
 const newTestsByTestFullname = new Map()
 const attemptToFixTestsByTestFullname = new Map()
@@ -117,6 +121,68 @@ function getSuiteStatusFromTestStatuses (testStatuses) {
   return 'pass'
 }
 
+function getConfiguredEfdRetryCount () {
+  const maxSlowTestRetryCount = getMaxEfdRetryCount(earlyFlakeDetectionSlowTestRetries)
+  return maxSlowTestRetryCount || earlyFlakeDetectionNumRetries
+}
+
+function publishWorkerEfdRetryCount (pickle, retryCount) {
+  if (typeof process.send !== 'function') return
+
+  try {
+    process.send({
+      [DD_EFD_RETRY_COUNT_MESSAGE]: {
+        pickleId: pickle.id,
+        retryCount,
+        testFileAbsolutePath: pickle.uri,
+        testName: pickle.name,
+      },
+    })
+  } catch {
+    // ignore IPC errors
+  }
+}
+
+function finishParallelSuiteIfDone (testFileAbsolutePath) {
+  const finished = pickleResultByFile[testFileAbsolutePath]
+  const expectedPickles = pickleByFile[testFileAbsolutePath]
+
+  if (!finished || !expectedPickles || finished.length !== expectedPickles.length) return
+  if (finishedParallelSuites.has(testFileAbsolutePath)) return
+
+  finishedParallelSuites.add(testFileAbsolutePath)
+  testSuiteFinishCh.publish({
+    status: getSuiteStatusFromTestStatuses(finished),
+    testSuitePath: getTestSuitePath(testFileAbsolutePath, process.cwd()),
+  })
+}
+
+function maybeRecordFinalParallelEfdStatus ({ pickleId, testFileAbsolutePath, testFullname }) {
+  const efdRetryCount = efdRetryCountByPickleId.get(pickleId)
+  const testStatuses = newTestsByTestFullname.get(testFullname)
+  const finished = pickleResultByFile[testFileAbsolutePath]
+
+  if (efdRetryCount === undefined || !testStatuses || !finished) return
+  if (testStatuses.length !== efdRetryCount + 1) return
+
+  finished.push(getTestStatusFromRetries(testStatuses))
+  newTestsByTestFullname.delete(testFullname)
+  finishParallelSuiteIfDone(testFileAbsolutePath)
+}
+
+function handleEfdRetryCountMessage (message) {
+  const { pickleId, retryCount, testFileAbsolutePath, testName } = message
+
+  if (!pickleId || typeof retryCount !== 'number' || !testFileAbsolutePath || !testName) return
+
+  efdRetryCountByPickleId.set(pickleId, retryCount)
+  maybeRecordFinalParallelEfdStatus({
+    pickleId,
+    testFileAbsolutePath,
+    testFullname: `${testFileAbsolutePath}:${testName}`,
+  })
+}
+
 function getStatusFromResult (result) {
   if (result.status === 1) {
     return { status: 'pass' }
@@ -639,21 +705,34 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
     testManagementAttemptToFixRetries = configurationResponse.libraryConfig?.testManagementAttemptToFixRetries
     isImpactedTestsEnabled = configurationResponse.libraryConfig?.isImpactedTestsEnabled
 
+    const {
+      knownTestsResponse,
+      testManagementTestsResponse,
+      skippableSuitesResponse,
+    } = await getTestOptimizationRequestResults({
+      isKnownTestsEnabled,
+      isTestManagementTestsEnabled,
+      isSuitesSkippingEnabled,
+      getKnownTests: () => getChannelPromise(knownTestsCh),
+      getTestManagementTests: () => getChannelPromise(testManagementTestsCh),
+      getSkippableSuites: () => getChannelPromise(skippableSuitesCh),
+    })
+
     if (isKnownTestsEnabled) {
-      const knownTestsResponse = await getChannelPromise(knownTestsCh)
-      if (knownTestsResponse.err) {
+      const currentKnownTestsResponse = knownTestsResponse || await getChannelPromise(knownTestsCh)
+      if (currentKnownTestsResponse.err) {
         isEarlyFlakeDetectionEnabled = false
         isKnownTestsEnabled = false
       } else {
-        knownTests = knownTestsResponse.knownTests
+        knownTests = currentKnownTestsResponse.knownTests
       }
     }
 
     if (isSuitesSkippingEnabled) {
-      const skippableResponse = await getChannelPromise(skippableSuitesCh)
+      const skippableResponse = skippableSuitesResponse || await getChannelPromise(skippableSuitesCh)
 
       errorSkippableRequest = skippableResponse.err
-      skippableSuites = skippableResponse.skippableSuites
+      skippableSuites = skippableResponse.skippableSuites ?? []
 
       if (!errorSkippableRequest) {
         const filteredPickles = isCoordinator
@@ -694,11 +773,12 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
     }
 
     if (isTestManagementTestsEnabled) {
-      const testManagementTestsResponse = await getChannelPromise(testManagementTestsCh)
-      if (testManagementTestsResponse.err) {
+      const currentTestManagementTestsResponse =
+        testManagementTestsResponse || await getChannelPromise(testManagementTestsCh)
+      if (currentTestManagementTestsResponse.err) {
         isTestManagementTestsEnabled = false
       } else {
-        testManagementTests = testManagementTestsResponse.testManagementTests
+        testManagementTests = currentTestManagementTestsResponse.testManagementTests
       }
     }
 
@@ -720,7 +800,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
     attemptToFixTestsByTestFullname.clear()
     efdRetryCountByPickleId.clear()
     efdSlowAbortedPickleIds.clear()
-    testCaseStartedTimesById.clear()
+    finishedParallelSuites.clear()
     newTestsByTestFullname.clear()
     sessionStartCh.publish({ command, frameworkVersion })
 
@@ -875,6 +955,9 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
           efdSlowAbortedPickleIds.add(pickle.id)
         }
       }
+      if (isWorker) {
+        publishWorkerEfdRetryCount(pickle, efdRetryCount)
+      }
       for (let retryIndex = 0; retryIndex < efdRetryCount; retryIndex++) {
         numRetriesByPickleId.set(pickle.id, retryIndex + 1)
         // eslint-disable-next-line no-await-in-loop
@@ -973,6 +1056,10 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
         return
       }
     }
+    if (message[DD_EFD_RETRY_COUNT_MESSAGE]) {
+      handleEfdRetryCountMessage(message[DD_EFD_RETRY_COUNT_MESSAGE])
+      return
+    }
 
     const envelope = isNewVersion ? message.envelope : message.jsonEnvelope
 
@@ -989,12 +1076,13 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
         return parseWorkerMessageFunction.apply(this, arguments)
       }
     }
+    if (parsed[DD_EFD_RETRY_COUNT_MESSAGE]) {
+      handleEfdRetryCountMessage(parsed[DD_EFD_RETRY_COUNT_MESSAGE])
+      return
+    }
     let pickle
 
     if (parsed.testCaseStarted) {
-      if (parsed.testCaseStarted.id) {
-        testCaseStartedTimesById.set(parsed.testCaseStarted.id, performance.now())
-      }
       if (isNewVersion) {
         pickle = this.inProgress[worker.id].pickle
       } else {
@@ -1016,10 +1104,6 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
 
     // after calling `parseWorkerMessageFunction`, the test status can already be read
     if (parsed.testCaseFinished) {
-      const testCaseStartedId = parsed.testCaseFinished.testCaseStartedId
-      const testCaseStartedAt = testCaseStartedTimesById.get(testCaseStartedId)
-      testCaseStartedTimesById.delete(testCaseStartedId)
-
       let worstTestStepResult
       if (isNewVersion && eventDataCollector) {
         pickle = this.inProgress[worker.id].pickle
@@ -1052,21 +1136,15 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
         }
         let efdRetryCount = efdRetryCountByPickleId.get(pickle.id)
         if (efdRetryCount === undefined) {
-          const firstExecutionDurationMs = testCaseStartedAt === undefined ? 0 : performance.now() - testCaseStartedAt
           efdRetryCount = status === 'skip'
             ? 0
-            : getEfdRetryCount(firstExecutionDurationMs, earlyFlakeDetectionSlowTestRetries)
+            : getConfiguredEfdRetryCount()
           efdRetryCountByPickleId.set(pickle.id, efdRetryCount)
           if (efdRetryCount === 0 && status !== 'skip') {
             efdSlowAbortedPickleIds.add(pickle.id)
           }
         }
-        // We have finished all retries
-        if (testStatuses.length === efdRetryCount + 1) {
-          const newTestFinalStatus = getTestStatusFromRetries(testStatuses)
-          // we only push to `finished` if the retries have finished
-          finished.push(newTestFinalStatus)
-        }
+        maybeRecordFinalParallelEfdStatus({ pickleId: pickle.id, testFileAbsolutePath, testFullname })
       } else if (
         isTestManagementTestsEnabled &&
         getTestProperties(getTestSuitePath(testFileAbsolutePath, process.cwd()), pickle.name).attemptToFix
@@ -1090,12 +1168,7 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
         finished.push(status)
       }
 
-      if (finished.length === pickleByFile[testFileAbsolutePath].length) {
-        testSuiteFinishCh.publish({
-          status: getSuiteStatusFromTestStatuses(finished),
-          testSuitePath: getTestSuitePath(testFileAbsolutePath, process.cwd()),
-        })
-      }
+      finishParallelSuiteIfDone(testFileAbsolutePath)
     }
 
     return parseWorkerResponse

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

@@ -51,9 +51,9 @@ function createWrapSelect () {
   const connectCh = channel('apm:elasticsearch:query:connect')
   return function wrapRequest (request) {
     return function (...args) {
-      if (args.length === 1) {
-        const cb = args[0]
-        args[0] = shimmer.wrapFunction(cb, cb => function (err, connection) {
+      const cb = args[0]
+      if (args.length === 1 && typeof cb === 'function') {
+        args[0] = shimmer.wrapCallback(cb, cb => function (err, connection) {
           if (connectCh.hasSubscribers && connection && connection.host) {
             connectCh.publish({ hostname: connection.host.host, port: connection.host.port })
           }
@@ -85,7 +85,7 @@ function createWrapRequest (name) {
           cb = arguments[lastIndex]
 
           if (typeof cb === 'function') {
-            arguments[lastIndex] = shimmer.wrapFunction(cb, cb => function (error) {
+            arguments[lastIndex] = shimmer.wrapCallback(cb, cb => function (error) {
               if (error) {
                 ctx.error = error
                 errorCh.publish(ctx)

package/packages/datadog-instrumentations/src/electron/preload.js

@@ -0,0 +1,42 @@
+'use strict'
+
+// eslint-disable-next-line n/no-missing-require
+const { contextBridge, ipcRenderer } = require('electron')
+
+const BRIDGE_CHANNEL = 'datadog:bridge-send'
+const CONFIG_CHANNEL = 'datadog:bridge-config'
+
+// Privacy levels matching @datadog/browser-core DefaultPrivacyLevel
+const MASK = 'mask'
+
+const config = ipcRenderer.sendSync(CONFIG_CHANNEL)
+
+const defaultPrivacyLevel = config?.defaultPrivacyLevel ?? MASK
+const configuredHosts = config?.allowedWebViewHosts ?? []
+// eslint-disable-next-line no-undef
+const allowedHosts = [...new Set([location.hostname, ...configuredHosts])]
+
+const bridge = {
+  getCapabilities () {
+    return '[]'
+  },
+  getPrivacyLevel () {
+    return defaultPrivacyLevel
+  },
+  getAllowedWebViewHosts () {
+    return JSON.stringify(allowedHosts)
+  },
+  send (msg) {
+    ipcRenderer.send(BRIDGE_CHANNEL, msg)
+  },
+}
+
+// Support both contextIsolation enabled (default) and disabled
+
+window.DatadogEventBridge = bridge
+
+try {
+  contextBridge.exposeInMainWorld('DatadogEventBridge', bridge)
+} catch {
+  // exposeInMainWorld throws when contextIsolation is disabled
+}

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

@@ -0,0 +1,240 @@
+'use strict'
+
+const { join } = require('path')
+const { wrap } = require('../../datadog-shimmer')
+const { addHook, channel, tracingChannel } = require('./helpers/instrument')
+
+const requestCh = tracingChannel('apm:electron:net:request')
+const mainReceiveCh = tracingChannel('apm:electron:ipc:main:receive')
+const mainHandleCh = tracingChannel('apm:electron:ipc:main:handle')
+const mainSendCh = tracingChannel('apm:electron:ipc:main:send')
+const rendererPatchedCh = channel('apm:electron:ipc:renderer:patched')
+const rendererReceiveCh = tracingChannel('apm:electron:ipc:renderer:receive')
+const rendererSendCh = tracingChannel('apm:electron:ipc:renderer:send')
+
+const listeners = {}
+const handlers = {}
+
+function createWrapRequest (ch) {
+  return function wrapRequest (request) {
+    return function (...args) {
+      if (!ch.start.hasSubscribers) return request.apply(this, arguments)
+
+      const ctx = { args }
+
+      return ch.start.runStores(ctx, () => {
+        try {
+          const req = request.apply(this, ctx.args)
+          const emit = req.emit
+
+          ctx.req = req
+
+          req.emit = function (eventName, arg) {
+            /* eslint-disable no-fallthrough */
+            switch (eventName) {
+              case 'response':
+                ctx.res = arg
+                ctx.res.on('error', error => {
+                  ctx.error = error
+                  ch.error.publish(ctx)
+                  ch.asyncStart.publish(ctx)
+                })
+                ctx.res.on('end', () => ch.asyncStart.publish(ctx))
+                break
+              case 'error':
+                ctx.error = arg
+                ch.error.publish(ctx)
+              case 'abort':
+                ch.asyncStart.publish(ctx)
+            }
+
+            return emit.apply(this, arguments)
+          }
+
+          return req
+        } catch (e) {
+          ctx.error = e
+          ch.error.publish(ctx)
+          throw e
+        } finally {
+          ch.end.publish(ctx)
+        }
+      })
+    }
+  }
+}
+
+function createWrapAddListener (ch, mappings) {
+  return function wrapAddListener (addListener) {
+    return function (channel, listener) {
+      const wrappedListener = (event, ...args) => {
+        const ctx = { args, channel, event }
+
+        return ch.tracePromise(() => listener.call(this, event, ...args), ctx)
+      }
+
+      const mapping = mappings[channel] || new WeakMap()
+      const wrapper = mapping.get(listener) || wrappedListener
+
+      mapping.set(listener, wrapper)
+
+      return addListener.call(this, channel, wrappedListener)
+    }
+  }
+}
+
+function createWrapRemoveListener (mappings) {
+  return function wrapRemoveListener (removeListener) {
+    return function (channel, listener) {
+      const mapping = mappings[channel]
+
+      if (mapping) {
+        const wrapper = mapping.get(listener)
+
+        if (wrapper) {
+          return removeListener.call(this, channel, wrapper)
+        }
+      }
+
+      return removeListener.call(this, channel, listener)
+    }
+  }
+}
+
+function createWrapRemoveAllListeners (mappings) {
+  return function wrapRemoveAllListeners (removeAllListeners) {
+    return function (channel) {
+      if (channel) {
+        delete mappings[channel]
+      } else {
+        for (const key of Object.keys(mappings)) delete mappings[key]
+      }
+
+      return removeAllListeners.call(this, channel)
+    }
+  }
+}
+
+function createWrapSend (ch, promise = false) {
+  const trace = (promise ? ch.tracePromise : ch.traceSync).bind(ch)
+
+  return function wrapSend (send) {
+    return function (channel, ...args) {
+      const ctx = { args, channel, self: this }
+
+      return trace(() => send.call(this, channel, ...args), ctx)
+    }
+  }
+}
+
+function wrapSendToFrame (send) {
+  return function (frameId, channel, ...args) {
+    const ctx = { args, channel, frameId, self: this }
+
+    return mainSendCh.traceSync(() => send.call(this, frameId, channel, ...args), ctx)
+  }
+}
+
+function wrapBrowserWindow (electron) {
+  const moduleExports = {}
+
+  class DatadogBrowserWindow extends electron.BrowserWindow {
+    constructor (options = {}) {
+      const win = super(options)
+
+      win.webContents.session.registerPreloadScript({
+        type: 'frame', // TODO: service-worker
+        filePath: join(__dirname, 'electron', 'preload.js'),
+      })
+
+      // BrowserWindow doesn't support subclassing because it's all native code
+      // so we return an instance of it instead of the subclass.
+      return win
+    }
+  }
+
+  Object.defineProperty(moduleExports, 'BrowserWindow', {
+    enumerable: true,
+    get: () => DatadogBrowserWindow,
+    configurable: false,
+  })
+
+  for (const key of Reflect.ownKeys(electron)) {
+    const descriptor = Reflect.getOwnPropertyDescriptor(electron, key)
+
+    if (key === 'BrowserWindow') continue
+
+    Object.defineProperty(moduleExports, key, descriptor)
+  }
+
+  return moduleExports
+}
+
+function wrapWebContents (proto) {
+  const descriptor = Object.getOwnPropertyDescriptor(proto, 'webContents')
+  const wrapped = new WeakSet()
+  const wrapSend = createWrapSend(mainSendCh)
+
+  Object.defineProperty(proto, 'webContents', {
+    get () {
+      const webContents = descriptor.get.apply(this)
+
+      if (!wrapped.has(webContents)) {
+        // wrap(webContents, 'postMessage', wrapSend)
+        wrap(webContents, 'send', wrapSend)
+        wrap(webContents, 'sendToFrame', wrapSendToFrame)
+
+        wrapped.add(webContents)
+      }
+
+      return webContents
+    },
+  })
+}
+
+addHook({ name: 'electron', versions: ['>=37.0.0'] }, electron => {
+  // Electron exports a string in Node and an object in Electron.
+  if (typeof electron === 'string') return electron
+
+  const { BrowserWindow, ipcMain, ipcRenderer, net } = electron
+
+  if (net) {
+    // This also covers `fetch` as it uses `request` under the hood.
+    wrap(net, 'request', createWrapRequest(requestCh))
+  }
+
+  if (ipcRenderer) {
+    wrap(ipcRenderer, 'invoke', createWrapSend(rendererSendCh, true))
+    // wrap(ipcRenderer, 'postMessage', createWrapSend(rendererSendCh))
+    wrap(ipcRenderer, 'send', createWrapSend(rendererSendCh))
+    wrap(ipcRenderer, 'sendSync', createWrapSend(rendererSendCh))
+    wrap(ipcRenderer, 'sendToHost', createWrapSend(rendererSendCh))
+
+    wrap(ipcRenderer, 'addListener', createWrapAddListener(rendererReceiveCh, listeners))
+    wrap(ipcRenderer, 'off', createWrapRemoveListener(listeners))
+    wrap(ipcRenderer, 'on', createWrapAddListener(rendererReceiveCh, listeners))
+    wrap(ipcRenderer, 'once', createWrapAddListener(rendererReceiveCh, listeners))
+    wrap(ipcRenderer, 'removeListener', createWrapRemoveListener(listeners))
+    wrap(ipcRenderer, 'removeAllListeners', createWrapRemoveAllListeners(listeners))
+
+    ipcRenderer.send('datadog:apm:renderer:patched')
+  } else {
+    wrap(ipcMain, 'addListener', createWrapAddListener(mainReceiveCh, listeners))
+    wrap(ipcMain, 'handle', createWrapAddListener(mainHandleCh, handlers))
+    wrap(ipcMain, 'handleOnce', createWrapAddListener(mainHandleCh, handlers))
+    wrap(ipcMain, 'off', createWrapRemoveListener(listeners))
+    wrap(ipcMain, 'on', createWrapAddListener(mainReceiveCh, listeners))
+    wrap(ipcMain, 'once', createWrapAddListener(mainReceiveCh, listeners))
+    wrap(ipcMain, 'removeAllListeners', createWrapRemoveAllListeners(listeners))
+    wrap(ipcMain, 'removeHandler', createWrapRemoveAllListeners(handlers))
+    wrap(ipcMain, 'removeListener', createWrapRemoveListener(listeners))
+
+    ipcMain.once('datadog:apm:renderer:patched', event => rendererPatchedCh.publish(event))
+
+    wrapWebContents(BrowserWindow.prototype)
+
+    electron = wrapBrowserWindow(electron)
+  }
+
+  return electron
+})

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

@@ -5,10 +5,10 @@ const { IS_SERVERLESS } = require('../../dd-trace/src/serverless')
 if (globalThis.fetch) {
   const globalFetch = globalThis.fetch
 
-  let fetch = (input, init) => {
+  let wrappedFetch = (input, init) => {
     wrapRealFetch()
 
-    return fetch(input, init)
+    return wrappedFetch(input, init)
   }
 
   function wrapRealFetch () {
@@ -20,14 +20,14 @@ if (globalThis.fetch) {
       channel('dd-trace:instrumentation:load').publish({ name: 'global:fetch' })
     })
 
-    fetch = wrapFetch(globalFetch)
+    wrappedFetch = wrapFetch(globalFetch)
   }
 
   if (!IS_SERVERLESS) {
     wrapRealFetch()
   }
 
-  globalThis.fetch = function value (input, init) {
-    return fetch(input, init)
+  globalThis.fetch = function fetch (input, init) {
+    return wrappedFetch(input, init)
   }
 }

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

@@ -169,7 +169,7 @@ function wrapExecute (execute) {
       const ctx = {
         operation,
         args,
-        docSource: documentSources.get(document),
+        docSource: source,
         source,
         fields: Object.create(null),
         abortController: new AbortController(),
@@ -257,13 +257,17 @@ function callInAsyncScope (fn, thisArg, args, abortController, cb) {
 }
 
 function pathToArray (path) {
-  const flattened = []
-  let curr = path
-  while (curr) {
-    flattened.push(curr.key)
-    curr = curr.prev
+  let length = 0
+  for (let curr = path; curr; curr = curr.prev) {
+    length += 1
   }
-  return flattened.reverse()
+
+  const flattened = new Array(length)
+  let index = length
+  for (let curr = path; curr; curr = curr.prev) {
+    flattened[--index] = curr.key
+  }
+  return flattened
 }
 
 function assertField (rootCtx, info, args) {
@@ -295,9 +299,7 @@ function wrapFields (type) {
 
   patchedTypes.add(type)
 
-  for (const key of Object.keys(type._fields)) {
-    const field = type._fields[key]
-
+  for (const field of Object.values(type._fields)) {
     wrapFieldResolve(field)
     wrapFieldType(field)
   }
@@ -321,8 +323,7 @@ function wrapFieldType (field) {
 }
 
 function finishResolvers ({ fields }) {
-  for (const key of Object.keys(fields).reverse()) {
-    const field = fields[key]
+  for (const field of Object.values(fields)) {
     field.ctx.finishTime = field.finishTime
     field.ctx.field = field
     if (field.error) {
@@ -342,11 +343,6 @@ addHook({ name: '@graphql-tools/executor', versions: ['>=0.0.14'] }, executor =>
   return executor
 })
 
-addHook({ name: '@graphql-tools/executor', file: 'cjs/execution/execute.js', versions: ['>=0.0.14'] }, execute => {
-  shimmer.wrap(execute, 'execute', wrapExecute(execute))
-  return execute
-})
-
 addHook({ name: 'graphql', file: 'execution/execute.js', versions: ['>=0.10'] }, execute => {
   shimmer.wrap(execute, 'execute', wrapExecute(execute))
   return execute