dd-trace 5.67.0 → 5.69.0

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

@@ -13,14 +13,24 @@ exports.channel = function (name) {
   return ch
 }
 
+const tracingChannelMap = {}
+exports.tracingChannel = function (name) {
+  const maybe = tracingChannelMap[name]
+  if (maybe) return maybe
+  const tc = dc.tracingChannel(name)
+  tracingChannelMap[name] = tc
+  return tc
+}
+
 /**
- * @param {string} args.name module name
+ * @param {object} args
+ * @param {string|string[]} args.name module name
  * @param {string[]} args.versions array of semver range strings
- * @param {string} args.file path to file within package to instrument
- * @param {string} args.filePattern pattern to match files within package to instrument
+ * @param {string} [args.file='index.js'] path to file within package to instrument
+ * @param {string} [args.filePattern] pattern to match files within package to instrument
  * @param Function hook
  */
-exports.addHook = function addHook ({ name, versions, file, filePattern }, hook) {
+exports.addHook = function addHook ({ name, versions, file, filePattern, patchDefault }, hook) {
   if (typeof name === 'string') {
     name = [name]
   }
@@ -29,7 +39,7 @@ exports.addHook = function addHook ({ name, versions, file, filePattern }, hook)
     if (!instrumentations[val]) {
       instrumentations[val] = []
     }
-    instrumentations[val].push({ name: val, versions, file, filePattern, hook })
+    instrumentations[val].push({ name: val, versions, file, filePattern, hook, patchDefault })
   }
 }
 

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

@@ -66,7 +66,7 @@ for (const packageName of names) {
   // get the instrumentation file name to save all hooked versions
   const instrumentationFileName = parseHookInstrumentationFileName(packageName)
 
-  Hook([packageName], hookOptions, (moduleExports, moduleName, moduleBaseDir, moduleVersion) => {
+  Hook([packageName], hookOptions, (moduleExports, moduleName, moduleBaseDir, moduleVersion, isIitm) => {
     moduleName = moduleName.replace(pathSepExpr, '/')
 
     // This executes the integration file thus adding its entries to `instrumentations`
@@ -77,7 +77,13 @@ for (const packageName of names) {
     }
 
     const namesAndSuccesses = {}
-    for (const { name, file, versions, hook, filePattern } of instrumentations[packageName]) {
+    for (const { name, file, versions, hook, filePattern, patchDefault } of instrumentations[packageName]) {
+      if (patchDefault === false && !moduleExports.default && isIitm) {
+        return moduleExports
+      } else if (patchDefault === true && moduleExports.default && isIitm) {
+        moduleExports = moduleExports.default
+      }
+
       let fullFilePattern = filePattern
       const fullFilename = filename(name, file)
       if (fullFilePattern) {
@@ -137,7 +143,8 @@ for (const packageName of names) {
             // picked up due to the unification. Check what modules actually use the name.
             // TODO(BridgeAR): Only replace moduleExports if the hook returns a new value.
             // This allows to reduce the instrumentation code (no return needed).
-            moduleExports = hook(moduleExports, version, name) ?? moduleExports
+
+            moduleExports = hook(moduleExports, version, name, isIitm) ?? moduleExports
             // Set the moduleExports in the hooks WeakSet
             hook[HOOK_SYMBOL].add(moduleExports)
           } catch (e) {

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

@@ -70,6 +70,7 @@ function wrapConnect (connect) {
 
 addHook({ name: names }, http2 => {
   shimmer.wrap(http2, 'connect', wrapConnect)
+  if (http2.default) http2.default.connect = http2.connect
 
   return http2
 })

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

@@ -18,7 +18,6 @@ const names = ['http2', 'node:http2']
 addHook({ name: names }, http2 => {
   shimmer.wrap(http2, 'createSecureServer', wrapCreateServer)
   shimmer.wrap(http2, 'createServer', wrapCreateServer)
-  return http2
 })
 
 function wrapCreateServer (createServer) {

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

@@ -10,7 +10,7 @@ const startCh = channel('apm:ioredis:command:start')
 const finishCh = channel('apm:ioredis:command:finish')
 const errorCh = channel('apm:ioredis:command:error')
 
-addHook({ name: 'ioredis', versions: ['>=2'] }, Redis => {
+function wrapRedis (Redis) {
   shimmer.wrap(Redis.prototype, 'sendCommand', sendCommand => function (command, stream) {
     if (!startCh.hasSubscribers) return sendCommand.apply(this, arguments)
 
@@ -35,8 +35,19 @@ addHook({ name: 'ioredis', versions: ['>=2'] }, Redis => {
     })
   })
   return Redis
+}
+
+addHook({ name: 'ioredis', versions: ['>=2 <4'], file: 'lib/redis.js' }, wrapRedis)
+
+addHook({ name: 'ioredis', versions: ['>=4 <4.11.0'], file: 'built/redis.js' }, wrapRedis)
+
+addHook({ name: 'ioredis', versions: ['>=4.11.0 <5'], file: 'built/redis/index.js' }, (exports) => {
+  wrapRedis(exports.default)
+  return exports
 })
 
+addHook({ name: 'ioredis', versions: ['>=5'] }, wrapRedis)
+
 function finish (finishCh, errorCh, ctx, error) {
   if (error) {
     ctx.error = error

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

@@ -160,15 +160,15 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       this.isImpactedTestsEnabled = this.testEnvironmentOptions._ddIsImpactedTestsEnabled
 
       if (this.isKnownTestsEnabled) {
+        earlyFlakeDetectionNumRetries = this.testEnvironmentOptions._ddEarlyFlakeDetectionNumRetries
         try {
-          const hasKnownTests = !!knownTests?.jest
-          earlyFlakeDetectionNumRetries = this.testEnvironmentOptions._ddEarlyFlakeDetectionNumRetries
-          this.knownTestsForThisSuite = hasKnownTests
-            ? (knownTests?.jest?.[this.testSuite] || [])
-            : this.getKnownTestsForSuite(this.testEnvironmentOptions._ddKnownTests)
-          log.debug(`this.knownTestsForThisSuite is an array: ${Array.isArray(this.knownTestsForThisSuite)}`)
-          log.debug(`this.knownTestsForThisSuite is null: ${this.knownTestsForThisSuite === null}`)
-          log.debug(`this.knownTestsForThisSuite is undefined: ${this.knownTestsForThisSuite === undefined}`)
+          this.knownTestsForThisSuite = this.getKnownTestsForSuite(this.testEnvironmentOptions._ddKnownTests)
+
+          if (!Array.isArray(this.knownTestsForThisSuite)) {
+            log.warn('this.knownTestsForThisSuite is not an array so new test and Early Flake detection is disabled.')
+            this.isEarlyFlakeDetectionEnabled = false
+            this.isKnownTestsEnabled = false
+          }
         } catch {
           // If there has been an error parsing the tests, we'll disable Early Flake Deteciton
           this.isEarlyFlakeDetectionEnabled = false
@@ -224,19 +224,20 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       return hasSnapshotTests
     }
 
-    // Function that receives a list of known tests for a test service and
-    // returns the ones that belong to the current suite
-    getKnownTestsForSuite (knownTests) {
-      if (this.knownTestsForThisSuite) {
-        return this.knownTestsForThisSuite
+    // This function returns an array if the known tests are valid and null otherwise.
+    getKnownTestsForSuite (suiteKnownTests) {
+      // `suiteKnownTests` is `this.testEnvironmentOptions._ddKnownTests`,
+      // which is only set if jest is configured to run in parallel.
+      if (suiteKnownTests) {
+        return suiteKnownTests
       }
-      let knownTestsForSuite = knownTests
-      // If jest is using workers, known tests are serialized to json.
-      // If jest runs in band, they are not.
-      if (typeof knownTestsForSuite === 'string') {
-        knownTestsForSuite = JSON.parse(knownTestsForSuite)
+      // Global variable `knownTests` is set only in the main process.
+      // If jest is configured to run serially, the tests run in the same process, so `knownTests` is set.
+      // The assumption is that if the key `jest` is defined in the dictionary, the response is valid.
+      if (knownTests?.jest) {
+        return knownTests.jest[this.testSuite] || []
       }
-      return knownTestsForSuite
+      return null
     }
 
     getTestManagementTestsForSuite (testManagementTests) {
@@ -472,10 +473,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           }
         }
         if (this.isKnownTestsEnabled) {
-          // Check if knownTestsForThisSuite is an array, since the worker may not have provided this information.
-          // If it's null or undefined, we can't determine if the test is new.
-          const isNew = Array.isArray(this.knownTestsForThisSuite) &&
-            !this.knownTestsForThisSuite.includes(originalTestName)
+          const isNew = !this.knownTestsForThisSuite.includes(originalTestName)
           if (isNew && !isSkipped && !retriedTestsToNumAttempts.has(originalTestName)) {
             retriedTestsToNumAttempts.set(originalTestName, 0)
             if (this.isEarlyFlakeDetectionEnabled) {
@@ -623,9 +621,17 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
 function getTestEnvironment (pkg, jestVersion) {
   if (pkg.default) {
     const wrappedTestEnvironment = getWrappedEnvironment(pkg.default, jestVersion)
-    pkg.default = wrappedTestEnvironment
-    pkg.TestEnvironment = wrappedTestEnvironment
-    return pkg
+    return new Proxy(pkg, {
+      get (target, prop) {
+        if (prop === 'default') {
+          return wrappedTestEnvironment
+        }
+        if (prop === 'TestEnvironment') {
+          return wrappedTestEnvironment
+        }
+        return target[prop]
+      }
+    })
   }
   return getWrappedEnvironment(pkg, jestVersion)
 }
@@ -657,6 +663,11 @@ addHook({
   versions: ['>=24.8.0']
 }, getTestEnvironment)
 
+addHook({
+  name: '@happy-dom/jest-environment',
+  versions: ['>=10.0.0']
+}, getTestEnvironment)
+
 function getWrappedScheduleTests (scheduleTests, frameworkVersion) {
   // `scheduleTests` is an async function
   return function (tests) {
@@ -681,8 +692,11 @@ function searchSourceWrapper (searchSourcePackage, frameworkVersion) {
 
     if (isKnownTestsEnabled) {
       const projectSuites = testPaths.tests.map(test => getTestSuitePath(test.path, test.context.config.rootDir))
-      const isFaulty =
-        getIsFaultyEarlyFlakeDetection(projectSuites, knownTests?.jest || {}, earlyFlakeDetectionFaultyThreshold)
+
+      // If the `jest` key does not exist in the known tests response, we consider the Early Flake detection faulty.
+      const isFaulty = !knownTests?.jest ||
+        getIsFaultyEarlyFlakeDetection(projectSuites, knownTests.jest, earlyFlakeDetectionFaultyThreshold)
+
       if (isFaulty) {
         log.error('Early flake detection is disabled because the number of new suites is too high.')
         isEarlyFlakeDetectionEnabled = false
@@ -1266,12 +1280,6 @@ const LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE = new Set([
   'winston'
 ])
 
-function shouldBypassJestRequireEngine (moduleName) {
-  return (
-    LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.has(moduleName)
-  )
-}
-
 addHook({
   name: 'jest-runtime',
   versions: ['>=24.8.0']
@@ -1283,6 +1291,10 @@ addHook({
     const suiteFilePath = this._testPath
 
     shimmer.wrap(result, 'mock', mock => function (moduleName) {
+      // If the library is mocked with `jest.mock`, we don't want to bypass jest's own require engine
+      if (LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.has(moduleName)) {
+        LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.delete(moduleName)
+      }
       if (suiteFilePath) {
         const existingMockedFiles = testSuiteMockedFiles.get(suiteFilePath) || []
         const suiteDir = path.dirname(suiteFilePath)
@@ -1297,7 +1309,7 @@ addHook({
 
   shimmer.wrap(Runtime.prototype, 'requireModuleOrMock', requireModuleOrMock => function (from, moduleName) {
     // TODO: do this for every library that we instrument
-    if (shouldBypassJestRequireEngine(moduleName)) {
+    if (LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.has(moduleName)) {
       // To bypass jest's own require engine
       return this._requireCoreModule(moduleName)
     }
@@ -1336,7 +1348,7 @@ function sendWrapper (send) {
     // https://github.com/jestjs/jest/blob/1d682f21c7a35da4d3ab3a1436a357b980ebd0fa/packages/jest-worker/src/workers/ChildProcessWorker.ts#L424
     if (type === CHILD_MESSAGE_CALL) {
       // This is the message that the main process sends to the worker to run a test suite (=test file).
-      // In here we modify the config.testEnvironmentOptions to include the known tests for the suite.
+      // In here we modify the `config.testEnvironmentOptions` to include the known tests for the suite.
       // This way the suite only knows about the tests that are part of it.
       const args = request.at(-1)
       if (args.length > 1) {

package/packages/datadog-instrumentations/src/limitd-client.js

@@ -13,7 +13,8 @@ function wrapRequest (original) {
 
 addHook({
   name: 'limitd-client',
-  versions: ['>=2.8']
+  versions: ['>=2.8'],
+  file: ['client.js']
 }, LimitdClient => {
   shimmer.wrap(LimitdClient.prototype, '_directRequest', wrapRequest)
   shimmer.wrap(LimitdClient.prototype, '_retriedRequest', wrapRequest)

package/packages/datadog-instrumentations/src/mocha/main.js

@@ -663,14 +663,22 @@ addHook({
     const newWorkerArgs = { ...workerArgs }
 
     if (config.isKnownTestsEnabled) {
-      const testSuiteKnownTests = config.knownTests.mocha?.[testPath] || []
-      newWorkerArgs._ddEfdNumRetries = config.earlyFlakeDetectionNumRetries
-      newWorkerArgs._ddIsEfdEnabled = config.isEarlyFlakeDetectionEnabled
-      newWorkerArgs._ddIsKnownTestsEnabled = true
-      newWorkerArgs._ddKnownTests = {
-        mocha: {
-          [testPath]: testSuiteKnownTests
+      if (config.knownTests?.mocha) {
+        const testSuiteKnownTests = config.knownTests.mocha[testPath] || []
+        newWorkerArgs._ddEfdNumRetries = config.earlyFlakeDetectionNumRetries
+        newWorkerArgs._ddIsEfdEnabled = config.isEarlyFlakeDetectionEnabled
+        newWorkerArgs._ddIsKnownTestsEnabled = true
+        newWorkerArgs._ddKnownTests = {
+          mocha: {
+            [testPath]: testSuiteKnownTests
+          }
         }
+      } else {
+        config.isEarlyFlakeDetectionEnabled = false
+        config.isKnownTestsEnabled = false
+        newWorkerArgs._ddIsKnownTestsEnabled = false
+        newWorkerArgs._ddIsEfdEnabled = false
+        newWorkerArgs._ddKnownTests = {}
       }
     }
     if (config.isTestManagementTestsEnabled) {

package/packages/datadog-instrumentations/src/mocha/utils.js

@@ -56,6 +56,9 @@ function getTestProperties (test, testManagementTests) {
 }
 
 function isNewTest (test, knownTests) {
+  if (!knownTests?.mocha) { // invalid response, so we won't consider it as new
+    return false
+  }
   const testSuite = getTestSuitePath(test.file, process.cwd())
   const testName = removeEfdStringFromTestName(test.fullTitle())
   const testsForSuite = knownTests.mocha?.[testSuite] || []

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

@@ -24,7 +24,8 @@ function wrapAddQueue (addQueue) {
 
 addHook({
   name: 'mongoose',
-  versions: ['>=4.6.4 <5', '5', '6', '>=7']
+  versions: ['>=4.6.4 <5', '5', '6', '>=7'],
+  file: 'lib/index.js'
 }, mongoose => {
   // As of Mongoose 7, custom promise libraries are no longer supported and mongoose.Promise may be undefined
   if (mongoose.Promise && mongoose.Promise !== global.Promise) {

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

@@ -20,7 +20,7 @@ function finish (ctx) {
   finishChannel.publish(ctx)
 }
 
-addHook({ name: 'oracledb', versions: ['>=5'] }, oracledb => {
+addHook({ name: 'oracledb', versions: ['>=5'], file: 'lib/oracledb.js' }, oracledb => {
   shimmer.wrap(oracledb.Connection.prototype, 'execute', execute => {
     return function wrappedExecute (dbQuery, ...args) {
       if (!startChannel.hasSubscribers) {
@@ -40,22 +40,28 @@ addHook({ name: 'oracledb', versions: ['>=5'] }, oracledb => {
         })
       }
 
-      // The connAttrs are used to pass through the argument to the potential
-      // serviceName method a user might have passed through as well as parsing
-      // the connection string in v5.
-      const connAttrs = connectionAttributes.get(this)
-
-      const details = typeof this.hostName === 'string' ? this : this._impl
-
       let hostname
       let port
       let dbInstance
 
-      if (details) {
-        dbInstance = details.serviceName
-        hostname = details.hostName ?? details.nscon?.ntAdapter?.hostName
-        port = String(details.port ?? details.nscon?.ntAdapter?.port ?? '')
-      }
+      try {
+        if (this.thin) {
+          const details = this._impl ?? this
+          // Prefer public getters when available (v6), fallback to nscon in v5.
+          dbInstance = this.serviceName ?? details.serviceName
+          hostname = this.hostName ?? details.nscon?.ntAdapter?.hostName
+          const p = this.port ?? details.nscon?.ntAdapter?.port
+          if (p != null) port = String(p)
+        } else {
+          // Avoid host/port getters in thick mode, as they may throw.
+          dbInstance = this.serviceName
+        }
+      } catch {}
+
+      // The connAttrs are used to pass through the argument to the potential
+      // serviceName method a user might have passed through as well as parsing
+      // the connection string in v5 as well as in thick mode.
+      const connAttrs = connectionAttributes.get(this)
 
       const ctx = {
         dbInstance,

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

@@ -15,17 +15,21 @@ const finishPoolQueryCh = channel('datadog:pg:pool:query:finish')
 
 const { errorMonitor } = require('node:events')
 
-addHook({ name: 'pg', versions: ['>=8.0.3'] }, pg => {
-  shimmer.wrap(pg.Client.prototype, 'query', query => wrapQuery(query))
-  shimmer.wrap(pg.Pool.prototype, 'query', query => wrapPoolQuery(query))
-  return pg
+addHook({ name: 'pg', versions: ['>=8.0.3'], file: 'lib/native/client.js' }, Client => {
+  shimmer.wrap(Client.prototype, 'query', query => wrapQuery(query))
+  return Client
 })
 
-addHook({ name: 'pg', file: 'lib/native/index.js', versions: ['>=8.0.3'] }, Client => {
+addHook({ name: 'pg', versions: ['>=8.0.3 <8.15.0', '>=8.15.0 <9'], file: 'lib/client.js' }, Client => {
   shimmer.wrap(Client.prototype, 'query', query => wrapQuery(query))
   return Client
 })
 
+addHook({ name: 'pg', versions: ['>=8.0.3'] }, pg => {
+  shimmer.wrap(pg.Pool.prototype, 'query', query => wrapPoolQuery(query))
+  return pg
+})
+
 function wrapQuery (query) {
   return function () {
     if (!startCh.hasSubscribers) {

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

@@ -73,19 +73,31 @@ function wrapPrettyFactory (prettyFactory) {
   }
 }
 
-addHook({ name: 'pino', versions: ['2 - 3', '4', '>=5 <5.14.0'] }, pino => {
+addHook({ name: 'pino', versions: ['2 - 3', '4'], patchDefault: true }, (pino) => {
   const asJsonSym = (pino.symbols && pino.symbols.asJsonSym) || 'asJson'
 
-  return shimmer.wrapFunction(pino, pino => wrapPino(asJsonSym, wrapAsJson, pino))
+  const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(asJsonSym, wrapAsJson, pino))
+
+  return wrapped
 })
 
-addHook({ name: 'pino', versions: ['>=5.14.0 <6.8.0'] }, pino => {
-  const mixinSym = pino.symbols.mixinSym
+addHook({ name: 'pino', versions: ['>=5 <5.14.0'], patchDefault: true }, (pino) => {
+  const asJsonSym = ((pino.default || pino)?.symbols.asJsonSym) || 'asJson'
+
+  const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(asJsonSym, wrapAsJson, pino))
+
+  return wrapped
+})
+
+addHook({ name: 'pino', versions: ['>=5.14.0 <6.8.0'] }, (pino) => {
+  const mixinSym = (pino.default || pino).symbols.mixinSym
 
-  return shimmer.wrapFunction(pino, pino => wrapPino(mixinSym, wrapMixin, pino))
+  const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(mixinSym, wrapMixin, pino.default || pino))
+
+  return wrapped
 })
 
-addHook({ name: 'pino', versions: ['>=6.8.0'] }, pino => {
+addHook({ name: 'pino', versions: ['>=6.8.0'], patchDefault: false }, (pino, _1, _2, isIitm) => {
   const mixinSym = pino.symbols.mixinSym
 
   const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(mixinSym, wrapMixin, pino))

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

@@ -51,6 +51,7 @@ let remainingTestsByFile = {}
 let isKnownTestsEnabled = false
 let isEarlyFlakeDetectionEnabled = false
 let earlyFlakeDetectionNumRetries = 0
+let isEarlyFlakeDetectionFaulty = false
 let isFlakyTestRetriesEnabled = false
 let flakyTestRetriesCount = 0
 let knownTests = {}
@@ -64,6 +65,10 @@ let quarantinedButNotAttemptToFixFqns = new Set()
 let rootDir = ''
 const MINIMUM_SUPPORTED_VERSION_RANGE_EFD = '>=1.38.0' // TODO: remove this once we drop support for v5
 
+function isValidKnownTests (receivedKnownTests) {
+  return !!receivedKnownTests.playwright
+}
+
 function getTestFullyQualifiedName (test) {
   const fullname = getTestFullname(test)
   return `${test._requireFile} ${fullname}`
@@ -79,8 +84,11 @@ function getTestProperties (test) {
 }
 
 function isNewTest (test) {
+  if (!isValidKnownTests(knownTests)) {
+    return false
+  }
   const testSuite = getTestSuitePath(test._requireFile, rootDir)
-  const testsForSuite = knownTests?.playwright?.[testSuite] || []
+  const testsForSuite = knownTests.playwright[testSuite] || []
 
   return !testsForSuite.includes(getTestFullname(test))
 }
@@ -557,6 +565,11 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
         } else {
           knownTests = receivedKnownTests
         }
+        if (!isValidKnownTests(receivedKnownTests)) {
+          isEarlyFlakeDetectionFaulty = true
+          isEarlyFlakeDetectionEnabled = false
+          isKnownTestsEnabled = false
+        }
       } catch (err) {
         isEarlyFlakeDetectionEnabled = false
         isKnownTestsEnabled = false
@@ -652,6 +665,7 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
     testSessionFinishCh.publish({
       status: STATUS_TO_TEST_STATUS[sessionStatus],
       isEarlyFlakeDetectionEnabled,
+      isEarlyFlakeDetectionFaulty,
       isTestManagementTestsEnabled,
       onDone
     })

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

@@ -7,7 +7,7 @@ const {
 
 const shimmer = require('../../datadog-shimmer')
 
-addHook({ name: 'sequelize', versions: ['>=4'] }, Sequelize => {
+addHook({ name: 'sequelize', versions: ['>=4'], file: ['lib/sequelize.js'] }, Sequelize => {
   const startCh = channel('datadog:sequelize:query:start')
   const finishCh = channel('datadog:sequelize:query:finish')