/
logger.go
179 lines (154 loc) · 4.82 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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
package bootstrap
import (
"os"
"github.com/sirupsen/logrus"
"go.uber.org/zap"
"go.uber.org/zap/zapcore"
"gopkg.in/natefinch/lumberjack.v2"
aliyunLogger "github.com/go-kratos/kratos/contrib/log/aliyun/v2"
fluentLogger "github.com/go-kratos/kratos/contrib/log/fluent/v2"
logrusLogger "github.com/go-kratos/kratos/contrib/log/logrus/v2"
tencentLogger "github.com/go-kratos/kratos/contrib/log/tencent/v2"
zapLogger "github.com/go-kratos/kratos/contrib/log/zap/v2"
"github.com/go-kratos/kratos/v2/log"
"github.com/go-kratos/kratos/v2/middleware/tracing"
"github.com/lalifeier/vvgo-mall/gen/api/go/common/conf"
)
type LoggerType string
const (
LoggerTypeStd LoggerType = "std"
LoggerTypeFluent LoggerType = "fluent"
LoggerTypeLogrus LoggerType = "logrus"
LoggerTypeZap LoggerType = "zap"
LoggerTypeAliyun LoggerType = "aliyun"
LoggerTypeTencent LoggerType = "tencent"
)
// NewLoggerProvider 创建一个新的日志记录器提供者
func NewLoggerProvider(cfg *conf.Logger, serviceInfo *ServiceInfo) log.Logger {
l := NewLogger(cfg)
return log.With(
l,
"service.id", serviceInfo.Id,
"service.name", serviceInfo.Name,
"service.version", serviceInfo.Version,
"ts", log.DefaultTimestamp,
"caller", log.DefaultCaller,
"trace_id", tracing.TraceID(),
"span_id", tracing.SpanID(),
)
}
// NewLogger 创建一个新的日志记录器
func NewLogger(cfg *conf.Logger) log.Logger {
if cfg == nil {
return NewStdLogger()
}
switch LoggerType(cfg.Type) {
default:
fallthrough
case LoggerTypeStd:
return NewStdLogger()
case LoggerTypeFluent:
return NewFluentLogger(cfg)
case LoggerTypeZap:
return NewZapLogger(cfg)
case LoggerTypeLogrus:
return NewLogrusLogger(cfg)
case LoggerTypeAliyun:
return NewAliyunLogger(cfg)
case LoggerTypeTencent:
return NewTencentLogger(cfg)
}
}
// NewStdLogger 创建一个新的日志记录器 - Kratos内置,控制台输出
func NewStdLogger() log.Logger {
l := log.NewStdLogger(os.Stdout)
return l
}
// NewZapLogger 创建一个新的日志记录器 - Zap
func NewZapLogger(cfg *conf.Logger) log.Logger {
encoderConfig := zap.NewProductionEncoderConfig()
encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
encoderConfig.TimeKey = "time"
encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder
encoderConfig.EncodeDuration = zapcore.SecondsDurationEncoder
encoderConfig.EncodeCaller = zapcore.ShortCallerEncoder
jsonEncoder := zapcore.NewJSONEncoder(encoderConfig)
lumberJackLogger := &lumberjack.Logger{
Filename: cfg.Zap.Filename,
MaxSize: int(cfg.Zap.MaxSize),
MaxBackups: int(cfg.Zap.MaxBackups),
MaxAge: int(cfg.Zap.MaxAge),
}
writeSyncer := zapcore.AddSync(lumberJackLogger)
var lvl = new(zapcore.Level)
if err := lvl.UnmarshalText([]byte(cfg.Zap.Level)); err != nil {
return nil
}
core := zapcore.NewCore(jsonEncoder, writeSyncer, lvl)
logger := zap.New(core).WithOptions()
wrapped := zapLogger.NewLogger(logger)
return wrapped
}
// NewLogrusLogger 创建一个新的日志记录器 - Logrus
func NewLogrusLogger(cfg *conf.Logger) log.Logger {
loggerLevel, err := logrus.ParseLevel(cfg.Logrus.Level)
if err != nil {
loggerLevel = logrus.InfoLevel
}
var loggerFormatter logrus.Formatter
switch cfg.Logrus.Formatter {
default:
fallthrough
case "text":
loggerFormatter = &logrus.TextFormatter{
DisableColors: cfg.Logrus.DisableColors,
DisableTimestamp: cfg.Logrus.DisableTimestamp,
TimestampFormat: cfg.Logrus.TimestampFormat,
}
break
case "json":
loggerFormatter = &logrus.JSONFormatter{
DisableTimestamp: cfg.Logrus.DisableTimestamp,
TimestampFormat: cfg.Logrus.TimestampFormat,
}
break
}
logger := logrus.New()
logger.Level = loggerLevel
logger.Formatter = loggerFormatter
wrapped := logrusLogger.NewLogger(logger)
return wrapped
}
// NewFluentLogger 创建一个新的日志记录器 - Fluent
func NewFluentLogger(cfg *conf.Logger) log.Logger {
wrapped, err := fluentLogger.NewLogger(cfg.Fluent.Endpoint)
if err != nil {
panic("create fluent logger failed")
return nil
}
return wrapped
}
// NewAliyunLogger 创建一个新的日志记录器 - Aliyun
func NewAliyunLogger(cfg *conf.Logger) log.Logger {
wrapped := aliyunLogger.NewAliyunLog(
aliyunLogger.WithProject(cfg.Aliyun.Project),
aliyunLogger.WithEndpoint(cfg.Aliyun.Endpoint),
aliyunLogger.WithAccessKey(cfg.Aliyun.AccessKey),
aliyunLogger.WithAccessSecret(cfg.Aliyun.AccessSecret),
)
return wrapped
}
// NewTencentLogger 创建一个新的日志记录器 - Tencent
func NewTencentLogger(cfg *conf.Logger) log.Logger {
wrapped, err := tencentLogger.NewLogger(
tencentLogger.WithTopicID(cfg.Tencent.TopicId),
tencentLogger.WithEndpoint(cfg.Tencent.Endpoint),
tencentLogger.WithAccessKey(cfg.Tencent.AccessKey),
tencentLogger.WithAccessSecret(cfg.Tencent.AccessSecret),
)
if err != nil {
panic(err)
return nil
}
return wrapped
}