generated from liuzhaomax/go-maxms
/
logger.go
246 lines (233 loc) · 7.24 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
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
package core
import (
"context"
"fmt"
"github.com/gin-gonic/gin"
"github.com/sirupsen/logrus"
"github.com/snowzach/rotatefilehook"
"google.golang.org/grpc"
"google.golang.org/grpc/metadata"
"os"
"runtime"
"time"
)
// 初始化logrus,让在初始化日志前的log也在console中打印,但不记录在日志文件中
func init() {
logrus.SetLevel(logrus.InfoLevel)
logrus.SetFormatter(selectFormatter("text"))
}
type Log struct {
Level string `mapstructure:"level"`
Format string `mapstructure:"format"`
Color bool `mapstructure:"color"`
FilePath string `mapstructure:"file_path"`
FileName string `mapstructure:"file_name"`
}
// 日志扩展loggerx的Provider
func InitLogrus() *logrus.Logger {
return cfg.App.Logger
}
// 初始化系统日志
func InitLogger() func() {
log := GetConfig().Lib.Log
if err := os.MkdirAll(log.FilePath, 0666); err != nil {
logrus.WithField(FAILURE, GetFuncName()).Panic(FormatError(IOException, "日志目录创建失败", err))
}
// TODO NOT NOW 根据时间创建不同的日志文件,减小IO开支,日志必须保存至少180天
fileName := fmt.Sprintf("%s/%s", log.FilePath, log.FileName)
file, err := os.OpenFile(fileName, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0666)
if err != nil {
logrus.WithField(FAILURE, GetFuncName()).Panic(FormatError(IOException, "日志文件打开失败", err))
}
logger := logrus.New()
logger.SetLevel(selectLogLevel())
logger.SetFormatter(selectFormatter(log.Format))
// logger.SetReportCaller(true) // 输出caller
rotateFileHook, err := rotatefilehook.NewRotateFileHook(rotatefilehook.RotateFileConfig{
Filename: fileName,
MaxSize: 50, // megabytes
MaxBackups: 3, // amouts
MaxAge: 28, // days
Level: selectLogLevel(),
Formatter: selectFormatter(),
})
if err != nil {
logger.WithField(FAILURE, GetFuncName()).Panic(FormatError(Unknown, "日志hook生成失败", err))
panic(err)
}
logger.AddHook(rotateFileHook)
cfg.App.Logger = logger
return func() {
if file != nil {
err = file.Close()
if err != nil {
logger.WithField(FAILURE, GetFuncName()).Panic(FormatError(IOException, "日志文件关闭失败", err))
panic(err)
}
}
}
}
func selectFormatter(forceFormatter ...string) logrus.Formatter {
log := cfg.Lib.Log
format := log.Format
if len(forceFormatter) != 0 {
format = forceFormatter[0]
}
if forceFormatter == nil {
format = "json"
}
switch format {
case "text":
return &logrus.TextFormatter{
PadLevelText: true,
ForceColors: log.Color,
FullTimestamp: true,
TimestampFormat: time.DateTime,
CallerPrettyfier: func(f *runtime.Frame) (string, string) {
file := fmt.Sprintf("%s:%d", f.File, f.Line)
return "", fmt.Sprintf("\033[1;34m%s\033[0m", file)
},
}
case "json":
return &logrus.JSONFormatter{
TimestampFormat: time.RFC3339Nano,
DisableTimestamp: false,
DisableHTMLEscape: false,
DataKey: "",
FieldMap: nil,
CallerPrettyfier: nil,
PrettyPrint: false,
}
default:
return &logrus.JSONFormatter{
TimestampFormat: time.RFC3339Nano,
}
}
}
func selectLogLevel() logrus.Level {
switch cfg.Lib.Log.Level {
case "trace":
return logrus.TraceLevel
case "debug":
return logrus.DebugLevel
case "info":
return logrus.InfoLevel
case "warn":
return logrus.WarnLevel
case "error":
return logrus.ErrorLevel
case "fatal":
return logrus.FatalLevel
case "panic":
return logrus.PanicLevel
default:
return logrus.InfoLevel
}
}
// HTTP 日志中间件
func LoggerForHTTP() gin.HandlerFunc {
logger := cfg.App.Logger
return func(c *gin.Context) {
clientIP := GetClientIP(c)
userAgent := GetUserAgent(c)
LoggerFormat := logrus.Fields{
"method": c.Request.Method,
"uri": c.Request.RequestURI,
"client_ip": clientIP,
"user_agent": userAgent,
"token": c.Request.Header.Get(Authorization),
"trace_id": c.Request.Header.Get(TraceId),
"span_id": c.Request.Header.Get(SpanId),
"parent_id": c.Request.Header.Get(ParentId),
"app_id": c.Request.Header.Get(AppId),
"request_id": c.Request.Header.Get(RequestId),
"user_id": c.Request.Header.Get(UserId),
}
// Incoming日志是来的什么就是什么,只有traceID应一致
logger.WithFields(LoggerFormat).Info("请求开始")
startTime := time.Now()
c.Next()
endTime := time.Now()
took := endTime.Sub(startTime)
statusCode := c.Writer.Status()
// json标准写法
logger.WithFields(LoggerFormat).WithFields(logrus.Fields{
"took": took,
"status": statusCode,
}).Info("请求结束")
// concatenated json 写法
// format := &LoggerFormat{
// StatusCode: statusCode,
// Took: took,
// Method: c.Request.Method,
// URI: c.Request.RequestURI,
// ClientIP: clientIP,
// UserAgent: userAgent,
// Token: c.Request.Header.Get(Authorization),
// TraceId: c.Request.Header.Get(TraceId),
// SpanID: c.Request.Header.Get(SpanId),
// ParentID: c.Request.Header.Get(ParentId),
// AppID: c.Request.Header.Get(AppId),
// RequestID: c.Request.Header.Get(RequestId),
// UserID: c.Request.Header.Get(UserId),
// }
// formatBytes, _ := json.Marshal(format)
// logger.Info(string(formatBytes))
// 竖线分割写法
// logger.Infof("| %3d | %13v | %15s | %8s | %s | %20s",
// statusCode,
// took,
// clientIP,
// method,
// uri,
// userAgent,
// )
}
}
// type LoggerFormat struct {
// StatusCode int `json:"code"`
// Took time.Duration `json:"took"`
// Method string `json:"method"`
// URI string `json:"uri"`
// ClientIP string `json:"client_ip"`
// UserAgent string `json:"user_agent"`
// Token string `json:"token"`
// TraceId string `json:"trace_id"`
// SpanID string `json:"span_id"`
// ParentID string `json:"parent_id"`
// UpstreamID string `json:"upstream_id"`
// AppID string `json:"app_id"`
// RequestID string `json:"request_id"`
// UserID string `json:"user_id"`
// }
// RPC 日志中间件
func LoggerForRPC(ctx context.Context, req interface{}, _ *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
logger := cfg.App.Logger
md, ok := metadata.FromIncomingContext(ctx)
if !ok {
LogFailure(NotFound, "缺少metadata", nil)
}
LoggerFormat := logrus.Fields{
"method": SelectFromMetadata(md, Method),
"uri": SelectFromMetadata(md, URI),
"client_ip": SelectFromMetadata(md, ClientIp),
"user_agent": SelectFromMetadata(md, UserAgent),
"token": SelectFromMetadata(md, Authorization),
"trace_id": SelectFromMetadata(md, TraceId),
"span_id": SelectFromMetadata(md, SpanId),
"parent_id": SelectFromMetadata(md, ParentId),
"app_id": SelectFromMetadata(md, AppId),
"request_id": SelectFromMetadata(md, RequestId),
"user_id": SelectFromMetadata(md, UserId),
}
logger.WithFields(LoggerFormat).Info("请求开始")
startTime := time.Now()
res, err := handler(ctx, req)
endTime := time.Now()
took := endTime.Sub(startTime)
// json标准写法
logger.WithFields(LoggerFormat).WithFields(logrus.Fields{
"took": took,
}).Info("请求结束")
return res, err
}