feat:logger

cmd/run/service.go

@@ -5,18 +5,21 @@ import (
 	"fmt"
 	"grm/common"
 	"grm/global"
+	"grm/glog"
 	"grm/router"
 	"grm/web"
 	"io"
-	"log"
 	"net"
 	"net/http"
 	"os"
 	"os/signal"
 	"time"
 
+	"github.com/pkg/errors"
+
 	"github.com/gin-gonic/gin"
 	"github.com/kardianos/service"
+	"go.uber.org/zap"
 )
 
 type Services struct {
@@ -28,21 +31,6 @@ type Services struct {
 // 获取 service 对象
 func GetSrv() service.Service {
 
-	path, err := common.RootPath()
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(0)
-	}
-
-	File, err := common.OpenFile(path + "/log/service.log")
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(0)
-	}
-	defer File.Close()
-
-	log.SetOutput(File)
-
 	s := &Services{
 		Cfg: &service.Config{
 			Name:        "grm",
@@ -52,11 +40,15 @@ func GetSrv() service.Service {
 		}}
 	serv, err := service.New(s, s.Cfg)
 	if err != nil {
-		log.Printf("Set logger error:%s\n", err.Error())
+		errMsg := fmt.Sprintf("%+v", errors.WithStack(err))
+		glog.Logger.Error(errMsg, zap.Error(err))
+		os.Exit(0)
 	}
 	s.Log, err = serv.SystemLogger(nil)
 	if err != nil {
-		log.Printf("Set logger error:%s\n", err.Error())
+		errMsg := fmt.Sprintf("%+v", errors.WithStack(err))
+		glog.Logger.Error(errMsg, zap.Error(err))
+		os.Exit(0)
 	}
 
 	return serv
@@ -78,7 +70,6 @@ func (srv *Services) Stop(s service.Service) error {
 	if srv.Log != nil {
 		srv.Log.Info("Start stop http server")
 	}
-	log.Println("Server exiting")
 	return srv.Srv.Shutdown(context.Background())
 }
 
@@ -88,19 +79,21 @@ func (srv *Services) StarServer() {
 	gin.DisableConsoleColor()
 	gin.SetMode(gin.ReleaseMode)
 
-	path, err := common.RootPath()
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(0)
-	}
+	// path, err := common.RootPath()
+	// if err != nil {
+	// 	errMsg := fmt.Sprintf("%+v", errors.WithStack(err))
+	// 	glog.Logger.Error(errMsg, zap.Error(err))
+	// 	os.Exit(0)
+	// }
 
 	// 创建记录日志的文件
-	f, err := common.OpenFile(path + "/log/grm_error.log")
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(0)
-	}
-	gin.DefaultErrorWriter = io.MultiWriter(f)
+	// f, err := common.OpenFile(path + "/log/grm_error.log")
+	// if err != nil {
+	// 	errMsg := fmt.Sprintf("%+v", errors.WithStack(err))
+	// 	glog.Logger.Error(errMsg, zap.Error(err))
+	// 	os.Exit(0)
+	// }
+	// gin.DefaultErrorWriter = io.MultiWriter(f)
 	gin.DefaultWriter = io.Discard
 
 	router := router.Init()
@@ -114,7 +107,8 @@ func (srv *Services) StarServer() {
 
 	go func() {
 		if err := srv.Srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			log.Fatalf("listen: %s\n", err)
+			errMsg := fmt.Sprintf("%+v", errors.WithStack(err))
+			glog.Logger.Error(errMsg, zap.Error(err))
 		}
 	}()
 
@@ -127,15 +121,16 @@ func (srv *Services) StarServer() {
 
 	<-quit
 
-	log.Println("Shutdown Server ...")
+	glog.Logger.Info("Shutdown Server ...")
 
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 
 	defer cancel()
 
 	if err := srv.Srv.Shutdown(ctx); err != nil {
-		log.Fatal("Server Shutdown:", err)
+		errMsg := fmt.Sprintf("%+v", errors.WithStack(err))
+		glog.Logger.Error(errMsg, zap.Error(err))
 	}
 
-	log.Println("Server exiting")
+	glog.Logger.Info("Server exiting")
 }

glog/log.go

@@ -0,0 +1,57 @@
+package glog
+
+import (
+	"grm/common"
+
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+	"gopkg.in/natefinch/lumberjack.v2"
+)
+
+var Logger *zap.Logger
+
+func init() {
+	Logger = NewLogger("service.log")
+}
+
+func NewLogger(path string) *zap.Logger {
+
+	rootPath, _ := common.RootPath()
+
+	hook := lumberjack.Logger{
+		Filename:   rootPath + "/log/" + path, // 日志文件路径
+		MaxSize:    128,                       // 每个日志文件保存的最大尺寸 单位：M
+		MaxBackups: 30,                        // 日志文件最多保存多少个备份
+		MaxAge:     7,                         // 文件最多保存多少天
+		Compress:   true,                      // 是否压缩
+	}
+
+	encoderConfig := zapcore.EncoderConfig{
+		TimeKey:        "time",
+		LevelKey:       "level",
+		NameKey:        "logger",
+		CallerKey:      "linenum",
+		MessageKey:     "msg",
+		StacktraceKey:  "stacktrace",
+		LineEnding:     zapcore.DefaultLineEnding,
+		EncodeLevel:    zapcore.LowercaseLevelEncoder,  // 小写编码器
+		EncodeTime:     zapcore.ISO8601TimeEncoder,     // ISO8601 UTC 时间格式
+		EncodeDuration: zapcore.SecondsDurationEncoder, //
+		EncodeCaller:   zapcore.FullCallerEncoder,      // 全路径编码器
+		EncodeName:     zapcore.FullNameEncoder,
+	}
+
+	// 设置日志级别
+	atomicLevel := zap.NewAtomicLevel()
+	atomicLevel.SetLevel(zap.InfoLevel)
+
+	core := zapcore.NewCore(
+		zapcore.NewJSONEncoder(encoderConfig),               // 编码器配置
+		zapcore.NewMultiWriteSyncer(zapcore.AddSync(&hook)), // 打印到控制台和文件
+		atomicLevel, // 日志级别
+	)
+
+	// 构造日志
+	return zap.New(core)
+
+}

middleware/log.go

@@ -0,0 +1,59 @@
+package middleware
+
+import (
+	"net"
+	"net/http"
+	"net/http/httputil"
+	"os"
+	"runtime/debug"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+func GinRecovery(logger *zap.Logger, stack bool) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		defer func() {
+			if err := recover(); err != nil {
+				// Check for a broken connection, as it is not really a
+				// condition that warrants a panic stack trace.
+				var brokenPipe bool
+				if ne, ok := err.(*net.OpError); ok {
+					if se, ok := ne.Err.(*os.SyscallError); ok {
+						if strings.Contains(strings.ToLower(se.Error()), "broken pipe") || strings.Contains(strings.ToLower(se.Error()), "connection reset by peer") {
+							brokenPipe = true
+						}
+					}
+				}
+
+				httpRequest, _ := httputil.DumpRequest(c.Request, false)
+				if brokenPipe {
+					logger.Error(c.Request.URL.Path,
+						zap.Any("error", err),
+						zap.String("request", string(httpRequest)),
+					)
+					// If the connection is dead, we can't write a status to it.
+					c.Error(err.(error)) // nolint: errcheck
+					c.Abort()
+					return
+				}
+
+				if stack {
+					logger.Error("[Recovery from panic]",
+						zap.Any("error", err),
+						zap.String("request", string(httpRequest)),
+						zap.String("stack", string(debug.Stack())),
+					)
+				} else {
+					logger.Error("[Recovery from panic]",
+						zap.Any("error", err),
+						zap.String("request", string(httpRequest)),
+					)
+				}
+				c.AbortWithStatus(http.StatusInternalServerError)
+			}
+		}()
+		c.Next()
+	}
+}

router/default.go

@@ -7,6 +7,7 @@ package router
 
 import (
 	"grm/controllers"
+	"grm/glog"
 	"grm/middleware"
 	"net/http"
 
@@ -17,11 +18,11 @@ import (
 )
 
 func Init() *gin.Engine {
-	router := gin.Default()
+	router := gin.New()
 
 	store := cookie.NewStore([]byte("goredismanagerphper"))
 	router.Use(middleware.StaticCache(), gzip.Gzip(gzip.DefaultCompression), sessions.Sessions("goredismanager", store))
-	router.Use(gin.Logger(), gin.Recovery())
+	router.Use(gin.Logger(), middleware.GinRecovery(glog.NewLogger("gin_error.log"), true))
 	router.NoRoute(func(ctx *gin.Context) {
 		ctx.Redirect(http.StatusMovedPermanently, "/static/#")
 	})

service/service.go

@@ -9,6 +9,7 @@ import (
 	"context"
 	"grm/common"
 	"grm/global"
+	"grm/glog"
 	"net"
 	"time"
 
@@ -40,7 +41,7 @@ func NewRedisClient(conf global.RedisService) (*redis.Client, error) {
 	client := redis.NewClient(optConf)
 
 	client.AddHook(common.RedisLog{
-		Logger: common.NewLogger(conf.RedisService),
+		Logger: glog.NewLogger(conf.RedisService + "/redis.log"),
 	})
 
 	_, err := client.Ping(ctx).Result()