4810802fa9
Maintaining the dafault max log file size of 10MB, but increasing the default number of retained files from 3 to 20.
116 lines
3.5 KiB
Go
116 lines
3.5 KiB
Go
// Copyright (c) 2020-2021 The Decred developers
|
|
// Use of this source code is governed by an ISC
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
|
|
"github.com/decred/slog"
|
|
"github.com/jrick/logrotate/rotator"
|
|
|
|
"github.com/decred/vspd/background"
|
|
"github.com/decred/vspd/database"
|
|
"github.com/decred/vspd/rpc"
|
|
"github.com/decred/vspd/webapi"
|
|
)
|
|
|
|
// logWriter implements an io.Writer that outputs to both standard output and
|
|
// the write-end pipe of an initialized log rotator.
|
|
type logWriter struct{}
|
|
|
|
func (logWriter) Write(p []byte) (n int, err error) {
|
|
os.Stdout.Write(p)
|
|
return logRotator.Write(p)
|
|
}
|
|
|
|
// Loggers per subsystem. A single backend logger is created and all subsytem
|
|
// loggers created from it will write to the backend. When adding new
|
|
// subsystems, add the subsystem logger variable here and to the
|
|
// subsystemLoggers map.
|
|
//
|
|
// Loggers can not be used before the log rotator has been initialized with a
|
|
// log file. This must be performed early during application startup by calling
|
|
// initLogRotator.
|
|
var (
|
|
// backendLog is the logging backend used to create all subsystem loggers.
|
|
// The backend must not be used before the log rotator has been initialized,
|
|
// or data races and/or nil pointer dereferences will occur.
|
|
backendLog = slog.NewBackend(logWriter{})
|
|
|
|
// logRotator is one of the logging outputs. It should be closed on
|
|
// application shutdown.
|
|
logRotator *rotator.Rotator
|
|
|
|
log = backendLog.Logger("VSP")
|
|
dbLog = backendLog.Logger(" DB")
|
|
bgLog = backendLog.Logger(" BG")
|
|
apiLog = backendLog.Logger("API")
|
|
rpcLog = backendLog.Logger("RPC")
|
|
)
|
|
|
|
// Initialize package-global logger variables.
|
|
func init() {
|
|
database.UseLogger(dbLog)
|
|
background.UseLogger(bgLog)
|
|
webapi.UseLogger(apiLog)
|
|
rpc.UseLogger(rpcLog)
|
|
}
|
|
|
|
// subsystemLoggers maps each subsystem identifier to its associated logger.
|
|
var subsystemLoggers = map[string]slog.Logger{
|
|
"VSP": log,
|
|
" DB": dbLog,
|
|
" BG": bgLog,
|
|
"API": apiLog,
|
|
"RPC": rpcLog,
|
|
}
|
|
|
|
// initLogRotator initializes the logging rotater to write logs to logFile and
|
|
// create roll files in the same directory. It must be called before the
|
|
// package-global log rotater variables are used.
|
|
func initLogRotator(logFile string, maxLogSize int64, logsToKeep int) {
|
|
logDir, _ := filepath.Split(logFile)
|
|
err := os.MkdirAll(logDir, 0700)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "failed to create log directory: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
r, err := rotator.New(logFile, maxLogSize*1024, false, logsToKeep)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "failed to create file rotator: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
logRotator = r
|
|
}
|
|
|
|
// setLogLevel sets the logging level for provided subsystem. Invalid
|
|
// subsystems are ignored. Uninitialized subsystems are dynamically created as
|
|
// needed.
|
|
func setLogLevel(subsystemID string, logLevel string) {
|
|
// Ignore invalid subsystems.
|
|
logger, ok := subsystemLoggers[subsystemID]
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
// Defaults to info if the log level is invalid.
|
|
level, _ := slog.LevelFromString(logLevel)
|
|
logger.SetLevel(level)
|
|
}
|
|
|
|
// setLogLevels sets the log level for all subsystem loggers to the passed
|
|
// level. It also dynamically creates the subsystem loggers as needed, so it
|
|
// can be used to initialize the logging system.
|
|
func setLogLevels(logLevel string) {
|
|
// Configure all sub-systems with the new logging level. Dynamically
|
|
// create loggers as needed.
|
|
for subsystemID := range subsystemLoggers {
|
|
setLogLevel(subsystemID, logLevel)
|
|
}
|
|
}
|