dd-trace 6.16.0 → 6.18.0

package/packages/datadog-instrumentations/src/helpers/graphql-jit-runtime.js

@@ -214,7 +214,6 @@ function createGraphqlJitRuntime ({
    * @param {string} resolverCall
    * @param {string} resolverName
    * @param {number | undefined} descriptorId
-   * @returns {string}
    */
   function compileResolverCall (context, resolverCall, resolverName, descriptorId) {
     const openParenthesis = resolverCall.indexOf('(')
@@ -254,7 +253,6 @@ function createGraphqlJitRuntime ({
    * @param {CompiledArguments} args
    * @param {string} argumentSource
    * @param {string} compiledField
-   * @returns {string}
    */
   function compileDefaultField (
     context,
@@ -377,7 +375,6 @@ function createDescriptor (context, compilerPath, input, fieldNode, createFieldM
  * @param {JitFieldDescriptor} descriptor
  * @param {CompiledArguments['missing']} missing
  * @param {string} argumentSource
- * @returns {string}
  */
 function compileArgumentFactory (context, descriptor, missing, argumentSource) {
   if (missing.length === 0 && argumentSource === '{}') return 'undefined'
@@ -418,7 +415,6 @@ function compileArgumentFactory (context, descriptor, missing, argumentSource) {
 
 /**
  * @param {ArgumentPath} path
- * @returns {string}
  */
 function compileArgumentPath (path) {
   let source = 'args'
@@ -430,7 +426,6 @@ function compileArgumentPath (path) {
 
 /**
  * @param {string} value
- * @returns {string}
  */
 function quoteString (value) {
   const json = JSON.stringify(value)

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

@@ -2,6 +2,12 @@
 
 module.exports = {
   // Only list unprefixed node modules. They will automatically be instrumented as prefixed and unprefixed.
+  '@supabase/auth-js': { esmFirst: true, fn: () => require('../supabase') },
+  '@supabase/functions-js': { esmFirst: true, fn: () => require('../supabase') },
+  '@supabase/postgrest-js': { esmFirst: true, fn: () => require('../supabase') },
+  '@supabase/realtime-js': { esmFirst: true, fn: () => require('../supabase') },
+  '@supabase/storage-js': { esmFirst: true, fn: () => require('../supabase') },
+  '@supabase/supabase-js': { esmFirst: true, fn: () => require('../supabase') },
   child_process: () => require('../child_process'),
   crypto: () => require('../crypto'),
   dns: () => require('../dns'),
@@ -19,14 +25,12 @@ module.exports = {
   '@anthropic-ai/sdk': { esmFirst: true, fn: () => require('../anthropic') },
   '@apollo/server': () => require('../apollo-server'),
   '@apollo/gateway': () => require('../apollo'),
-  '@langchain/langgraph': { esmFirst: true, fn: () => require('../langgraph') },
   '@modelcontextprotocol/sdk': { esmFirst: true, fn: () => require('../modelcontextprotocol-sdk') },
   '@openai/agents': () => require('../openai-agents'),
   '@openai/agents-openai': () => require('../openai-agents'),
   'apollo-server-core': () => require('../apollo-server-core'),
   '@aws-sdk/smithy-client': () => require('../aws-sdk'),
   '@aws/durable-execution-sdk-js': () => require('../aws-durable-execution-sdk-js'),
-  '@azure/cosmos': { esmFirst: true, fn: () => require('../azure-cosmos') },
   '@azure/event-hubs': () => require('../azure-event-hubs'),
   '@azure/functions': () => require('../azure-functions'),
   'durable-functions': () => require('../azure-durable-functions'),
@@ -42,12 +46,12 @@ module.exports = {
   '@grpc/grpc-js': () => require('../grpc'),
   '@hapi/hapi': () => require('../hapi'),
   '@happy-dom/jest-environment': () => require('../jest'),
+  '@jest/console': () => require('../jest'),
   '@jest/core': () => require('../jest'),
   '@jest/reporters': () => require('../jest'),
   '@jest/test-sequencer': () => require('../jest'),
   '@jest/transform': () => require('../jest'),
   '@koa/router': () => require('../koa'),
-  '@langchain/core': { esmFirst: true, fn: () => require('../langchain') },
   '@node-redis/client': () => require('../redis'),
   '@opensearch-project/opensearch': () => require('../opensearch'),
   '@opentelemetry/sdk-trace': () => require('../otel-sdk-trace'),
@@ -71,7 +75,6 @@ module.exports = {
   bluebird: () => require('../bluebird'),
   'body-parser': () => require('../body-parser'),
   'browser-bunyan': () => require('../browser-bunyan'),
-  bullmq: () => require('../bullmq'),
   bunyan: () => require('../bunyan'),
   'cassandra-driver': () => require('../cassandra-driver'),
   connect: () => require('../connect'),
@@ -107,14 +110,12 @@ module.exports = {
   'koa-router': () => require('../koa'),
   '@confluentinc/kafka-javascript': () => require('../confluentinc-kafka-javascript'),
   kafkajs: () => require('../kafkajs'),
-  langchain: () => require('../langchain'),
   ldapjs: () => require('../ldapjs'),
   'light-my-request': () => require('../light-my-request'),
   'limitd-client': () => require('../limitd-client'),
   lodash: () => require('../lodash'),
   mariadb: { esmFirst: true, fn: () => require('../mariadb') },
   memcached: () => require('../memcached'),
-  mercurius: () => require('../mercurius'),
   'microgateway-core': () => require('../microgateway-core'),
   mocha: () => require('../mocha'),
   'mocha-each': () => require('../mocha'),
@@ -141,6 +142,7 @@ module.exports = {
   'pino-pretty': () => require('../pino'),
   playwright: () => require('../playwright'),
   'playwright-core': () => require('../playwright'),
+  postgres: { esmFirst: true, fn: () => require('../postgres') },
   'promise-js': () => require('../promise-js'),
   promise: () => require('../promise'),
   protobufjs: () => require('../protobufjs'),

package/packages/datadog-instrumentations/src/helpers/instrumentation-utils.js

@@ -9,7 +9,6 @@ const { isRelativeRequire } = require('./shared-utils')
 /**
  * @param {string|undefined} version
  * @param {string[]|undefined} ranges
- * @returns {boolean}
  */
 function matchVersion (version, ranges) {
   return !version || !ranges || ranges.some(range => satisfies(version, range))
@@ -18,7 +17,6 @@ function matchVersion (version, ranges) {
 /**
  * @param {string} name
  * @param {string} [file]
- * @returns {string}
  */
 function filename (name, file) {
   return file ? `${name}/${file}` : name
@@ -29,7 +27,6 @@ function filename (name, file) {
  * @param {string|undefined} version
  * @param {string} moduleName
  * @param {{ file?: string, filePattern?: string, versions?: string[] }} instrumentation
- * @returns {boolean}
  */
 function matchesInstrumentation (name, version, moduleName, instrumentation) {
   const { file, filePattern, versions } = instrumentation

package/packages/datadog-instrumentations/src/helpers/pool-acquire.js

@@ -400,9 +400,6 @@ function getConnectionForAcquire (getConnection, pool, args, acquireCtx, start,
   }
 }
 
-/**
- * @returns {boolean}
- */
 function isPoolQueryAcquire () {
   return currentPoolQueryAcquire !== undefined
 }
@@ -436,7 +433,6 @@ function runWithPoolQueryAcquire (acquire, method, receiver, args) {
 
 /**
  * @param {object} pool
- * @returns {boolean}
  */
 function takeDeferredPoolQueryAcquire (pool) {
   const acquire = deferredPoolQueryAcquireStorage?.getStore()
@@ -579,7 +575,6 @@ function setPoolAcquireCaptureWaitTime (capture, waitTime) {
  * @param {Record<string, unknown>} receiver
  * @param {string} acquireMethod
  * @param {unknown[]} args
- * @returns {boolean}
  */
 function dispatchesAcquireSynchronously (method, receiver, acquireMethod, args) {
   let dispatched = false
@@ -618,7 +613,6 @@ function acquireStart (pool, acquire) {
 
 /**
  * @param {number|undefined} start
- * @returns {number}
  */
 function acquireWait (start) {
   return start === undefined ? 0 : performance.now() - start

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

@@ -25,6 +25,7 @@ const pathSepExpr = new RegExp(`\\${path.sep}`, 'g')
 const disabledInstrumentations = getDisabledInstrumentations()
 
 const loadChannel = channel('dd-trace:instrumentation:load')
+const orchestrionLoadChannel = channel('dd-trace:instrumentation:load:orchestrion')
 
 // Globals
 if (!disabledInstrumentations.has('fetch')) {
@@ -35,6 +36,10 @@ if (!disabledInstrumentations.has('process')) {
   require('../process')
 }
 
+if (!disabledInstrumentations.has('console')) {
+  require('../console')
+}
+
 const debugEnabled = DD_TRACE_DEBUG
 checkRequireCache.checkForRequiredModules()
 if (debugEnabled) {
@@ -51,6 +56,25 @@ const instrumentedNodeModules = new Map()
 const instrumentedIntegrationsSuccess = new Map()
 /** @type {Set<string>} */
 const alreadyLoggedIncompatibleIntegrations = new Set()
+/** @type {Set<string>} */
+const compatibleOrchestrionTargets = new Set()
+
+orchestrionLoadChannel.subscribe(({ moduleName, version, result }) => {
+  const nameVersion = `${moduleName}@${version}`
+
+  if (result === 'unsupported') {
+    if (!compatibleOrchestrionTargets.has(nameVersion) && !instrumentedIntegrationsSuccess.has(nameVersion)) {
+      instrumentedIntegrationsSuccess.set(nameVersion, false)
+    }
+    return
+  }
+
+  if (result === 'matched' || result === 'rewritten') {
+    compatibleOrchestrionTargets.add(nameVersion)
+    instrumentedIntegrationsSuccess.set(nameVersion, true)
+    if (result === 'rewritten') loadChannel.publish({ name: moduleName })
+  }
+})
 
 for (const name of names) {
   if (disabledInstrumentations.has(name)) continue

package/packages/datadog-instrumentations/src/helpers/rewriter/index.js

@@ -2,9 +2,10 @@
 
 const { readFileSync } = require('node:fs')
 const { join } = require('node:path')
-const { pathToFileURL } = require('node:url')
+const { fileURLToPath, pathToFileURL } = require('node:url')
 
 const log = require('../../../../dd-trace/src/log')
+const { getDisabledInstrumentations } = require('../instrumentation-utils')
 const instrumentations = require('./instrumentations')
 const { getRewriteTarget } = require('./targets')
 
@@ -18,7 +19,7 @@ const { getRewriteTarget } = require('./targets')
  *   { code: string, map?: string|object }} transform
  *
  * @typedef {(content: string|Buffer|ArrayBuffer|Uint8Array, filename: string, format?: string,
- *   target?: { moduleName: string, filePath: string }, sourceMap?: string|object) =>
+ *   target?: { moduleName: string, filePath: string, activate?: boolean }, sourceMap?: string|object) =>
  *   { code: string|Buffer|ArrayBuffer|Uint8Array, map?: string|object }} BundlerRewriter
  */
 
@@ -26,7 +27,8 @@ const { getRewriteTarget } = require('./targets')
  * @type {Record<string, string>} map of module base name to version
  */
 const moduleVersions = {}
-const disabled = new Set()
+// Asynchronous loader workers have their own module graph and cannot receive disable() calls made on the main thread.
+const disabled = getDisabledInstrumentations()
 
 // Matchers are built on the first module that actually needs rewriting. The
 // vendored transformer is a quarter megabyte of bundle that an application
@@ -42,40 +44,76 @@ let matcherEsm
 // eslint-disable-next-line unicorn/no-useless-concat -- Keep the source-map marker non-contiguous.
 const SOURCE_MAP_PREFIX = '//# sourceMapping' + 'URL=data:application/json;base64,'
 
+/**
+ * Loader hooks hand `file://` URLs to the rewriter while CommonJS and bundler
+ * callers pass plain paths. `fileURLToPath` is the only correct conversion: a
+ * plain scheme strip leaves Windows paths rooted at `/C:/` and keeps
+ * percent-encoded characters undecoded, which breaks version resolution.
+ * Rewrite-target paths use forward slashes, including on Windows.
+ *
+ * @param {string} filename
+ */
+function normalizeFilename (filename) {
+  const path = filename.startsWith('file://') ? fileURLToPath(filename) : filename
+  return path.replaceAll('\\', '/')
+}
+
 /**
  * @param {string|Buffer|ArrayBuffer|Uint8Array} content
  * @param {string} filename
  * @param {string} [format]
- * @param {{ moduleName: string, filePath: string }} [target]
+ * @param {{ moduleName: string, filePath: string, activate?: boolean }} [target]
  * @returns {string|Buffer|ArrayBuffer|Uint8Array}
  */
 function rewrite (content, filename, format, target) {
   if (!content) return content
 
-  target ||= getRewriteTarget(filename)
-  if (!target) return content
-
-  filename = filename.replace('file://', '')
+  try {
+    filename = normalizeFilename(filename)
+    target ||= getRewriteTarget(filename)
+    if (!target) return content
 
-  const moduleType = format === 'module' ? 'esm' : 'cjs'
-  const { moduleName, filePath } = target
-  const version = getVersion(filename, filePath)
+    const moduleType = format === 'module' ? 'esm' : 'cjs'
+    const { moduleName, filePath, activate } = target
+    if (disabled.has(moduleName)) return content
 
-  if (disabled.has(moduleName)) return content
+    const version = getVersion(filename, filePath)
+    if (!version) return content
 
-  const transformer = getMatcher(moduleType).getTransformer(moduleName, version, filePath)
+    const transformer = getMatcher(moduleType).getTransformer(moduleName, version, filePath)
 
-  if (!transformer) return content
+    if (!transformer && !activate) return content
 
-  try {
     const source = getSourceText(content)
 
+    if (!transformer) {
+      return appendOrchestrionLoad(
+        source,
+        { moduleName, version, result: 'unsupported' },
+        moduleType
+      )
+    }
+
     // TODO: pass existing sourcemap as input for remapping
-    const { code, map } = transformer.transform(source, moduleType)
+    let { code, map } = transformer.transform(source, moduleType)
+
+    if (source.startsWith('#!') && !code.startsWith('#!')) {
+      // A shebang must be the entire first line, and JavaScript recognizes
+      // exactly four line terminators: \n, \r, \u2028 (line separator), and
+      // \u2029 (paragraph separator). Any of the four can end the shebang line.
+      const shebangEnd = source.search(/[\r\n\u2028\u2029]/)
+      code = (shebangEnd === -1 ? source : source.slice(0, shebangEnd)) + '\n' + code
+      map = shiftSourceMapLine(map)
+    }
+
+    if (activate) {
+      const result = code === source ? 'matched' : 'rewritten'
+      code = appendOrchestrionLoad(code, { moduleName, version, result }, moduleType)
+    }
 
     if (!map) return code
 
-    const inlineMap = Buffer.from(map).toString('base64')
+    const inlineMap = Buffer.from(typeof map === 'string' ? map : JSON.stringify(map)).toString('base64')
 
     return code + '\n' + SOURCE_MAP_PREFIX + inlineMap
   } catch (e) {
@@ -95,16 +133,19 @@ function createBundlerRewriter (dcModule) {
   return function rewriteBundled (content, filename, format, target, sourceMap) {
     if (!content) return { code: content, map: sourceMap }
 
-    target ||= getRewriteTarget(filename)
-    if (!target) return { code: content, map: sourceMap }
+    try {
+      filename = normalizeFilename(filename)
+      target ||= getRewriteTarget(filename)
+      if (!target) return { code: content, map: sourceMap }
 
-    filename = filename.replace('file://', '')
-    const moduleType = format === 'module' ? 'esm' : 'cjs'
-    const { moduleName, filePath } = target
-    const transformer = matcher.getTransformer(moduleName, getVersion(filename, filePath), filePath)
-    if (!transformer) return { code: content, map: sourceMap }
+      const moduleType = format === 'module' ? 'esm' : 'cjs'
+      const { moduleName, filePath } = target
+      const version = getVersion(filename, filePath)
+      if (!version) return { code: content, map: sourceMap }
+
+      const transformer = matcher.getTransformer(moduleName, version, filePath)
+      if (!transformer) return { code: content, map: sourceMap }
 
-    try {
       return transformer.transform(getSourceText(content), moduleType, sourceMap)
     } catch (error) {
       log.error(error)
@@ -146,6 +187,11 @@ function createMatcher (dcModule) {
     publishDurableOrchestrationFailure,
     waitForAsyncEnd,
   } = require('./transforms')
+  const {
+    postgresQueryHandlers,
+    postgresQueryLifecycle,
+    postgresQueryPreparation,
+  } = require('./transforms/postgres')
 
   const matcher = create(instrumentations, dcModule)
 
@@ -158,6 +204,9 @@ function createMatcher (dcModule) {
   matcher.addTransform('configureGraphqlJitRuntime', configureGraphqlJitRuntime)
   matcher.addTransform('configureMercuriusRequest', configureMercuriusRequest)
   matcher.addTransform('publishDurableOrchestrationFailure', publishDurableOrchestrationFailure)
+  matcher.addTransform('postgresQueryHandlers', postgresQueryHandlers)
+  matcher.addTransform('postgresQueryLifecycle', postgresQueryLifecycle)
+  matcher.addTransform('postgresQueryPreparation', postgresQueryPreparation)
 
   return matcher
 }
@@ -191,7 +240,6 @@ function getDcPolyfillSpecifier (moduleType) {
  * Convert the source representations accepted by Node.js loader hooks to text.
  *
  * @param {string | ArrayBuffer | BufferView} source
- * @returns {string}
  */
 function getSourceText (source) {
   if (typeof source === 'string') return source
@@ -201,6 +249,43 @@ function getSourceText (source) {
   return Buffer.from(source).toString('utf8')
 }
 
+/**
+ * Publish target-level compatibility on the application thread when a pure target is evaluated.
+ *
+ * @param {string} source
+ * @param {{ moduleName: string, version: string,
+ *   result: 'unsupported'|'matched'|'rewritten' }} payload
+ * @param {'cjs'|'esm'} moduleType
+ */
+function appendOrchestrionLoad (source, payload, moduleType) {
+  const dcModule = JSON.stringify(getDcPolyfillSpecifier(moduleType) ?? 'diagnostics_channel')
+  const message = JSON.stringify(payload)
+
+  if (moduleType === 'esm') {
+    let binding = 'ddTraceOrchestrionDc'
+    let suffix = 0
+    while (source.includes(binding)) binding = `ddTraceOrchestrionDc${++suffix}`
+
+    return `${source};import ${binding} from ${dcModule};` +
+      `${binding}.channel('dd-trace:instrumentation:load:orchestrion').publish(${message});`
+  }
+
+  return `${source};require(${dcModule}).channel('dd-trace:instrumentation:load:orchestrion').publish(${message});`
+}
+
+/**
+ * Account for a shebang restored ahead of the generated program. The transformer already maps original positions
+ * past the input shebang, so only the generated side needs an additional empty line.
+ *
+ * @param {string|object|undefined} map
+ */
+function shiftSourceMapLine (map) {
+  if (!map) return map
+  const sourceMap = typeof map === 'string' ? JSON.parse(map) : map
+  const shifted = { ...sourceMap, mappings: `;${sourceMap.mappings}` }
+  return typeof map === 'string' ? JSON.stringify(shifted) : shifted
+}
+
 function disable (instrumentation) {
   disabled.add(instrumentation)
 }

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentation-registry.js

@@ -0,0 +1,41 @@
+'use strict'
+
+// Activated rewrites publish their module name to the plugin manager after evaluation.
+// Only pure Orchestrion integrations that need this activation set activate: true.
+// Other entries use hooks or another activation path, or do not need activation from a rewrite.
+const registry = [
+  { instrumentations: require('./instrumentations/ai') },
+  { activate: true, instrumentations: require('./instrumentations/azure-cosmos') },
+  { instrumentations: require('./instrumentations/azure-durable-functions') },
+  { activate: true, instrumentations: require('./instrumentations/bullmq') },
+  { instrumentations: require('./instrumentations/claude-agent-sdk') },
+  { instrumentations: require('./instrumentations/graphql') },
+  { instrumentations: require('./instrumentations/graphql-jit') },
+  { activate: true, instrumentations: require('./instrumentations/langchain') },
+  { activate: true, instrumentations: require('./instrumentations/langgraph') },
+  { activate: true, instrumentations: require('./instrumentations/mercurius') },
+  { instrumentations: require('./instrumentations/modelcontextprotocol-sdk') },
+  { instrumentations: require('./instrumentations/openai-agents') },
+  { instrumentations: require('./instrumentations/playwright') },
+  { instrumentations: require('./instrumentations/postgres') },
+  { instrumentations: require('./instrumentations/webdriverio') },
+  { instrumentations: require('./instrumentations/aws-durable-execution-sdk-js') },
+  { instrumentations: require('./instrumentations/supabase') },
+]
+
+const activatedModules = new Set()
+for (const { activate, instrumentations } of registry) {
+  if (!activate) continue
+  for (const { module } of instrumentations) activatedModules.add(module.name)
+}
+
+const instrumentations = registry.flatMap(entry => entry.instrumentations)
+
+/**
+ * @param {string} moduleName
+ */
+function isRewriteActivationEnabled (moduleName) {
+  return activatedModules.has(moduleName)
+}
+
+module.exports = { isRewriteActivationEnabled, instrumentations, registry }

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/index.js

@@ -1,19 +1,5 @@
 'use strict'
 
-module.exports = [
-  ...require('./ai'),
-  ...require('./azure-cosmos'),
-  ...require('./azure-durable-functions'),
-  ...require('./bullmq'),
-  ...require('./claude-agent-sdk'),
-  ...require('./graphql'),
-  ...require('./graphql-jit'),
-  ...require('./langchain'),
-  ...require('./langgraph'),
-  ...require('./mercurius'),
-  ...require('./modelcontextprotocol-sdk'),
-  ...require('./openai-agents'),
-  ...require('./playwright'),
-  ...require('./webdriverio'),
-  ...require('./aws-durable-execution-sdk-js'),
-]
+const { instrumentations } = require('../instrumentation-registry')
+
+module.exports = instrumentations

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

@@ -3,6 +3,49 @@
 // Playwright keeps several hook targets in private local classes/functions.
 // Keep these rewrites limited to bundled internals that addHook cannot wrap.
 module.exports = [
+  {
+    module: {
+      name: '@playwright/test',
+      versionRange: '>=1.18.0 <1.38.0',
+      filePath: 'lib/reporters/multiplexer.js',
+    },
+    functionQuery: {
+      className: 'Multiplexer',
+      methodName: 'onError',
+      kind: 'Sync',
+    },
+    channelName: 'Multiplexer_onError',
+  },
+  {
+    module: {
+      name: 'playwright',
+      versionRange: '>=1.44.0 <1.60.0',
+      filePath: 'lib/runner/runner.js',
+    },
+    astQuery: 'FunctionDeclaration[id.name="writeLastRunInfo"] ' +
+      'CallExpression[callee.property.name="map"] > ArrowFunctionExpression',
+    channelName: 'lastRunTestId',
+  },
+  {
+    module: {
+      name: 'playwright',
+      versionRange: '>=1.44.0 <1.60.0',
+      filePath: 'lib/runner/lastRun.js',
+    },
+    astQuery: 'ClassDeclaration[id.name="LastRunReporter"] ' +
+      'CallExpression[callee.property.name="map"] > ArrowFunctionExpression',
+    channelName: 'lastRunTestId',
+  },
+  {
+    module: {
+      name: 'playwright',
+      versionRange: '>=1.60.0',
+      filePath: 'lib/runner/index.js',
+    },
+    astQuery: 'VariableDeclarator[id.name="LastRunReporter"] ' +
+      'CallExpression[callee.property.name="map"] > ArrowFunctionExpression',
+    channelName: 'lastRunTestId',
+  },
   {
     module: {
       name: 'playwright',
@@ -93,6 +136,18 @@ module.exports = [
     },
     channelName: 'createRootSuite',
   },
+  {
+    module: {
+      name: 'playwright',
+      versionRange: '>=1.60.0',
+      filePath: 'lib/runner/index.js',
+    },
+    functionQuery: {
+      functionName: 'filterForShard',
+      kind: 'Sync',
+    },
+    channelName: 'filterForShard',
+  },
   {
     module: {
       name: 'playwright-core',

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/postgres.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const handlers = ['src/index.js', 'cjs/src/index.js'].map(filePath => ({
+  module: {
+    name: 'postgres',
+    versionRange: '>=3.0.0',
+    filePath,
+  },
+  astQuery: 'Program',
+  transform: 'postgresQueryHandlers',
+  channelName: 'query',
+}))
+
+const preparations = ['src/connection.js', 'cjs/src/connection.js'].map(filePath => ({
+  module: {
+    name: 'postgres',
+    versionRange: '>=3.0.0',
+    filePath,
+  },
+  astQuery: 'Program',
+  transform: 'postgresQueryPreparation',
+  channelName: 'query:prepare',
+}))
+
+const lifecycles = ['src/query.js', 'cjs/src/query.js'].map(filePath => ({
+  module: {
+    name: 'postgres',
+    versionRange: '>=3.0.0',
+    filePath,
+  },
+  astQuery: 'Program',
+  transform: 'postgresQueryLifecycle',
+  channelName: 'query',
+}))
+
+module.exports = [...handlers, ...preparations, ...lifecycles]