What kind of change does this PR introduce?
feature

Did you add tests for your changes?
yes

Does this PR introduce a breaking change?
no

What needs to be documented once your changes are merged?

• Plugins should prefer to use compilation.getLogger("PluginName") for logging. This kind of logging is stored to the Stats and formatted in this way. It can be filtered and exported by the user.

• Plugins may use the compiler.getInfrastructureLogger("PluginName") for logging to, but logging to this is not stored in the Stats and therefore not formatted this way. Instead it's usually logged to the console/dashboard/gui directly. It can be filtered by the user.

• Loaders should prefer to use this.getLogger(). This is a shortcut to compilation.getLogger() with loader path and processed file.

• Loaders may use this.getLogger("name") to get an independent logger with a child name. Loader path and processed file is still added.

• Plugins may use compilation.getLogger ? compilation.getLogger("PluginName") : console to provide a fallback for webpack version not supporting getLogger. Similar for Loaders.

• Logger API

  • Important hint: Avoid noise in the log! Keep in mind that multiple plugins and loaders are used together. Loader usually process multiple files and are invoked for every file. Choose a log level as low as possible to keep log output informative.
  • Use logger.error(...) for error messages
  • Use logger.warn(...) for warnings
  • Use logger.info(...) for important information messages (they are displayed in the default settings, only use them for things the user really need to know)
  • Use logger.log(...) for unimportant information messages (they are only displayed when opt-in into displaying them)
  • Use logger.debug(...) for debugging information (they are only displayed when opt-in into debug logging for specific modules)
  • Use logger.trace() to display a stack trace (displayed like logger.debug)
  • Use logger.group(...) to group messages together (displayed like logger.log)
  • Use logger.groupEnd() to end a group
  • Use logger.groupCollapsed(...) to group messages together (displayed collapsed like logger.log, displayed expanded when verbose logging or debug logging is enabled)
  • Use logger.clear() to clear the log (it may only print a horizontal line instead) (displayed like logger.log)
  • Use logger.profile(...) and logger.profileEnd(...) to capture a profile (delegated to console.profile when supported)

• Logging configuration

  • stats.logging: "none"|"error"|"warn"|"info"|"log"|"verbose" to choose displayed log level
    • none: nothing
    • error: only errors
    • warn: errors and warnings
    • info: errors, warnings, and info messages (default)
    • log: errors, warnings, info messages, log messages, groups, clear. Collapsed groups are displayed collapsed.
    • verbose: all except debug and trace. Collapsed groups are displayed expanded
  • stats.logging: false to disable all log output
  • stats.logging: true alias to stats.logging: "log"
  • stats.loggingDebug: true|false|/regexp/|"string"|(name) => true to enable debug output for specific items (intended for plugin/loader developer)
    • When stats.logging: false: stats.loggingDebug is ignored.
  • stats.loggingTrace: true enable stack traces in log output for errors, warnings and traces.
  • infrastructureLogging.level: "none"|"error"|"warn"|"info"|"log"|"verbose"
    • like stats.logging but for infrastructure logging
  • infrastructureLogging.debug: true|false|/regexp/|"string"|(name) => true
    • like stats.loggingDebug but for infrastructure logging

• Plugins

  • Compiler.hooks.infrastructureLog and Compilation.hooks.log for plugins
  • With webpack 5 there will be plugins for the Stats to modify the log display in stats too

• Runtime Logger API

  • Only for devtooling. Not intended to be included in production mode.
  • const logging = require("webpack/logging/runtime")
  • logging.getLogger("name")
  • logging.configureDefaultLogger({ level: "log", debug: /something/ })
  • logging.hooks.log to apply plugins to the runtime logger