dd-trace 5.92.0 → 5.94.0

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

@@ -6,6 +6,9 @@ const log = require('../../dd-trace/src/log')
 const {
   VITEST_WORKER_TRACE_PAYLOAD_CODE,
   VITEST_WORKER_LOGS_PAYLOAD_CODE,
+  DYNAMIC_NAME_RE,
+  collectDynamicNamesFromTraces,
+  logDynamicNamesWarning,
 } = require('../../dd-trace/src/plugins/util/test')
 const { addHook, channel } = require('./helpers/instrument')
 
@@ -20,6 +23,7 @@ const isAttemptToFixCh = channel('ci:vitest:test:is-attempt-to-fix')
 const isDisabledCh = channel('ci:vitest:test:is-disabled')
 const isQuarantinedCh = channel('ci:vitest:test:is-quarantined')
 const isModifiedCh = channel('ci:vitest:test:is-modified')
+const testFnCh = channel('ci:vitest:test:fn')
 
 // test suite hooks
 const testSuiteStartCh = channel('ci:vitest:test-suite:start')
@@ -41,7 +45,10 @@ const codeCoverageReportCh = channel('ci:vitest:coverage-report')
 
 const taskToCtx = new WeakMap()
 const taskToStatuses = new WeakMap()
+const originalHookFns = new WeakMap()
 const newTasks = new WeakSet()
+const dynamicNameTasks = new WeakSet()
+const newTestsWithDynamicNames = new Set()
 const disabledTasks = new WeakSet()
 const quarantinedTasks = new WeakSet()
 const attemptToFixTasks = new WeakSet()
@@ -58,6 +65,9 @@ let isEarlyFlakeDetectionFaulty = false
 let isKnownTestsEnabled = false
 let isTestManagementTestsEnabled = false
 let isImpactedTestsEnabled = false
+let vitestGetFn = null
+let vitestSetFn = null
+let vitestGetHooks = null
 let testManagementAttemptToFixRetries = 0
 let isDiEnabled = false
 let testCodeCoverageLinesTotal
@@ -241,6 +251,37 @@ function getTestName (task) {
   return testName
 }
 
+/**
+ * Wraps a function so it runs inside the current test span context.
+ * @param {object} task
+ * @param {Function} fn
+ * @returns {Function}
+ */
+function wrapTestScopedFn (task, fn) {
+  return shimmer.wrapFunction(fn, fn => function () {
+    return testFnCh.runStores(taskToCtx.get(task), () => fn.apply(this, arguments))
+  })
+}
+
+/**
+ * Wraps a `beforeEach` cleanup callback so it inherits the test span context.
+ * Vitest allows `beforeEach` to return a cleanup function, including via a promise.
+ * @param {object} task
+ * @param {unknown} result
+ * @returns {unknown}
+ */
+function wrapBeforeEachCleanupResult (task, result) {
+  if (typeof result === 'function') {
+    return wrapTestScopedFn(task, result)
+  }
+
+  if (result && typeof result.then === 'function') {
+    return result.then(cleanupFn => wrapBeforeEachCleanupResult(task, cleanupFn))
+  }
+
+  return result
+}
+
 function getSortWrapper (sort, frameworkVersion) {
   return async function () {
     if (!testSessionFinishCh.hasSubscribers) {
@@ -435,6 +476,8 @@ function getFinishWrapper (exitOrClose) {
       onFinish,
     })
 
+    logDynamicNamesWarning(newTestsWithDynamicNames)
+
     await flushPromise
 
     // If coverage was generated, publish coverage report channel for upload
@@ -495,6 +538,7 @@ function threadHandler (thread) {
   workerProcess.on('message', (message) => {
     if (message.__tinypool_worker_message__ && message.data) {
       if (message.interprocessCode === VITEST_WORKER_TRACE_PAYLOAD_CODE) {
+        collectDynamicNamesFromTraces(message.data, newTestsWithDynamicNames)
         workerReportTraceCh.publish(message.data)
       } else if (message.interprocessCode === VITEST_WORKER_LOGS_PAYLOAD_CODE) {
         workerReportLogsCh.publish(message.data)
@@ -536,6 +580,7 @@ function getWrappedOn (on) {
       if (message.type !== 'Buffer' && Array.isArray(message)) {
         const [interprocessCode, data] = message
         if (interprocessCode === VITEST_WORKER_TRACE_PAYLOAD_CODE) {
+          collectDynamicNamesFromTraces(data, newTestsWithDynamicNames)
           workerReportTraceCh.publish(data)
         } else if (interprocessCode === VITEST_WORKER_LOGS_PAYLOAD_CODE) {
           workerReportLogsCh.publish(data)
@@ -659,6 +704,9 @@ function wrapVitestTestRunner (VitestTestRunner) {
             }
             newTasks.add(task)
             taskToStatuses.set(task, [])
+            if (DYNAMIC_NAME_RE.test(testName)) {
+              dynamicNameTasks.add(task)
+            }
           }
         },
       })
@@ -828,6 +876,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
       isRetryReasonEfd,
       isRetryReasonAttemptToFix: isRetryReasonAttemptToFix && numRepetition > 0,
       isNew,
+      hasDynamicName: dynamicNameTasks.has(task),
       mightHitProbe: isDiEnabled && numAttempt > 0,
       isAttemptToFix: attemptToFixTasks.has(task),
       isDisabled: disabledTasks.has(task),
@@ -838,6 +887,47 @@ function wrapVitestTestRunner (VitestTestRunner) {
     taskToCtx.set(task, ctx)
 
     testStartCh.runStores(ctx, () => {})
+
+    // Wrap the test function so it runs inside the test span context.
+    // Without this, HTTP requests during test execution become orphaned root spans.
+    if (vitestGetFn && vitestSetFn) {
+      const originalFn = vitestGetFn(task)
+      if (originalFn && !originalFn.__ddTraceWrapped) {
+        const wrappedFn = wrapTestScopedFn(task, originalFn)
+        wrappedFn.__ddTraceWrapped = true
+        vitestSetFn(task, wrappedFn)
+      }
+    }
+
+    // Wrap beforeEach/afterEach hooks so they also run inside the test span context.
+    // In vitest 4+, hooks are in a WeakMap accessed via getHooks(). In older versions, they're on suite.hooks.
+    let currentSuite = task.suite
+    while (currentSuite) {
+      const hooks = vitestGetHooks ? vitestGetHooks(currentSuite) : currentSuite.hooks
+      if (hooks) {
+        for (const hookType of ['beforeEach', 'afterEach']) {
+          const hookArray = hooks[hookType]
+          if (!hookArray) continue
+          for (let i = 0; i < hookArray.length; i++) {
+            const currentFn = hookArray[i]
+            const originalFn = originalHookFns.get(currentFn) || currentFn
+            const wrappedFn = shimmer.wrapFunction(originalFn, fn => function () {
+              const result = testFnCh.runStores(taskToCtx.get(task), () => fn.apply(this, arguments))
+
+              if (hookType === 'beforeEach') {
+                return wrapBeforeEachCleanupResult(task, result)
+              }
+
+              return result
+            })
+            originalHookFns.set(wrappedFn, originalFn)
+            hookArray[i] = wrappedFn
+          }
+        }
+      }
+      currentSuite = currentSuite.suite
+    }
+
     return onBeforeTryTask.apply(this, arguments)
   })
 
@@ -886,6 +976,20 @@ function wrapVitestTestRunner (VitestTestRunner) {
     })
 }
 
+function captureRunnerFunctions (pkg) {
+  if (vitestGetFn) return
+  const getFnExport = findExportByName(pkg, 'getFn')
+  const setFnExport = findExportByName(pkg, 'setFn')
+  if (getFnExport && setFnExport) {
+    vitestGetFn = getFnExport.value
+    vitestSetFn = setFnExport.value
+  }
+  const getHooksExport = findExportByName(pkg, 'getHooks')
+  if (getHooksExport) {
+    vitestGetHooks = getHooksExport.value
+  }
+}
+
 addHook({
   name: 'vitest',
   versions: ['>=4.0.0'],
@@ -896,11 +1000,26 @@ addHook({
     return testPackage
   }
 
+  captureRunnerFunctions(testPackage)
   wrapVitestTestRunner(testRunner.value)
 
   return testPackage
 })
 
+addHook({
+  name: '@vitest/runner',
+  versions: ['>=1.6.0'],
+}, (runnerModule) => {
+  if (!vitestGetFn && runnerModule.getFn && runnerModule.setFn) {
+    vitestGetFn = runnerModule.getFn
+    vitestSetFn = runnerModule.setFn
+  }
+  if (!vitestGetHooks && runnerModule.getHooks) {
+    vitestGetHooks = runnerModule.getHooks
+  }
+  return runnerModule
+})
+
 addHook({
   name: 'vitest',
   versions: ['>=1.6.0 <4.0.0'],

package/packages/datadog-plugin-aws-sdk/src/base.js

@@ -154,6 +154,11 @@ class BaseAwsSdkPlugin extends ClientPlugin {
       })
 
       this.finish(ctx)
+
+      if (IS_SERVERLESS) {
+        const peerStore = storage('peerServerless').getStore()
+        if (peerStore) delete peerStore.peerHostname
+      }
     })
 
     this.addBind(`apm:aws:response:start:${this.serviceIdentifier}`, ctx => {

package/packages/datadog-plugin-cypress/src/cypress-plugin.js

@@ -49,6 +49,9 @@ const {
   getSessionRequestErrorTags,
   DD_CI_LIBRARY_CONFIGURATION_ERROR,
   TEST_IS_MODIFIED,
+  TEST_HAS_DYNAMIC_NAME,
+  DYNAMIC_NAME_RE,
+  logDynamicNamesWarning,
   getPullRequestBaseBranch,
 } = require('../../dd-trace/src/plugins/util/test')
 const { isMarkedAsUnskippable } = require('../../datadog-plugin-jest/src/util')
@@ -261,6 +264,7 @@ class CypressPlugin {
   testManagementAttemptToFixRetries = 0
   isImpactedTestsEnabled = false
   modifiedFiles = []
+  newTestsWithDynamicNames = new Set()
 
   constructor () {
     const {
@@ -675,6 +679,8 @@ class CypressPlugin {
         this.testSessionSpan.setTag(TEST_MANAGEMENT_ENABLED, 'true')
       }
 
+      logDynamicNamesWarning(this.newTestsWithDynamicNames)
+
       this.testModuleSpan.finish()
       this.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
       this.testSessionSpan.finish()
@@ -990,6 +996,12 @@ class CypressPlugin {
             this.activeTestSpan.setTag(TEST_IS_RETRY, 'true')
             this.activeTestSpan.setTag(TEST_RETRY_REASON, TEST_RETRY_REASON_TYPES.efd)
           }
+          if (DYNAMIC_NAME_RE.test(testName)) {
+            this.activeTestSpan.setTag(TEST_HAS_DYNAMIC_NAME, 'true')
+            if (testStatuses.length === 1) {
+              this.newTestsWithDynamicNames.add(`${testSuite} › ${testName}`)
+            }
+          }
         }
         if (isModified) {
           this.activeTestSpan.setTag(TEST_IS_MODIFIED, 'true')

package/packages/datadog-plugin-jest/src/index.js

@@ -23,6 +23,7 @@ const {
   TEST_SOURCE_FILE,
   TEST_IS_NEW,
   TEST_IS_RETRY,
+  TEST_HAS_DYNAMIC_NAME,
   TEST_EARLY_FLAKE_ENABLED,
   TEST_EARLY_FLAKE_ABORT_REASON,
   JEST_DISPLAY_NAME,
@@ -501,6 +502,7 @@ class JestPlugin extends CiPlugin {
       isDisabled,
       isQuarantined,
       isModified,
+      hasDynamicName,
       testSuiteAbsolutePath,
     } = test
 
@@ -549,6 +551,10 @@ class JestPlugin extends CiPlugin {
     if (isNew) {
       extraTags[TEST_IS_NEW] = 'true'
     }
+
+    if (hasDynamicName) {
+      extraTags[TEST_HAS_DYNAMIC_NAME] = 'true'
+    }
     const testSuiteSpan = this.testSuiteSpanPerTestSuiteAbsolutePath.get(testSuiteAbsolutePath) || this.testSuiteSpan
 
     return super.startTestSpan(name, suite, testSuiteSpan, extraTags)

package/packages/datadog-plugin-mocha/src/index.js

@@ -32,6 +32,8 @@ const {
   TEST_MANAGEMENT_ATTEMPT_TO_FIX_PASSED,
   TEST_RETRY_REASON_TYPES,
   TEST_IS_MODIFIED,
+  TEST_FINAL_STATUS,
+  TEST_HAS_DYNAMIC_NAME,
   isModifiedTest,
 } = require('../../dd-trace/src/plugins/util/test')
 const { COMPONENT } = require('../../dd-trace/src/constants')
@@ -213,9 +215,13 @@ class MochaPlugin extends CiPlugin {
       attemptToFixFailed,
       isAttemptToFixRetry,
       isAtrRetry,
+      finalStatus,
     }) => {
       if (span) {
         span.setTag(TEST_STATUS, status)
+        if (finalStatus) {
+          span.setTag(TEST_FINAL_STATUS, finalStatus)
+        }
         if (hasBeenRetried) {
           span.setTag(TEST_IS_RETRY, 'true')
           if (isAtrRetry) {
@@ -422,6 +428,7 @@ class MochaPlugin extends CiPlugin {
       isDisabled,
       isQuarantined,
       isModified,
+      hasDynamicName,
     } = testInfo
 
     const extraTags = {}
@@ -473,6 +480,10 @@ class MochaPlugin extends CiPlugin {
       }
     }
 
+    if (hasDynamicName) {
+      extraTags[TEST_HAS_DYNAMIC_NAME] = 'true'
+    }
+
     return super.startTestSpan(testName, testSuite, testSuiteSpan, extraTags)
   }
 }

package/packages/datadog-plugin-playwright/src/index.js

@@ -38,6 +38,8 @@ const {
   TEST_STATUS,
   TEST_SUITE_ID,
   TEST_SUITE,
+  TEST_HAS_DYNAMIC_NAME,
+  DYNAMIC_NAME_RE,
 } = require('../../dd-trace/src/plugins/util/test')
 const { RESOURCE_NAME } = require('../../../ext/tags')
 const { COMPONENT } = require('../../dd-trace/src/constants')
@@ -221,6 +223,9 @@ class PlaywrightPlugin extends CiPlugin {
             trace_id: id(span.trace_id),
             parent_id: id(span.parent_id),
           }
+          if (span.meta[TEST_IS_NEW] === 'true' && DYNAMIC_NAME_RE.test(span.meta[TEST_NAME] || '')) {
+            formattedSpan.meta[TEST_HAS_DYNAMIC_NAME] = 'true'
+          }
           if (span.name === 'playwright.test') {
             // TODO: remove this comment
             // TODO: Let's pass rootDir, repositoryRoot, command, session id and module id as env vars
@@ -303,6 +308,7 @@ class PlaywrightPlugin extends CiPlugin {
       error,
       extraTags,
       isNew,
+      hasDynamicName,
       isEfdRetry,
       isRetry,
       isAttemptToFix,
@@ -335,6 +341,9 @@ class PlaywrightPlugin extends CiPlugin {
           span.setTag(TEST_RETRY_REASON, TEST_RETRY_REASON_TYPES.efd)
         }
       }
+      if (hasDynamicName) {
+        span.setTag(TEST_HAS_DYNAMIC_NAME, 'true')
+      }
       if (isRetry) {
         span.setTag(TEST_IS_RETRY, 'true')
         if (isAtrRetry) {

package/packages/datadog-plugin-vitest/src/index.js

@@ -33,6 +33,7 @@ const {
   TEST_RETRY_REASON_TYPES,
   isModifiedTest,
   TEST_IS_MODIFIED,
+  TEST_HAS_DYNAMIC_NAME,
 } = require('../../dd-trace/src/plugins/util/test')
 const { COMPONENT } = require('../../dd-trace/src/constants')
 const {
@@ -117,6 +118,7 @@ class VitestPlugin extends CiPlugin {
         testSuiteAbsolutePath,
         isRetry,
         isNew,
+        hasDynamicName,
         isAttemptToFix,
         isQuarantined,
         isDisabled,
@@ -148,6 +150,9 @@ class VitestPlugin extends CiPlugin {
       if (isNew) {
         extraTags[TEST_IS_NEW] = 'true'
       }
+      if (hasDynamicName) {
+        extraTags[TEST_HAS_DYNAMIC_NAME] = 'true'
+      }
       if (isAttemptToFix) {
         extraTags[TEST_MANAGEMENT_IS_ATTEMPT_TO_FIX] = 'true'
       }
@@ -180,6 +185,10 @@ class VitestPlugin extends CiPlugin {
       return ctx.currentStore
     })
 
+    this.addBind('ci:vitest:test:fn', (ctx) => {
+      return ctx.currentStore
+    })
+
     this.addBind('ci:vitest:test:finish-time', (ctx) => {
       const { status, task, attemptToFixPassed, attemptToFixFailed } = ctx
       const span = ctx.currentStore?.span

package/packages/datadog-webpack/index.js

@@ -0,0 +1,187 @@
+'use strict'
+
+const { execSync } = require('node:child_process')
+const fs = require('node:fs')
+
+const instrumentations = require('../datadog-instrumentations/src/helpers/instrumentations')
+const extractPackageAndModulePath = require('../datadog-instrumentations/src/helpers/extract-package-and-module-path')
+const hooks = require('../datadog-instrumentations/src/helpers/hooks')
+const { isESMFile } = require('../datadog-esbuild/src/utils')
+const log = require('./src/log')
+
+const PLUGIN_NAME = 'DatadogWebpackPlugin'
+
+for (const hook of Object.values(hooks)) {
+  if (hook !== null && typeof hook === 'object') {
+    hook.fn()
+  } else {
+    hook()
+  }
+}
+
+const modulesOfInterest = new Set()
+
+for (const instrumentation of Object.values(instrumentations)) {
+  for (const entry of instrumentation) {
+    if (entry.file) {
+      modulesOfInterest.add(`${entry.name}/${entry.file}`) // e.g. "redis/my/file.js"
+    } else {
+      modulesOfInterest.add(entry.name) // e.g. "redis"
+    }
+  }
+}
+
+/**
+ * @returns {{ repositoryURL: string | null, commitSHA: string | null }}
+ */
+function getGitMetadata () {
+  const gitMetadata = {
+    repositoryURL: null,
+    commitSHA: null,
+  }
+
+  try {
+    gitMetadata.repositoryURL = execSync('git config --get remote.origin.url', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'ignore'],
+      cwd: process.cwd(),
+    }).trim()
+  } catch (e) {
+    log.warn('failed to get git repository URL:', e.message)
+  }
+
+  try {
+    gitMetadata.commitSHA = execSync('git rev-parse HEAD', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'ignore'],
+      cwd: process.cwd(),
+    }).trim()
+  } catch (e) {
+    log.warn('failed to get git commit SHA:', e.message)
+  }
+
+  return gitMetadata
+}
+
+class DatadogWebpackPlugin {
+  /**
+   * @param {object} compiler
+   */
+  apply (compiler) {
+    // optimization.minimize is not yet set when apply() is called in webpack 5.54.0+
+    // (applyWebpackOptionsDefaults runs after plugins), so we defer the check to the
+    // environment hook which fires synchronously after defaults are applied.
+    compiler.hooks.environment.tap(PLUGIN_NAME, () => {
+      if (compiler.options.optimization?.minimize) {
+        throw new Error(
+          'optimization.minimize is not compatible with DatadogWebpackPlugin and will break dd-trace ' +
+          'instrumentation. Disable optimization.minimize when using this plugin.'
+        )
+      }
+    })
+
+    const gitMetadata = getGitMetadata()
+    if (gitMetadata.repositoryURL || gitMetadata.commitSHA) {
+      const banner =
+        'if (typeof process === \'object\' && process !== null &&\n' +
+        '    process.env !== null && typeof process.env === \'object\') {\n' +
+        (gitMetadata.repositoryURL
+          ? `  process.env.DD_GIT_REPOSITORY_URL = ${JSON.stringify(gitMetadata.repositoryURL)};\n`
+          : '') +
+        (gitMetadata.commitSHA
+          ? `  process.env.DD_GIT_COMMIT_SHA = ${JSON.stringify(gitMetadata.commitSHA)};\n`
+          : '') +
+        '}\n'
+
+      compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+        compilation.hooks.processAssets.tap(
+          { name: PLUGIN_NAME, stage: -2000 },
+          () => {
+            for (const chunk of compilation.chunks) {
+              if (!chunk.canBeInitial()) continue
+              for (const filename of chunk.files) {
+                if (!filename.endsWith('.js') && !filename.endsWith('.mjs')) continue
+                compilation.updateAsset(filename, (old) => {
+                  const content = banner + old.source()
+                  return {
+                    source () { return content },
+                    size () { return Buffer.byteLength(content, 'utf8') },
+                    map () { return old.map() },
+                    sourceAndMap () { return { source: content, map: old.map() } },
+                    updateHash (hash) { hash.update(content) },
+                  }
+                })
+              }
+            }
+          }
+        )
+      })
+
+      log.debug(
+        'Automatically injected git metadata (DD_GIT_REPOSITORY_URL: %s, DD_GIT_COMMIT_SHA: %s)',
+        gitMetadata.repositoryURL || 'not available',
+        gitMetadata.commitSHA || 'not available'
+      )
+    } else {
+      log.warn('No git metadata available - skipping injection')
+    }
+
+    compiler.hooks.normalModuleFactory.tap(PLUGIN_NAME, (nmf) => {
+      nmf.hooks.afterResolve.tap(PLUGIN_NAME, (resolveData) => {
+        const { createData } = resolveData
+        const resource = createData?.resource
+        if (!resource || !resource.includes('node_modules')) {
+          return
+        }
+
+        const normalizedResource = resource.replaceAll('\\', '/')
+        const { pkg, path: modulePath, pkgJson } = extractPackageAndModulePath(normalizedResource)
+        if (!pkg) {
+          return
+        }
+
+        const request = resolveData.request
+
+        if (!modulesOfInterest.has(request) && !modulesOfInterest.has(`${pkg}/${modulePath}`)) {
+          return
+        }
+
+        if (!pkgJson) {
+          return
+        }
+
+        let packageJson
+        try {
+          packageJson = JSON.parse(fs.readFileSync(pkgJson).toString())
+        } catch (e) {
+          if (e.code === 'ENOENT') {
+            log.debug(
+              'Skipping `package.json` lookup for %s. The package may be vendored.',
+              pkg
+            )
+            return
+          }
+          throw e
+        }
+
+        if (isESMFile(normalizedResource, pkgJson, packageJson)) {
+          log.warn('Skipping ESM module (ESM support is not available in the webpack plugin): %s', resource)
+          return
+        }
+
+        const version = packageJson.version
+        const pkgPath = request === pkg ? pkg : `${pkg}/${modulePath}`
+
+        createData.loaders = createData.loaders || []
+        createData.loaders.unshift({
+          loader: require.resolve('./src/loader'),
+          options: { pkg, version, path: pkgPath },
+        })
+
+        log.debug('LOAD: %s@%s, pkg "%s"', pkg, version, pkgPath)
+      })
+    })
+  }
+}
+
+module.exports = DatadogWebpackPlugin

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

@@ -0,0 +1,27 @@
+'use strict'
+
+const CHANNEL = 'dd-trace:bundler:load'
+
+/**
+ * Webpack loader that appends a dc-polyfill channel publish to a CJS module.
+ * Called for each module-of-interest identified by DatadogWebpackPlugin.
+ *
+ * @param {string} source
+ * @returns {string}
+ */
+module.exports = function loader (source) {
+  this.cacheable(false)
+  const { pkg, version, path: pkgPath } = this.getOptions()
+
+  return (
+    source +
+    '\n;{\n' +
+    '  const __dd_dc = require(\'dc-polyfill\');\n' +
+    `  const __dd_ch = __dd_dc.channel('${CHANNEL}');\n` +
+    '  const __dd_mod = module.exports;\n' +
+    `  const __dd_payload = { module: __dd_mod, version: '${version}', package: '${pkg}', path: '${pkgPath}' };\n` +
+    '  __dd_ch.publish(__dd_payload);\n' +
+    '  module.exports = __dd_payload.module;\n' +
+    '}\n'
+  )
+}

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

@@ -0,0 +1,32 @@
+'use strict'
+
+const { format } = require('util')
+
+// eslint-disable-next-line eslint-rules/eslint-process-env
+const DD_TRACE_DEBUG = (process.env.DD_TRACE_DEBUG || '').trim().toLowerCase()
+const DEBUG = DD_TRACE_DEBUG === 'true' || DD_TRACE_DEBUG === '1'
+
+const noop = () => {}
+
+const formatWithLogPrefix = (prefix, str, ...args) => {
+  if (typeof str === 'string') {
+    return format(`${prefix} ${str}`, ...args)
+  }
+  return format(prefix, str, ...args)
+}
+
+module.exports = DEBUG
+  ? {
+      debug (...args) {
+        // eslint-disable-next-line no-console
+        console.log(formatWithLogPrefix('[dd-trace/webpack]', ...args))
+      },
+      warn (...args) {
+        // eslint-disable-next-line no-console
+        console.warn(formatWithLogPrefix('[dd-trace/webpack] Warning:', ...args))
+      },
+    }
+  : {
+      debug: noop,
+      warn: noop,
+    }