-
Notifications
You must be signed in to change notification settings - Fork 376
/
logger.go
130 lines (109 loc) · 2.97 KB
/
logger.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
128
129
130
package core
import (
"fmt"
p2plog "github.com/ipfs/go-log"
"github.com/whyrusleeping/go-logging"
"go.uber.org/zap"
"go.uber.org/zap/zapcore"
)
type Logger interface {
Log(level, namespace, message string) error
LevelEnabler(level string) bool
}
type mobileCore struct {
zapcore.Core
enc zapcore.Encoder
l Logger
}
func newMobileCore(next zapcore.Core, encoder zapcore.Encoder, l Logger) zapcore.Core {
return &mobileCore{next, encoder, l}
}
func (mc *mobileCore) Check(entry zapcore.Entry, checked *zapcore.CheckedEntry) *zapcore.CheckedEntry {
if mc.l.LevelEnabler(entry.Level.CapitalString()) {
return checked.AddCore(entry, mc)
}
return checked
}
func (mc *mobileCore) Write(entry zapcore.Entry, fields []zapcore.Field) error {
buff, err := mc.enc.EncodeEntry(entry, fields)
if err != nil {
return err
}
return mc.l.Log(entry.Level.CapitalString(), entry.LoggerName, buff.String())
}
type p2pLogBackendWrapper struct {
logger *zap.Logger
}
func (l *p2pLogBackendWrapper) Log(level logging.Level, calldepth int, rec *logging.Record) error {
module := l.logger.Named(rec.Module)
switch level {
case logging.DEBUG:
module.Debug(rec.Message())
case logging.WARNING:
module.Warn(rec.Message())
case logging.ERROR:
module.Error(rec.Message())
case logging.CRITICAL:
module.Panic(rec.Message())
case logging.NOTICE:
case logging.INFO:
module.Info(rec.Message())
}
return nil
}
func getP2PLogLevel(level zapcore.Level) logging.Level {
switch level {
case zap.DebugLevel:
return logging.DEBUG
case zap.InfoLevel:
return logging.INFO
case zap.WarnLevel:
return logging.WARNING
case zap.ErrorLevel:
return logging.ERROR
}
return logging.CRITICAL
}
func setupLogger(logLevel string, mlogger Logger) error {
var zapLogLevel zapcore.Level
switch logLevel {
case "debug":
zapLogLevel = zap.DebugLevel
case "info":
zapLogLevel = zap.InfoLevel
case "warn":
zapLogLevel = zap.WarnLevel
case "error":
zapLogLevel = zap.ErrorLevel
default:
return fmt.Errorf("unknown log level: %q", logLevel)
}
// configure zap
config := zap.NewDevelopmentConfig()
config.Level.SetLevel(zapLogLevel)
config.DisableStacktrace = true
// configure log encoder
// disable unwanted info
config.EncoderConfig.LevelKey = ""
config.EncoderConfig.TimeKey = ""
config.EncoderConfig.NameKey = ""
config.EncoderConfig.CallerKey = ""
l, err := config.Build()
if err != nil {
return err
}
consoleEncoder := zapcore.NewConsoleEncoder(config.EncoderConfig)
mobileCore := zap.WrapCore(func(core zapcore.Core) zapcore.Core {
return newMobileCore(core, consoleEncoder, mlogger)
})
zap.ReplaceGlobals(l.WithOptions(mobileCore))
logger().Debug("logger initialized")
// configure p2p log
logging.SetBackend(&p2pLogBackendWrapper{
logger: zap.L().Named("vendor.libp2p").WithOptions(zap.AddCallerSkip(4)),
})
if err := p2plog.SetLogLevel("*", getP2PLogLevel(zapLogLevel).String()); err != nil {
logger().Warn("failed to set p2p log level", zap.Error(err))
}
return nil
}