feat: Migrate to Webpack Built-in Infrastructure Logger with Backward…

.changeset/use-webpack-infrastructure-logger.md

@@ -0,0 +1,5 @@
+---
+"webpack-bundle-analyzer": minor
+---
+
+Use Webpack's infrastructure logger when available (`compiler.getInfrastructureLogger('webpack-bundle-analyzer')`) and deprecate the plugin's `logLevel` option in favor of Webpack's native `infrastructureLogging` configuration.

README.md

@@ -68,7 +68,7 @@ new BundleAnalyzerPlugin(options?: object)
 |    **`statsFilename`**     |                                                                                       `{String}`                                                                                       | Default: `stats.json`. Name of webpack stats JSON file that will be generated if `generateStatsFile` is `true`. It can be either an absolute path or a path relative to a bundle output directory (which is output.path in webpack config).                                                                                                                                                                                             |
 |     **`statsOptions`**     |                                                                                  `null` or `{Object}`                                                                                  | Default: `null`. Options for `stats.toJson()` method. For example you can exclude sources of your modules from stats file with `source: false` option. [See more options here](https://webpack.js.org/configuration/stats/).                                                                                                                                                                                                            |
 |    **`excludeAssets`**     |                                                  `{null\|pattern\|pattern[]}` where `pattern` equals to `{String\|RegExp\|function}`                                                   | Default: `null`. Patterns that will be used to match against asset names to exclude them from the report. If pattern is a string it will be converted to RegExp via `new RegExp(str)`. If pattern is a function it should have the following signature `(assetName: string) => boolean` and should return `true` to _exclude_ matching asset. If multiple patterns are provided asset should match at least one of them to be excluded. |
-|       **`logLevel`**       |                                                                       One of: `info`, `warn`, `error`, `silent`                                                                        | Default: `info`. Used to control how much details the plugin outputs.                                                                                                                                                                                                                                                                                                                                                                   |
+|       **`logLevel`**       |                                                                       One of: `info`, `warn`, `error`, `silent`                                                                        | **Deprecated**. Default: `info`. Used to control how much details the plugin outputs. Please use webpack's [`infrastructureLogging`](https://webpack.js.org/configuration/infrastructureLogging/) configuration instead.                                                                                                                                                                                                                |
 
 ### Absolute output paths
 

src/BundleAnalyzerPlugin.js

@@ -16,6 +16,7 @@ const viewer = require("./viewer");
 /** @typedef {import("webpack").StatsCompilation} StatsCompilation */
 /** @typedef {import("./sizeUtils").Algorithm} CompressionAlgorithm */
 /** @typedef {import("./Logger").Level} LogLever */
+/** @typedef {ReturnType<import("webpack").Compiler["getInfrastructureLogger"]>} WebpackLogger */
 /** @typedef {import("./viewer").ViewerServerObj} ViewerServerObj */
 
 /** @typedef {string | boolean | StatsOptions} PluginStatsOptions */
@@ -70,7 +71,7 @@ const analyzerStatsOptions = {
  * @property {string=} statsFilename stats filename
  * @property {PluginStatsOptions=} statsOptions stats options
  * @property {ExcludeAssets=} excludeAssets exclude assets
- * @property {LogLever=} logLevel exclude assets
+ * @property {LogLever=} logLevel (deprecated) log level
  * @property {boolean=} startAnalyzer start analyzer
  * @property {AnalyzerUrl=} analyzerUrl start analyzer
  */
@@ -80,6 +81,8 @@ class BundleAnalyzerPlugin {
    * @param {Options=} opts options
    */
   constructor(opts = {}) {
+    const hasCustomLogLevel = typeof opts.logLevel !== "undefined";
+
     /** @type {Required<Omit<Options, "analyzerPort" | "statsOptions">> & { analyzerPort: number, statsOptions: undefined | PluginStatsOptions }} */
     this.opts = {
       analyzerMode: "server",
@@ -102,10 +105,13 @@ class BundleAnalyzerPlugin {
         opts.analyzerPort === "auto" ? 0 : (opts.analyzerPort ?? 8888),
     };
 
+    /** @type {boolean} */
+    this.hasCustomLogLevel = hasCustomLogLevel;
     /** @type {Compiler | null} */
     this.compiler = null;
     /** @type {Promise<ViewerServerObj> | null} */
     this.server = null;
+    /** @type {Logger | WebpackLogger} */
     this.logger = new Logger(this.opts.logLevel);
   }
 
@@ -115,6 +121,18 @@ class BundleAnalyzerPlugin {
   apply(compiler) {
     this.compiler = compiler;
 
+    if (compiler.getInfrastructureLogger) {
+      const infraLogger = compiler.getInfrastructureLogger(
+        "webpack-bundle-analyzer",
+      );
+      this.logger = Logger.createInfrastructureLoggerAdapter(
+        infraLogger,
+        this.hasCustomLogLevel ? this.opts.logLevel : undefined,
+      );
+    } else {
+      this.logger = new Logger(this.opts.logLevel);
+    }
+
     /**
      * @param {Stats} stats stats
      * @param {(err?: Error) => void} callback callback

src/Logger.js

@@ -1,4 +1,5 @@
 /** @typedef {import("./BundleAnalyzerPlugin").EXPECTED_ANY} EXPECTED_ANY */
+/** @typedef {ReturnType<import("webpack").Compiler["getInfrastructureLogger"]>} WebpackLogger */
 
 /** @typedef {"debug" | "info" | "warn" | "error" | "silent"} Level */
 
@@ -95,6 +96,98 @@ class Logger {
       (LEVEL_TO_CONSOLE_METHOD.get(level) || level)
     ](...args);
   }
+
+  /**
+   * @param {WebpackLogger} infrastructureLogger infrastructure logger
+   * @param {Level=} userLogLevel user log level
+   * @param {boolean=} warned whether deprecation warning has been logged
+   * @returns {WebpackLogger} logger adapter
+   */
+  static createInfrastructureLoggerAdapter(
+    infrastructureLogger,
+    userLogLevel,
+    warned = false,
+  ) {
+    if (typeof userLogLevel === "undefined") {
+      return infrastructureLogger;
+    }
+
+    const levelIndex = LEVELS.indexOf(userLogLevel);
+
+    if (levelIndex === -1) {
+      throw new Error(
+        `Invalid log level "${userLogLevel}". Use one of these: ${LEVELS.join(", ")}`,
+      );
+    }
+
+    /** @type {Set<Level>} */
+    const activeLevels = new Set();
+
+    for (const [i, level] of LEVELS.entries()) {
+      if (i >= levelIndex) activeLevels.add(level);
+    }
+
+    if (!warned && activeLevels.has("warn")) {
+      infrastructureLogger.warn(
+        "The 'logLevel' option is deprecated and will be removed in a future release. " +
+          "Please use webpack's 'infrastructureLogging.level' option instead.",
+      );
+    }
+
+    return new Proxy(infrastructureLogger, {
+      get(target, prop, receiver) {
+        if (prop === "activeLevels") {
+          return activeLevels;
+        }
+
+        if (prop === "setLogLevel") {
+          return (/** @type {Level} */ level) => {
+            const idx = LEVELS.indexOf(level);
+
+            if (idx === -1) {
+              throw new Error(
+                `Invalid log level "${level}". Use one of these: ${LEVELS.join(", ")}`,
+              );
+            }
+
+            activeLevels.clear();
+
+            for (const [i, l] of LEVELS.entries()) {
+              if (i >= idx) activeLevels.add(l);
+            }
+          };
+        }
+
+        if (prop === "getChildLogger") {
+          return (/** @type {string | (() => string)} */ name) =>
+            Logger.createInfrastructureLoggerAdapter(
+              target.getChildLogger(name),
+              userLogLevel,
+              true,
+            );
+        }
+
+        const value = Reflect.get(target, prop, receiver);
+
+        if (typeof value === "function") {
+          const isManagedLevel =
+            LEVELS.includes(/** @type {Level} */ (prop)) || prop === "log";
+          const levelToCheck = prop === "log" ? "info" : prop;
+
+          if (
+            isManagedLevel &&
+            !activeLevels.has(/** @type {Level} */ (levelToCheck))
+          ) {
+            return () => {};
+          }
+
+          return value.bind(target);
+        }
+
+        return value;
+      },
+    });
+  }
 }
 
 module.exports = Logger;

src/analyzer.js

@@ -17,6 +17,7 @@ const FILENAME_EXTENSIONS = /\.(js|mjs|cjs|bundle)$/iu;
 /** @typedef {import("webpack").StatsAsset} StatsAsset */
 /** @typedef {import("./BundleAnalyzerPlugin").CompressionAlgorithm} CompressionAlgorithm */
 /** @typedef {import("./BundleAnalyzerPlugin").ExcludeAssets} ExcludeAssets */
+/** @typedef {ReturnType<import("webpack").Compiler["getInfrastructureLogger"]>} WebpackLogger */
 
 /**
  * @typedef {object} AnalyzerOptions
@@ -225,7 +226,7 @@ function isEntryModule(statsModule) {
 
 /**
  * @typedef {object} ViewerDataOptions
- * @property {Logger} logger logger
+ * @property {Logger | WebpackLogger} logger logger
  * @property {CompressionAlgorithm} compressionAlgorithm compression algorithm
  * @property {ExcludeAssets} excludeAssets exclude assets
  */

src/utils.js

@@ -6,7 +6,7 @@ const opener = require("opener");
 
 /** @typedef {import("./BundleAnalyzerPlugin").ExcludeAssets} ExcludeAssets */
 /** @typedef {import("./BundleAnalyzerPlugin").AnalyzerUrl} AnalyzerUrl */
-/** @typedef {import("./Logger")} Logger */
+/** @typedef {import("./Logger") | ReturnType<import("webpack").Compiler["getInfrastructureLogger"]>} Logger */
 
 const MONTHS = [
   "Jan",

src/viewer.js

@@ -21,6 +21,7 @@ const { open } = require("./utils");
 /** @typedef {import("./BundleAnalyzerPlugin").ExcludeAssets} ExcludeAssets */
 /** @typedef {import("./analyzer").ViewerDataOptions} ViewerDataOptions */
 /** @typedef {import("./analyzer").ChartData} ChartData */
+/** @typedef {ReturnType<import("webpack").Compiler["getInfrastructureLogger"]>} WebpackLogger */
 
 const projectRoot = path.resolve(__dirname, "..");
 
@@ -107,7 +108,7 @@ function getChartData(analyzerOpts, bundleStats, bundleDir) {
  * @property {string} host host
  * @property {boolean} openBrowser true when need to open browser, otherwise false
  * @property {string | null} bundleDir bundle dir
- * @property {Logger} logger logger
+ * @property {Logger | WebpackLogger} logger logger
  * @property {Sizes} defaultSizes default sizes
  * @property {CompressionAlgorithm} compressionAlgorithm compression algorithm
  * @property {ExcludeAssets | null} excludeAssets exclude assets
@@ -245,7 +246,7 @@ async function startServer(bundleStats, opts) {
  * @property {string} reportFilename report filename
  * @property {ReportTitle} reportTitle report title
  * @property {string | null} bundleDir bundle dir
- * @property {Logger} logger logger
+ * @property {Logger | WebpackLogger} logger logger
  * @property {Sizes} defaultSizes default sizes
  * @property {CompressionAlgorithm} compressionAlgorithm compression algorithm
  * @property {ExcludeAssets} excludeAssets exclude assets
@@ -307,7 +308,7 @@ async function generateReport(bundleStats, opts) {
  * @typedef {object} GenerateJSONReportOptions
  * @property {string} reportFilename report filename
  * @property {string | null} bundleDir bundle dir
- * @property {Logger} logger logger
+ * @property {Logger | WebpackLogger} logger logger
  * @property {ExcludeAssets} excludeAssets exclude assets
  * @property {CompressionAlgorithm} compressionAlgorithm compression algorithm
  */