dd-trace 5.101.0 → 5.103.0

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

@@ -1,5 +1,7 @@
 'use strict'
 
+const { performance } = require('node:perf_hooks')
+
 const { createCoverageMap } = require('../../../vendor/dist/istanbul-lib-coverage')
 const shimmer = require('../../datadog-shimmer')
 const log = require('../../dd-trace/src/log')
@@ -12,6 +14,7 @@ const {
   getTestSuitePath,
   CUCUMBER_WORKER_TRACE_PAYLOAD_CODE,
   getIsFaultyEarlyFlakeDetection,
+  getEfdRetryCount,
   recordAttemptToFixExecution,
   collectAttemptToFixExecutionsFromTraces,
   logAttemptToFixTestExecution,
@@ -62,6 +65,9 @@ const lastStatusByPickleId = new Map()
 /** For ATR: statuses keyed by stable scenario id (uri:name) so retries accumulate correctly */
 const atrStatusesByScenarioKey = new Map()
 const numRetriesByPickleId = new Map()
+const efdRetryCountByPickleId = new Map()
+const efdSlowAbortedPickleIds = new Set()
+const testCaseStartedTimesById = new Map()
 const numAttemptToCtx = new Map()
 const newTestsByTestFullname = new Map()
 const attemptToFixTestsByTestFullname = new Map()
@@ -82,6 +88,7 @@ let isUnskippable = false
 let isSuitesSkippingEnabled = false
 let isEarlyFlakeDetectionEnabled = false
 let earlyFlakeDetectionNumRetries = 0
+let earlyFlakeDetectionSlowTestRetries = {}
 let earlyFlakeDetectionFaultyThreshold = 0
 let isEarlyFlakeDetectionFaulty = false
 let isFlakyTestRetriesEnabled = false
@@ -290,9 +297,9 @@ function wrapRun (pl, isLatestVersion, version) {
 
   patched.add(pl)
 
-  shimmer.wrap(pl.prototype, 'run', run => function () {
+  shimmer.wrap(pl.prototype, 'run', run => function (...args) {
     if (!testFinishCh.hasSubscribers) {
-      return run.apply(this, arguments)
+      return run.apply(this, args)
     }
 
     let numAttempt = 0
@@ -360,9 +367,10 @@ function wrapRun (pl, isLatestVersion, version) {
       }
       this.eventBroadcaster.on('envelope', onEnvelope)
       let promise
+      const executionStart = performance.now()
 
       testFnCh.runStores(ctx, () => {
-        promise = run.apply(this, arguments)
+        promise = run.apply(this, args)
       })
       promise.finally(async () => {
         this.eventBroadcaster.removeListener('envelope', onEnvelope)
@@ -424,15 +432,31 @@ function wrapRun (pl, isLatestVersion, version) {
           isEfdRetry = numRetries > 0
         }
 
+        if (
+          isEarlyFlakeDetectionEnabled &&
+          status !== 'skip' &&
+          (isNew || isModified) &&
+          !isEfdRetry &&
+          !efdRetryCountByPickleId.has(this.pickle.id)
+        ) {
+          const retryCount = getEfdRetryCount(performance.now() - executionStart, earlyFlakeDetectionSlowTestRetries)
+          efdRetryCountByPickleId.set(this.pickle.id, retryCount)
+          if (retryCount === 0) {
+            efdSlowAbortedPickleIds.add(this.pickle.id)
+          }
+        }
+
+        const efdRetryCount = efdRetryCountByPickleId.get(this.pickle.id) ?? earlyFlakeDetectionNumRetries
+
         // Check if all EFD retries failed
         if (isEfdRetry && (isNew || isModified)) {
           const statuses = lastStatusByPickleId.get(this.pickle.id)
-          if (statuses.length === earlyFlakeDetectionNumRetries + 1) {
+          if (statuses.length === efdRetryCount + 1) {
             const { fail } = statuses.reduce((acc, status) => {
               acc[status]++
               return acc
             }, { pass: 0, fail: 0 })
-            if (fail === earlyFlakeDetectionNumRetries + 1) {
+            if (fail === efdRetryCount + 1) {
               hasFailedAllRetries = true
             }
           }
@@ -480,7 +504,7 @@ function wrapRun (pl, isLatestVersion, version) {
         const isLastAtrRetry = isFlakyTestRetriesEnabled && !isAttemptToFix && !isEfdRetry && numTestRetries > 0
 
         const statuses = lastStatusByPickleId.get(this.pickle.id)
-        const isLastEfdRetry = isEfdRetry && statuses?.length === earlyFlakeDetectionNumRetries + 1
+        const isLastEfdRetry = isEfdRetry && statuses?.length === efdRetryCount + 1
         const isLastAttemptToFixRetry = isAttemptToFix && statuses?.length === testManagementAttemptToFixRetries + 1
 
         // Intermediate (non-last EFD or ATF retries) executions do not report a final status
@@ -514,6 +538,7 @@ function wrapRun (pl, isLatestVersion, version) {
           isDisabled,
           isQuarantined,
           isModified,
+          earlyFlakeAbortReason: efdSlowAbortedPickleIds.has(this.pickle.id) ? 'slow' : undefined,
           ...attemptCtx.currentStore,
           finalStatus,
         })
@@ -526,11 +551,11 @@ function wrapRun (pl, isLatestVersion, version) {
       })
     }
   })
-  shimmer.wrap(pl.prototype, 'runStep', runStep => function () {
+  shimmer.wrap(pl.prototype, 'runStep', runStep => function (...args) {
     if (!testFinishCh.hasSubscribers) {
-      return runStep.apply(this, arguments)
+      return runStep.apply(this, args)
     }
-    const testStep = arguments[0]
+    const testStep = args[0]
     let resource
 
     if (isLatestVersion) {
@@ -542,7 +567,7 @@ function wrapRun (pl, isLatestVersion, version) {
     const ctx = { resource }
     return testStepStartCh.runStores(ctx, () => {
       try {
-        const promise = runStep.apply(this, arguments)
+        const promise = runStep.apply(this, args)
 
         promise.then((result) => {
           const finalResult = satisfies(version, '>=12.0.0') ? result.result : result
@@ -603,6 +628,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
 
     isEarlyFlakeDetectionEnabled = configurationResponse.libraryConfig?.isEarlyFlakeDetectionEnabled
     earlyFlakeDetectionNumRetries = configurationResponse.libraryConfig?.earlyFlakeDetectionNumRetries
+    earlyFlakeDetectionSlowTestRetries = configurationResponse.libraryConfig?.earlyFlakeDetectionSlowTestRetries ?? {}
     earlyFlakeDetectionFaultyThreshold = configurationResponse.libraryConfig?.earlyFlakeDetectionFaultyThreshold
     isSuitesSkippingEnabled = configurationResponse.libraryConfig?.isSuitesSkippingEnabled
     isFlakyTestRetriesEnabled = configurationResponse.libraryConfig?.isFlakyTestRetriesEnabled
@@ -627,7 +653,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
       const skippableResponse = await getChannelPromise(skippableSuitesCh)
 
       errorSkippableRequest = skippableResponse.err
-      skippableSuites = skippableResponse.skippableSuites
+      skippableSuites = skippableResponse.skippableSuites ?? []
 
       if (!errorSkippableRequest) {
         const filteredPickles = isCoordinator
@@ -692,6 +718,10 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
 
     atrStatusesByScenarioKey.clear()
     attemptToFixTestsByTestFullname.clear()
+    efdRetryCountByPickleId.clear()
+    efdSlowAbortedPickleIds.clear()
+    testCaseStartedTimesById.clear()
+    newTestsByTestFullname.clear()
     sessionStartCh.publish({ command, frameworkVersion })
 
     if (!errorSkippableRequest && skippedSuites.length) {
@@ -816,7 +846,9 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       }
     }
     // TODO: for >=11 we could use `runTestCaseResult` instead of accumulating results in `lastStatusByPickleId`
+    const firstExecutionStart = performance.now()
     let runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
+    const firstExecutionDurationMs = performance.now() - firstExecutionStart
 
     // Restore dryRun so it doesn't affect subsequent tests in the same worker
     this.options.dryRun = originalDryRun
@@ -835,7 +867,15 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
 
     // If it's a new test and it hasn't been skipped, we run it again
     if (isEarlyFlakeDetectionEnabled && lastTestStatus !== 'skip' && (isNew || isModified)) {
-      for (let retryIndex = 0; retryIndex < earlyFlakeDetectionNumRetries; retryIndex++) {
+      let efdRetryCount = efdRetryCountByPickleId.get(pickle.id)
+      if (efdRetryCount === undefined) {
+        efdRetryCount = getEfdRetryCount(firstExecutionDurationMs, earlyFlakeDetectionSlowTestRetries)
+        efdRetryCountByPickleId.set(pickle.id, efdRetryCount)
+        if (efdRetryCount === 0) {
+          efdSlowAbortedPickleIds.add(pickle.id)
+        }
+      }
+      for (let retryIndex = 0; retryIndex < efdRetryCount; retryIndex++) {
         numRetriesByPickleId.set(pickle.id, retryIndex + 1)
         // eslint-disable-next-line no-await-in-loop
         runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
@@ -952,6 +992,9 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
     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 {
@@ -973,6 +1016,10 @@ 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
@@ -1003,8 +1050,19 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
           testStatuses = [status]
           newTestsByTestFullname.set(testFullname, testStatuses)
         }
+        let efdRetryCount = efdRetryCountByPickleId.get(pickle.id)
+        if (efdRetryCount === undefined) {
+          const firstExecutionDurationMs = testCaseStartedAt === undefined ? 0 : performance.now() - testCaseStartedAt
+          efdRetryCount = status === 'skip'
+            ? 0
+            : getEfdRetryCount(firstExecutionDurationMs, earlyFlakeDetectionSlowTestRetries)
+          efdRetryCountByPickleId.set(pickle.id, efdRetryCount)
+          if (efdRetryCount === 0 && status !== 'skip') {
+            efdSlowAbortedPickleIds.add(pickle.id)
+          }
+        }
         // We have finished all retries
-        if (testStatuses.length === earlyFlakeDetectionNumRetries + 1) {
+        if (testStatuses.length === efdRetryCount + 1) {
           const newTestFinalStatus = getTestStatusFromRetries(testStatuses)
           // we only push to `finished` if the retries have finished
           finished.push(newTestFinalStatus)
@@ -1143,9 +1201,9 @@ addHook({
   versions: ['>=11.0.0'],
   file: 'lib/formatter/helpers/event_data_collector.js',
 }, (eventDataCollectorPackage) => {
-  shimmer.wrap(eventDataCollectorPackage.default.prototype, 'parseEnvelope', parseEnvelope => function () {
+  shimmer.wrap(eventDataCollectorPackage.default.prototype, 'parseEnvelope', parseEnvelope => function (...args) {
     eventDataCollector = this
-    return parseEnvelope.apply(this, arguments)
+    return parseEnvelope.apply(this, args)
   })
   return eventDataCollectorPackage
 })
@@ -1164,18 +1222,20 @@ addHook({
     parseWorkerMessage => getWrappedParseWorkerMessage(parseWorkerMessage, true)
   )
   // EFD in parallel mode only supported in >=11.0.0
-  shimmer.wrap(adapterPackage.ChildProcessAdapter.prototype, 'startWorker', startWorker => function () {
+  shimmer.wrap(adapterPackage.ChildProcessAdapter.prototype, 'startWorker', startWorker => function (...args) {
     if (isKnownTestsEnabled && isValidKnownTests(knownTests)) {
       this.options.worldParameters._ddIsKnownTestsEnabled = true
       this.options.worldParameters._ddIsEarlyFlakeDetectionEnabled = isEarlyFlakeDetectionEnabled
       this.options.worldParameters._ddKnownTests = knownTests
       this.options.worldParameters._ddEarlyFlakeDetectionNumRetries = earlyFlakeDetectionNumRetries
+      this.options.worldParameters._ddEarlyFlakeDetectionSlowTestRetries = earlyFlakeDetectionSlowTestRetries
     } else {
       isEarlyFlakeDetectionEnabled = false
       isKnownTestsEnabled = false
       this.options.worldParameters._ddIsEarlyFlakeDetectionEnabled = false
       this.options.worldParameters._ddIsKnownTestsEnabled = false
       this.options.worldParameters._ddEarlyFlakeDetectionNumRetries = 0
+      this.options.worldParameters._ddEarlyFlakeDetectionSlowTestRetries = {}
     }
 
     if (isImpactedTestsEnabled) {
@@ -1192,7 +1252,7 @@ addHook({
       this.options.worldParameters._ddTestManagementAttemptToFixRetries = testManagementAttemptToFixRetries
     }
 
-    return startWorker.apply(this, arguments)
+    return startWorker.apply(this, args)
   })
   return adapterPackage
 })
@@ -1222,6 +1282,7 @@ addHook({
       isEarlyFlakeDetectionEnabled = !!this.options.worldParameters._ddIsEarlyFlakeDetectionEnabled
       if (isEarlyFlakeDetectionEnabled) {
         earlyFlakeDetectionNumRetries = this.options.worldParameters._ddEarlyFlakeDetectionNumRetries
+        earlyFlakeDetectionSlowTestRetries = this.options.worldParameters._ddEarlyFlakeDetectionSlowTestRetries ?? {}
       }
       isImpactedTestsEnabled = !!this.options.worldParameters._ddImpactedTestsEnabled
       if (isImpactedTestsEnabled) {

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

@@ -18,8 +18,6 @@ const rrtypes = {
   resolveSoa: 'SOA',
 }
 
-const rrtypeMap = new WeakMap()
-
 addHook({ name: 'dns' }, dns => {
   const lookup = createCallbackInstrumentor('apm:dns:lookup', { captureResult: true })
   const lookupService = createCallbackInstrumentor('apm:dns:lookup_service', { captureResult: true })
@@ -46,7 +44,6 @@ addHook({ name: 'dns' }, dns => {
 function patchResolveShorthands (prototype, resolve) {
   for (const method of Object.keys(rrtypes)) {
     if (prototype[method]) {
-      rrtypeMap.set(prototype[method], rrtypes[method])
       shimmer.wrap(prototype, method, resolve(buildArgsContext(rrtypes[method])))
     }
   }

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

@@ -24,24 +24,21 @@ function wrapTransportPrototype (Transport) {
 addHook({ name: '@elastic/elasticsearch', file: 'lib/Transport.js', versions: ['>=5.6.16 <8', '>=8'] }, Transport => {
   shimmer.wrap(Transport.prototype, 'request', createWrapRequest('elasticsearch'))
   shimmer.wrap(Transport.prototype, 'getConnection', createWrapGetConnection('elasticsearch'))
-  return Transport
 })
 
 addHook({ name: 'elasticsearch', file: 'src/lib/transport.js', versions: ['>=10'] }, Transport => {
   shimmer.wrap(Transport.prototype, 'request', createWrapRequest('elasticsearch'))
-  return Transport
 })
 
 addHook({ name: 'elasticsearch', file: 'src/lib/connection_pool.js', versions: ['>=10'] }, ConnectionPool => {
-  shimmer.wrap(ConnectionPool.prototype, 'select', createWrapSelect('elasticsearch'))
-  return ConnectionPool
+  shimmer.wrap(ConnectionPool.prototype, 'select', createWrapSelect())
 })
 
 function createWrapGetConnection (name) {
   const connectCh = channel(`apm:${name}:query:connect`)
   return function wrapRequest (request) {
-    return function () {
-      const connection = request.apply(this, arguments)
+    return function (...args) {
+      const connection = request.apply(this, args)
       if (connectCh.hasSubscribers && connection && connection.url) {
         connectCh.publish(connection.url)
       }
@@ -53,17 +50,17 @@ function createWrapGetConnection (name) {
 function createWrapSelect () {
   const connectCh = channel('apm:elasticsearch:query:connect')
   return function wrapRequest (request) {
-    return function () {
-      if (arguments.length === 1) {
-        const cb = arguments[0]
-        arguments[0] = shimmer.wrapFunction(cb, cb => function (err, connection) {
+    return function (...args) {
+      if (args.length === 1) {
+        const cb = args[0]
+        args[0] = shimmer.wrapFunction(cb, cb => function (err, connection) {
           if (connectCh.hasSubscribers && connection && connection.host) {
             connectCh.publish({ hostname: connection.host.host, port: connection.host.port })
           }
           cb(err, connection)
         })
       }
-      return request.apply(this, arguments)
+      return request.apply(this, args)
     }
   }
 }

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/express-mongo-sanitize.js

@@ -12,8 +12,8 @@ const sanitizeMiddlewareFinished = channel('datadog:express-mongo-sanitize:filte
 const propertiesToSanitize = ['body', 'params', 'headers', 'query']
 
 addHook({ name: 'express-mongo-sanitize', versions: ['>=1.0.0'] }, expressMongoSanitize => {
-  shimmer.wrap(expressMongoSanitize, 'sanitize', sanitize => function () {
-    const sanitizedObject = sanitize.apply(this, arguments)
+  shimmer.wrap(expressMongoSanitize, 'sanitize', sanitize => function (...args) {
+    const sanitizedObject = sanitize.apply(this, args)
 
     if (sanitizeMethodFinished.hasSubscribers) {
       sanitizeMethodFinished.publish({ sanitizedObject })
@@ -22,21 +22,21 @@ addHook({ name: 'express-mongo-sanitize', versions: ['>=1.0.0'] }, expressMongoS
     return sanitizedObject
   })
 
-  return shimmer.wrapFunction(expressMongoSanitize, expressMongoSanitize => function () {
-    const middleware = expressMongoSanitize.apply(this, arguments)
+  return shimmer.wrapFunction(expressMongoSanitize, expressMongoSanitize => function (...args) {
+    const middleware = expressMongoSanitize.apply(this, args)
 
     return shimmer.wrapFunction(middleware, middleware => function (req, res, next) {
       if (!sanitizeMiddlewareFinished.hasSubscribers) {
         return middleware.apply(this, arguments)
       }
 
-      const wrappedNext = shimmer.wrapFunction(next, next => function () {
+      const wrappedNext = shimmer.wrapFunction(next, next => function (...args) {
         sanitizeMiddlewareFinished.publish({
           sanitizedProperties: propertiesToSanitize,
           req,
         })
 
-        return next.apply(this, arguments)
+        return next.apply(this, args)
       })
 
       return middleware.call(this, req, res, wrappedNext)