mirror of
https://github.com/gohugoio/hugo.git
synced 2024-11-07 20:30:36 -05:00
339 lines
8 KiB
Go
339 lines
8 KiB
Go
// Copyright 2020 The Hugo Authors. All rights reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package loggers
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"log"
|
|
"os"
|
|
"regexp"
|
|
"runtime"
|
|
"time"
|
|
|
|
"github.com/gohugoio/hugo/common/terminal"
|
|
|
|
jww "github.com/spf13/jwalterweatherman"
|
|
)
|
|
|
|
// Counts ERROR logs to the global jww logger.
|
|
var GlobalErrorCounter *jww.Counter
|
|
|
|
func init() {
|
|
GlobalErrorCounter = &jww.Counter{}
|
|
jww.SetLogListeners(jww.LogCounter(GlobalErrorCounter, jww.LevelError))
|
|
}
|
|
|
|
func LoggerToWriterWithPrefix(logger *log.Logger, prefix string) io.Writer {
|
|
return prefixWriter{
|
|
logger: logger,
|
|
prefix: prefix,
|
|
}
|
|
}
|
|
|
|
type prefixWriter struct {
|
|
logger *log.Logger
|
|
prefix string
|
|
}
|
|
|
|
func (w prefixWriter) Write(p []byte) (n int, err error) {
|
|
w.logger.Printf("%s: %s", w.prefix, p)
|
|
return len(p), nil
|
|
}
|
|
|
|
type Logger interface {
|
|
Printf(format string, v ...interface{})
|
|
Println(v ...interface{})
|
|
PrintTimerIfDelayed(start time.Time, name string)
|
|
Debug() *log.Logger
|
|
Debugf(format string, v ...interface{})
|
|
Debugln(v ...interface{})
|
|
Info() *log.Logger
|
|
Infof(format string, v ...interface{})
|
|
Infoln(v ...interface{})
|
|
Warn() *log.Logger
|
|
Warnf(format string, v ...interface{})
|
|
Warnln(v ...interface{})
|
|
Error() *log.Logger
|
|
Errorf(format string, v ...interface{})
|
|
Errorln(v ...interface{})
|
|
Errors() string
|
|
|
|
Out() io.Writer
|
|
|
|
Reset()
|
|
|
|
// Used in tests.
|
|
LogCounters() *LogCounters
|
|
}
|
|
|
|
type LogCounters struct {
|
|
ErrorCounter *jww.Counter
|
|
WarnCounter *jww.Counter
|
|
}
|
|
|
|
type logger struct {
|
|
*jww.Notepad
|
|
|
|
// The writer that represents stdout.
|
|
// Will be ioutil.Discard when in quiet mode.
|
|
out io.Writer
|
|
|
|
logCounters *LogCounters
|
|
|
|
// This is only set in server mode.
|
|
errors *bytes.Buffer
|
|
}
|
|
|
|
func (l *logger) Printf(format string, v ...interface{}) {
|
|
l.FEEDBACK.Printf(format, v...)
|
|
}
|
|
|
|
func (l *logger) Println(v ...interface{}) {
|
|
l.FEEDBACK.Println(v...)
|
|
}
|
|
|
|
func (l *logger) Debug() *log.Logger {
|
|
return l.DEBUG
|
|
}
|
|
|
|
func (l *logger) Debugf(format string, v ...interface{}) {
|
|
l.DEBUG.Printf(format, v...)
|
|
}
|
|
|
|
func (l *logger) Debugln(v ...interface{}) {
|
|
l.DEBUG.Println(v...)
|
|
}
|
|
|
|
func (l *logger) Infof(format string, v ...interface{}) {
|
|
l.INFO.Printf(format, v...)
|
|
}
|
|
|
|
func (l *logger) Infoln(v ...interface{}) {
|
|
l.INFO.Println(v...)
|
|
}
|
|
|
|
func (l *logger) Info() *log.Logger {
|
|
return l.INFO
|
|
}
|
|
|
|
func (l *logger) Warnf(format string, v ...interface{}) {
|
|
l.WARN.Printf(format, v...)
|
|
}
|
|
|
|
func (l *logger) Warnln(v ...interface{}) {
|
|
l.WARN.Println(v...)
|
|
}
|
|
|
|
func (l *logger) Warn() *log.Logger {
|
|
return l.WARN
|
|
}
|
|
|
|
func (l *logger) Errorf(format string, v ...interface{}) {
|
|
l.ERROR.Printf(format, v...)
|
|
}
|
|
|
|
func (l *logger) Errorln(v ...interface{}) {
|
|
l.ERROR.Println(v...)
|
|
}
|
|
|
|
func (l *logger) Error() *log.Logger {
|
|
return l.ERROR
|
|
}
|
|
|
|
func (l *logger) LogCounters() *LogCounters {
|
|
return l.logCounters
|
|
}
|
|
|
|
func (l *logger) Out() io.Writer {
|
|
return l.out
|
|
}
|
|
|
|
// PrintTimerIfDelayed prints a time statement to the FEEDBACK logger
|
|
// if considerable time is spent.
|
|
func (l *logger) PrintTimerIfDelayed(start time.Time, name string) {
|
|
elapsed := time.Since(start)
|
|
milli := int(1000 * elapsed.Seconds())
|
|
if milli < 500 {
|
|
return
|
|
}
|
|
l.Printf("%s in %v ms", name, milli)
|
|
}
|
|
|
|
func (l *logger) PrintTimer(start time.Time, name string) {
|
|
elapsed := time.Since(start)
|
|
milli := int(1000 * elapsed.Seconds())
|
|
l.Printf("%s in %v ms", name, milli)
|
|
}
|
|
|
|
func (l *logger) Errors() string {
|
|
if l.errors == nil {
|
|
return ""
|
|
}
|
|
return ansiColorRe.ReplaceAllString(l.errors.String(), "")
|
|
}
|
|
|
|
// Reset resets the logger's internal state.
|
|
func (l *logger) Reset() {
|
|
l.logCounters.ErrorCounter.Reset()
|
|
if l.errors != nil {
|
|
l.errors.Reset()
|
|
}
|
|
}
|
|
|
|
// NewLogger creates a new Logger for the given thresholds
|
|
func NewLogger(stdoutThreshold, logThreshold jww.Threshold, outHandle, logHandle io.Writer, saveErrors bool) Logger {
|
|
return newLogger(stdoutThreshold, logThreshold, outHandle, logHandle, saveErrors)
|
|
}
|
|
|
|
// NewDebugLogger is a convenience function to create a debug logger.
|
|
func NewDebugLogger() Logger {
|
|
return NewBasicLogger(jww.LevelDebug)
|
|
}
|
|
|
|
// NewWarningLogger is a convenience function to create a warning logger.
|
|
func NewWarningLogger() Logger {
|
|
return NewBasicLogger(jww.LevelWarn)
|
|
}
|
|
|
|
// NewInfoLogger is a convenience function to create a info logger.
|
|
func NewInfoLogger() Logger {
|
|
return NewBasicLogger(jww.LevelInfo)
|
|
}
|
|
|
|
// NewErrorLogger is a convenience function to create an error logger.
|
|
func NewErrorLogger() Logger {
|
|
return NewBasicLogger(jww.LevelError)
|
|
}
|
|
|
|
// NewBasicLogger creates a new basic logger writing to Stdout.
|
|
func NewBasicLogger(t jww.Threshold) Logger {
|
|
return newLogger(t, jww.LevelError, os.Stdout, ioutil.Discard, false)
|
|
}
|
|
|
|
// NewBasicLoggerForWriter creates a new basic logger writing to w.
|
|
func NewBasicLoggerForWriter(t jww.Threshold, w io.Writer) Logger {
|
|
return newLogger(t, jww.LevelError, w, ioutil.Discard, false)
|
|
}
|
|
|
|
var (
|
|
ansiColorRe = regexp.MustCompile("(?s)\\033\\[\\d*(;\\d*)*m")
|
|
errorRe = regexp.MustCompile("^(ERROR|FATAL|WARN)")
|
|
)
|
|
|
|
type ansiCleaner struct {
|
|
w io.Writer
|
|
}
|
|
|
|
func (a ansiCleaner) Write(p []byte) (n int, err error) {
|
|
return a.w.Write(ansiColorRe.ReplaceAll(p, []byte("")))
|
|
}
|
|
|
|
type labelColorizer struct {
|
|
w io.Writer
|
|
}
|
|
|
|
func (a labelColorizer) Write(p []byte) (n int, err error) {
|
|
replaced := errorRe.ReplaceAllStringFunc(string(p), func(m string) string {
|
|
switch m {
|
|
case "ERROR", "FATAL":
|
|
return terminal.Error(m)
|
|
case "WARN":
|
|
return terminal.Warning(m)
|
|
default:
|
|
return m
|
|
}
|
|
})
|
|
// io.MultiWriter will abort if we return a bigger write count than input
|
|
// bytes, so we lie a little.
|
|
_, err = a.w.Write([]byte(replaced))
|
|
return len(p), err
|
|
}
|
|
|
|
// InitGlobalLogger initializes the global logger, used in some rare cases.
|
|
func InitGlobalLogger(stdoutThreshold, logThreshold jww.Threshold, outHandle, logHandle io.Writer) {
|
|
outHandle, logHandle = getLogWriters(outHandle, logHandle)
|
|
|
|
jww.SetStdoutOutput(outHandle)
|
|
jww.SetLogOutput(logHandle)
|
|
jww.SetLogThreshold(logThreshold)
|
|
jww.SetStdoutThreshold(stdoutThreshold)
|
|
}
|
|
|
|
func getLogWriters(outHandle, logHandle io.Writer) (io.Writer, io.Writer) {
|
|
isTerm := terminal.IsTerminal(os.Stdout)
|
|
if logHandle != ioutil.Discard && isTerm {
|
|
// Remove any Ansi coloring from log output
|
|
logHandle = ansiCleaner{w: logHandle}
|
|
}
|
|
|
|
if isTerm {
|
|
outHandle = labelColorizer{w: outHandle}
|
|
}
|
|
|
|
return outHandle, logHandle
|
|
}
|
|
|
|
type fatalLogWriter int
|
|
|
|
func (s fatalLogWriter) Write(p []byte) (n int, err error) {
|
|
trace := make([]byte, 1500)
|
|
runtime.Stack(trace, true)
|
|
fmt.Printf("\n===========\n\n%s\n", trace)
|
|
os.Exit(-1)
|
|
|
|
return 0, nil
|
|
}
|
|
|
|
var fatalLogListener = func(t jww.Threshold) io.Writer {
|
|
if t != jww.LevelError {
|
|
// Only interested in ERROR
|
|
return nil
|
|
}
|
|
|
|
return new(fatalLogWriter)
|
|
}
|
|
|
|
func newLogger(stdoutThreshold, logThreshold jww.Threshold, outHandle, logHandle io.Writer, saveErrors bool) *logger {
|
|
errorCounter := &jww.Counter{}
|
|
warnCounter := &jww.Counter{}
|
|
outHandle, logHandle = getLogWriters(outHandle, logHandle)
|
|
|
|
listeners := []jww.LogListener{jww.LogCounter(errorCounter, jww.LevelError), jww.LogCounter(warnCounter, jww.LevelWarn)}
|
|
var errorBuff *bytes.Buffer
|
|
if saveErrors {
|
|
errorBuff = new(bytes.Buffer)
|
|
errorCapture := func(t jww.Threshold) io.Writer {
|
|
if t != jww.LevelError {
|
|
// Only interested in ERROR
|
|
return nil
|
|
}
|
|
return errorBuff
|
|
}
|
|
|
|
listeners = append(listeners, errorCapture)
|
|
}
|
|
|
|
return &logger{
|
|
Notepad: jww.NewNotepad(stdoutThreshold, logThreshold, outHandle, logHandle, "", log.Ldate|log.Ltime, listeners...),
|
|
out: outHandle,
|
|
logCounters: &LogCounters{
|
|
ErrorCounter: errorCounter,
|
|
WarnCounter: warnCounter,
|
|
},
|
|
errors: errorBuff,
|
|
}
|
|
}
|