The old setup tried to log >= warning to stderr, the rest to stdout.
However, that logic was flawed, so warnings ended up in stdout, which makes `hugo list all` etc. hard to reason about from scripts.
This commit fixes this by making all logging (info, warn, error) log to stderr and let stdout be reserved for program output.
Fixes #13074
type rootCommand struct {
Printf func(format string, v ...interface{})
Println func(a ...interface{})
- Out io.Writer
+ StdOut io.Writer
+ StdErr io.Writer
logger loggers.Logger
}
func (r *rootCommand) newDepsConfig(conf *commonConfig) deps.DepsCfg {
- return deps.DepsCfg{Configs: conf.configs, Fs: conf.fs, LogOut: r.logger.Out(), LogLevel: r.logger.Level(), ChangesFromBuild: r.changesFromBuild}
+ return deps.DepsCfg{Configs: conf.configs, Fs: conf.fs, StdOut: r.logger.StdOut(), StdErr: r.logger.StdErr(), LogLevel: r.logger.Level(), ChangesFromBuild: r.changesFromBuild}
}
func (r *rootCommand) Name() string {
}
func (r *rootCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
- r.Out = os.Stdout
+ r.StdOut = os.Stdout
+ r.StdErr = os.Stderr
if r.quiet {
- r.Out = io.Discard
+ r.StdOut = io.Discard
+ r.StdErr = io.Discard
}
// Used by mkcert (server).
- log.SetOutput(r.Out)
+ log.SetOutput(r.StdOut)
r.Printf = func(format string, v ...interface{}) {
if !r.quiet {
- fmt.Fprintf(r.Out, format, v...)
+ fmt.Fprintf(r.StdOut, format, v...)
}
}
r.Println = func(a ...interface{}) {
if !r.quiet {
- fmt.Fprintln(r.Out, a...)
+ fmt.Fprintln(r.StdOut, a...)
}
}
_, running := runner.Command.(*serverCommand)
optsLogger := loggers.Options{
DistinctLevel: logg.LevelWarn,
Level: level,
- Stdout: r.Out,
- Stderr: r.Out,
+ StdOut: r.StdOut,
+ StdErr: r.StdErr,
StoreErrors: running,
}
return err
}
- writer := csv.NewWriter(r.Out)
+ writer := csv.NewWriter(r.StdOut)
defer writer.Flush()
writer.Write([]string{
type noAnsiEscapeHandler struct {
mu sync.Mutex
- outWriter io.Writer // Defaults to os.Stdout.
- errWriter io.Writer // Defaults to os.Stderr.
+ outWriter io.Writer
+ errWriter io.Writer
predicate func(*logg.Entry) bool
noLevelPrefix bool
}
// Options defines options for the logger.
type Options struct {
Level logg.Level
- Stdout io.Writer
- Stderr io.Writer
+ StdOut io.Writer
+ StdErr io.Writer
DistinctLevel logg.Level
StoreErrors bool
HandlerPost func(e *logg.Entry) error
// New creates a new logger with the given options.
func New(opts Options) Logger {
- if opts.Stdout == nil {
- opts.Stdout = os.Stdout
+ if opts.StdOut == nil {
+ opts.StdOut = os.Stdout
}
- if opts.Stderr == nil {
- opts.Stderr = os.Stdout
+ if opts.StdErr == nil {
+ opts.StdErr = os.Stderr
}
+
if opts.Level == 0 {
opts.Level = logg.LevelWarn
}
var logHandler logg.Handler
- if terminal.PrintANSIColors(os.Stdout) {
- logHandler = newDefaultHandler(opts.Stdout, opts.Stderr)
+ if terminal.PrintANSIColors(os.Stderr) {
+ logHandler = newDefaultHandler(opts.StdErr, opts.StdErr)
} else {
- logHandler = newNoAnsiEscapeHandler(opts.Stdout, opts.Stderr, false, nil)
+ logHandler = newNoAnsiEscapeHandler(opts.StdErr, opts.StdErr, false, nil)
}
errorsw := &strings.Builder{}
logCounters: logCounters,
errors: errorsw,
reset: reset,
- out: opts.Stdout,
+ stdOut: opts.StdOut,
+ stdErr: opts.StdErr,
level: opts.Level,
logger: logger,
tracel: l.WithLevel(logg.LevelTrace),
opts := Options{
DistinctLevel: logg.LevelWarn,
Level: logg.LevelWarn,
- Stdout: os.Stdout,
- Stderr: os.Stdout,
}
return New(opts)
}
opts := Options{
DistinctLevel: logg.LevelWarn,
Level: logg.LevelTrace,
- Stdout: os.Stdout,
- Stderr: os.Stdout,
}
return New(opts)
}
Level() logg.Level
LoggCount(logg.Level) int
Logger() logg.Logger
- Out() io.Writer
+ StdOut() io.Writer
+ StdErr() io.Writer
Printf(format string, v ...any)
Println(v ...any)
PrintTimerIfDelayed(start time.Time, name string)
logCounters *logLevelCounter
errors *strings.Builder
reset func()
- out io.Writer
+ stdOut io.Writer
+ stdErr io.Writer
level logg.Level
logger logg.Logger
tracel logg.LevelLogger
return l.logger
}
-func (l *logAdapter) Out() io.Writer {
- return l.out
+func (l *logAdapter) StdOut() io.Writer {
+ return l.stdOut
+}
+
+func (l *logAdapter) StdErr() io.Writer {
+ return l.stdErr
}
// PrintTimerIfDelayed prints a time statement to the FEEDBACK logger
if !strings.HasSuffix(format, "\n") {
format += "\n"
}
- fmt.Fprintf(l.out, format, v...)
+ fmt.Fprintf(l.stdOut, format, v...)
}
func (l *logAdapter) Println(v ...any) {
- fmt.Fprintln(l.out, v...)
+ fmt.Fprintln(l.stdOut, v...)
}
func (l *logAdapter) Reset() {
opts := loggers.Options{
DistinctLevel: logg.LevelWarn,
StoreErrors: true,
- Stdout: io.Discard,
- Stderr: io.Discard,
+ StdOut: io.Discard,
+ StdErr: io.Discard,
}
l := loggers.New(opts)
HandlerPost: func(e *logg.Entry) error {
panic(e.Message)
},
- Stdout: io.Discard,
- Stderr: io.Discard,
+ StdOut: io.Discard,
+ StdErr: io.Discard,
}
l := loggers.New(opts)
opts := loggers.Options{
StoreErrors: true,
- Stderr: &sb,
- Stdout: &sb,
+ StdErr: &sb,
+ StdOut: &sb,
}
l := loggers.New(opts)
opts := loggers.Options{
StoreErrors: true,
DistinctLevel: logg.LevelWarn,
- Stdout: io.Discard,
- Stderr: io.Discard,
+ StdOut: io.Discard,
+ StdErr: io.Discard,
}
l := loggers.New(opts)
// The logging level to use.
LogLevel logg.Level
- // Where to write the logs.
- // Currently we typically write everything to stdout.
- LogOut io.Writer
+ // Logging output.
+ StdErr io.Writer
+
+ // The console output.
+ StdOut io.Writer
// The file systems to use
Fs *hugofs.Fs
logger := loggers.New(
loggers.Options{
- Stdout: w,
- Stderr: w,
+ StdOut: w,
+ StdErr: w,
Level: s.Cfg.LogLevel,
DistinctLevel: logg.LevelWarn,
},
s.Assert(err, qt.IsNil)
- depsCfg := deps.DepsCfg{Configs: res, Fs: fs, LogLevel: logger.Level(), LogOut: logger.Out()}
+ depsCfg := deps.DepsCfg{Configs: res, Fs: fs, LogLevel: logger.Level(), StdErr: logger.StdErr()}
sites, err := NewHugoSites(depsCfg)
if err != nil {
initErr = err
if cfg.Configs.Base.PanicOnWarning {
logHookLast = loggers.PanicOnWarningHook
}
- if cfg.LogOut == nil {
- cfg.LogOut = os.Stdout
+ if cfg.StdOut == nil {
+ cfg.StdOut = os.Stdout
+ }
+ if cfg.StdErr == nil {
+ cfg.StdErr = os.Stderr
}
if cfg.LogLevel == 0 {
cfg.LogLevel = logg.LevelWarn
Level: cfg.LogLevel,
DistinctLevel: logg.LevelWarn, // This will drop duplicate log warning and errors.
HandlerPost: logHookLast,
- Stdout: cfg.LogOut,
- Stderr: cfg.LogOut,
+ StdOut: cfg.StdOut,
+ StdErr: cfg.StdErr,
StoreErrors: conf.Watching(),
SuppressStatements: conf.IgnoredLogs(),
}
}
func (c *Client) get(args ...string) error {
- if err := c.runGo(context.Background(), c.logger.Out(), append([]string{"get"}, args...)...); err != nil {
+ if err := c.runGo(context.Background(), c.logger.StdOut(), append([]string{"get"}, args...)...); err != nil {
return fmt.Errorf("failed to get %q: %w", args, err)
}
return nil
// If path is empty, Go will try to guess.
// If this succeeds, this project will be marked as Go Module.
func (c *Client) Init(path string) error {
- err := c.runGo(context.Background(), c.logger.Out(), "mod", "init", path)
+ err := c.runGo(context.Background(), c.logger.StdOut(), "mod", "init", path)
if err != nil {
return fmt.Errorf("failed to init modules: %w", err)
}
# Test deprecation logging.
hugo -e info --logLevel info
-stdout 'INFO deprecated: item was deprecated in Hugo'
+stderr 'INFO deprecated: item was deprecated in Hugo'
hugo -e warn --logLevel warn
-stdout 'WARN deprecated: item was deprecated in Hugo'
+stderr 'WARN deprecated: item was deprecated in Hugo'
! hugo -e error --logLevel warn
-stdout 'ERROR deprecated: item was deprecated in Hugo'
+stderr 'ERROR deprecated: item was deprecated in Hugo'
-- hugo.toml --
baseURL = "https://example.com/"
! stderr .
-- config/_default/hugo.toml --
-baseURL = "https://example.com/"
\ No newline at end of file
+baseURL = "https://example.com/"
+disableKinds = ["RSS", "page", "sitemap", "robotsTXT", "404", "taxonomy", "term", "home"]
\ No newline at end of file
hugo --printPathWarnings
-stdout 'Duplicate'
+stderr 'Duplicate'
-- hugo.toml --
-- assets/css/styles.css --
hugo --printPathWarnings
-stdout 'Duplicate target paths: .index.html \(2\)'
+stderr 'Duplicate target paths: .index.html \(2\)'
-- hugo.toml --
disableKinds = ["taxonomy", "term", "RSS", "sitemap", "robotsTXT", "404", "section"]
hugo --printUnusedTemplates
-stdout 'Template _default/list.html is unused'
+stderr 'Template _default/list.html is unused'
-- hugo.toml --
disableKinds = ["taxonomy", "term", "RSS", "sitemap", "robotsTXT", "404", "section", "page"]
--- /dev/null
+# Issue #13074
+
+hugo
+stderr 'warning'
+! stdout 'warning'
+
+-- hugo.toml --
+baseURL = "http://example.org/"
+disableKinds = ["RSS", "page", "sitemap", "robotsTXT", "404", "taxonomy", "term"]
+-- layouts/index.html --
+Home
+{{ warnf "This is a warning" }}
+
projects / brevno-suite / hugo / commitdiff