@datadog/webpack-plugin 2.3.3-dev-2 → 2.3.3-dev-3

package/dist/src/index.mjs

@@ -26,16 +26,16 @@ const logPriority = {
 const getLoggerFactory = (build, logLevel = "warn") => (name) => {
   const log = (text, type = "debug") => {
     let color = chalk.dim;
-    let logFn2 = console.log;
+    let logFn = console.log;
     if (type === "error") {
       color = chalk.red;
-      logFn2 = console.error;
+      logFn = console.error;
     } else if (type === "warn") {
       color = chalk.yellow;
-      logFn2 = console.warn;
+      logFn = console.warn;
     } else if (type === "info") {
       color = chalk.cyan;
-      logFn2 = console.log;
+      logFn = console.log;
     }
     const prefix = `[${type}|${name}]`;
     const content = typeof text === "string" ? text : JSON.stringify(text, null, 2);
@@ -47,17 +47,19 @@ const getLoggerFactory = (build, logLevel = "warn") => (name) => {
       build.warnings.push(content);
     }
     if (logPriority[type] >= logPriority[logLevel]) {
-      logFn2(`${color(prefix)} ${content}`);
+      logFn(`${color(prefix)} ${content}`);
     }
   };
-  const logFn = (text, type = "debug") => {
-    log(text, type);
+  return {
+    getLogger: (subName) => {
+      const logger = getLoggerFactory(build, logLevel);
+      return logger(`${name}:${subName}`);
+    },
+    error: (text) => log(text, "error"),
+    warn: (text) => log(text, "warn"),
+    info: (text) => log(text, "info"),
+    debug: (text) => log(text, "debug")
   };
-  logFn.error = (text) => log(text, "error");
-  logFn.warn = (text) => log(text, "warn");
-  logFn.info = (text) => log(text, "info");
-  logFn.debug = (text) => log(text, "debug");
-  return logFn;
 };
 const getContext = ({
   options,
@@ -88,7 +90,6 @@ const getContext = ({
     inject: (item) => {
       injections.push(item);
     },
-    getLogger: getLoggerFactory(build, options.logLevel),
     start: Date.now(),
     version
   };
@@ -103,9 +104,6 @@ const validateOptions$2 = (options = {}) => {
   };
 };
 
-const CONFIG_KEY$1 = "rum";
-const PLUGIN_NAME$4 = "datadog-rum-plugin";
-
 const decomposePath = (options, context, sourcemapFilePath) => {
   if (path.extname(sourcemapFilePath) !== ".map") {
     throw new Error(`The file ${chalk.green.bold(sourcemapFilePath)} is not a sourcemap.`);
@@ -428,7 +426,7 @@ const upload = async (payloads, options, context, log) => {
         "."
       )
     };
-    log(`Queuing ${green(metadata.sourcemap)} | ${green(metadata.file)}`);
+    log.debug(`Queuing ${green(metadata.sourcemap)} | ${green(metadata.file)}`);
     addPromises.push(
       queue.add(async () => {
         try {
@@ -442,10 +440,10 @@ const upload = async (payloads, options, context, log) => {
   ${error.message}
 Retrying ${attempt}/${NB_RETRIES}`;
               warnings.push(warningMessage);
-              log(warningMessage, "warn");
+              log.warn(warningMessage);
             }
           });
-          log(`Sent ${green(metadata.sourcemap)} | ${green(metadata.file)}`);
+          log.debug(`Sent ${green(metadata.sourcemap)} | ${green(metadata.file)}`);
         } catch (e) {
           errors.push({ metadata, error: e });
           if (options.bailOnError === true) {
@@ -477,13 +475,13 @@ const sendSourcemaps = async (sourcemaps, options, context, log) => {
   const errors = payloads.map((payload) => payload.errors).flat();
   const warnings = payloads.map((payload) => payload.warnings).flat();
   if (warnings.length > 0) {
-    log(`Warnings while preparing payloads:
-    - ${warnings.join("\n    - ")}`, "warn");
+    log.warn(`Warnings while preparing payloads:
+    - ${warnings.join("\n    - ")}`);
   }
   if (errors.length > 0) {
     const errorMsg = `Failed to prepare payloads, aborting upload :
     - ${errors.join("\n    - ")}`;
-    log(errorMsg, "error");
+    log.error(errorMsg);
     if (options.bailOnError === true) {
       throw new Error(errorMsg);
     }
@@ -495,9 +493,8 @@ const sendSourcemaps = async (sourcemaps, options, context, log) => {
     context,
     log
   );
-  log(
-    `Done uploading ${green(sourcemaps.length.toString())} sourcemaps in ${green(formatDuration(Date.now() - start))}.`,
-    "info"
+  log.info(
+    `Done uploading ${green(sourcemaps.length.toString())} sourcemaps in ${green(formatDuration(Date.now() - start))}.`
   );
   if (uploadErrors.length > 0) {
     const listOfErrors = `    - ${uploadErrors.map(({ metadata: fileMetadata, error }) => {
@@ -508,14 +505,14 @@ const sendSourcemaps = async (sourcemaps, options, context, log) => {
     }).join("\n    - ")}`;
     const errorMsg = `Failed to upload some sourcemaps:
 ${listOfErrors}`;
-    log(errorMsg, "error");
+    log.error(errorMsg);
     if (options.bailOnError === true) {
       throw new Error(errorMsg);
     }
   }
   if (uploadWarnings.length > 0) {
-    log(`Warnings while uploading sourcemaps:
-    - ${warnings.join("\n    - ")}`, "warn");
+    log.warn(`Warnings while uploading sourcemaps:
+    - ${warnings.join("\n    - ")}`);
   }
 };
 
@@ -527,19 +524,22 @@ const uploadSourcemaps = async (options, context, log) => {
     Uploading ${green(sourcemaps.length.toString())} sourcemaps with configuration:
     ${configurationString}
     `;
-  log(summary, "info");
+  log.info(summary);
   await sendSourcemaps(sourcemaps, options.sourcemaps, context, log);
 };
 
+const CONFIG_KEY$1 = "rum";
+const PLUGIN_NAME$5 = "datadog-rum-plugin";
+
 const defaultIntakeUrl = `https://sourcemap-intake.${process.env.DATADOG_SITE || "datadoghq.com"}/api/v2/srcmap`;
 const validateOptions$1 = (config, log) => {
   const errors = [];
   const sourcemapsResults = validateSourcemapsOptions(config);
   errors.push(...sourcemapsResults.errors);
   if (errors.length) {
-    log(`
-  - ${errors.join("\n  - ")}`, "error");
-    throw new Error(`Invalid configuration for ${PLUGIN_NAME$4}.`);
+    log.error(`
+  - ${errors.join("\n  - ")}`);
+    throw new Error(`Invalid configuration for ${PLUGIN_NAME$5}.`);
   }
   const toReturn = {
     ...config[CONFIG_KEY$1],
@@ -597,8 +597,7 @@ const validateSourcemapsOptions = (config) => {
   return toReturn;
 };
 
-const getPlugins$2 = (opts, context) => {
-  const log = context.getLogger(PLUGIN_NAME$4);
+const getPlugins$1 = (opts, context, log) => {
   const rumOptions = validateOptions$1(opts, log);
   return [
     {
@@ -617,7 +616,7 @@ const getPlugins$2 = (opts, context) => {
 };
 
 const CONFIG_KEY = "telemetry";
-const PLUGIN_NAME$3 = `datadog-telemetry-plugin`;
+const PLUGIN_NAME$4 = `datadog-telemetry-plugin`;
 
 const filterTreeMetrics = (metric) => (
   // Remove tree metrics because way too verbose
@@ -733,9 +732,8 @@ const getValueContext = (args) => {
   }));
 };
 
-const getPlugins$1 = (plugins) => {
-  const metrics = [];
-  metrics.push({
+const addPluginMetrics = (plugins, metrics) => {
+  metrics.add({
     metric: "plugins.count",
     type: "count",
     value: plugins.size,
@@ -752,67 +750,54 @@ const getPlugins$1 = (plugins) => {
         hookDuration += duration;
         pluginDuration += duration;
       }
-      metrics.push(
-        {
-          metric: "plugins.hooks.duration",
-          type: "duration",
-          value: hookDuration,
-          tags: [`pluginName:${plugin.name}`, `hookName:${hook.name}`]
-        },
-        {
-          metric: "plugins.hooks.increment",
-          type: "count",
-          value: hook.values.length,
-          tags: [`pluginName:${plugin.name}`, `hookName:${hook.name}`]
-        }
-      );
-    }
-    metrics.push(
-      {
-        metric: "plugins.duration",
+      metrics.add({
+        metric: "plugins.hooks.duration",
         type: "duration",
-        value: pluginDuration,
-        tags: [`pluginName:${plugin.name}`]
-      },
-      {
-        metric: "plugins.increment",
+        value: hookDuration,
+        tags: [`pluginName:${plugin.name}`, `hookName:${hook.name}`]
+      }).add({
+        metric: "plugins.hooks.increment",
         type: "count",
-        value: pluginCount,
-        tags: [`pluginName:${plugin.name}`]
-      }
-    );
+        value: hook.values.length,
+        tags: [`pluginName:${plugin.name}`, `hookName:${hook.name}`]
+      });
+    }
+    metrics.add({
+      metric: "plugins.duration",
+      type: "duration",
+      value: pluginDuration,
+      tags: [`pluginName:${plugin.name}`]
+    }).add({
+      metric: "plugins.increment",
+      type: "count",
+      value: pluginCount,
+      tags: [`pluginName:${plugin.name}`]
+    });
   }
-  return metrics;
 };
-const getLoaders = (loaders) => {
-  const metrics = [];
-  metrics.push({
+const addLoaderMetrics = (loaders, metrics) => {
+  metrics.add({
     metric: "loaders.count",
     type: "count",
     value: loaders.size,
     tags: []
   });
   for (const loader of loaders.values()) {
-    metrics.push(
-      {
-        metric: "loaders.duration",
-        type: "duration",
-        value: loader.duration,
-        tags: [`loaderName:${loader.name}`]
-      },
-      {
-        metric: "loaders.increment",
-        type: "count",
-        value: loader.increment,
-        tags: [`loaderName:${loader.name}`]
-      }
-    );
+    metrics.add({
+      metric: "loaders.duration",
+      type: "duration",
+      value: loader.duration,
+      tags: [`loaderName:${loader.name}`]
+    }).add({
+      metric: "loaders.increment",
+      type: "count",
+      value: loader.increment,
+      tags: [`loaderName:${loader.name}`]
+    });
   }
-  return metrics;
 };
 
-const getUniversalMetrics = (globalContext) => {
-  const metrics = [];
+const addUniversalMetrics = (globalContext, metrics) => {
   const inputs = globalContext.build.inputs || [];
   const outputs = globalContext.build.outputs || [];
   const entries = globalContext.build.entries || [];
@@ -845,40 +830,34 @@ const getUniversalMetrics = (globalContext) => {
       assetsPerInput.get(input.filepath).push(output.name);
     }
   }
-  metrics.push(
-    {
-      metric: "assets.count",
-      type: "count",
-      value: outputs.length,
-      tags: []
-    },
-    {
-      metric: "entries.count",
-      type: "count",
-      value: entries.length,
-      tags: []
-    },
-    {
-      metric: "errors.count",
-      type: "count",
-      value: nbErrors,
-      tags: []
-    },
-    {
-      metric: "modules.count",
-      type: "count",
-      value: inputs.length,
-      tags: []
-    },
-    {
-      metric: "warnings.count",
-      type: "count",
-      value: nbWarnings,
-      tags: []
-    }
-  );
+  metrics.add({
+    metric: "assets.count",
+    type: "count",
+    value: outputs.length,
+    tags: []
+  }).add({
+    metric: "entries.count",
+    type: "count",
+    value: entries.length,
+    tags: []
+  }).add({
+    metric: "errors.count",
+    type: "count",
+    value: nbErrors,
+    tags: []
+  }).add({
+    metric: "modules.count",
+    type: "count",
+    value: inputs.length,
+    tags: []
+  }).add({
+    metric: "warnings.count",
+    type: "count",
+    value: nbWarnings,
+    tags: []
+  });
   if (duration) {
-    metrics.push({
+    metrics.add({
       metric: "compilation.duration",
       type: "duration",
       value: duration,
@@ -897,26 +876,22 @@ const getUniversalMetrics = (globalContext) => {
         ...assetsPerInput.get(input.filepath).map((assetName) => `assetName:${assetName}`)
       );
     }
-    metrics.push(
-      {
-        metric: "modules.size",
-        type: "size",
-        value: input.size,
-        tags
-      },
-      {
-        metric: "modules.dependencies",
-        type: "count",
-        value: input.dependencies.size,
-        tags
-      },
-      {
-        metric: "modules.dependents",
-        type: "count",
-        value: input.dependents.size,
-        tags
-      }
-    );
+    metrics.add({
+      metric: "modules.size",
+      type: "size",
+      value: input.size,
+      tags
+    }).add({
+      metric: "modules.dependencies",
+      type: "count",
+      value: input.dependencies.size,
+      tags
+    }).add({
+      metric: "modules.dependents",
+      type: "count",
+      value: input.dependents.size,
+      tags
+    });
   }
   for (const output of outputs) {
     const tags = [`assetName:${output.name}`, `assetType:${output.type}`];
@@ -926,72 +901,69 @@ const getUniversalMetrics = (globalContext) => {
         ...entriesPerAsset.get(cleanAssetName).map((entryName) => `entryName:${entryName}`)
       );
     }
-    metrics.push(
-      {
-        metric: "assets.size",
-        type: "size",
-        value: output.size,
-        tags
-      },
-      {
-        metric: "assets.modules.count",
-        type: "count",
-        value: output.inputs.length,
-        tags
-      }
-    );
+    metrics.add({
+      metric: "assets.size",
+      type: "size",
+      value: output.size,
+      tags
+    }).add({
+      metric: "assets.modules.count",
+      type: "count",
+      value: output.inputs.length,
+      tags
+    });
   }
   for (const entry of entries) {
     const tags = [`entryName:${entry.name}`];
-    metrics.push(
-      {
-        metric: "entries.size",
-        type: "size",
-        value: entry.size,
-        tags
-      },
-      {
-        metric: "entries.modules.count",
-        type: "count",
-        value: entry.inputs.length,
-        tags
-      },
-      {
-        metric: "entries.assets.count",
-        type: "count",
-        value: entry.outputs.length,
-        tags
-      }
-    );
+    metrics.add({
+      metric: "entries.size",
+      type: "size",
+      value: entry.size,
+      tags
+    }).add({
+      metric: "entries.modules.count",
+      type: "count",
+      value: entry.inputs.length,
+      tags
+    }).add({
+      metric: "entries.assets.count",
+      type: "count",
+      value: entry.outputs.length,
+      tags
+    });
   }
   return metrics;
 };
-const getMetrics = (globalContext, optionsDD, report) => {
-  const metrics = [];
+const addMetrics = (globalContext, optionsDD, metricsToSend, report) => {
+  const metrics = /* @__PURE__ */ new Set();
   if (report) {
     const { timings } = report;
     if (timings) {
       if (timings.tapables) {
-        metrics.push(...getPlugins$1(timings.tapables));
+        addPluginMetrics(timings.tapables, metrics);
       }
       if (timings.loaders) {
-        metrics.push(...getLoaders(timings.loaders));
+        addLoaderMetrics(timings.loaders, metrics);
       }
     }
   }
-  metrics.push(...getUniversalMetrics(globalContext));
-  const metricsToSend = metrics.map((m) => {
-    let metric = m;
+  addUniversalMetrics(globalContext, metrics);
+  for (const metric of metrics) {
     if (optionsDD.filters?.length) {
+      let filteredMetric = metric;
       for (const filter of optionsDD.filters) {
-        if (metric) {
-          metric = filter(metric);
+        if (!filteredMetric) {
+          break;
         }
+        filteredMetric = filter(metric);
+      }
+      if (filteredMetric) {
+        metricsToSend.add(getMetric(filteredMetric, optionsDD));
       }
+    } else {
+      metricsToSend.add(getMetric(metric, optionsDD));
     }
-    return metric ? getMetric(metric, optionsDD) : null;
-  }).filter((m) => m !== null);
-  return metricsToSend;
+  }
 };
 
 const outputFiles = async (data, outputOptions, log, cwd) => {
@@ -1025,37 +997,35 @@ const outputFiles = async (data, outputOptions, log, cwd) => {
         }
       };
     }
-    if (metrics && files.metrics) {
-      filesToWrite.metrics = { content: metrics };
+    if (files.metrics) {
+      filesToWrite.metrics = { content: Array.from(metrics) };
     }
     const proms = Object.entries(filesToWrite).map(async ([filename, file]) => {
       const start = Date.now();
-      log(`Start writing ${filename}.json.`);
+      log.debug(`Start writing ${filename}.json.`);
       try {
         await outputJson(path.join(outputPath, `${filename}.json`), file.content);
-        log(`Wrote ${filename}.json in ${formatDuration(Date.now() - start)}`);
+        log.debug(`Wrote ${filename}.json in ${formatDuration(Date.now() - start)}`);
       } catch (e) {
-        log(
-          `Failed to write ${filename}.json in ${formatDuration(Date.now() - start)}`,
-          "error"
+        log.error(
+          `Failed to write ${filename}.json in ${formatDuration(Date.now() - start)}`
         );
         errors[filename] = e;
       }
     });
     await Promise.all(proms);
-    log(`Wrote files in ${formatDuration(Date.now() - startWriting)}.`);
+    log.debug(`Wrote files in ${formatDuration(Date.now() - startWriting)}.`);
     const fileErrored = Object.keys(errors);
     if (fileErrored.length) {
-      log(
+      log.error(
         `Couldn't write files.
 ${fileErrored.map(
           (file) => `  - ${file}: ${errors[file].toString()}`
-        )}`,
-        "error"
+        )}`
       );
     }
   } catch (e) {
-    log(`Couldn't write files. ${e}`, "error");
+    log.error(`Couldn't write files. ${e}`);
   }
 };
 
@@ -1446,22 +1416,31 @@ const outputTexts = (globalContext, log, report) => {
   valuesToPrint.push(...getAssetsValues(globalContext));
   valuesToPrint.push(...getGeneralValues(globalContext));
   const outputString = renderValues(valuesToPrint);
-  log(outputString, "info");
+  log.info(outputString);
 };
 
 const sendMetrics = (metrics, auth, log) => {
   const startSending = Date.now();
   if (!auth.apiKey) {
-    log(`Won't send metrics to Datadog: missing API Key.`, "warn");
+    log.warn(`Won't send metrics to Datadog: missing API Key.`);
     return;
   }
-  if (!metrics || metrics.length === 0) {
-    log(`No metrics to send.`, "warn");
+  if (!metrics.size) {
+    log.warn(`No metrics to send.`);
     return;
   }
-  const metricsNames = [...new Set(metrics.map((m) => m.metric))].sort().map((name) => `${name} - ${metrics.filter((m) => m.metric === name).length}`);
-  log(`
-Sending ${metrics.length} metrics.
+  const metricIterations = /* @__PURE__ */ new Map();
+  for (const metric of metrics) {
+    if (!metricIterations.has(metric.metric)) {
+      metricIterations.set(metric.metric, 0);
+    }
+    metricIterations.set(metric.metric, metricIterations.get(metric.metric) + 1);
+  }
+  const metricsNames = Array.from(metricIterations.entries()).map(
+    ([name, count]) => `${name} - ${count}`
+  );
+  log.debug(`
+Sending ${metrics.size} metrics.
 Metrics:
     - ${metricsNames.join("\n    - ")}`);
   return doRequest({
@@ -1469,9 +1448,9 @@ Metrics:
     url: `${auth.endPoint}/api/v1/series?api_key=${auth.apiKey}`,
     getData: () => ({ data: JSON.stringify({ series: metrics }) })
   }).then(() => {
-    log(`Sent metrics in ${formatDuration(Date.now() - startSending)}.`);
+    log.debug(`Sent metrics in ${formatDuration(Date.now() - startSending)}.`);
   }).catch((e) => {
-    log(`Error sending metrics ${e}`, "error");
+    log.error(`Error sending metrics ${e}`);
   });
 };
 
@@ -1487,7 +1466,7 @@ const wrapPlugins = (build, context) => {
       };
     });
     for (const plugin of plugins) {
-      if (plugin.name.includes(PLUGIN_NAME$3)) {
+      if (plugin.name.includes(PLUGIN_NAME$4)) {
         continue;
       }
       const oldSetup = plugin.setup;
@@ -1565,7 +1544,7 @@ const getEsbuildPlugin$1 = (bundlerContext, globalContext, logger) => {
       wrapPlugins(build, globalContext.cwd);
       build.onEnd(async (result) => {
         if (!result.metafile) {
-          logger("Missing metafile, can't proceed with modules data.", "warn");
+          logger.warn("Missing metafile, can't proceed with modules data.");
           return;
         }
         const { plugins, modules } = getResults();
@@ -1790,7 +1769,7 @@ class Tapables {
     if (hook._fakeHook) {
       return;
     }
-    if (tapableName.includes(PLUGIN_NAME$3)) {
+    if (tapableName.includes(PLUGIN_NAME$4)) {
       return;
     }
     if (!this.hooks[tapableName]) {
@@ -1831,10 +1810,10 @@ class Tapables {
   }
 }
 
-const getWebpackPlugin$1 = (bundlerContext, globalContext) => {
+const getWebpackPlugin = (bundlerContext, globalContext) => {
   return async (compiler) => {
     globalContext.build.start = Date.now();
-    const HOOK_OPTIONS = { name: PLUGIN_NAME$3 };
+    const HOOK_OPTIONS = { name: PLUGIN_NAME$4 };
     const tapables = new Tapables(globalContext.cwd);
     const loaders = new Loaders(globalContext.cwd);
     tapables.throughHooks(compiler);
@@ -1864,19 +1843,19 @@ const getWebpackPlugin$1 = (bundlerContext, globalContext) => {
 const helpers$2 = {
   filters: defaultFilters
 };
-const getPlugins = (options, context) => {
+const getPlugins = (options, context, logger) => {
   let realBuildEnd = 0;
   const bundlerContext = {
     start: Date.now()
   };
   const telemetryOptions = validateOptions(options);
-  const logger = context.getLogger(PLUGIN_NAME$3);
   const plugins = [];
   const legacyPlugin = {
-    name: PLUGIN_NAME$3,
+    name: PLUGIN_NAME$4,
     enforce: "pre",
     esbuild: getEsbuildPlugin$1(bundlerContext, context, logger),
-    webpack: getWebpackPlugin$1(bundlerContext, context)
+    webpack: getWebpackPlugin(bundlerContext, context),
+    rspack: getWebpackPlugin(bundlerContext, context)
   };
   const universalPlugin = {
     name: "datadog-universal-telemetry-plugin",
@@ -1892,9 +1871,9 @@ const getPlugins = (options, context) => {
       context.build.end = Date.now();
       context.build.duration = context.build.end - context.build.start;
       context.build.writeDuration = context.build.end - realBuildEnd;
-      const metrics = [];
+      const metrics = /* @__PURE__ */ new Set();
       const optionsDD = getOptionsDD(telemetryOptions);
-      metrics.push(...getMetrics(context, optionsDD, bundlerContext.report));
+      addMetrics(context, optionsDD, metrics, bundlerContext.report);
       await outputFiles(
         { report: bundlerContext.report, metrics },
         telemetryOptions.output,
@@ -1959,11 +1938,15 @@ const getEsbuildPlugin = (context, log) => {
       const entrypoints = build.initialOptions.entryPoints;
       const entryNames = getEntryNames(entrypoints, context);
       build.onEnd((result) => {
-        context.build.errors.push(...result.errors.map((err) => err.text));
-        context.build.warnings.push(...result.warnings.map((err) => err.text));
+        for (const error of result.errors) {
+          context.build.errors.push(error.text);
+        }
+        for (const warning of result.warnings) {
+          context.build.warnings.push(warning.text);
+        }
         const warn = (warning) => {
           context.build.warnings.push(warning);
-          log(warning, "warn");
+          log.warn(warning);
         };
         if (!result.metafile) {
           warn("Missing metafile from build result.");
@@ -2210,7 +2193,7 @@ const getRollupPlugin = (context, log) => {
       const reportOutputsIndexed = {};
       const warn = (warning) => {
         context.build.warnings.push(warning);
-        log(warning, "warn");
+        log.warn(warning);
       };
       for (const [filepath, { dependencies, dependents }] of Object.entries(importsReport)) {
         for (const dependency of dependencies) {
@@ -2360,14 +2343,14 @@ const getRollupPlugin = (context, log) => {
   };
 };
 
-const getWebpackPlugin = (context, PLUGIN_NAME, log) => (compiler) => {
+const getXpackPlugin = (context, PLUGIN_NAME, log) => (compiler) => {
   const inputs = [];
   const outputs = [];
   const entries = [];
-  const warnings = [];
   const reportInputsIndexed = /* @__PURE__ */ new Map();
   const reportOutputsIndexed = /* @__PURE__ */ new Map();
   const modulesPerFile = /* @__PURE__ */ new Map();
+  const moduleIndex = /* @__PURE__ */ new Map();
   const tempSourcemaps = [];
   const tempDeps = /* @__PURE__ */ new Map();
   const isModuleSupported = (moduleIdentifier) => {
@@ -2377,83 +2360,148 @@ const getWebpackPlugin = (context, PLUGIN_NAME, log) => (compiler) => {
     );
   };
   const warn = (warning) => {
-    warnings.push(warning);
-    log(warning, "warn");
+    context.build.warnings.push(warning);
+    log.warn(warning);
   };
-  compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
-    compilation.hooks.finishModules.tap(PLUGIN_NAME, (finishedModules) => {
-      const getModuleFromDep = (dep) => {
-        return compilation.moduleGraph ? compilation.moduleGraph.getModule(dep) : dep.module;
-      };
-      for (const module of finishedModules) {
-        const moduleIdentifier = module.identifier();
-        const dependencies = new Set(
-          [...module.dependencies, ...module.blocks.flatMap((b) => b.dependencies)].filter(
-            (dep) => (
-              // Ignore side effects.
-              dep.type !== "harmony side effect evaluation" && // Ignore those we can't identify.
-              getModuleFromDep(dep)?.identifier() && // Only what we support.
-              isModuleSupported(getModuleFromDep(dep)?.identifier()) && // Don't add itself as a dependency.
-              getModuleFromDep(dep)?.identifier() !== moduleIdentifier
-            )
-          ).map((dep) => {
-            return getModuleFromDep(dep)?.identifier();
-          }).filter(Boolean)
-        );
-        if (!isModuleSupported(moduleIdentifier)) {
-          continue;
-        }
-        for (const depIdentifier of dependencies) {
-          const depDeps = tempDeps.get(depIdentifier) || {
-            dependencies: /* @__PURE__ */ new Set(),
-            dependents: /* @__PURE__ */ new Set()
-          };
-          depDeps.dependents.add(moduleIdentifier);
-          tempDeps.set(depIdentifier, depDeps);
-        }
-        const moduleDeps = tempDeps.get(moduleIdentifier) || {
-          dependents: /* @__PURE__ */ new Set(),
-          dependencies: /* @__PURE__ */ new Set()
-        };
-        for (const moduleDep of dependencies) {
-          moduleDeps.dependencies.add(moduleDep);
+  const getKeysToIndex = (mod) => {
+    const values = {
+      identifier: mod.identifier()
+    };
+    if ("resource" in mod && typeof mod.resource === "string") {
+      values.resource = mod.resource;
+    }
+    if ("request" in mod && typeof mod.request === "string") {
+      values.request = mod.request;
+    }
+    if ("rawRequest" in mod && typeof mod.rawRequest === "string") {
+      values.rawRequest = mod.rawRequest;
+    }
+    if ("userRequest" in mod && typeof mod.userRequest === "string") {
+      values.userRequest = mod.userRequest;
+    }
+    const keysToIndex = /* @__PURE__ */ new Set();
+    for (const [key, value] of Object.entries(values)) {
+      if (!value) {
+        continue;
+      }
+      if (moduleIndex.has(value)) {
+        warn(`Module ${mod.identifier()} is already indexed by ${key}.`);
+        if (moduleIndex.get(value) !== mod) {
+          warn(`Module ${mod.identifier()} is indexed with a different value.`);
         }
-        tempDeps.set(moduleIdentifier, moduleDeps);
-        const file = {
-          size: module.size() || 0,
-          name: cleanName(context, moduleIdentifier),
-          dependencies: /* @__PURE__ */ new Set(),
-          dependents: /* @__PURE__ */ new Set(),
-          filepath: moduleIdentifier,
-          type: getType(moduleIdentifier)
-        };
-        inputs.push(file);
-        reportInputsIndexed.set(moduleIdentifier, file);
+      } else {
+        keysToIndex.add(value);
       }
-      for (const input of inputs) {
-        const depsReport = tempDeps.get(input.filepath);
-        if (!depsReport) {
-          warn(`Could not find dependency report for ${input.name}`);
-          continue;
+    }
+    return keysToIndex;
+  };
+  const getAllDependencies = (module, dependencies = []) => {
+    if ("dependencies" in module) {
+      for (const dependency of module.dependencies) {
+        dependencies.push(dependency);
+        getAllDependencies(dependency, dependencies);
+      }
+    }
+    if ("blocks" in module) {
+      for (const block of module.blocks) {
+        getAllDependencies(block, dependencies);
+      }
+    }
+    return dependencies;
+  };
+  const getModuleFromDep = (mod, dep) => {
+    if ("request" in dep && dep.request) {
+      if (moduleIndex.has(dep.request)) {
+        return moduleIndex.get(dep.request);
+      }
+      if (mod.context && moduleIndex.has(getAbsolutePath(mod.context, dep.request))) {
+        return moduleIndex.get(getAbsolutePath(mod.context, dep.request));
+      }
+    }
+  };
+  compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+    compilation.hooks.finishModules.tap(
+      PLUGIN_NAME,
+      (finishedModules) => {
+        for (const module of finishedModules) {
+          const keysToIndex = getKeysToIndex(module);
+          for (const key of keysToIndex) {
+            moduleIndex.set(key, module);
+          }
         }
-        for (const dependency of depsReport.dependencies) {
-          const depInput = reportInputsIndexed.get(dependency);
-          if (!depInput) {
-            warn(`Could not find input of dependency ${dependency}`);
+        for (const module of finishedModules) {
+          const moduleIdentifier = module.identifier();
+          const dependencies = new Set(
+            getAllDependencies(module).map((dep) => {
+              const mod = getModuleFromDep(module, dep);
+              if (!mod || !mod.identifier()) {
+                return false;
+              }
+              const identifier = mod.identifier();
+              if (!isModuleSupported(identifier)) {
+                return false;
+              }
+              if (identifier === moduleIdentifier) {
+                return false;
+              }
+              return identifier;
+            }).filter(Boolean)
+          );
+          if (!isModuleSupported(moduleIdentifier)) {
             continue;
           }
-          input.dependencies.add(depInput);
+          for (const depIdentifier of dependencies) {
+            const depDeps = tempDeps.get(depIdentifier) || {
+              dependencies: /* @__PURE__ */ new Set(),
+              dependents: /* @__PURE__ */ new Set()
+            };
+            depDeps.dependents.add(moduleIdentifier);
+            tempDeps.set(depIdentifier, depDeps);
+          }
+          const moduleDeps = tempDeps.get(moduleIdentifier) || {
+            dependents: /* @__PURE__ */ new Set(),
+            dependencies: /* @__PURE__ */ new Set()
+          };
+          for (const moduleDep of dependencies) {
+            moduleDeps.dependencies.add(moduleDep);
+          }
+          tempDeps.set(moduleIdentifier, moduleDeps);
+          const file = {
+            size: module.size() || 0,
+            name: cleanName(context, moduleIdentifier),
+            dependencies: /* @__PURE__ */ new Set(),
+            dependents: /* @__PURE__ */ new Set(),
+            filepath: moduleIdentifier,
+            type: getType(moduleIdentifier)
+          };
+          inputs.push(file);
+          reportInputsIndexed.set(moduleIdentifier, file);
         }
-        for (const dependent of depsReport.dependents) {
-          const depInput = reportInputsIndexed.get(dependent);
-          if (!depInput) {
-            warn(`Could not find input of dependent ${dependent}`);
+        for (const input of inputs) {
+          const depsReport = tempDeps.get(input.filepath);
+          if (!depsReport) {
+            warn(`Could not find dependency report for ${input.name}`);
             continue;
           }
-          input.dependents.add(depInput);
+          for (const dependency of depsReport.dependencies) {
+            const depInput = reportInputsIndexed.get(dependency);
+            if (!depInput) {
+              warn(`Could not find input of dependency ${dependency}`);
+              continue;
+            }
+            input.dependencies.add(depInput);
+          }
+          for (const dependent of depsReport.dependents) {
+            const depInput = reportInputsIndexed.get(dependent);
+            if (!depInput) {
+              warn(`Could not find input of dependent ${dependent}`);
+              continue;
+            }
+            input.dependents.add(depInput);
+          }
         }
       }
-    });
+    );
   });
   compiler.hooks.afterEmit.tap(PLUGIN_NAME, (result) => {
     const chunks = result.chunks;
@@ -2466,7 +2514,13 @@ const getWebpackPlugin = (context, PLUGIN_NAME, log) => (compiler) => {
     const chunkGraph = result.chunkGraph;
     for (const chunk of chunks) {
       const files = getChunkFiles(chunk);
-      const chunkModules = (chunkGraph ? chunkGraph?.getChunkModules(chunk) : chunk.getModules()).flatMap((m) => {
+      const chunkModules = (chunkGraph ? (
+        // @ts-expect-error: Reconciliating Webpack 4, Webpack 5 and Rspack is hard.
+        chunkGraph?.getChunkModules(chunk)
+      ) : (
+        // This one is for webpack 4.
+        "getModules" in chunk && typeof chunk.getModules === "function" ? chunk.getModules() : []
+      )).flatMap((m) => {
         return "modules" in m && Array.isArray(m.modules) ? m.modules.map((m2) => m2.identifier()) : m.identifier();
       }).filter(isModuleSupported);
       for (const file of files) {
@@ -2521,11 +2575,16 @@ const getWebpackPlugin = (context, PLUGIN_NAME, log) => (compiler) => {
       let size = 0;
       const entryFiles = entrypoint.chunks.flatMap(getChunkFiles);
       const entryFilename = entrypoint.chunks.filter(
-        (c) => (
-          // Webpack5 forces you to use the chunkGraph to get the modules.
-          chunkGraph ? chunkGraph.getNumberOfEntryModules(c) > 0 : c.hasEntryModule()
+        (chunk) => chunkGraph ? (
+          // @ts-expect-error: Reconciliating Webpack 4, Webpack 5 and Rspack is hard.
+          chunkGraph.getChunkEntryModulesIterable(chunk)
+        ) : (
+          // This one is for webpack 4.
+          "hasEntryModule" in chunk && typeof chunk.hasEntryModule === "function" ? chunk.hasEntryModule() : false
         )
-      ).flatMap((c) => Array.from(c.files))[0];
+      ).flatMap((c) => Array.from(c.files)).filter(
+        (f) => f.includes(name) || entrypoint.name && f.includes(entrypoint.name)
+      )[0];
       for (const file2 of entryFiles) {
         const outputFound = reportOutputsIndexed.get(file2);
         if (!file2 || !outputFound) {
@@ -2548,23 +2607,27 @@ const getWebpackPlugin = (context, PLUGIN_NAME, log) => (compiler) => {
       };
       entries.push(file);
     }
-    context.build.errors.push(...result.errors.map((err) => err.message));
-    context.build.warnings.push(...warnings, ...result.warnings.map((err) => err.message));
+    for (const error of result.errors) {
+      context.build.errors.push(error.message);
+    }
+    for (const warning of result.warnings) {
+      context.build.warnings.push(warning.message);
+    }
     context.build.inputs = inputs;
     context.build.outputs = outputs;
     context.build.entries = entries;
   });
 };
 
-const PLUGIN_NAME$2 = "datadog-build-report-plugin";
-const getBuildReportPlugins = (context) => {
-  const log = context.getLogger(PLUGIN_NAME$2);
+const PLUGIN_NAME$3 = "datadog-build-report-plugin";
+const getBuildReportPlugins = (context, log) => {
   return [
     {
-      name: PLUGIN_NAME$2,
+      name: PLUGIN_NAME$3,
       enforce: "post",
       esbuild: getEsbuildPlugin(context, log),
-      webpack: getWebpackPlugin(context, PLUGIN_NAME$2, log),
+      rspack: getXpackPlugin(context, PLUGIN_NAME$3, log),
+      webpack: getXpackPlugin(context, PLUGIN_NAME$3, log),
       // Vite and Rollup have the same API.
       vite: getRollupPlugin(context, log),
       rollup: getRollupPlugin(context, log)
@@ -2572,7 +2635,7 @@ const getBuildReportPlugins = (context) => {
   ];
 };
 
-const PLUGIN_NAME$1 = "datadog-bundler-report-plugin";
+const PLUGIN_NAME$2 = "datadog-bundler-report-plugin";
 const rollupPlugin = (context) => ({
   options(options) {
     context.bundler.rawConfig = options;
@@ -2587,9 +2650,15 @@ const rollupPlugin = (context) => ({
     }
   }
 });
+const xpackPlugin = (context) => (compiler) => {
+  context.bundler.rawConfig = compiler.options;
+  if (compiler.options.output?.path) {
+    context.bundler.outDir = compiler.options.output.path;
+  }
+};
 const getBundlerReportPlugins = (globalContext) => {
   const bundlerReportPlugin = {
-    name: PLUGIN_NAME$1,
+    name: PLUGIN_NAME$2,
     enforce: "pre",
     esbuild: {
       setup(build) {
@@ -2603,12 +2672,8 @@ const getBundlerReportPlugins = (globalContext) => {
         build.initialOptions.metafile = true;
       }
     },
-    webpack(compiler) {
-      globalContext.bundler.rawConfig = compiler.options;
-      if (compiler.options.output?.path) {
-        globalContext.bundler.outDir = compiler.options.output.path;
-      }
-    },
+    webpack: xpackPlugin(globalContext),
+    rspack: xpackPlugin(globalContext),
     // Vite and Rollup have the same API.
     vite: rollupPlugin(globalContext),
     rollup: rollupPlugin(globalContext)
@@ -2776,10 +2841,11 @@ const getRepositoryData = async (git, repositoryURL) => {
   return data;
 };
 
+const PLUGIN_NAME$1 = "datadog-git-plugin";
 const getGitPlugins = (options, context) => {
   return [
     {
-      name: "datadog-git-plugin",
+      name: PLUGIN_NAME$1,
       enforce: "pre",
       async buildStart() {
         const shouldGetGitInfo = options.rum?.sourcemaps && options.disableGit !== true;
@@ -2837,10 +2903,10 @@ const processItem = async (item, log) => {
   } catch (error) {
     const itemId = `${item.type} - ${truncateString(item.value)}`;
     if (item.fallback) {
-      log(`Fallback for "${itemId}": ${error.toString()}`, "warn");
+      log.warn(`Fallback for "${itemId}": ${error.toString()}`);
       result = await processItem(item.fallback, log);
     } else {
-      log(`Failed "${itemId}": ${error.toString()}`, "warn");
+      log.warn(`Failed "${itemId}": ${error.toString()}`);
       result = "";
     }
   }
@@ -2855,8 +2921,7 @@ const processInjections = async (toInject, log) => {
   return results.filter(Boolean);
 };
 
-const getInjectionPlugins = (bundler, context, toInject) => {
-  const log = context.getLogger(PLUGIN_NAME);
+const getInjectionPlugins = (bundler, context, toInject, log) => {
   const contentToInject = [];
   const getContentToInject = () => {
     const before = `
@@ -2896,11 +2961,11 @@ ${after}`;
         );
         try {
           if (fs.existsSync(absolutePathInjectFile)) {
-            log(`Temporary file "${INJECTED_FILE_PATH}" already exists.`, "warn");
+            log.warn(`Temporary file "${INJECTED_FILE_PATH}" already exists.`);
           }
           await outputFile(absolutePathInjectFile, getContentToInject());
         } catch (e) {
-          log(`Could not create the file: ${e.message}`, "error");
+          log.error(`Could not create the file: ${e.message}`);
         }
       },
       async buildEnd() {
@@ -2911,6 +2976,7 @@ ${after}`;
           context.bundler.outDir,
           INJECTED_FILE_PATH
         );
+        log.debug(`Removing temporary file "${INJECTED_FILE_PATH}".`);
         await rm(absolutePathInjectFile);
       }
     },
@@ -2933,7 +2999,7 @@ ${after}`;
         const BannerPlugin = compiler?.webpack?.BannerPlugin || bundler?.BannerPlugin || bundler?.default?.BannerPlugin;
         compiler?.webpack?.ChunkGraph || bundler?.ChunkGraph || bundler?.default?.ChunkGraph;
         if (!BannerPlugin) {
-          log("Missing BannerPlugin", "error");
+          log.error("Missing BannerPlugin");
         }
         let chunkGraph;
         compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
@@ -2965,6 +3031,20 @@ ${after}`;
           })
         );
       },
+      rspack: (compiler) => {
+        compiler.options.plugins = compiler.options.plugins || [];
+        compiler.options.plugins.push(
+          new compiler.rspack.BannerPlugin({
+            // Not wrapped in comments.
+            raw: true,
+            // Only entry modules.
+            entryOnly: true,
+            banner() {
+              return getContentToInject();
+            }
+          })
+        );
+      },
       rollup: rollupInjectionPlugin,
       vite: rollupInjectionPlugin
     }
@@ -2996,25 +3076,43 @@ const buildPluginFactory = ({
       injections,
       version
     });
+    const getLogger = getLoggerFactory(context.build, options.logLevel);
     context.pluginNames.push(HOST_NAME);
     const plugins = [
       // Prefill with our internal plugins.
       // #internal-plugins-injection-marker
-      ...getBuildReportPlugins(context),
+      ...getBuildReportPlugins(context, getLogger("datadog-build-report-plugin")),
       ...getBundlerReportPlugins(context),
       ...getGitPlugins(options, context),
-      ...getInjectionPlugins(bundler, context, injections)
+      ...getInjectionPlugins(
+        bundler,
+        context,
+        injections,
+        getLogger("datadog-injection-plugin")
+      )
       // #internal-plugins-injection-marker
     ];
     if (options.customPlugins) {
-      const customPlugins = options.customPlugins(options, context);
+      const customPlugins = options.customPlugins(
+        options,
+        context,
+        getLogger("datadog-custom-plugins")
+      );
       plugins.push(...customPlugins);
     }
     if (options[CONFIG_KEY$1] && options[CONFIG_KEY$1].disabled !== true) {
-      plugins.push(...getPlugins$2(options, context));
+      plugins.push(
+        ...getPlugins$1(options, context, getLogger(PLUGIN_NAME$5))
+      );
     }
     if (options[CONFIG_KEY] && options[CONFIG_KEY].disabled !== true) {
-      plugins.push(...getPlugins(options, context));
+      plugins.push(
+        ...getPlugins(
+          options,
+          context,
+          getLogger(PLUGIN_NAME$4)
+        )
+      );
     }
     context.pluginNames.push(...plugins.map((plugin) => plugin.name));
     return plugins;
@@ -3023,7 +3121,7 @@ const buildPluginFactory = ({
 
 var name = "@datadog/webpack-plugin";
 var packageManager = "yarn@4.0.2";
-var version$1 = "2.3.3-dev-2";
+var version$1 = "2.3.3-dev-3";
 var license = "MIT";
 var author = "Datadog";
 var description = "Datadog Webpack Plugin";