dd-trace 6.15.0 → 6.17.0

package/packages/datadog-turbopack/index.js

@@ -0,0 +1,206 @@
+'use strict'
+
+const fs = require('node:fs')
+const Module = require('node:module')
+const path = require('node:path')
+
+const satisfies = require('../../vendor/dist/semifies')
+const hooks = require('../datadog-instrumentations/src/helpers/hooks')
+const { SYNTHETIC_EXTENSION } = require('./src/constants')
+
+const BUILTIN_MODULES = new Set(Module.builtinModules)
+const loader = path.join(__dirname, 'src/loader.js')
+const EXTENSIONLESS_PATH_PATTERN = /(?:^|\/)[^/.]+$/
+const PHASE_PRODUCTION_SERVER = 'phase-production-server'
+const SOURCE_EXTENSIONS = ['*.js', '*.cjs', '*.mjs', '*.jsx', '*.ts', '*.cts', '*.mts', '*.tsx']
+const SOURCE_PATH_PATTERN = /\.(?:cjs|cts|js|jsx|mjs|mts|ts|tsx)$/
+const PACKAGE_PATH_PATTERN = createPackagePathPattern()
+
+/**
+ * Adds Datadog instrumentation to a Next.js Turbopack configuration.
+ *
+ * @param {object|Promise<object>|Function} [nextConfig]
+ * @returns {Function}
+ */
+function withDatadogTurbopack (nextConfig = {}) {
+  const nextMajor = getNextMajor()
+
+  return function datadogNextConfig (...args) {
+    const config = typeof nextConfig === 'function'
+      ? nextConfig.apply(this, args)
+      : nextConfig
+    if (config && typeof config.then === 'function') {
+      return config.then(config => configureTurbopack(config, args[0], nextMajor))
+    }
+    return configureTurbopack(config, args[0], nextMajor)
+  }
+}
+
+/**
+ * @param {object|undefined} config
+ * @param {unknown} phase
+ * @param {number} nextMajor
+ * @returns {object}
+ */
+function configureTurbopack (config, phase, nextMajor) {
+  const normalized = normalizeConfig(config)
+  if (phase === PHASE_PRODUCTION_SERVER || hasDatadogLoader(normalized.turbopack?.rules)) return normalized
+
+  const turbopack = normalized.turbopack ?? {}
+  const configured = nextMajor === 15 ? addLegacyRule(turbopack) : addModernRules(turbopack)
+  return { ...normalized, turbopack: configured }
+}
+
+/**
+ * @param {object|undefined} config
+ * @returns {object}
+ */
+function normalizeConfig (config) {
+  if (config === undefined) return {}
+  if (!isObject(config)) {
+    throw new TypeError('withDatadogTurbopack expects a Next.js configuration object, promise, or function')
+  }
+  if (config.turbopack !== undefined && !isObject(config.turbopack)) {
+    throw new TypeError('nextConfig.turbopack must be an object')
+  }
+  if (config.turbopack?.rules !== undefined && !isObject(config.turbopack.rules)) {
+    throw new TypeError('nextConfig.turbopack.rules must be an object')
+  }
+  if (config.turbopack?.conditions !== undefined && !isObject(config.turbopack.conditions)) {
+    throw new TypeError('nextConfig.turbopack.conditions must be an object')
+  }
+  return config
+}
+
+/**
+ * @param {unknown} value
+ */
+function isObject (value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+}
+
+/**
+ * @param {object} turbopack
+ * @returns {object}
+ */
+function addModernRules (turbopack) {
+  const rules = { ...turbopack.rules }
+  for (const extension of SOURCE_EXTENSIONS) {
+    appendRule(rules, extension, {
+      condition: { all: ['node', 'foreign', { path: PACKAGE_PATH_PATTERN }] },
+      loaders: [createLoader()],
+    })
+  }
+  appendRule(rules, '*', {
+    as: `*${SYNTHETIC_EXTENSION}`,
+    condition: {
+      all: ['node', 'foreign', { path: PACKAGE_PATH_PATTERN }, { path: EXTENSIONLESS_PATH_PATTERN }],
+    },
+    loaders: [createLoader()],
+  })
+  return { ...turbopack, rules }
+}
+
+/**
+ * @param {Record<string, object|object[]>} rules
+ * @param {string} extension
+ * @param {object} rule
+ */
+function appendRule (rules, extension, rule) {
+  const existing = rules[extension]
+  if (existing === undefined) {
+    rules[extension] = rule
+  } else {
+    rules[extension] = Array.isArray(existing) ? [...existing, rule] : [existing, rule]
+  }
+}
+
+/**
+ * @param {object} turbopack
+ * @returns {object}
+ */
+function addLegacyRule (turbopack) {
+  const name = '#dd-trace/modules'
+  const conditions = { ...turbopack.conditions }
+  const rules = { ...turbopack.rules }
+  if (Object.hasOwn(conditions, name) || Object.hasOwn(rules, name)) {
+    throw new Error(`Next.js Turbopack configuration already uses the reserved condition ${name}`)
+  }
+  conditions[name] = {
+    all: [
+      { path: PACKAGE_PATH_PATTERN },
+      { any: [{ path: SOURCE_PATH_PATTERN }, { path: EXTENSIONLESS_PATH_PATTERN }] },
+    ],
+  }
+  rules[name] = { node: { foreign: { loaders: [createLoader()] } } }
+  return { ...turbopack, conditions, rules }
+}
+
+/**
+ * @returns {{ loader: string, options: object }}
+ */
+function createLoader () {
+  return { loader, options: {} }
+}
+
+/**
+ * @param {unknown} value
+ */
+function hasDatadogLoader (value) {
+  if (Array.isArray(value)) return value.some(hasDatadogLoader)
+  if (!value || typeof value !== 'object') return false
+  if (/** @type {{ loader?: unknown }} */ (value).loader === loader) return true
+  return Object.values(value).some(hasDatadogLoader)
+}
+
+/**
+ * @returns {RegExp}
+ */
+function createPackagePathPattern () {
+  const names = []
+  for (const name of Object.keys(hooks)) {
+    if (!name.startsWith('.') && !BUILTIN_MODULES.has(name)) names.push(escapeRegExp(name))
+  }
+  names.sort()
+  return new RegExp(`(?:^|/)(?:${names.join('|')})(?:/|$)`)
+}
+
+/**
+ * @param {string} value
+ */
+function escapeRegExp (value) {
+  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)
+}
+
+function getNextMajor () {
+  const entrypoints = []
+  if (require.main?.filename) entrypoints.push(require.main.filename)
+  entrypoints.push(path.join(process.cwd(), 'package.json'))
+
+  let version
+  let resolutionError
+  for (const entrypoint of entrypoints) {
+    try {
+      const appRequire = Module.createRequire(entrypoint)
+      version = JSON.parse(fs.readFileSync(appRequire.resolve('next/package.json'), 'utf8')).version
+      break
+    } catch (error) {
+      resolutionError = error
+    }
+  }
+  if (!version) {
+    throw new Error('withDatadogTurbopack could not resolve the active Next.js installation', {
+      cause: resolutionError,
+    })
+  }
+
+  if (!satisfies(version, '>=0')) {
+    throw new Error(`withDatadogTurbopack could not parse Next.js version ${version}`)
+  }
+  if (!satisfies(version, '>=15.5.0')) {
+    throw new RangeError(`withDatadogTurbopack requires Next.js 15.5 or newer; found ${version}`)
+  }
+  return Number.parseInt(version, 10)
+}
+
+module.exports = { withDatadogTurbopack }

package/packages/datadog-turbopack/src/constants.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const SYNTHETIC_EXTENSION = '.__dd_trace_turbopack.js'
+
+module.exports = { SYNTHETIC_EXTENSION }

package/packages/datadog-turbopack/src/loader.js

@@ -0,0 +1,484 @@
+'use strict'
+
+const fs = require('node:fs')
+const Module = require('node:module')
+const path = require('node:path')
+
+const extractPackageAndModulePath = require(
+  '../../datadog-instrumentations/src/helpers/extract-package-and-module-path'
+)
+const hooks = require('../../datadog-instrumentations/src/helpers/hooks')
+const instrumentations = require('../../datadog-instrumentations/src/helpers/instrumentations')
+const { filename, matchesInstrumentation } = require('../../datadog-instrumentations/src/helpers/instrumentation-utils')
+const { createBundlerRewriter } = require('../../datadog-instrumentations/src/helpers/rewriter')
+const { getRewriteTarget } = require('../../datadog-instrumentations/src/helpers/rewriter/targets')
+const { isESMFile } = require('../../datadog-esbuild/src/utils')
+const { SYNTHETIC_EXTENSION } = require('./constants')
+
+const CHANNEL = 'dd-trace:bundler:load'
+const ARGUMENTS_BINDING = 1
+const MODULE_BINDING = 2
+const REQUIRE_BINDING = 4
+const COMMONJS_BINDINGS = MODULE_BINDING | REQUIRE_BINDING
+const targetPackages = new Set(Object.keys(hooks))
+const entrypoints = new Map()
+const loadedHooks = new Set()
+const packageCache = new Map()
+const rewriters = new Map()
+
+/**
+ * @typedef {object} LoaderContext
+ * @property {(error: Error|undefined, code?: string, sourceMap?: string|object) => void} callback
+ * @property {(warning: Error) => void} [emitWarning]
+ * @property {string} resourcePath
+ */
+
+/**
+ * @typedef {object} PackageInfo
+ * @property {string} [entrypoint]
+ * @property {boolean} esm
+ * @property {string} moduleName
+ * @property {string} name
+ * @property {string} packageJsonPath
+ * @property {string} version
+ */
+
+/**
+ * Instruments a resolved foreign Node.js module.
+ *
+ * @this {LoaderContext}
+ * @param {string} source
+ * @param {string|object} [inputSourceMap]
+ */
+module.exports = function loader (source, inputSourceMap) {
+  try {
+    const nativeResourcePath = fs.realpathSync(getResourcePath(this))
+    const resourcePath = nativeResourcePath.replaceAll('\\', '/')
+    const extracted = extractPackageAndModulePath(resourcePath)
+    if (!extracted.pkg || !targetPackages.has(extracted.pkg)) {
+      this.callback(undefined, source, inputSourceMap)
+      return
+    }
+
+    const rewriteTarget = getRewriteTarget(resourcePath)
+    const packageInfo = getPackageInfo(
+      nativeResourcePath,
+      extracted.pkg,
+      /** @type {string} */ (extracted.path),
+      path.normalize(/** @type {string} */ (extracted.pkgJson))
+    )
+    const esm = packageInfo.esm
+    const publications = esm ? [] : getPublications(resourcePath, packageInfo)
+    if (!rewriteTarget && publications.length === 0) {
+      this.callback(undefined, source, inputSourceMap)
+      return
+    }
+    if (publications.length > 0 && hasUnsafeCommonJsBindings(source)) {
+      this.emitWarning?.(new Error(`Skipped CommonJS publication for unsafe wrapper bindings in ${resourcePath}`))
+      this.callback(undefined, source, inputSourceMap)
+      return
+    }
+
+    const dcModule = relativeImport(path.dirname(nativeResourcePath), require.resolve('dc-polyfill'))
+    let code = source
+    let sourceMap = inputSourceMap
+    let rewritten = false
+    if (rewriteTarget) {
+      const rewrite = getRewriter(dcModule)
+      const result = rewrite(
+        source,
+        resourcePath,
+        esm ? 'module' : 'commonjs',
+        rewriteTarget,
+        inputSourceMap
+      )
+      code = /** @type {string} */ (result.code)
+      sourceMap = result.map
+      rewritten = code !== source
+    }
+
+    if (publications.length > 0) code = appendCommonJsPublications(code, publications, dcModule)
+    if (rewritten && publications.length === 0) {
+      if (!esm && hasUnsafeCommonJsBindings(code)) {
+        this.emitWarning?.(new Error(`Skipped CommonJS activation for unsafe wrapper bindings in ${resourcePath}`))
+        this.callback(undefined, source, inputSourceMap)
+        return
+      }
+      code = appendActivation(code, {
+        package: rewriteTarget.moduleName,
+        path: filename(rewriteTarget.moduleName, rewriteTarget.filePath),
+        version: packageInfo.version,
+      }, dcModule, esm)
+    }
+    this.callback(undefined, code, sourceMap)
+  } catch (error) {
+    const warning = error instanceof Error ? error : new Error(String(error))
+    this.emitWarning?.(warning)
+    this.callback(undefined, source, inputSourceMap)
+  }
+}
+
+/**
+ * @param {LoaderContext} context
+ */
+function getResourcePath (context) {
+  const { resourcePath } = context
+  if (!resourcePath.endsWith(SYNTHETIC_EXTENSION) || fs.existsSync(resourcePath)) return resourcePath
+
+  const extensionlessPath = resourcePath.slice(0, -SYNTHETIC_EXTENSION.length)
+  return fs.existsSync(extensionlessPath) ? extensionlessPath : resourcePath
+}
+
+/**
+ * @param {string} nativeResourcePath
+ * @param {string} name
+ * @param {string} modulePath
+ * @param {string} packageJsonPath
+ * @returns {PackageInfo}
+ */
+function getPackageInfo (nativeResourcePath, name, modulePath, packageJsonPath) {
+  let cached = packageCache.get(packageJsonPath)
+  if (!cached) {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
+    cached = { packageJson, version: packageJson.version }
+    packageCache.set(packageJsonPath, cached)
+  }
+
+  return {
+    esm: isESMFile(nativeResourcePath, packageJsonPath, cached.packageJson),
+    moduleName: filename(name, modulePath),
+    name,
+    packageJsonPath,
+    version: cached.version,
+  }
+}
+
+/**
+ * @param {string} resourcePath
+ * @param {PackageInfo} packageInfo
+ * @returns {Array<{ package: string, path: string, version: string }>}
+ */
+function getPublications (resourcePath, packageInfo) {
+  loadPackageHook(packageInfo.name)
+  const entries = instrumentations[packageInfo.name]
+  if (!entries) return []
+
+  const publications = []
+  const paths = new Set()
+  for (const entry of entries) {
+    if (!entry.file && !entry.filePattern) {
+      packageInfo.entrypoint ??= getCommonJsEntrypoint(packageInfo.name, packageInfo.packageJsonPath)
+    }
+    const moduleName = entry.file || entry.filePattern
+      ? packageInfo.moduleName
+      : resourcePath === packageInfo.entrypoint ? packageInfo.name : undefined
+    if (!moduleName || paths.has(moduleName) ||
+      !matchesInstrumentation(packageInfo.name, packageInfo.version, moduleName, entry)) continue
+
+    paths.add(moduleName)
+    publications.push({ package: packageInfo.name, path: moduleName, version: packageInfo.version })
+  }
+  return publications
+}
+
+/**
+ * @param {string} name
+ * @param {string} packageJsonPath
+ */
+function getCommonJsEntrypoint (name, packageJsonPath) {
+  const cached = entrypoints.get(packageJsonPath)
+  if (cached) return cached
+
+  const packageRequire = Module.createRequire(packageJsonPath)
+  let entrypoint
+  try {
+    entrypoint = packageRequire.resolve(name)
+  } catch {
+    entrypoint = packageRequire.resolve(path.dirname(packageJsonPath))
+  }
+  const resolved = fs.realpathSync(entrypoint).replaceAll('\\', '/')
+  entrypoints.set(packageJsonPath, resolved)
+  return resolved
+}
+
+/**
+ * @param {string} name
+ */
+function loadPackageHook (name) {
+  if (loadedHooks.has(name)) return
+  const hook = hooks[name]
+  const load = hook?.fn ?? hook
+  if (typeof load === 'function') load()
+  loadedHooks.add(name)
+}
+
+/**
+ * @param {string} dcModule
+ * @returns {ReturnType<typeof createBundlerRewriter>}
+ */
+function getRewriter (dcModule) {
+  const cached = rewriters.get(dcModule)
+  if (cached) return cached
+  const rewrite = createBundlerRewriter(dcModule)
+  rewriters.set(dcModule, rewrite)
+  return rewrite
+}
+
+/**
+ * @param {string} source
+ */
+function hasUnsafeCommonJsBindings (source) {
+  try {
+    const { parse } = require('../../datadog-instrumentations/src/helpers/rewriter/compiler')
+    if (source.startsWith('#!')) source = `//${source.slice(2)}`
+    const program = parse(Module.wrap(source))
+    const wrapper = program.body[0]?.expression
+    return wrapper?.type !== 'FunctionExpression' || hasUnsafeNode(wrapper.body, 0, 0)
+  } catch {
+    return true
+  }
+}
+
+/**
+ * @param {object} node
+ * @param {number} functionDepth
+ * @param {number} shadowedBindings
+ * @param {object} [parent]
+ * @param {string} [parentKey]
+ */
+function hasUnsafeNode (node, functionDepth, shadowedBindings, parent, parentKey) {
+  if (functionDepth === 0 && hasCommonJsDeclaration(node, parent)) return true
+  if (node.type === 'AssignmentExpression' && mutatesCommonJsBinding(node.left, shadowedBindings)) return true
+  if (node.type === 'UpdateExpression' && mutatesCommonJsBinding(node.argument, shadowedBindings)) return true
+  if ((node.type === 'ForInStatement' || node.type === 'ForOfStatement') &&
+    mutatesCommonJsBinding(node.left, shadowedBindings)) return true
+  if (node.type === 'CallExpression' && node.callee?.type === 'Identifier' && node.callee.name === 'eval') return true
+  if (!(shadowedBindings & ARGUMENTS_BINDING) && node.type === 'Identifier' && node.name === 'arguments' &&
+    isReferencedIdentifier(parent, parentKey)) return true
+
+  const nestedFunction = node.type === 'ArrowFunctionExpression' || node.type === 'FunctionDeclaration' ||
+    node.type === 'FunctionExpression'
+  if (nestedFunction) {
+    functionDepth++
+    shadowedBindings |= getFunctionBindings(node)
+  }
+  shadowedBindings |= getLexicalBindings(node)
+
+  for (const key of Object.keys(node)) {
+    if ((node.type === 'VariableDeclarator' && key === 'id') ||
+      (node.type === 'CatchClause' && key === 'param')) continue
+    const value = node[key]
+    if (Array.isArray(value)) {
+      for (const child of value) {
+        if (child?.type && hasUnsafeNode(child, functionDepth, shadowedBindings, node, key)) return true
+      }
+    } else if (value?.type && hasUnsafeNode(value, functionDepth, shadowedBindings, node, key)) {
+      return true
+    }
+  }
+  return false
+}
+
+/**
+ * @param {object} node
+ * @param {object} [parent]
+ */
+function hasCommonJsDeclaration (node, parent) {
+  if (node.type === 'VariableDeclarator') {
+    return parent?.kind === 'var' && Boolean(getBindingMask(node.id) & COMMONJS_BINDINGS)
+  }
+  if (node.type === 'FunctionDeclaration') {
+    return Boolean(getBindingMask(node.id) & COMMONJS_BINDINGS)
+  }
+  return false
+}
+
+/**
+ * @param {object} node
+ * @param {number} shadowedBindings
+ */
+function mutatesCommonJsBinding (node, shadowedBindings) {
+  return Boolean(getBindingMask(node) & COMMONJS_BINDINGS & ~shadowedBindings)
+}
+
+/**
+ * @param {object} node
+ */
+function getBindingMask (node) {
+  if (!node) return 0
+  if (node.type === 'Identifier') {
+    if (node.name === 'arguments') return ARGUMENTS_BINDING
+    if (node.name === 'module') return MODULE_BINDING
+    return node.name === 'require' ? REQUIRE_BINDING : 0
+  }
+  if (node.type === 'AssignmentPattern') return getBindingMask(node.left)
+  if (node.type === 'RestElement') return getBindingMask(node.argument)
+  if (node.type === 'ArrayPattern') {
+    let bindings = 0
+    for (const element of node.elements) bindings |= getBindingMask(element)
+    return bindings
+  }
+  if (node.type === 'ObjectPattern') {
+    let bindings = 0
+    for (const property of node.properties) {
+      bindings |= getBindingMask(property.type === 'RestElement' ? property.argument : property.value)
+    }
+    return bindings
+  }
+  return 0
+}
+
+/**
+ * @param {object} node
+ */
+function getFunctionBindings (node) {
+  let bindings = node.type === 'ArrowFunctionExpression' ? 0 : ARGUMENTS_BINDING
+  bindings |= getBindingMask(node.id)
+  for (const param of node.params) bindings |= getBindingMask(param)
+  return bindings | getVarBindings(node.body)
+}
+
+/**
+ * @param {object} node
+ */
+function getVarBindings (node) {
+  if (node.type === 'ArrowFunctionExpression' || node.type === 'FunctionDeclaration' ||
+    node.type === 'FunctionExpression' || node.type === 'ClassDeclaration' || node.type === 'ClassExpression') return 0
+
+  let bindings = 0
+  if (node.type === 'VariableDeclaration' && node.kind === 'var') {
+    for (const declaration of node.declarations) bindings |= getBindingMask(declaration.id)
+  }
+  for (const key of Object.keys(node)) {
+    const value = node[key]
+    if (Array.isArray(value)) {
+      for (const child of value) {
+        if (child?.type) bindings |= getVarBindings(child)
+      }
+    } else if (value?.type) {
+      bindings |= getVarBindings(value)
+    }
+  }
+  return bindings
+}
+
+/**
+ * @param {object} node
+ */
+function getLexicalBindings (node) {
+  let bindings = 0
+  if (node.type === 'BlockStatement') {
+    for (const statement of node.body) bindings |= getStatementBindings(statement)
+  } else if (node.type === 'SwitchStatement') {
+    for (const switchCase of node.cases) {
+      for (const statement of switchCase.consequent) bindings |= getStatementBindings(statement)
+    }
+  } else if (node.type === 'CatchClause') {
+    bindings = getBindingMask(node.param)
+  } else if (node.type === 'ForStatement') {
+    bindings = getLexicalDeclarationBindings(node.init)
+  } else if (node.type === 'ForInStatement' || node.type === 'ForOfStatement') {
+    bindings = getLexicalDeclarationBindings(node.left)
+  } else if (node.type === 'ClassExpression') {
+    bindings = getBindingMask(node.id)
+  }
+  return bindings
+}
+
+/**
+ * @param {object} node
+ */
+function getStatementBindings (node) {
+  if (node.type === 'VariableDeclaration') return getLexicalDeclarationBindings(node)
+  if (node.type === 'FunctionDeclaration' || node.type === 'ClassDeclaration') return getBindingMask(node.id)
+  return 0
+}
+
+/**
+ * @param {object} [node]
+ */
+function getLexicalDeclarationBindings (node) {
+  if (node?.type !== 'VariableDeclaration' || node.kind === 'var') return 0
+  let bindings = 0
+  for (const declaration of node.declarations) bindings |= getBindingMask(declaration.id)
+  return bindings
+}
+
+/**
+ * @param {object} parent
+ * @param {string} parentKey
+ */
+function isReferencedIdentifier (parent, parentKey) {
+  if (parent.type === 'MemberExpression' && parentKey === 'property' && !parent.computed) return false
+  if ((parent.type === 'Property' || parent.type === 'MethodDefinition' || parent.type === 'PropertyDefinition') &&
+    parentKey === 'key' && !parent.computed) {
+    return parent.type === 'Property' && parent.shorthand
+  }
+  return parentKey !== 'label'
+}
+
+/**
+ * @param {string} source
+ * @param {Array<{ package: string, path: string, version: string }>} payloads
+ * @param {string} dcModule
+ */
+function appendCommonJsPublications (source, payloads, dcModule) {
+  let publications = ''
+  let index = 0
+  for (const payload of payloads) {
+    publications += `    const payload${index} = {
+      module: module.exports,
+      package: ${JSON.stringify(payload.package)},
+      path: ${JSON.stringify(payload.path)},
+      version: ${JSON.stringify(payload.version)},
+    }
+    channel.publish(payload${index})
+    module.exports = payload${index++}.module
+`
+  }
+
+  return `${source}
+{
+  const dc = require(${JSON.stringify(dcModule)})
+  const channel = dc.channel('${CHANNEL}')
+  if (channel.hasSubscribers) {
+${publications}  }
+}
+`
+}
+
+/**
+ * @param {string} source
+ * @param {{ package: string, path: string, version: string }} payload
+ * @param {string} dcModule
+ * @param {boolean} esm
+ */
+function appendActivation (source, payload, dcModule, esm) {
+  if (esm) {
+    return `${source}
+import ddTraceTurbopackDc from ${JSON.stringify(dcModule)}
+{
+  const channel = ddTraceTurbopackDc.channel('${CHANNEL}')
+  if (channel.hasSubscribers) channel.publish(${JSON.stringify({ activate: true, ...payload })})
+}
+`
+  }
+
+  return `${source}
+{
+  const dc = require(${JSON.stringify(dcModule)})
+  const channel = dc.channel('${CHANNEL}')
+  if (channel.hasSubscribers) channel.publish(${JSON.stringify({ activate: true, ...payload })})
+}
+`
+}
+
+/**
+ * @param {string} from
+ * @param {string} to
+ */
+function relativeImport (from, to) {
+  let value = path.relative(from, to).replaceAll('\\', '/')
+  if (!value.startsWith('.')) value = `./${value}`
+  return value
+}

package/packages/datadog-webpack/src/loader.js

@@ -7,7 +7,6 @@ const CHANNEL = 'dd-trace:bundler:load'
  * Called for each module-of-interest identified by DatadogWebpackPlugin.
  *
  * @param {string} source
- * @returns {string}
  */
 module.exports = function loader (source) {
   this.cacheable(false)