-
Notifications
You must be signed in to change notification settings - Fork 3
/
log.go
127 lines (112 loc) · 3.9 KB
/
log.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
// Copyright (c) 2016 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/btcsuite/btclog"
"github.com/dcrdata/dcrdata/blockdata"
"github.com/dcrdata/dcrdata/dcrsqlite"
"github.com/dcrdata/dcrdata/explorer"
"github.com/dcrdata/dcrdata/mempool"
"github.com/dcrdata/dcrdata/rpcutils"
"github.com/dcrdata/dcrdata/stakedb"
"github.com/decred/dcrrpcclient"
"github.com/jrick/logrotate/rotator"
)
// 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)
logRotator.Write(p)
return len(p), nil
}
// 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 = btclog.NewBackend(logWriter{})
// logRotator is one of the logging outputs. It should be closed on
// application shutdown.
logRotator *rotator.Rotator
sqliteLog = backendLog.Logger("DSQL")
stakedbLog = backendLog.Logger("SKDB")
blockdataLog = backendLog.Logger("BLKD")
clientLog = backendLog.Logger("RPCC")
mempoolLog = backendLog.Logger("MEMP")
expLog = backendLog.Logger("EXPR")
apiLog = backendLog.Logger("JAPI")
log = backendLog.Logger("DATD")
)
// Initialize package-global logger variables.
func init() {
dcrsqlite.UseLogger(sqliteLog)
stakedb.UseLogger(stakedbLog)
blockdata.UseLogger(blockdataLog)
dcrrpcclient.UseLogger(clientLog)
rpcutils.UseLogger(clientLog)
mempool.UseLogger(mempoolLog)
explorer.UseLogger(expLog)
}
// subsystemLoggers maps each subsystem identifier to its associated logger.
var subsystemLoggers = map[string]btclog.Logger{
"DSQL": sqliteLog,
"SKDB": stakedbLog,
"BLKD": blockdataLog,
"RPCC": clientLog,
"MEMP": mempoolLog,
"EXPR": expLog,
"JAPI": apiLog,
"DATD": log,
}
// 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) {
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, 10*1024, false, 8)
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, _ := btclog.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)
}
}